diff --git a/thys/KBPs/ClockView.thy b/thys/KBPs/ClockView.thy
--- a/thys/KBPs/ClockView.thy
+++ b/thys/KBPs/ClockView.thy
@@ -1,1551 +1,1549 @@
 (*<*)
 (*
  * Knowledge-based programs.
  * (C)opyright 2011, Peter Gammie, peteg42 at gmail.com.
  * License: BSD
  *)
 
 theory ClockView
 imports
   KBPsAlg
   Eval
   List_local
   ODList
   Trie2
   "Transitive-Closure.Transitive_Closure_List_Impl"
   "HOL-Library.Mapping"
 begin
 (*>*)
 
 subsection\<open>The Clock View\<close>
 
 text\<open>
 
 \label{sec:kbps-theory-clock-view}
 
 The \emph{clock view} records the current time and the observation for
 the most recent state:
 
 \<close>
 
 definition (in Environment)
   clock_jview :: "('a, 's, nat \<times> 'obs) JointView"
 where
   "clock_jview \<equiv> \<lambda>a t. (tLength t, envObs a (tLast t))"
 (*<*)
 
 context Environment
 begin
 
 lemma clock_jview_tInit:
   "clock_jview a (tInit s) = (0, envObs a s)"
   unfolding clock_jview_def by simp
 
 lemma clock_jview_tStep:
   "clock_jview a (t \<leadsto> s) = (Suc (tLength t), envObs a s)"
   unfolding clock_jview_def by simp
 
 lemma clock_jview_tStepI[intro]:
   "\<lbrakk> tLength t = Suc n; envObs a (tLast t) = obs \<rbrakk>
      \<Longrightarrow> clock_jview a t = (Suc n, obs)"
   unfolding clock_jview_def by (cases t) simp_all
 
 lemma clock_jview_inv:
   "clock_jview a t = (n, obs) \<Longrightarrow> envObs a (tLast t) = obs"
   unfolding clock_jview_def by (cases t) simp_all
 
 lemmas clock_jview_simps =
   clock_jview_tInit
   clock_jview_tStep
   clock_jview_inv
 
 lemma clock_jview_eq_inv[iff]:
   "clock_jview a t' = clock_jview a t
     \<longleftrightarrow> tLength t' = tLength t \<and> envObs a (tLast t') = envObs a (tLast t)"
   by (fastforce simp: clock_jview_def)
 
 end(*>*)
 
 text\<open>
 
 This is the least-information synchronous view, given the requirements
 of \S\ref{sec:kbps-views}. We show that finite-state implementations
 exist for all environments with respect to this view as per
 \citet{Ron:1996}.
 
 The corresponding incremental view simply increments the counter
 records the new observation.
 
 \<close>
 
 definition (in Environment)
   clock_jviewInit :: "'a \<Rightarrow> 'obs \<Rightarrow> nat \<times> 'obs"
 where
   "clock_jviewInit \<equiv> \<lambda>a obs. (0, obs)"
 
 definition (in Environment)
   clock_jviewIncr :: "'a \<Rightarrow> 'obs \<Rightarrow> nat \<times> 'obs \<Rightarrow> nat \<times> 'obs"
 where
   "clock_jviewIncr \<equiv> \<lambda>a obs' (l, obs). (l + 1, obs')"
 
 text\<open>
 
 It is straightforward to demonstrate the assumptions of the
 incremental environment locale (\S\ref{sec:kbps-environments}) with
 respect to an arbitrary environment.
 
 \<close>
 
 sublocale Environment
         < Clock: IncrEnvironment jkbp envInit envAction envTrans envVal
                         clock_jview envObs clock_jviewInit clock_jviewIncr
 (*<*)
   apply (unfold_locales)
   apply (simp_all add: clock_jviewInit_def clock_jviewIncr_def clock_jview_def)
   done
 
 (*>*)
 text\<open>
 
 As we later show, satisfaction of a formula at a trace \<open>t \<in>
 Clock.jkbpC\<^bsub>n\<^esub>\<close> is determined by the set of final states of traces in
 \<open>Clock.jkbpCn\<close>:
 
 \<close>
 
 context Environment
 begin
 
 abbreviation clock_commonAbs :: "'s Trace \<Rightarrow> 's set" where
   "clock_commonAbs t \<equiv> tLast ` Clock.jkbpCn (tLength t)"
 
 text\<open>
 
 Intuitively this set contains the states that the agents commonly
 consider possible at time @{term "n"}, which is sufficient for
 determining knowledge as the clock view ignores paths. Therefore we
 can simulate trace @{term "t"} by pairing this abstraction of @{term
 "t"} with its final state:
 
 \<close>
 
 type_synonym (in -) 's clock_simWorlds = "'s set \<times> 's"
 
 definition clock_sim :: "'s Trace \<Rightarrow> 's clock_simWorlds" where
   "clock_sim \<equiv> \<lambda>t. (clock_commonAbs t, tLast t)"
 
 text\<open>
 
 In the Kripke structure for our simulation, we relate worlds for
 @{term "a"} if the sets of commonly-held states coincide, and the
 observation of the final states of the traces is the
 same. Propositions are evaluated at the final state.
 
 \<close>
 
 definition clock_simRels :: "'a \<Rightarrow> 's clock_simWorlds Relation" where
   "clock_simRels \<equiv> \<lambda>a. { ((X, s), (X', s')) |X X' s s'.
                           X = X' \<and> {s, s'} \<subseteq> X \<and> envObs a s = envObs a s' }"
 
 definition clock_simVal :: "'s clock_simWorlds \<Rightarrow> 'p \<Rightarrow> bool" where
   "clock_simVal \<equiv> envVal \<circ> snd"
 
 abbreviation clock_simMC :: "('a, 'p, 's clock_simWorlds) KripkeStructure" where
   "clock_simMC \<equiv> mkKripke (clock_sim ` Clock.jkbpC) clock_simRels clock_simVal"
 (*<*)
 
 lemma clock_simVal_def2[iff]: "clock_simVal (clock_sim t) = envVal (tLast t)"
   unfolding clock_sim_def clock_simVal_def by simp
 
 lemma clock_sim_range:
   "sim_range Clock.MC clock_simMC clock_sim"
   by (rule sim_rangeI) (simp_all add: clock_sim_def)
 
 lemma clock_simVal:
   "sim_val Clock.MC clock_simMC clock_sim"
   by (rule sim_valI) (simp add: clock_simVal_def clock_sim_def)
 
 lemma clock_sim_f:
   "sim_f Clock.MC clock_simMC clock_sim"
 apply (rule sim_fI)
 apply (simp add: clock_simRels_def clock_sim_def)
 apply (intro conjI)
    apply (fastforce intro!: imageI)
   apply (fastforce intro!: imageI)
  apply (fastforce dest: Clock.mkM_simps(2))
 apply (rule_tac x=v in image_eqI)
  apply simp_all
 done
 
 lemma clock_sim_r:
   "sim_r Clock.MC clock_simMC clock_sim"
   apply (rule sim_rI)
   apply (clarsimp simp: clock_simRels_def clock_sim_def cong del: image_cong_simp)
   apply (rule_tac x=xa in exI)
   unfolding Clock.mkM_def
   apply auto
   done
 
 (*>*)
 text\<open>
 
 That this is in fact a simulation
 (\S\ref{sec:kripke-theory-simulations}) is entirely straightforward.
 
 \<close>
 
 lemma clock_sim:
   "sim Clock.MC clock_simMC clock_sim"
 (*<*)
   using clock_sim_range clock_simVal clock_sim_f clock_sim_r
   unfolding sim_def
   by blast
 (*>*)
 
 end (* context Environment *)
 
 text\<open>
 
 The \<open>SimIncrEnvironment\<close> of
 \S\ref{sec:kbps-theory-automata-env-sims} only requires that we
 provide it an @{term "Environment"} and a simulation.
 
 \<close>
 
 sublocale Environment
         < Clock: SimIncrEnvironment jkbp envInit envAction envTrans envVal
                   clock_jview envObs clock_jviewInit clock_jviewIncr
                   clock_sim clock_simRels clock_simVal
 (*<*)
   by (unfold_locales, simp_all add: clock_sim)
 (*>*)
 
 text\<open>
 
 We next consider algorithmic issues.
 
 \<close>
 
 (* **************************************** *)
 
 subsubsection\<open>Representations\<close>
 
 text\<open>
 
 \label{sec:kbps-theory-clock-view-rep}
 
 We now turn to the issue of how to represent equivalence classes of
 states. As these are used as map keys, it is easiest to represent them
 canonically. A simple approach is to use \emph{ordered distinct lists}
 of type @{typ "'a odlist"} for the sets and \emph{tries} for the
 maps. Therefore we ask that environment states @{typ "'s"} belong to
 the class \<open>linorder\<close> of linearly-ordered types, and moreover
 that the set \<open>agents\<close> be effectively presented. We introduce a
 new locale capturing these requirements:
 
 \<close>
 
 locale FiniteLinorderEnvironment =
   Environment jkbp envInit envAction envTrans envVal envObs
     for jkbp :: "('a::{finite, linorder}, 'p, 'aAct) JKBP"
     and envInit :: "('s::{finite, linorder}) list"
     and envAction :: "'s \<Rightarrow> 'eAct list"
     and envTrans :: "'eAct \<Rightarrow> ('a \<Rightarrow> 'aAct) \<Rightarrow> 's \<Rightarrow> 's"
     and envVal :: "'s \<Rightarrow> 'p \<Rightarrow> bool"
     and envObs :: "'a \<Rightarrow> 's \<Rightarrow> 'obs"
 + fixes agents :: "'a odlist"
   assumes agents: "ODList.toSet agents = UNIV"
 
 context FiniteLinorderEnvironment
 begin
 
 text\<open>
 
 \label{sec:kbps-theory-clock-view-algops}
 
 For a fixed agent @{term "a"}, we can reduce the number of worlds in
 @{term "clock_simMC"} by taking its quotient with respect to the
 equivalence relation for @{term "a"}. In other words, we represent a
 simulated equivalence class by a pair of the set of all states
 reachable at a particular time, and the subset of these that @{term
 "a"} considers possible. The worlds in our representational Kripke
 structure are therefore a pair of ordered, distinct lists:
 
 \<close>
 
 type_synonym (in -) 's clock_simWorldsRep = "'s odlist \<times> 's odlist"
 
 text\<open>
 
 We can readily abstract a representation to a set of simulated
 equivalence classes:
 
 \<close>
 
 definition (in -)
   clock_simAbs :: "'s::linorder clock_simWorldsRep \<Rightarrow> 's clock_simWorlds set"
 where
   "clock_simAbs X \<equiv> { (ODList.toSet (fst X), s) |s. s \<in> ODList.toSet (snd X) }"
 
 text\<open>
 
 Assuming @{term "X"} represents a simulated equivalence class for
 @{term "t \<in> jkbpC"}, @{term "clock_simAbs X"} decomposes into these
 two functions:
 
 \<close>
 
 definition
   agent_abs :: "'a \<Rightarrow> 's Trace \<Rightarrow> 's set"
 where
   "agent_abs a t \<equiv>
      { tLast t' |t'. t' \<in> Clock.jkbpC \<and> clock_jview a t' = clock_jview a t}"
 
 definition
   common_abs :: "'s Trace \<Rightarrow> 's set"
 where
   "common_abs t \<equiv> tLast ` Clock.jkbpCn (tLength t)"
 (*<*)
 
 lemma aec_refl[intro, simp]:
   "t \<in> Clock.jkbpC \<Longrightarrow> tLast t \<in> agent_abs a t"
   unfolding agent_abs_def by auto
 
 lemma aec_cec_subset:
   assumes tC: "t \<in> Clock.jkbpC"
       and aec: "ODList.toSet aec = agent_abs a t"
       and cec: "ODList.toSet cec = common_abs t"
   shows "x \<in> ODList.toSet aec \<Longrightarrow> x \<in> ODList.toSet cec"
   using assms
   unfolding agent_abs_def common_abs_def
   by fastforce
 
 lemma clock_simAbs_refl:
   assumes tC: "t \<in> Clock.jkbpC"
       and ec: "clock_simAbs ec = Clock.sim_equiv_class a t"
   shows "clock_sim t \<in> clock_simAbs ec"
   using assms by simp
 
 lemma common_abs:
   assumes tC: "t \<in> Clock.jkbpC"
   assumes ec: "clock_simAbs ec = Clock.sim_equiv_class a t"
   shows "ODList.toSet (fst ec) = common_abs t"
   using tC clock_simAbs_refl[OF tC ec]
   unfolding clock_sim_def clock_simAbs_def common_abs_def
   by (auto simp: ODList.toSet_def[symmetric])
 
 lemma agent_abs:
   assumes tC: "t \<in> Clock.jkbpC"
   assumes ec: "clock_simAbs ec = Clock.sim_equiv_class a t"
   shows "ODList.toSet (snd ec) = agent_abs a t"
   using assms
   unfolding clock_sim_def clock_simAbs_def agent_abs_def
   apply auto
   apply (subgoal_tac "(ODList.toSet (fst ec), x) \<in> {(ODList.toSet (fst ec), s) |s. s \<in> ODList.toSet (snd ec)}")
   apply auto (* FIXME filthy *)
   done
 
 (*>*)
 text\<open>
 
 This representation is canonical on the domain of interest (though not
 in general):
 
 \<close>
 
 lemma clock_simAbs_inj_on:
   "inj_on clock_simAbs { x . clock_simAbs x \<in> Clock.jkbpSEC }"
 (*<*)
 proof(rule inj_onI)
   fix x y
   assume x: "x \<in> { x . clock_simAbs x \<in> Clock.jkbpSEC }"
      and y: "y \<in> { x . clock_simAbs x \<in> Clock.jkbpSEC }"
      and xy: "clock_simAbs x = clock_simAbs y"
   from x obtain a t
     where tC: "t \<in> Clock.jkbpC"
       and ec: "clock_simAbs x = Clock.sim_equiv_class a t"
     by auto
   from common_abs[OF tC ec] common_abs[OF tC trans[OF xy[symmetric] ec], symmetric]
   have "fst x = fst y" by (blast intro: injD[OF toSet_inj])
   moreover
   from agent_abs[OF tC ec] agent_abs[OF tC trans[OF xy[symmetric] ec], symmetric]
   have "snd x = snd y" by (blast intro: injD[OF toSet_inj])
   ultimately show "x = y" by (simp add: prod_eqI)
 qed
 (*>*)
 text\<open>
 
 We could further compress this representation by labelling each
 element of the set of states reachable at time $n$ with a bit to
 indicate whether the agent considers that state possible.  Note,
 however, that the representation would be non-canonical: if \<open>(s, True)\<close> is in the representation, indicating that the agent
 considers \<open>s\<close> possible, then \<open>(s, False)\<close> may or may
 not be. The associated abstraction function is not injective and hence
 would obfuscate the following. Repairing this would entail introducing
 a new type, which would again complicate this development.
 
 
 
 The following lemmas make use of this Kripke structure, constructed
 from the set of final states of a temporal slice @{term "X"}:
 
 \<close>
 
 definition
   clock_repRels :: "'a \<Rightarrow> ('s \<times> 's) set"
 where
   "clock_repRels \<equiv> \<lambda>a. { (s, s'). envObs a s = envObs a s' }"
 
 abbreviation
   clock_repMC :: "'s set \<Rightarrow> ('a, 'p, 's) KripkeStructure"
 where
   "clock_repMC \<equiv> \<lambda>X. mkKripke X clock_repRels envVal"
 (*<*)
 
 lemma clock_repMC_kripke[intro, simp]: "kripke (clock_repMC X)"
   by (rule kripkeI) simp
 
 lemma clock_repMC_S5n[intro, simp]: "S5n (clock_repMC X)"
   unfolding clock_repRels_def
   by (intro S5nI equivI refl_onI symI transI) auto
 
 (*>*)
 text\<open>
 
 We can show that this Kripke structure retains sufficient information
 from @{term "Clock.MCS"} by showing simulation. This is eased by
 introducing an intermediary structure that focusses on a particular
 trace:
 
 \<close>
 
 abbreviation
   clock_jkbpCSt :: "'b Trace \<Rightarrow> 's clock_simWorlds set"
 where
   "clock_jkbpCSt t \<equiv> clock_sim ` Clock.jkbpCn (tLength t)"
 
 abbreviation
   clock_simMCt :: "'b Trace \<Rightarrow> ('a, 'p, 's clock_simWorlds) KripkeStructure"
 where
   "clock_simMCt t \<equiv> mkKripke (clock_jkbpCSt t) clock_simRels clock_simVal"
 
 definition clock_repSim :: "'s clock_simWorlds \<Rightarrow> 's" where
   "clock_repSim \<equiv> snd"
 (*<*)
 
 lemma jkbpCSt_jkbpCS_subset:
   "clock_jkbpCSt t \<subseteq> clock_sim ` Clock.jkbpC"
   by auto
 
 lemma jkbpCSt_refl[iff]:
   "t \<in> Clock.jkbpC \<Longrightarrow> clock_sim t \<in> clock_jkbpCSt t"
   by blast
 
 lemma fst_clock_sim[iff]:
   "t \<in> Clock.jkbpC \<Longrightarrow> fst (clock_sim t) = tLast ` Clock.jkbpCn (tLength t)"
   by (simp add: clock_sim_def)
 
 lemma clock_repSim_simps[simp]:
   "clock_repSim ` clock_sim ` T = tLast ` T"
   "clock_repSim (clock_sim t) = tLast t"
   unfolding clock_repSim_def clock_sim_def
   by (auto intro!: image_eqI)
 
 (*>*)
 text\<open>\<close>
 
 lemma clock_repSim:
   assumes tC: "t \<in> Clock.jkbpC"
   shows "sim (clock_simMCt t)
              ((clock_repMC \<circ> fst) (clock_sim t))
              clock_repSim"
 (*<*) (is "sim ?M ?M' ?f")
 proof
   show "sim_range ?M ?M' ?f"
   proof
     show "worlds ?M' = ?f ` worlds ?M"
       unfolding clock_sim_def clock_repSim_def by force
   next
     fix a
     show "relations ?M' a \<subseteq> worlds ?M' \<times> worlds ?M'"
       by (simp add: clock_sim_def clock_repSim_def)
   qed
 next
   show "sim_val ?M ?M' ?f"
     by (rule, simp add: clock_sim_def clock_simVal_def clock_repSim_def split: prod.split)
 next
   show "sim_f ?M ?M' ?f"
     apply rule
     unfolding clock_repRels_def clock_repSim_def clock_simRels_def
     apply (auto iff: clock_sim_def)
     done
 next
   show "sim_r ?M ?M' ?f"
     apply rule
     unfolding clock_repRels_def clock_repSim_def clock_simRels_def clock_sim_def
     apply clarsimp
     done
 qed
 
 (*>*)
 text\<open>
 
 The following sections show how we satisfy the remaining requirements
 of the \<open>Algorithm\<close> locale of
 Figure~\ref{fig:kbps-alg-alg-locale}. Where the proof is routine, we
 simply present the lemma without proof or comment.
 
 Due to a limitation in the code generator in the present version of
 Isabelle (2011), we need to define the equations we wish to execute
 outside of a locale; the syntax \<open>(in -)\<close> achieves this by
 making definitons at the theory top-level. We then define (but elide)
 locale-local abbreviations that supply the locale-bound variables to
 these definitions.
 
 \<close>
 
 (* **************************************** *)
 
 subsubsection\<open>Initial states\<close>
 
 text\<open>
 
 The initial states of the automaton for an agent is simply @{term
 "envInit"} paired with the partition of @{term "envInit"} under the
 agent's observation.
 
 \<close>
 
 definition (in -)
   clock_simInit :: "('s::linorder) list \<Rightarrow> ('a \<Rightarrow> 's \<Rightarrow> 'obs)
                 \<Rightarrow> 'a \<Rightarrow> 'obs \<Rightarrow> 's clock_simWorldsRep"
 where
   "clock_simInit envInit envObs \<equiv> \<lambda>a iobs.
     let cec = ODList.fromList envInit
      in (cec, ODList.filter (\<lambda>s. envObs a s = iobs) cec)"
 (*<*)
 
 abbreviation
   clock_simInit :: "'a \<Rightarrow> 'obs \<Rightarrow> 's clock_simWorldsRep"
 where
   "clock_simInit \<equiv> ClockView.clock_simInit envInit envObs"
 
 (*>*)
 text\<open>\<close>
 
 lemma clock_simInit:
   assumes "iobs \<in> envObs a ` set envInit"
   shows "clock_simAbs (clock_simInit a iobs)
        = clock_sim ` { t' \<in> Clock.jkbpC.
                        clock_jview a t' = clock_jviewInit a iobs }"
 (*<*)
   using assms
   unfolding clock_simInit_def clock_simAbs_def clock_sim_def [abs_def] Let_def
   apply clarsimp
   apply rule
    apply clarsimp
    apply (rule_tac x="tInit s" in image_eqI)
     apply (auto simp: Set.image_def Clock.jviewInit)[2]
   apply clarsimp
   apply (case_tac xa)
    apply clarsimp
    apply rule
     apply rule
      apply clarsimp
     apply clarsimp
     apply (rule_tac x="tInit xa" in image_eqI)
     apply (auto intro!: image_eqI simp: Clock.jviewInit)
   done
 (*>*)
 
 (* **************************************** *)
 
 subsubsection\<open>Simulated observations\<close>
 
 text\<open>
 
 Agent @{term "a"} will make the same observation at any of the worlds
 that it considers possible, so we choose the first one in the list:
 
 \<close>
 
 definition (in -)
   clock_simObs :: "('a \<Rightarrow> ('s :: linorder) \<Rightarrow> 'obs)
                 \<Rightarrow> 'a \<Rightarrow> 's clock_simWorldsRep \<Rightarrow> 'obs"
 where
   "clock_simObs envObs \<equiv> \<lambda>a. envObs a \<circ> ODList.hd \<circ> snd"
 (*<*)
 
 abbreviation
   clock_simObs :: "'a \<Rightarrow> 's clock_simWorldsRep \<Rightarrow> 'obs"
 where
   "clock_simObs \<equiv> ClockView.clock_simObs envObs"
 
 (*>*)
 text\<open>\<close>
 
 lemma clock_simObs:
   assumes tC: "t \<in> Clock.jkbpC"
       and ec: "clock_simAbs ec = Clock.sim_equiv_class a t"
   shows "clock_simObs a ec = envObs a (tLast t)"
 (*<*)
 proof -
   have A: "\<forall>s \<in> set (toList (snd ec)). envObs a s = envObs a (tLast t)"
     using agent_abs[OF tC ec]
     by (clarsimp simp: agent_abs_def toSet_def)
   have B: "tLast t \<in> set (toList (snd ec))"
     using clock_simAbs_refl[OF assms]
     unfolding clock_simAbs_def clock_sim_def
     by (simp add: toSet_def snd_def)
   show ?thesis
     unfolding clock_simObs_def by (simp add: list_choose_hd[OF A B] ODList.hd_def)
 qed
 (*>*)
 
 (* **************************************** *)
 
 subsubsection\<open>Evaluation\<close>
 
 text\<open>
 
 \label{sec:kbps-theory-clock-view-eval}
 
 We define our \<open>eval\<close> function in terms of @{term "evalS"},
 which implements boolean logic over @{typ "'s odlist"} in the usual
 way -- see \S\ref{sec:kbps-spr-single-agent-eval} for the relevant
 clauses. It requires three functions specific to the representation:
 one each for propositions, knowledge and common knowledge.
 
 Propositions define subsets of the worlds considered possible:
 
 \<close>
 
 abbreviation (in -)
   clock_evalProp :: "(('s::linorder) \<Rightarrow> 'p \<Rightarrow> bool)
                   \<Rightarrow> 's odlist \<Rightarrow> 'p \<Rightarrow> 's odlist"
 where
   "clock_evalProp envVal \<equiv> \<lambda>X p. ODList.filter (\<lambda>s. envVal s p) X"
 
 text\<open>
 
 The knowledge relation computes the subset of the
 commonly-held-possible worlds \<open>cec\<close> that agent @{term "a"}
 considers possible at world @{term "s"}:
 
 \<close>
 
 definition (in -)
   clock_knowledge :: "('a \<Rightarrow> ('s :: linorder) \<Rightarrow> 'obs) \<Rightarrow> 's odlist
                   \<Rightarrow> 'a \<Rightarrow> 's \<Rightarrow> 's odlist"
 where
   "clock_knowledge envObs cec \<equiv> \<lambda>a s.
      ODList.filter (\<lambda>s'. envObs a s = envObs a s') cec"
 
 text\<open>
 
 
 Similarly the common knowledge operation computes the transitive
 closure of the union of the knowledge relations for the agents \<open>as\<close>:
 
 \<close>
 
 definition (in -)
   clock_commonKnowledge :: "('a \<Rightarrow> ('s :: linorder) \<Rightarrow> 'obs) \<Rightarrow> 's odlist
            \<Rightarrow> 'a list \<Rightarrow> 's \<Rightarrow> 's odlist"
 where
   "clock_commonKnowledge envObs cec \<equiv> \<lambda>as s.
      let r = \<lambda>a. ODList.fromList [ (s', s'') . s' \<leftarrow> toList cec, s'' \<leftarrow> toList cec,
                                    envObs a s' = envObs a s'' ];
          R = toList (ODList.big_union r as)
       in ODList.fromList (memo_list_trancl R s)"
 
 text\<open>
 
 The function \<open>memo_list_trancl\<close> comes from the executable
 transitive closure theory of \citep{AFP:TRANCL}.
 
 The evaluation function evaluates a subjective knowledge formula on
 the representation of an equivalence class:
 
 \<close>
 
 definition (in -)
   eval :: "(('s :: linorder) \<Rightarrow> 'p \<Rightarrow> bool)
         \<Rightarrow> ('a \<Rightarrow> 's \<Rightarrow> 'obs)
         \<Rightarrow> 's clock_simWorldsRep \<Rightarrow> ('a, 'p) Kform \<Rightarrow> bool"
 where
   "eval envVal envObs \<equiv> \<lambda>(cec, aec). evalS (clock_evalProp envVal)
                                       (clock_knowledge envObs cec)
                                       (clock_commonKnowledge envObs cec)
                                       aec"
 
 text\<open>
 
 This function corresponds with the standard semantics:
 
 \<close>
 (*<*)
 
 lemma clock_coEC_relation_image:
   "s \<in> ODList.toSet Y
     \<Longrightarrow> ODList.toSet (clock_knowledge envObs Y a s) = relations (clock_repMC (ODList.toSet Y)) a `` {s}"
   unfolding clock_knowledge_def clock_repRels_def Image_def
   by auto
 
 lemma clock_commonKnowledge_relation_image_aux:
   "(\<Union>x\<in>set as. \<Union>a\<in>ODList.toSet Y. \<Union>aa\<in>ODList.toSet Y \<inter> {s''. envObs x a = envObs x s''}. {(a, aa)})
  = ((\<Union>a\<in>set as. {(s, s'). envObs a s = envObs a s'}) \<inter> ODList.toSet Y \<times> ODList.toSet Y)"
   by auto
 
 lemma clock_commonKnowledge_relation_image:
   "s \<in> ODList.toSet Y
     \<Longrightarrow> ODList.toSet (clock_commonKnowledge envObs Y as s) = (\<Union>a \<in> set as. relations (clock_repMC (ODList.toSet Y)) a)\<^sup>+ `` {s}"
   unfolding clock_commonKnowledge_def clock_repRels_def Let_def
   apply (simp add: memo_list_trancl toSet_def[symmetric] Image_def clock_commonKnowledge_relation_image_aux)
   done
 
 lemma eval_rec_models:
   assumes XY: "ODList.toSet X \<subseteq> ODList.toSet Y"
       and s: "s \<in> ODList.toSet X"
   shows "s \<in> ODList.toSet (eval_rec (clock_evalProp envVal) (clock_knowledge envObs Y) (clock_commonKnowledge envObs Y) X \<phi>)
      \<longleftrightarrow> clock_repMC (ODList.toSet Y), s \<Turnstile> \<phi>"
 using XY s
 proof(induct \<phi> arbitrary: X s)
   case (Kknows a' \<phi> X s)
   from \<open>s \<in> ODList.toSet X\<close> clock_coEC_relation_image[OF subsetD[OF Kknows(2) Kknows(3)], where a=a']
   show ?case
     apply simp
     apply rule
      apply (drule arg_cong[where f="ODList.toSet"])
      apply (clarsimp simp: odlist_all_iff)
      apply (cut_tac s3="w'" and X3="clock_knowledge envObs Y a' s" in Kknows.hyps)
       using Kknows(2) Kknows(3)
       apply (auto simp add: S5n_rels_closed[OF clock_repMC_S5n])[3]
 
     apply (clarsimp simp: toSet_eq_iff odlist_all_iff)
     apply (subst Kknows.hyps)
       using Kknows(2) Kknows(3)
       apply (auto simp add: S5n_rels_closed[OF clock_repMC_S5n])
     done
 next
   case (Kcknows as \<phi> X s)
   show ?case
   proof(cases "as = Nil")
     case True with \<open>s \<in> ODList.toSet X\<close> show ?thesis by clarsimp
   next
     case False
     with \<open>s \<in> ODList.toSet X\<close> clock_commonKnowledge_relation_image[OF subsetD[OF Kcknows(2) Kcknows(3)], where as=as]
     show ?thesis
       apply simp
       apply rule
        apply (drule arg_cong[where f="ODList.toSet"])
        apply (clarsimp simp: odlist_all_iff)
        apply (cut_tac s3="w'" and X3="clock_commonKnowledge envObs Y as s" in Kcknows.hyps)
         using Kcknows(2) Kcknows(3)
         apply (auto simp add: S5n_rels_closed[OF clock_repMC_S5n])[3]
         apply (subst (asm) trancl_unfold) back back back
         apply auto[1] (* FIXME disgusting *)
 
       apply (clarsimp simp: toSet_eq_iff odlist_all_iff)
       apply (subst Kcknows.hyps)
        using Kcknows(2) Kcknows(3)
        apply (auto simp add: S5n_rels_closed[OF clock_repMC_S5n])
         apply (subst (asm) trancl_unfold) back back back
         apply auto[1] (* FIXME disgusting *)
 
       done
   qed
 qed simp_all
 
 lemma trc_aux:
   assumes tC: "t \<in> Clock.jkbpC"
       and aec: "ODList.toSet aec = agent_abs a t"
       and cec: "ODList.toSet cec = common_abs t"
   shows "ODList.toSet (big_union (clock_commonKnowledge envObs cec as) (toList aec)) \<subseteq> ODList.toSet cec"
   apply (clarsimp simp: toSet_def[symmetric])
   apply (subst (asm) clock_commonKnowledge_relation_image)
    apply (erule aec_cec_subset[OF tC aec cec])
   apply (subst (asm) trancl_unfold)
   using assms
   apply (auto simp: agent_abs_def)
   done
 
 lemma clock_repMC_aec:
   assumes tC: "t \<in> Clock.jkbpC"
       and aec: "ODList.toSet aec = agent_abs a t"
       and cec: "ODList.toSet cec = common_abs t"
       and x: "x \<in> ODList.toSet aec"
       and xy: "(x, y) \<in> relations (clock_repMC (ODList.toSet cec)) a"
   shows "y \<in> ODList.toSet aec"
   using assms
   unfolding clock_repRels_def agent_abs_def common_abs_def
   by auto
 
 lemma clock_repMC_cec:
   assumes tC: "t \<in> Clock.jkbpC"
       and aec: "ODList.toSet aec = agent_abs a t"
       and cec: "ODList.toSet cec = common_abs t"
       and x: "x \<in> ODList.toSet aec"
       and y: "y \<in> ODList.toSet aec"
   shows "(x, y) \<in> relations (clock_repMC (ODList.toSet cec)) a"
   using assms
   unfolding clock_repRels_def agent_abs_def common_abs_def
   by auto
 
 lemma evalS_models:
   assumes tC: "t \<in> Clock.jkbpC"
       and aec: "ODList.toSet aec = agent_abs a t"
       and cec: "ODList.toSet cec = common_abs t"
       and subj_phi: "subjective a \<phi>"
       and s: "s \<in> ODList.toSet aec"
   shows "evalS (clock_evalProp envVal) (clock_knowledge envObs cec) (clock_commonKnowledge envObs cec) aec \<phi>
      \<longleftrightarrow> clock_repMC (ODList.toSet cec), s \<Turnstile> \<phi>" (is "?lhs \<phi> = ?rhs \<phi>")
 using subj_phi s aec cec
 proof(induct \<phi> rule: subjective.induct[case_names Kprop Knot Kand Kknows Kcknows])
   case (Kknows a a' \<psi>) show ?case
     apply (clarsimp simp: toSet_eq_iff)
     apply rule
      apply clarsimp
      apply (subgoal_tac "w' \<in> ODList.toSet aec")
      apply (drule_tac c="w'" in subsetD)
        apply assumption
       apply (simp add: eval_rec_models[OF subsetI[OF aec_cec_subset[OF tC aec cec]]])
      apply (rule clock_repMC_aec[OF tC Kknows(3) Kknows(4), rotated, where x=s])
        using Kknows
        apply simp
       using Kknows
       apply simp
 
     apply clarsimp
     apply (simp add: eval_rec_models[OF subsetI[OF aec_cec_subset[OF tC aec cec]]])
     using tC Kknows
     apply (clarsimp simp: agent_abs_def)
     apply (erule (1) ballE)
     using Kknows
     apply (cut_tac x="tLast t'" and y="tLast t'a" in clock_repMC_cec[OF tC Kknows(3) Kknows(4)])
       unfolding clock_repRels_def
       apply auto
     done
 next
   case (Kcknows a as \<psi>)
   have "?lhs (Kcknows as \<psi>)
       = (\<forall>y\<in>ODList.toSet aec.
            \<forall>x\<in>(\<Union>a\<in>set as. relations (clock_repMC (ODList.toSet cec)) a)\<^sup>+ `` {y}.
               x \<in> ODList.toSet (eval_rec (clock_evalProp envVal) (clock_knowledge envObs cec) (clock_commonKnowledge envObs cec)
                        (big_union (clock_commonKnowledge envObs cec as) (toList aec)) \<psi>))"
     (* FIXME dreaming of a cong rule here. *)
     using toSet_def[symmetric]
     apply (clarsimp simp: toSet_eq_iff toSet_def[symmetric] subset_eq)
     apply (rule ball_cong[OF refl])
     apply (rule ball_cong)
     apply (subst clock_commonKnowledge_relation_image[OF aec_cec_subset[OF tC Kcknows(3) Kcknows(4)]])
     apply simp_all
     done
   also have "... = (\<forall>s\<in>ODList.toSet aec. clock_repMC (ODList.toSet cec), s \<Turnstile> Kcknows as \<psi>)"
     apply (rule ball_cong[OF refl])
     apply simp
     apply (rule ball_cong[OF refl])
     apply (subst eval_rec_models[OF trc_aux[OF tC Kcknows(3) Kcknows(4), where as=as], symmetric])
      apply (simp add: toSet_def[symmetric])
      apply (rule_tac x=y in bexI)
       apply (subst clock_commonKnowledge_relation_image[OF aec_cec_subset[OF tC Kcknows(3) Kcknows(4)]])
-      apply assumption
-     apply simp
-     apply (rule refl)
+       apply simp_all
     done
   also have "... = clock_repMC (ODList.toSet cec), s \<Turnstile> Kknows a (Kcknows as \<psi>)"
     using clock_repMC_aec[OF tC Kcknows(3) Kcknows(4) Kcknows(2)]
           clock_repMC_cec[OF tC Kcknows(3) Kcknows(4) Kcknows(2)]
     by (auto cong: ball_cong)
   also have "... = clock_repMC (ODList.toSet cec), s \<Turnstile> Kcknows as \<psi>"
     apply (rule S5n_common_knowledge_fixed_point_simpler[symmetric])
     using Kcknows
     apply (auto intro: aec_cec_subset[OF tC Kcknows(3) Kcknows(4) Kcknows(2)])
     done
   finally show ?case .
 qed simp_all
 
 (*>*)
 lemma eval_models:
   assumes tC: "t \<in> Clock.jkbpC"
       and aec: "ODList.toSet aec = agent_abs a t"
       and cec: "ODList.toSet cec = common_abs t"
       and subj_phi: "subjective a \<phi>"
       and s: "s \<in> ODList.toSet aec"
   shows "eval envVal envObs (cec, aec) \<phi>
      \<longleftrightarrow> clock_repMC (ODList.toSet cec), s \<Turnstile> \<phi>"
 (*<*)
   unfolding eval_def
   using evalS_models[OF tC aec cec subj_phi s]
   apply (simp add: Let_def)
   done
 
 (*>*)
 
 (* **************************************** *)
 
 subsubsection\<open>Simulated actions\<close>
 
 text\<open>
 
 From a common equivalence class and a subjective equivalence class for
 agent @{term "a"}, we can compute the actions enabled for @{term "a"}:
 
 \<close>
 
 definition (in -)
   clock_simAction :: "('a, 'p, 'aAct) JKBP \<Rightarrow> (('s :: linorder) \<Rightarrow> 'p \<Rightarrow> bool)
                   \<Rightarrow> ('a \<Rightarrow> 's \<Rightarrow> 'obs)
                   \<Rightarrow> 'a \<Rightarrow> 's clock_simWorldsRep \<Rightarrow> 'aAct list"
 where
   "clock_simAction jkbp envVal envObs \<equiv> \<lambda>a (Y, X).
      [ action gc. gc \<leftarrow> jkbp a, eval envVal envObs (Y, X) (guard gc) ]"
 (*<*)
 
 abbreviation
   clock_simAction :: "'a \<Rightarrow> 's clock_simWorldsRep \<Rightarrow> 'aAct list"
 where
   "clock_simAction \<equiv> ClockView.clock_simAction jkbp envVal envObs"
 
 (*>*)
 text\<open>
 
 Using the above result about evaluation, we can relate \<open>clock_simAction\<close> to @{term "jAction"}. Firstly, \<open>clock_simAction\<close> behaves the same as @{term "jAction"} using the
 @{term "clock_repMC"} structure:
 
 \<close>
 
 lemma clock_simAction_jAction:
   assumes tC: "t \<in> Clock.jkbpC"
       and aec: "ODList.toSet aec = agent_abs a t"
       and cec: "ODList.toSet cec = common_abs t"
   shows "set (clock_simAction a (cec, aec))
        = set (jAction (clock_repMC (ODList.toSet cec)) (tLast t) a)"
 (*<*)
   unfolding clock_simAction_def jAction_def
   apply clarsimp
   apply rule
    apply clarsimp
    apply (rule_tac x=xa in bexI)
     apply simp
    apply clarsimp
    apply (subst eval_models[OF tC aec cec, symmetric])
      using tC aec cec subj
      apply simp_all
   apply clarsimp
   apply (rule_tac x=xa in bexI)
    apply (rule refl)
   apply clarsimp
   apply (subst eval_models[OF tC aec cec])
     using tC aec cec subj
     apply simp_all
   done
 
 lemma clock_submodel_aux:
   assumes tC: "t \<in> Clock.jkbpC"
       and s: "s \<in> worlds (clock_simMCt t)"
   shows "gen_model Clock.MCS s = gen_model (clock_simMCt t) s"
 proof(rule gen_model_subset[where T="clock_jkbpCSt t"])
   fix a
   let ?X = "clock_sim ` Clock.jkbpCn (tLength t)"
   show "relations Clock.MCS a \<inter> ?X \<times> ?X
       = relations (clock_simMCt t) a \<inter> ?X \<times> ?X"
     by (simp add: Int_ac Int_absorb1
                   relation_mono[OF jkbpCSt_jkbpCS_subset jkbpCSt_jkbpCS_subset])
 next
   let ?X = "clock_sim ` Clock.jkbpCn (tLength t)"
   from s show "(\<Union>a. relations (clock_simMCt t) a)\<^sup>* `` {s} \<subseteq> ?X"
     apply (clarsimp simp del: mkKripke_simps)
     apply (erule kripke_rels_trc_worlds)
     apply auto
     done
 next
   let ?Y = "Clock.jkbpCn (tLength t)"
   let ?X = "clock_sim ` ?Y"
   from s obtain t'
     where st': "s = clock_sim t'"
       and t'C: "t' \<in> Clock.jkbpC"
       and t'O: "tLength t = tLength t'"
     by fastforce
   { fix t''
     assume tt': "(t', t'') \<in> (\<Union>a. relations Clock.MC a)\<^sup>*"
     from t'C tt' have t''C: "t'' \<in> Clock.jkbpC"
       by - (erule kripke_rels_trc_worlds, simp_all)
     from t'O tt' have t''O: "tLength t = tLength t''"
       by (simp add: Clock.sync_tLength_eq_trc)
     from t''C t''O have "t'' \<in> ?Y" by fastforce }
   hence "(\<Union>a. relations Clock.MC a)\<^sup>* `` {t'} \<subseteq> ?Y"
     by clarsimp
   hence "clock_sim ` ((\<Union>a. relations Clock.MC a)\<^sup>* `` {t'}) \<subseteq> ?X"
     by (rule image_mono)
   with st' t'C
   show "(\<Union>a. relations Clock.MCS a)\<^sup>* `` {s} \<subseteq> ?X"
     using sim_trc_commute[OF Clock.mkM_kripke clock_sim, where t=t'] by simp
 qed (insert s, auto)
 
 (*>*)
 text\<open>
 
 We can connect the agent's choice of actions on the \<open>clock_repMC\<close> structure to those on the \<open>Clock.MC\<close>
 structure using our earlier results about actions being preserved by
 generated models and simulations.
 
 \<close>
 
 lemma clock_simAction':
   assumes tC: "t \<in> Clock.jkbpC"
   assumes aec: "ODList.toSet aec = agent_abs a t"
   assumes cec: "ODList.toSet cec = common_abs t"
   shows "set (clock_simAction a (cec, aec)) = set (jAction Clock.MC t a)"
 (*<*) (is "?lhs = ?rhs")
 proof -
   from tC aec cec
   have "?lhs = set (jAction (clock_repMC (ODList.toSet cec)) (tLast t) a)"
     by (rule clock_simAction_jAction)
   also from tC aec cec
   have "... = set (jAction (clock_simMCt t) (clock_sim t) a)"
     by (simp add: simulation_jAction_eq[OF _ clock_repSim] common_abs_def)
   also from tC
   have "... = set (jAction Clock.MCS (clock_sim t) a)"
     using gen_model_jAction_eq[OF clock_submodel_aux[OF tC, where s="clock_sim t"], where w'="clock_sim t"]
           gen_model_world_refl[where w="clock_sim t" and M="clock_simMCt t"]
     by simp
   also from tC have "... = set (jAction Clock.MC t a)"
     by (simp add: simulation_jAction_eq[OF _ clock_sim])
   finally show ?thesis .
 qed
 
 (*>*)
 text\<open>
 
 The @{term "Algorithm"} locale requires a specialisation of this
 lemma:
 
 \<close>
 
 lemma clock_simAction:
   assumes tC: "t \<in> Clock.jkbpC"
   assumes ec: "clock_simAbs ec = Clock.sim_equiv_class a t"
   shows "set (clock_simAction a ec) = set (jAction Clock.MC t a)"
 (*<*)
   using assms clock_simAction'[OF tC, where cec="fst ec" and aec="snd ec"]
   apply (simp add: common_abs agent_abs)
   done
 (*>*)
 
 (* **************************************** *)
 
 subsubsection\<open>Simulated transitions\<close>
 
 text\<open>
 
 We need to determine the image of the set of commonly-held-possible
 states under the transition function, and also for the agent's
 subjective equivalence class. We do this with the \<open>clock_trans\<close> function:
 
 \<close>
 
 definition (in -)
   clock_trans :: "('a :: linorder) odlist \<Rightarrow> ('a, 'p, 'aAct) JKBP
               \<Rightarrow> (('s :: linorder) \<Rightarrow> 'eAct list)
               \<Rightarrow> ('eAct \<Rightarrow> ('a \<Rightarrow> 'aAct) \<Rightarrow> 's \<Rightarrow> 's)
               \<Rightarrow> ('s \<Rightarrow> 'p \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 's \<Rightarrow> 'obs)
               \<Rightarrow> 's odlist \<Rightarrow> 's odlist \<Rightarrow> 's odlist"
 where
   "clock_trans agents jkbp envAction envTrans envVal envObs \<equiv> \<lambda>cec X.
      ODList.fromList (concat
        [ [ envTrans eact aact s .
                      eact \<leftarrow> envAction s,
                      aact \<leftarrow> listToFuns (\<lambda>a. clock_simAction jkbp envVal envObs a
                                         (cec, clock_knowledge envObs cec a s))
                                         (toList agents) ] .
                    s \<leftarrow> toList X ])"
 (*<*)
 
 abbreviation
   clock_trans :: "'s odlist \<Rightarrow> 's odlist \<Rightarrow> 's odlist"
 where
   "clock_trans \<equiv> ClockView.clock_trans agents jkbp envAction envTrans envVal envObs"
 
 lemma clock_trans_aux:
   assumes t'C: "t' \<in> Clock.jkbpC"
       and ec: "clock_simAbs ec = Clock.sim_equiv_class a' t'"
       and tC: "t \<in> Clock.jkbpCn (tLength t')"
       and eact: "eact \<in> set (envAction (tLast t))"
   shows "(aact \<in> set (listToFuns (\<lambda>a. clock_simAction a (fst ec, clock_knowledge envObs (fst ec) a (tLast t)))
                             (toList agents)))
      \<longleftrightarrow> (\<forall>a. aact a \<in> set (jAction (Clock.MCn (tLength t')) t a))"
   using assms
   apply -
   apply (frule Clock.jkbpCn_jkbpC_inc)
   apply (clarsimp simp: listToFuns_ext[OF agents[unfolded toSet_def]])
   apply (subst clock_simAction')
      apply (erule Clock.jkbpCn_jkbpC_inc)
     apply (subst clock_coEC_relation_image)
      apply (simp add: common_abs common_abs_def toSet_def[symmetric])
     apply (fastforce simp: common_abs agent_abs_def common_abs_def clock_repRels_def)
    apply (simp add: common_abs common_abs_def)
   apply (simp add: Clock.jkbpC_jkbpCn_jAction_eq)
   done
 
 (*>*)
 text\<open>
 
 The function @{term "listToFuns"} exhibits the isomorphism between @{typ
 "('a \<times> 'b list) list"} and @{typ "('a \<Rightarrow> 'b) list"} for finite types
 @{typ "'a"}.
 
 We can show that the transition function works for both the
 commonly-held set of states and the agent subjective one. The proofs
 are  straightforward.
 
 \<close>
 
 lemma clock_trans_common:
   assumes tC: "t \<in> Clock.jkbpC"
   assumes ec: "clock_simAbs ec = Clock.sim_equiv_class a t"
   shows "ODList.toSet (clock_trans (fst ec) (fst ec))
        = { s |t' s. t' \<leadsto> s \<in> Clock.jkbpC \<and> tLength t' = tLength t }"
 (*<*) (is "?lhs = ?rhs")
 proof
   show "?lhs \<subseteq> ?rhs"
     unfolding clock_trans_def
     apply (clarsimp simp: toSet_def[symmetric] common_abs[OF assms] common_abs_def)
     apply (rule_tac x=xa in exI)
     apply clarsimp
     apply (rule Clock.jkbpCn_jkbpC_inc[where n="Suc (tLength t)"])
     apply (auto simp: Let_def iff: clock_trans_aux[OF tC ec])
     done
 next
   show "?rhs \<subseteq> ?lhs"
     unfolding clock_trans_def
     apply (clarsimp simp: toSet_def[symmetric] common_abs[OF assms] common_abs_def)
     apply (drule Clock.jkbpC_tLength_inv[where n="Suc (tLength t)"])
     apply (auto simp: Let_def iff: clock_trans_aux[OF tC ec])
     done
 qed
 
 (*>*)
 text\<open>\<close>
 
 lemma clock_trans_agent:
   assumes tC: "t \<in> Clock.jkbpC"
   assumes ec: "clock_simAbs ec = Clock.sim_equiv_class a t"
   shows "ODList.toSet (clock_trans (fst ec) (snd ec))
        = { s |t' s. t' \<leadsto> s \<in> Clock.jkbpC \<and> clock_jview a t' = clock_jview a t }"
 (*<*) (is "?lhs = ?rhs")
 proof
   show "?lhs \<subseteq> ?rhs"
     unfolding clock_trans_def
     apply (clarsimp simp: toSet_def[symmetric] common_abs[OF assms] agent_abs[OF assms] common_abs_def agent_abs_def)
     apply (rule_tac x=t' in exI)
     apply clarsimp
     apply (rule Clock.jkbpCn_jkbpC_inc[where n="Suc (tLength t)"])
     apply (auto simp: Let_def iff: clock_trans_aux[OF tC ec])
     done
 next
   show "?rhs \<subseteq> ?lhs"
     unfolding clock_trans_def
     apply (clarsimp simp: toSet_def[symmetric] common_abs[OF assms] agent_abs[OF assms] common_abs_def agent_abs_def)
     apply (drule Clock.jkbpC_tLength_inv[where n="Suc (tLength t)"])
     apply (auto simp: Let_def iff: clock_trans_aux[OF tC ec])
     done
 qed
 
 (*>*)
 text\<open>
 
 Note that the clock semantics disregards paths, so we simply compute
 the successors of the temporal slice and partition that. Similarly the
 successors of the agent's subjective equivalence class tell us what
 the set of possible observations are:
 
 \<close>
 
 definition (in -)
   clock_mkSuccs :: "('s :: linorder \<Rightarrow> 'obs) \<Rightarrow> 'obs \<Rightarrow> 's odlist
                 \<Rightarrow> 's clock_simWorldsRep"
 where
   "clock_mkSuccs envObs obs Y' \<equiv> (Y', ODList.filter (\<lambda>s. envObs s = obs) Y')"
 
 text\<open>
 
 Finally we can define our transition function on simulated states:
 
 \<close>
 
 definition (in -)
   clock_simTrans :: "('a :: linorder) odlist \<Rightarrow> ('a, 'p, 'aAct) JKBP
               \<Rightarrow> (('s :: linorder) \<Rightarrow> 'eAct list)
               \<Rightarrow> ('eAct \<Rightarrow> ('a \<Rightarrow> 'aAct) \<Rightarrow> 's \<Rightarrow> 's)
               \<Rightarrow> ('s \<Rightarrow> 'p \<Rightarrow> bool) \<Rightarrow> ('a \<Rightarrow> 's \<Rightarrow> 'obs)
               \<Rightarrow> 'a \<Rightarrow> 's clock_simWorldsRep \<Rightarrow> 's clock_simWorldsRep list"
 where
   "clock_simTrans agents jkbp envAction envTrans envVal envObs \<equiv> \<lambda>a (Y, X).
      let X' = clock_trans agents jkbp envAction envTrans envVal envObs Y X;
         Y' = clock_trans agents jkbp envAction envTrans envVal envObs Y Y
       in [ clock_mkSuccs (envObs a) obs Y' .
              obs \<leftarrow> map (envObs a) (toList X') ]"
 (*<*)
 
 abbreviation
   clock_simTrans :: "'a \<Rightarrow> 's clock_simWorldsRep \<Rightarrow> 's clock_simWorldsRep list"
 where
   "clock_simTrans \<equiv> ClockView.clock_simTrans agents jkbp envAction envTrans envVal envObs"
 
 (*>*)
 text\<open>
 
 Showing that this respects the property asked of it by the @{term
 "Algorithm"} locale is straightforward:
 
 \<close>
 
 lemma clock_simTrans:
   assumes tC: "t \<in> Clock.jkbpC"
       and ec: "clock_simAbs ec = Clock.sim_equiv_class a t"
   shows "clock_simAbs ` set (clock_simTrans a ec)
       = { Clock.sim_equiv_class a (t' \<leadsto> s)
           |t' s. t' \<leadsto> s \<in> Clock.jkbpC \<and> clock_jview a t' = clock_jview a t }"
 (*<*) (is "?lhs = ?rhs")
 proof
   note image_cong_simp [cong del]
   show "?lhs \<subseteq> ?rhs"
     unfolding clock_simTrans_def clock_mkSuccs_def
     using clock_trans_common[OF tC ec] clock_trans_agent[OF tC ec]
     apply (clarsimp simp: toSet_def[symmetric] clock_simAbs_def Let_def)
 
     apply (rule_tac x=t' in exI)
     apply (rule_tac x=xa in exI)
 
     apply (clarsimp simp: clock_sim_def)
     apply safe
 
      apply clarsimp
      apply (rule_tac x="t'a \<leadsto> s" in image_eqI)
       apply (clarsimp simp: Let_def Set.image_def)
       apply safe
         apply (rule_tac x="t'b \<leadsto> x" in exI)
         apply (clarsimp simp: Let_def Set.image_def)
         apply (drule_tac t="t'b \<leadsto> x" in Clock.jkbpC_tLength_inv[OF _ refl])
         apply (auto simp: Let_def)[1]
        apply (rule_tac x="ta" in exI)
        apply simp
        apply (rule Clock.jkbpCn_jkbpC_inc[where n="Suc (tLength t)"])
        apply (auto simp: Let_def)[3]
 
     apply (rule_tac x="tLast ta" in exI)
     apply (clarsimp simp: Let_def Set.image_def)
     apply safe
       apply (rule_tac x="taa" in exI)
       apply simp
       apply (rule Clock.jkbpCn_jkbpC_inc[where n="Suc (tLength t)"])
        apply (auto simp: Let_def)[1]
      apply (drule_tac t="t'a \<leadsto> x" in Clock.jkbpC_tLength_inv[OF _ refl])
      apply (rule_tac x="t'a \<leadsto> x" in exI)
      apply (auto simp: Let_def)[1]
     apply (drule_tac t="ta" in Clock.jkbpC_tLength_inv)
      apply blast
     apply (clarsimp simp: Let_def)
     apply (rule_tac x="ta" in exI)
     apply simp
     apply (rule Clock.jkbpCn_jkbpC_inc[where n="Suc (tLength t)"])
     apply (auto simp: Let_def)
     done
 next
   show "?rhs \<subseteq> ?lhs"
     unfolding clock_simTrans_def Let_def
     apply (cases ec)
     using clock_trans_common[OF tC ec] clock_trans_agent[OF tC ec]
     apply (clarsimp simp: toSet_def[symmetric] Set.image_def clock_simAbs_def
                 simp del: split_paired_Ex)
 
     apply (rule_tac x="clock_mkSuccs (envObs a) (envObs a s) (clock_trans aa aa)" in exI)
     apply safe
       apply auto[1]
      apply (rule_tac x="tLast x" in exI)
      apply (clarsimp simp: clock_trans_common[OF tC ec] clock_mkSuccs_def)
      apply safe
        apply (clarsimp simp: clock_sim_def simp del: Clock.jkbpCn.simps)
        apply rule
         apply (clarsimp simp: Let_def)
         apply (rule_tac x="ta" in exI)
         apply (simp add: Let_def)
         apply (rule Clock.jkbpCn_jkbpC_inc[where n="Suc (tLength t)"])
         apply (clarsimp simp: Let_def)
         apply (rule_tac x=eact in exI)
         apply (rule_tac x=aact in exI)
         apply clarsimp
        apply (clarsimp simp: Let_def Set.image_def)
        apply (drule_tac t="t'a \<leadsto> xa" in Clock.jkbpC_tLength_inv[OF _ refl])
        apply (rule_tac x="t'a \<leadsto> xa" in exI)
        apply (auto simp: Let_def)[1]
       apply (drule_tac t="x" in Clock.jkbpC_tLength_inv[OF _ refl])
       apply (simp only: Let_def Clock.jkbpCn.simps)
       apply clarify
       apply (rule_tac x="ta" in exI)
       apply simp
       apply (rule Clock.jkbpCn_jkbpC_inc[where n="Suc (tLength t)"])
       apply (auto simp: Let_def)[1]
      apply (clarsimp simp: clock_trans_common[OF tC ec] clock_mkSuccs_def)
      apply (rule_tac x="t'a \<leadsto> sa" in exI)
      apply (clarsimp simp: clock_sim_def Let_def)
      (* FIXME similar to above *)
      apply rule
       apply (clarsimp simp: Set.image_def)
       apply (rule_tac x="t'b \<leadsto> x" in exI)
       apply (drule_tac t="t'b \<leadsto> x" in Clock.jkbpC_tLength_inv[OF _ refl])
       apply (auto simp: Let_def)[1]
     apply clarsimp
     apply (rule_tac x="ta" in exI)
     apply auto
     apply (rule Clock.jkbpCn_jkbpC_inc[where n="Suc (tLength t)"])
     apply (auto simp: Let_def)
     done
 qed
 (*>*)
 
 end (* context FiniteLinorderEnvironment *)
 
 (* **************************************** *)
 
 subsubsection\<open>Maps\<close>
 
 text\<open>
 
 \label{sec:kbps-theory-clock-view-maps}
 
 As mentioned above, the canonicity of our ordered, distinct list
 representation of automaton states allows us to use them as keys in a
 digital trie; a value of type @{typ "('key, 'val) trie"} maps keys of
 type @{typ "'key list"} to values of type @{typ "'val"}.
 
 In this specific case we track automaton transitions using a two-level
 structure mapping sets of states to an association list mapping
 observations to sets of states, and for actions automaton states map
 directly to agent actions.
 
 \<close>
 
 type_synonym ('s, 'obs) clock_trans_trie
   = "('s, ('s, ('obs, 's clock_simWorldsRep) mapping) trie) trie"
 type_synonym ('s, 'aAct) clock_acts_trie = "('s, ('s, 'aAct) trie) trie"
 (*<*)
 
 definition
   trans_MapOps_lookup :: "('s :: linorder, 'obs) clock_trans_trie
                         \<Rightarrow> 's clock_simWorldsRep \<times> 'obs
                         \<rightharpoonup> 's clock_simWorldsRep"
 where
   "trans_MapOps_lookup \<equiv> \<lambda>m k.
      Option.bind (trie_odlist_lookup m (fst (fst k))) (\<lambda>m.
        (Option.bind (trie_odlist_lookup m (snd (fst k))) (\<lambda>m.
          Mapping.lookup m (snd k))))"
 
 definition
   trans_MapOps_update :: "('s :: linorder) clock_simWorldsRep \<times> 'obs \<Rightarrow> 's clock_simWorldsRep
                         \<Rightarrow> ('s :: linorder, 'obs) clock_trans_trie
                         \<Rightarrow> ('s :: linorder, 'obs) clock_trans_trie"
 where
   "trans_MapOps_update \<equiv> \<lambda>k v m.
      trie_odlist_update_with (fst (fst k)) m empty_trie (\<lambda>m.
        trie_odlist_update_with (snd (fst k)) m Mapping.empty (\<lambda>m.
           Mapping.update (snd k) v m))"
 
 definition
   trans_MapOps :: "(('s :: linorder, 'obs) clock_trans_trie,
                     's clock_simWorldsRep \<times> 'obs, 's clock_simWorldsRep) MapOps"
 where
   "trans_MapOps \<equiv>
      \<lparr> MapOps.empty = empty_trie,
        lookup = trans_MapOps_lookup,
        update = trans_MapOps_update \<rparr>"
 
 lemma (in FiniteLinorderEnvironment) trans_MapOps:
   "MapOps (\<lambda>k. (clock_simAbs (fst k), snd k)) (Clock.jkbpSEC \<times> UNIV) trans_MapOps"
 proof
   fix k show "MapOps.lookup trans_MapOps (MapOps.empty trans_MapOps) k = None"
     unfolding trans_MapOps_def trans_MapOps_lookup_def trie_odlist_lookup_def
     by (auto split: prod.split)
 next
   fix e k k' M
   assume k: "(clock_simAbs (fst k), snd k) \<in> Clock.jkbpSEC \<times> (UNIV :: 'z set)"
      and k': "(clock_simAbs (fst k'), snd k') \<in> Clock.jkbpSEC \<times> (UNIV :: 'z set)"
   show "MapOps.lookup trans_MapOps (MapOps.update trans_MapOps k e M) k'
          = (if (clock_simAbs (fst k'), snd k') = (clock_simAbs (fst k), snd k)
              then Some e else MapOps.lookup trans_MapOps M k')"
   proof(cases "(clock_simAbs (fst k'), snd k') = (clock_simAbs (fst k), snd k)")
     case True hence "k = k'"
       using inj_onD[OF clock_simAbs_inj_on] k k' by (auto iff: prod_eqI)
     thus ?thesis
       unfolding trans_MapOps_def trans_MapOps_lookup_def trans_MapOps_update_def trie_odlist_lookup_def trie_odlist_update_with_def
         by (simp add: lookup_trie_update_with lookup_update split: option.split prod.split) 
   next
     case False thus ?thesis
       unfolding trans_MapOps_def trans_MapOps_lookup_def trans_MapOps_update_def trie_odlist_lookup_def trie_odlist_update_with_def
       by (cases "fst k = fst k'")
        (auto simp add: lookup_empty lookup_update_neq prod_eq_iff lookup_trie_update_with split: option.split prod.split)
   qed
 qed
 
 (* A map for the agent actions. *)
 
 definition
   acts_MapOps_lookup :: "('s :: linorder, 'aAct) clock_acts_trie
                       \<Rightarrow> 's clock_simWorldsRep
                       \<rightharpoonup> 'aAct"
 where
   "acts_MapOps_lookup \<equiv> \<lambda>m k.
      Option.bind (trie_odlist_lookup m (fst k)) (\<lambda>m.
        (trie_odlist_lookup m (snd k)))"
 
 definition
   acts_MapOps_update :: "('s :: linorder) clock_simWorldsRep \<Rightarrow> 'aAct
                       \<Rightarrow> ('s :: linorder, 'aAct) clock_acts_trie
                       \<Rightarrow> ('s :: linorder, 'aAct) clock_acts_trie"
 where
   "acts_MapOps_update \<equiv> \<lambda>k v m.
      trie_odlist_update_with (fst k) m empty_trie (\<lambda>m.
        trie_odlist_update (snd k) v m)"
 
 definition
   acts_MapOps :: "(('s :: linorder, 'aAct) clock_acts_trie, 's clock_simWorldsRep, 'aAct) MapOps"
 where
   "acts_MapOps \<equiv>
      \<lparr> MapOps.empty = empty_trie,
        lookup = acts_MapOps_lookup,
        update = acts_MapOps_update \<rparr>"
 
 lemma (in FiniteLinorderEnvironment) acts_MapOps:
   "MapOps clock_simAbs Clock.jkbpSEC acts_MapOps"
 proof
   fix k show "MapOps.lookup acts_MapOps (MapOps.empty acts_MapOps) k = None"
     unfolding acts_MapOps_def acts_MapOps_lookup_def trie_odlist_lookup_def
     by auto
 next
   fix e k k' M
   assume k: "clock_simAbs k \<in> Clock.jkbpSEC"
      and k': "clock_simAbs k' \<in> Clock.jkbpSEC"
   show "MapOps.lookup acts_MapOps (MapOps.update acts_MapOps k e M) k'
          = (if clock_simAbs k' = clock_simAbs k
              then Some e else MapOps.lookup acts_MapOps M k')"
   proof(cases "clock_simAbs k' = clock_simAbs k")
     case True hence "k = k'"
       using inj_onD[OF clock_simAbs_inj_on] k k' by (auto iff: prod_eqI)
     thus ?thesis
       unfolding acts_MapOps_def acts_MapOps_lookup_def acts_MapOps_update_def
       by (auto simp: lookup_trie_update lookup_trie_update_with
                      trie_odlist_update_with_def trie_odlist_update_def trie_odlist_lookup_def)
   next
     case False thus ?thesis
       unfolding acts_MapOps_def acts_MapOps_lookup_def acts_MapOps_update_def
       by (auto simp: lookup_trie_update lookup_trie_update_with
                      trie_odlist_update_with_def trie_odlist_update_def trie_odlist_lookup_def
                dest: prod_eqI
               split: option.split)
   qed
 qed
 
 (*>*)
 text\<open>
 
 We define two records @{term "acts_MapOps"} and @{term "trans_MapOps"}
 satisfying the @{term "MapOps"} predicate
 (\S\ref{sec:kbps-theory-map-ops}). Discharging the obligations in the
 @{term "Algorithm"} locale is routine, leaning on the work of
 \citet{DBLP:conf/itp/LammichL10}.
 
 \<close>
 
 subsubsection\<open>Locale instantiation\<close>
 
 text\<open>
 
 Finally we assemble the algorithm and discharge the proof obligations.
 
 \<close>
 
 sublocale FiniteLinorderEnvironment
         < Clock: Algorithm
             jkbp envInit envAction envTrans envVal
             clock_jview envObs clock_jviewInit clock_jviewIncr
             clock_sim clock_simRels clock_simVal
             clock_simAbs clock_simObs clock_simInit clock_simTrans clock_simAction
             acts_MapOps trans_MapOps
 (*<*)
   apply (unfold_locales)
 
   apply clarify
   apply (rule clock_simInit)
   apply simp
 
   apply clarify
   apply (erule (1) clock_simObs)
 
   apply clarify
   apply (erule (1) clock_simAction)
 
   apply clarify
   apply (erule (1) clock_simTrans)
 
   apply (rule acts_MapOps)
   apply (rule trans_MapOps)
 
   done
 
 (*>*)
 text\<open>
 
 Explicitly, the algorithm for this case is:
 
 \<close>
 
 definition
   "mkClockAuto \<equiv> \<lambda>agents jkbp envInit envAction envTrans envVal envObs.
     mkAlgAuto acts_MapOps
               trans_MapOps
               (clock_simObs envObs)
               (clock_simInit envInit envObs)
               (clock_simTrans agents jkbp envAction envTrans envVal envObs)
               (clock_simAction jkbp envVal envObs)
               (\<lambda>a. map (clock_simInit envInit envObs a \<circ> envObs a) envInit)"
 
 lemma (in FiniteLinorderEnvironment) mkClockAuto_implements:
   "Clock.implements
     (mkClockAuto agents jkbp envInit envAction envTrans envVal envObs)"
 (*<*)
   using Clock.k_mkAlgAuto_implements
   unfolding mkClockAuto_def mkAlgAuto_def Clock.k_frontier_def
   by simp
 
 (*
 
 We actually run this unfolding of the algorithm. The lemma is keeping
 us honest.
 
 *)
 
 definition
   "ClockAutoDFS \<equiv> \<lambda>agents jkbp envInit envAction envTrans envVal envObs. \<lambda>a.
     alg_dfs acts_MapOps
             trans_MapOps
             (clock_simObs envObs a)
             (clock_simTrans agents jkbp envAction envTrans envVal envObs a)
             (clock_simAction jkbp envVal envObs a)
             (map (clock_simInit envInit envObs a \<circ> envObs a) envInit)"
 
 lemma (in FiniteLinorderEnvironment)
   "mkClockAuto agents jkbp envInit envAction envTrans envVal envObs
  = (\<lambda>a. alg_mk_auto acts_MapOps trans_MapOps (clock_simInit a) (ClockAutoDFS agents jkbp envInit envAction envTrans envVal envObs a))"
   unfolding mkClockAuto_def ClockAutoDFS_def mkAlgAuto_def alg_mk_auto_def by (simp add: Let_def)
 
 (*>*)
 text\<open>
 
 We discuss the clock semantics further in \S\ref{sec:kbps-alg-clock}.
 
 \<close>
 
 (*<*)
 end
 (*>*)
diff --git a/thys/Nested_Multisets_Ordinals/Syntactic_Ordinal.thy b/thys/Nested_Multisets_Ordinals/Syntactic_Ordinal.thy
--- a/thys/Nested_Multisets_Ordinals/Syntactic_Ordinal.thy
+++ b/thys/Nested_Multisets_Ordinals/Syntactic_Ordinal.thy
@@ -1,878 +1,878 @@
 (*  Title:       Syntactic Ordinals in Cantor Normal Form
     Author:      Jasmin Blanchette <jasmin.blanchette at inria.fr>, 2016
     Author:      Mathias Fleury <mfleury at mpi-inf.mpg.de>, 2016
     Author:      Dmitriy Traytel <traytel at inf.ethz.ch>, 2016
     Maintainer:  Jasmin Blanchette <jasmin.blanchette at inria.fr>
 *)
 
 section \<open>Syntactic Ordinals in Cantor Normal Form\<close>
 
 theory Syntactic_Ordinal
 imports Hereditary_Multiset "HOL-Library.Product_Order" "HOL-Library.Extended_Nat"
 begin
 
 
 subsection \<open>Natural (Hessenberg) Product\<close>
 
 instantiation hmultiset :: comm_semiring_1
 begin
 
 abbreviation \<omega>_exp :: "hmultiset \<Rightarrow> hmultiset" ("\<omega>^") where
   "\<omega>^ \<equiv> \<lambda>m. HMSet {#m#}"
 
 definition one_hmultiset :: hmultiset where
   "1 = \<omega>^0"
 
 abbreviation \<omega> :: hmultiset where
   "\<omega> \<equiv> \<omega>^1"
 
 definition times_hmultiset :: "hmultiset \<Rightarrow> hmultiset \<Rightarrow> hmultiset"  where
   "A * B = HMSet (image_mset (case_prod (+)) (hmsetmset A \<times># hmsetmset B))"
 
 lemma hmsetmset_times:
   "hmsetmset (m * n) = image_mset (case_prod (+)) (hmsetmset m \<times># hmsetmset n)"
   unfolding times_hmultiset_def by simp
 
 instance
 proof (intro_classes, goal_cases assoc comm one distrib_plus zeroL zeroR zero_one)
   case (assoc a b c)
   thus ?case
     by (auto simp: times_hmultiset_def Times_mset_image_mset1 Times_mset_image_mset2
       Times_mset_assoc ac_simps intro: multiset.map_cong)
 next
   case (comm a b)
   thus ?case
     unfolding times_hmultiset_def
     by (subst product_swap_mset[symmetric]) (auto simp: ac_simps intro: multiset.map_cong)
 next
   case (one a)
   thus ?case
     by (auto simp: one_hmultiset_def times_hmultiset_def Times_mset_single_left)
 next
   case (distrib_plus a b c)
   thus ?case
     by (auto simp: plus_hmultiset_def times_hmultiset_def)
 next
   case (zeroL a)
   thus ?case
     by (auto simp: times_hmultiset_def)
 next
   case (zeroR a)
   thus ?case
     by (auto simp: times_hmultiset_def)
 next
   case zero_one
   thus ?case
     by (auto simp: one_hmultiset_def)
 qed
 
 end
 
 lemma empty_times_left_hmset[simp]: "HMSet {#} * M = 0"
   by (simp add: times_hmultiset_def)
 
 lemma empty_times_right_hmset[simp]: "M * HMSet {#} = 0"
   by (metis mult_zero_right zero_hmultiset_def)
 
 lemma singleton_times_left_hmset[simp]: "\<omega>^M * N = HMSet (image_mset ((+) M) (hmsetmset N))"
   by (simp add: times_hmultiset_def Times_mset_single_left)
 
 lemma singleton_times_right_hmset[simp]: "N * \<omega>^M = HMSet (image_mset ((+) M) (hmsetmset N))"
   by (metis mult.commute singleton_times_left_hmset)
 
 
 subsection \<open>Inequalities\<close>
 
 definition plus_nmultiset :: "unit nmultiset \<Rightarrow> unit nmultiset \<Rightarrow> unit nmultiset"  where
   "plus_nmultiset X Y = Rep_hmultiset (Abs_hmultiset X + Abs_hmultiset Y)"
 
 lemma plus_nmultiset_mono:
   assumes less: "(X, Y) < (X', Y')" and no_elem: "no_elem X" "no_elem Y" "no_elem X'" "no_elem Y'"
   shows "plus_nmultiset X Y < plus_nmultiset X' Y'"
   using less[unfolded less_le_not_le] no_elem
   by (auto simp: plus_nmultiset_def plus_hmultiset_def less_multiset_ext\<^sub>D\<^sub>M_less less_eq_nmultiset_def
           union_less_mono type_definition.Abs_inverse[OF type_definition_hmultiset, simplified]
         elim!: no_elem.cases)
 
 lemma plus_hmultiset_transfer[transfer_rule]:
   "(rel_fun pcr_hmultiset (rel_fun pcr_hmultiset pcr_hmultiset)) plus_nmultiset (+)"
   unfolding rel_fun_def plus_nmultiset_def pcr_hmultiset_def nmultiset.rel_eq eq_OO cr_hmultiset_def
   by (auto simp: type_definition.Rep_inverse[OF type_definition_hmultiset])
 
 lemma Times_mset_monoL:
   assumes less: "M < N" and Z_nemp: "Z \<noteq> {#}"
   shows "M \<times># Z < N \<times># Z"
 proof -
   obtain Y X where
     Y_nemp: "Y \<noteq> {#}" and Y_sub_N: "Y \<subseteq># N" and M_eq: "M = N - Y + X" and
     ex_Y: "\<forall>x. x \<in># X \<longrightarrow> (\<exists>y. y \<in># Y \<and> x < y)"
     using less[unfolded less_multiset\<^sub>D\<^sub>M] by blast
 
   let ?X = "X \<times># Z"
   let ?Y = "Y \<times># Z"
 
   show ?thesis
     unfolding less_multiset\<^sub>D\<^sub>M
   proof (intro exI conjI)
     show "M \<times># Z = N \<times># Z - ?Y + ?X"
       unfolding M_eq by (auto simp: Sigma_mset_Diff_distrib1)
   next
     obtain y where y: "\<forall>x. x \<in># X \<longrightarrow> y x \<in># Y \<and> x < y x"
       using ex_Y by moura
 
     show "\<forall>x. x \<in># ?X \<longrightarrow> (\<exists>y. y \<in># ?Y \<and> x < y)"
     proof (intro allI impI)
       fix x
       assume "x \<in># ?X"
       thus "\<exists>y. y \<in># ?Y \<and> x < y"
         using y by (intro exI[of _ "(y (fst x), snd x)"]) (auto simp: less_le_not_le)
     qed
   qed (auto simp: Z_nemp Y_nemp Y_sub_N Sigma_mset_mono)
 qed
 
 lemma times_hmultiset_monoL:
   "a < b \<Longrightarrow> 0 < c \<Longrightarrow> a * c < b * c" for a b c :: hmultiset
   by (cases a, cases b, cases c, hypsubst_thin,
     unfold times_hmultiset_def zero_hmultiset_def hmultiset.sel, transfer,
     auto simp: less_multiset_ext\<^sub>D\<^sub>M_less multiset.pred_set
       intro!: image_mset_strict_mono Times_mset_monoL elim!: plus_nmultiset_mono)
 
 instance hmultiset :: linordered_semiring_strict
-  by intro_classes (subst (1 2) mult.commute, rule times_hmultiset_monoL)
+  by intro_classes (subst (1 2) mult.commute, (fact times_hmultiset_monoL)+)
 
 lemma mult_le_mono1_hmset: "i \<le> j \<Longrightarrow> i * k \<le> j * k" for i j k :: hmultiset
   by (simp add: mult_right_mono)
 
 lemma mult_le_mono2_hmset: "i \<le> j \<Longrightarrow> k * i \<le> k * j" for i j k :: hmultiset
   by (simp add: mult_left_mono)
 
 lemma mult_le_mono_hmset: "i \<le> j \<Longrightarrow> k \<le> l \<Longrightarrow> i * k \<le> j * l" for i j k l :: hmultiset
   by (simp add: mult_mono)
 
 lemma less_iff_add1_le_hmset: "m < n \<longleftrightarrow> m + 1 \<le> n" for m n :: hmultiset
 proof (cases m n rule: hmultiset.exhaust[case_product hmultiset.exhaust])
   case (HMSet_HMSet m0 n0)
   note m = this(1) and n = this(2)
 
   show ?thesis
   proof (simp add: m n one_hmultiset_def plus_hmultiset_def order.order_iff_strict
       less_multiset_ext\<^sub>D\<^sub>M_less, intro iffI)
     assume m0_lt_n0: "m0 < n0"
     note
       m0_ne_n0 = m0_lt_n0[unfolded less_multiset\<^sub>H\<^sub>O, THEN conjunct1] and
       ex_n0_gt_m0 = m0_lt_n0[unfolded less_multiset\<^sub>H\<^sub>O, THEN conjunct2, rule_format]
 
     {
       assume zero_m0_gt_n0: "add_mset 0 m0 > n0"
       note
         n0_ne_0m0 = zero_m0_gt_n0[unfolded less_multiset\<^sub>H\<^sub>O, THEN conjunct1] and
         ex_0m0_gt_n0 = zero_m0_gt_n0[unfolded less_multiset\<^sub>H\<^sub>O, THEN conjunct2, rule_format]
 
       {
         fix y
         assume m0y_lt_n0y: "count m0 y < count n0 y"
 
         have "\<exists>x > y. count n0 x < count m0 x"
         proof (cases "count (add_mset 0 m0) y < count n0 y")
           case True
           then obtain aa where
             aa_gt_y: "aa > y" and
             count_n0aa_lt_count_0m0aa: "count n0 aa < count (add_mset 0 m0) aa"
             using ex_0m0_gt_n0 by blast
           have "aa \<noteq> 0"
             by (rule gr_implies_not_zero_hmset[OF aa_gt_y])
           hence "count (add_mset 0 m0) aa = count m0 aa"
             by simp
           thus ?thesis
             using count_n0aa_lt_count_0m0aa aa_gt_y by auto
         next
           case not_0m0_y_lt_n0y: False
           hence y_eq_0: "y = 0"
             by (metis count_add_mset m0y_lt_n0y)
           have sm0y_eq_n0y: "Suc (count m0 y) = count n0 y"
             using m0y_lt_n0y not_0m0_y_lt_n0y count_add_mset[of 0 _ 0] unfolding y_eq_0 by simp
 
           obtain bb where "count n0 bb < count (add_mset 0 m0) bb"
             using lt_imp_ex_count_lt[OF zero_m0_gt_n0] by blast
           hence n0bb_lt_m0bb: "count n0 bb < count m0 bb"
             unfolding count_add_mset by (metis (full_types) less_irrefl_nat sm0y_eq_n0y y_eq_0)
           hence "bb \<noteq> 0"
             using sm0y_eq_n0y y_eq_0 by auto
           thus ?thesis
             unfolding y_eq_0 using n0bb_lt_m0bb not_gr_zero_hmset by blast
         qed
       }
       hence "n0 < m0"
         unfolding less_multiset\<^sub>H\<^sub>O using m0_ne_n0 by blast
       hence False
         using m0_lt_n0 by simp
     }
     thus "add_mset 0 m0 < n0 \<or> add_mset 0 m0 = n0"
       using antisym_conv3 by blast
   next
     assume "add_mset 0 m0 < n0 \<or> add_mset 0 m0 = n0"
     thus "m0 < n0"
       using dual_order.strict_trans le_multiset_right_total by blast
   qed
 qed
 
 lemma zero_less_iff_1_le_hmset: "0 < n \<longleftrightarrow> 1 \<le> n" for n :: hmultiset
   by (rule less_iff_add1_le_hmset[of 0, simplified])
 
 lemma less_add_1_iff_le_hmset: "m < n + 1 \<longleftrightarrow> m \<le> n" for m n :: hmultiset
   by (rule less_iff_add1_le_hmset[of m "n + 1", simplified])
 
 instance hmultiset :: ordered_cancel_comm_semiring
   by intro_classes (simp add: mult_le_mono2_hmset)
 
 instance hmultiset :: zero_less_one
   by intro_classes (simp add: zero_less_iff_neq_zero_hmset)
 
 instance hmultiset :: linordered_semiring_1_strict
   by intro_classes
 
 instance hmultiset :: bounded_lattice_bot
   by intro_classes
 
 instance hmultiset :: linordered_nonzero_semiring
   by intro_classes simp
 
 instance hmultiset :: semiring_no_zero_divisors
   by intro_classes (use mult_pos_pos not_gr_zero_hmset in blast)
 
 lemma lt_1_iff_eq_0_hmset: "M < 1 \<longleftrightarrow> M = 0" for M :: hmultiset
   by (simp add: less_iff_add1_le_hmset)
 
 lemma zero_less_mult_iff_hmset[simp]: "0 < m * n \<longleftrightarrow> 0 < m \<and> 0 < n" for m n :: hmultiset
   using mult_eq_0_iff not_gr_zero_hmset by blast
 
 lemma one_le_mult_iff_hmset[simp]: "1 \<le> m * n \<longleftrightarrow> 1 \<le> m \<and> 1 \<le> n" for m n :: hmultiset
   by (metis lt_1_iff_eq_0_hmset mult_eq_0_iff not_le)
 
 lemma mult_less_cancel2_hmset[simp]: "m * k < n * k \<longleftrightarrow> 0 < k \<and> m < n" for k m n :: hmultiset
   by (metis gr_zeroI_hmset leD leI le_cases mult_right_mono mult_zero_right times_hmultiset_monoL)
 
 lemma mult_less_cancel1_hmset[simp]: "k * m < k * n \<longleftrightarrow> 0 < k \<and> m < n" for k m n :: hmultiset
   by (simp add: mult.commute[of k])
 
 lemma mult_le_cancel1_hmset[simp]: "k * m \<le> k * n \<longleftrightarrow> (0 < k \<longrightarrow> m \<le> n)" for k m n :: hmultiset
   by (simp add: linorder_not_less[symmetric], auto)
 
 lemma mult_le_cancel2_hmset[simp]: "m * k \<le> n * k \<longleftrightarrow> (0 < k \<longrightarrow> m \<le> n)" for k m n :: hmultiset
   by (simp add: linorder_not_less[symmetric], auto)
 
 lemma mult_le_cancel_left1_hmset: "y > 0 \<Longrightarrow> x \<le> x * y" for x y :: hmultiset
   by (metis zero_less_iff_1_le_hmset mult.commute mult.left_neutral mult_le_cancel2_hmset)
 
 lemma mult_le_cancel_left2_hmset: "y \<le> 1 \<Longrightarrow> x * y \<le> x" for x y :: hmultiset
   by (metis mult.commute mult.left_neutral mult_le_cancel2_hmset)
 
 lemma mult_le_cancel_right1_hmset: "y > 0 \<Longrightarrow> x \<le> y * x" for x y :: hmultiset
   by (subst mult.commute) (fact mult_le_cancel_left1_hmset)
 
 lemma mult_le_cancel_right2_hmset: "y \<le> 1 \<Longrightarrow> y * x \<le> x" for x y :: hmultiset
   by (subst mult.commute) (fact mult_le_cancel_left2_hmset)
 
 lemma le_square_hmset: "m \<le> m * m" for m :: hmultiset
   using mult_le_cancel_left1_hmset by force
 
 lemma le_cube_hmset: "m \<le> m * (m * m)" for m :: hmultiset
   using mult_le_cancel_left1_hmset by force
 
 lemma
   less_imp_minus_plus_hmset: "m < n \<Longrightarrow> k < k - m + n" and
   le_imp_minus_plus_hmset: "m \<le> n \<Longrightarrow> k \<le> k - m + n" for k m n :: hmultiset
   by (meson add_less_cancel_left leD le_minus_plus_same_hmset less_le_trans not_le_imp_less)+
 
 lemma gt_0_lt_mult_gt_1_hmset:
   fixes m n :: hmultiset
   assumes "m > 0" and "n > 1"
   shows "m < m * n"
   using assms by (metis mult.right_neutral mult_less_cancel1_hmset)
 
 instance hmultiset :: linordered_comm_semiring_strict
   by intro_classes simp
 
 
 subsection \<open>Embedding of Natural Numbers\<close>
 
 lemma of_nat_hmset: "of_nat n = HMSet (replicate_mset n 0)"
   by (induct n) (auto simp: zero_hmultiset_def one_hmultiset_def plus_hmultiset_def)
 
 lemma of_nat_inject_hmset[simp]: "(of_nat m :: hmultiset) = of_nat n \<longleftrightarrow> m = n"
   unfolding of_nat_hmset by simp
 
 lemma of_nat_minus_hmset: "of_nat (m - n) = (of_nat m :: hmultiset) - of_nat n"
   unfolding of_nat_hmset minus_hmultiset_def by simp
 
 lemma plus_of_nat_plus_of_nat_hmset:
   "k + of_nat m + of_nat n = k + of_nat (m + n)" for k :: hmultiset
   by simp
 
 lemma plus_of_nat_minus_of_nat_hmset:
   fixes k :: hmultiset
   assumes "n \<le> m"
   shows "k + of_nat m - of_nat n = k + of_nat (m - n)"
   using assms by (metis add.left_commute add_diff_cancel_left' le_add_diff_inverse of_nat_add)
 
 lemma of_nat_lt_\<omega>[simp]: "of_nat n < \<omega>"
   by (auto simp: of_nat_hmset zero_less_iff_neq_zero_hmset less_multiset_ext\<^sub>D\<^sub>M_less)
 
 lemma of_nat_ne_\<omega>[simp]: "of_nat n \<noteq> \<omega>"
   by (simp add: neq_iff)
 
 lemma of_nat_less_hmset[simp]: "(of_nat M :: hmultiset) < of_nat N \<longleftrightarrow> M < N"
   unfolding of_nat_hmset less_multiset_ext\<^sub>D\<^sub>M_less by simp
 
 lemma of_nat_le_hmset[simp]: "(of_nat M :: hmultiset) \<le> of_nat N \<longleftrightarrow> M \<le> N"
   unfolding of_nat_hmset order_le_less less_multiset_ext\<^sub>D\<^sub>M_less by simp
 
 lemma of_nat_times_\<omega>_exp: "of_nat n * \<omega>^m = HMSet (replicate_mset n m)"
   by (induct n) (simp_all add: hmsetmset_plus one_hmultiset_def)
 
 lemma \<omega>_exp_times_of_nat: "\<omega>^m * of_nat n = HMSet (replicate_mset n m)"
   using of_nat_times_\<omega>_exp by simp
 
 
 subsection \<open>Embedding of Extended Natural Numbers\<close>
 
 primrec hmset_of_enat :: "enat \<Rightarrow> hmultiset" where
   "hmset_of_enat (enat n) = of_nat n"
 | "hmset_of_enat \<infinity> = \<omega>"
 
 lemma hmset_of_enat_0[simp]: "hmset_of_enat 0 = 0"
   by (simp add: zero_enat_def)
 
 lemma hmset_of_enat_1[simp]: "hmset_of_enat 1 = 1"
   by (simp add: one_enat_def del: One_nat_def)
 
 lemma hmset_of_enat_of_nat[simp]: "hmset_of_enat (of_nat n) = of_nat n"
   using of_nat_eq_enat by auto
 
 lemma hmset_of_enat_numeral[simp]: "hmset_of_enat (numeral n) = numeral n"
   by (simp add: numeral_eq_enat)
 
 lemma hmset_of_enat_le_\<omega>[simp]: "hmset_of_enat n \<le> \<omega>"
   using of_nat_lt_\<omega>[THEN less_imp_le] by (cases n) auto
 
 lemma hmset_of_enat_eq_\<omega>_iff[simp]: "hmset_of_enat n = \<omega> \<longleftrightarrow> n = \<infinity>"
   by (cases n) auto
 
 
 subsection \<open>Head Omega\<close>
 
 definition head_\<omega> :: "hmultiset \<Rightarrow> hmultiset" where
   "head_\<omega> M = (if M = 0 then 0 else \<omega>^(Max (set_mset (hmsetmset M))))"
 
 lemma head_\<omega>_subseteq: "hmsetmset (head_\<omega> M) \<subseteq># hmsetmset M"
   unfolding head_\<omega>_def by simp
 
 lemma head_\<omega>_eq_0_iff[simp]: "head_\<omega> m = 0 \<longleftrightarrow> m = 0"
   unfolding head_\<omega>_def zero_hmultiset_def by simp
 
 lemma head_\<omega>_0[simp]: "head_\<omega> 0 = 0"
   by simp
 
 lemma head_\<omega>_1[simp]: "head_\<omega> 1 = 1"
   unfolding head_\<omega>_def one_hmultiset_def by simp
 
 lemma head_\<omega>_of_nat[simp]: "head_\<omega> (of_nat n) = (if n = 0 then 0 else 1)"
   unfolding head_\<omega>_def one_hmultiset_def of_nat_hmset by simp
 
 lemma head_\<omega>_numeral[simp]: "head_\<omega> (numeral n) = 1"
   by (metis head_\<omega>_of_nat of_nat_numeral zero_neq_numeral)
 
 lemma head_\<omega>_\<omega>[simp]: "head_\<omega> \<omega> = \<omega>"
   unfolding head_\<omega>_def by simp
 
 lemma le_imp_head_\<omega>_le:
   assumes m_le_n: "m \<le> n"
   shows "head_\<omega> m \<le> head_\<omega> n"
 proof -
   have le_in_le_max: "\<And>a M N. M \<le> N \<Longrightarrow> a \<in># M \<Longrightarrow> a \<le> Max (set_mset N)"
     by (metis (no_types) Max_ge finite_set_mset le_less less_eq_multiset\<^sub>H\<^sub>O linorder_not_less
       mem_Collect_eq neq0_conv order_trans set_mset_def)
   show ?thesis
     using m_le_n unfolding head_\<omega>_def
     by (cases m, cases n,
       auto simp del: hmsetmset_le simp: head_\<omega>_def hmsetmset_le[symmetric] zero_hmultiset_def,
       metis Max_in dual_order.antisym finite_set_mset le_in_le_max le_less set_mset_eq_empty_iff)
 qed
 
 lemma head_\<omega>_lt_imp_lt: "head_\<omega> m < head_\<omega> n \<Longrightarrow> m < n"
   unfolding head_\<omega>_def hmsetmset_less[symmetric]
   by (rule all_lt_Max_imp_lt_mset, auto simp: zero_hmultiset_def split: if_splits)
 
 lemma head_\<omega>_plus[simp]: "head_\<omega> (m + n) = sup (head_\<omega> m) (head_\<omega> n)"
 proof (cases m n rule: hmultiset.exhaust[case_product hmultiset.exhaust])
   case m_n: (HMSet_HMSet M N)
   show ?thesis
   proof (cases "Max_mset M < Max_mset N")
     case True
     thus ?thesis
       unfolding m_n head_\<omega>_def sup_hmultiset_def zero_hmultiset_def plus_hmultiset_def
       by (simp add: Max.union max_def dual_order.strict_implies_order)
   next
     case False
     thus ?thesis
       unfolding m_n head_\<omega>_def sup_hmultiset_def zero_hmultiset_def plus_hmultiset_def
       by simp (metis False Max.union finite_set_mset leI max_def set_mset_eq_empty_iff sup.commute)
   qed
 qed
 
 lemma head_\<omega>_times[simp]: "head_\<omega> (m * n) = head_\<omega> m * head_\<omega> n"
 proof (cases "m = 0 \<or> n = 0")
   case False
   hence m_nz: "m \<noteq> 0" and n_nz: "n \<noteq> 0"
     by simp+
 
   define \<delta> where "\<delta> = hmsetmset m"
   define \<epsilon> where "\<epsilon> = hmsetmset n"
 
   have \<delta>_nemp: "\<delta> \<noteq> {#}"
     unfolding \<delta>_def using m_nz by simp
   have \<epsilon>_nemp: "\<epsilon> \<noteq> {#}"
     unfolding \<epsilon>_def using n_nz by simp
 
   let ?D = "set_mset \<delta>"
   let ?E = "set_mset \<epsilon>"
   let ?DE = "{z. \<exists>x \<in> ?D. \<exists>y \<in> ?E. z = x + y}"
 
   have max_D_in: "Max ?D \<in> ?D"
     using \<delta>_nemp by simp
   have max_E_in: "Max ?E \<in> ?E"
     using \<epsilon>_nemp by simp
 
   have "Max ?DE = Max ?D + Max ?E"
   proof (rule order_antisym, goal_cases le ge)
     case le
     have "\<And>x y. x \<in> ?D \<Longrightarrow> y \<in> ?E \<Longrightarrow> x + y \<le> Max ?D + Max ?E"
       by (simp add: add_mono)
     hence mem_imp_le: "\<And>z. z \<in> ?DE \<Longrightarrow> z \<le> Max ?D + Max ?E"
       by auto
     show ?case
       by (intro mem_imp_le Max_in, simp, use \<delta>_nemp \<epsilon>_nemp in fast)
   next
     case ge
     have "{z. \<exists>x \<in> {Max ?D}. \<exists>y \<in> {Max ?E}. z = x + y} \<subseteq> {z. \<exists>x \<in># \<delta>. \<exists>y \<in># \<epsilon>. z = x + y}"
       using max_D_in max_E_in by fast
     thus ?case
       by simp
   qed
   thus ?thesis
     unfolding \<delta>_def \<epsilon>_def by (auto simp: head_\<omega>_def image_def times_hmultiset_def)
 qed auto
 
 
 subsection \<open>More Inequalities and Some Equalities\<close>
 
 lemma zero_lt_\<omega>[simp]: "0 < \<omega>"
   by (metis of_nat_lt_\<omega> of_nat_0)
 
 lemma one_lt_\<omega>[simp]: "1 < \<omega>"
   by (metis enat_defs(2) hmset_of_enat.simps(1) hmset_of_enat_1 of_nat_lt_\<omega>)
 
 lemma numeral_lt_\<omega>[simp]: "numeral n < \<omega>"
   using hmset_of_enat_numeral[symmetric] hmset_of_enat.simps(1) of_nat_lt_\<omega> numeral_eq_enat
   by presburger
 
 lemma one_le_\<omega>[simp]: "1 \<le> \<omega>"
   by (simp add: less_imp_le)
 
 lemma of_nat_le_\<omega>[simp]: "of_nat n \<le> \<omega>"
   by (simp add: le_less)
 
 lemma numeral_le_\<omega>[simp]: "numeral n \<le> \<omega>"
   by (simp add: less_imp_le)
 
 lemma not_\<omega>_lt_1[simp]: "\<not> \<omega> < 1"
   by (simp add: not_less)
 
 lemma not_\<omega>_lt_of_nat[simp]: "\<not> \<omega> < of_nat n"
   by (simp add: not_less)
 
 lemma not_\<omega>_lt_numeral[simp]: "\<not> \<omega> < numeral n"
   by (simp add: not_less)
 
 lemma not_\<omega>_le_1[simp]: "\<not> \<omega> \<le> 1"
   by (simp add: not_le)
 
 lemma not_\<omega>_le_of_nat[simp]: "\<not> \<omega> \<le> of_nat n"
   by (simp add: not_le)
 
 lemma not_\<omega>_le_numeral[simp]: "\<not> \<omega> \<le> numeral n"
   by (simp add: not_le)
 
 lemma zero_ne_\<omega>[simp]: "0 \<noteq> \<omega>"
   by (metis not_\<omega>_le_1 zero_le_hmset)
 
 lemma one_ne_\<omega>[simp]: "1 \<noteq> \<omega>"
   using not_\<omega>_le_1 by force
 
 lemma numeral_ne_\<omega>[simp]: "numeral n \<noteq> \<omega>"
   by (metis not_\<omega>_le_numeral numeral_le_\<omega>)
 
 lemma
   \<omega>_ne_0[simp]: "\<omega> \<noteq> 0" and
   \<omega>_ne_1[simp]: "\<omega> \<noteq> 1" and
   \<omega>_ne_of_nat[simp]: "\<omega> \<noteq> of_nat m" and
   \<omega>_ne_numeral[simp]: "\<omega> \<noteq> numeral n"
   using zero_ne_\<omega> one_ne_\<omega> of_nat_ne_\<omega> numeral_ne_\<omega> by metis+
 
 lemma
   hmset_of_enat_inject[simp]: "hmset_of_enat m = hmset_of_enat n \<longleftrightarrow> m = n" and
   hmset_of_enat_less[simp]: "hmset_of_enat m < hmset_of_enat n \<longleftrightarrow> m < n" and
   hmset_of_enat_le[simp]: "hmset_of_enat m \<le> hmset_of_enat n \<longleftrightarrow> m \<le> n"
   by (cases m; cases n; simp)+
 
 lemma lt_\<omega>_imp_ex_of_nat:
   assumes M_lt_\<omega>: "M < \<omega>"
   shows "\<exists>n. M = of_nat n"
 proof -
   have M_lt_single_1: "hmsetmset M < {#1#}"
     by (rule M_lt_\<omega>[unfolded hmsetmset_less[symmetric] less_multiset_ext\<^sub>D\<^sub>M_less hmultiset.sel])
 
   have "N = 0" if "N \<in># hmsetmset M" for N
   proof -
     have "0 < count (hmsetmset M) N"
       using that by auto
     hence "N < 1"
       by (metis (no_types) M_lt_single_1 count_single gr_implies_not0 less_eq_multiset\<^sub>H\<^sub>O less_one
         neq_iff not_le)
     thus ?thesis
       by (simp add: lt_1_iff_eq_0_hmset)
   qed
   then obtain n where hmmM: "M = HMSet (replicate_mset n 0)"
     using ex_replicate_mset_if_all_elems_eq by (metis hmultiset.collapse)
   show ?thesis
     unfolding hmmM of_nat_hmset by blast
 qed
 
 lemma le_\<omega>_imp_ex_hmset_of_enat:
   assumes M_le_\<omega>: "M \<le> \<omega>"
   shows "\<exists>n. M = hmset_of_enat n"
 proof (cases "M = \<omega>")
   case True
   thus ?thesis
     by (metis hmset_of_enat.simps(2))
 next
   case False
   thus ?thesis
     using M_le_\<omega> lt_\<omega>_imp_ex_of_nat by (metis hmset_of_enat.simps(1) le_less)
 qed
 
 lemma lt_\<omega>_lt_\<omega>_imp_times_lt_\<omega>: "M < \<omega> \<Longrightarrow> N < \<omega> \<Longrightarrow> M * N < \<omega>"
   by (metis lt_\<omega>_imp_ex_of_nat of_nat_lt_\<omega> of_nat_mult)
 
 lemma times_\<omega>_minus_of_nat[simp]: "m * \<omega> - of_nat n = m * \<omega>"
   by (auto intro!: Diff_triv_mset simp: times_hmultiset_def minus_hmultiset_def
     Times_mset_single_right of_nat_hmset disjunct_not_in image_def)
 
 lemma times_\<omega>_minus_numeral[simp]: "m * \<omega> - numeral n = m * \<omega>"
   by (metis of_nat_numeral times_\<omega>_minus_of_nat)
 
 lemma \<omega>_minus_of_nat[simp]: "\<omega> - of_nat n = \<omega>"
   using times_\<omega>_minus_of_nat[of 1] by (metis mult.left_neutral)
 
 lemma \<omega>_minus_1[simp]: "\<omega> - 1 = \<omega>"
   using \<omega>_minus_of_nat[of 1] by simp
 
 lemma \<omega>_minus_numeral[simp]: "\<omega> - numeral n = \<omega>"
   using times_\<omega>_minus_numeral[of 1] by (metis mult.left_neutral)
 
 lemma hmset_of_enat_minus_enat[simp]: "hmset_of_enat (m - enat n) = hmset_of_enat m - of_nat n"
   by (cases m) (auto simp: of_nat_minus_hmset)
 
 lemma of_nat_lt_hmset_of_enat_iff: "of_nat m < hmset_of_enat n \<longleftrightarrow> enat m < n"
   by (metis hmset_of_enat.simps(1) hmset_of_enat_less)
 
 lemma of_nat_le_hmset_of_enat_iff: "of_nat m \<le> hmset_of_enat n \<longleftrightarrow> enat m \<le> n"
   by (metis hmset_of_enat.simps(1) hmset_of_enat_le)
 
 lemma hmset_of_enat_lt_iff_ne_infinity: "hmset_of_enat x < \<omega> \<longleftrightarrow> x \<noteq> \<infinity>"
   by (cases x; simp)
 
 lemma minus_diff_sym_hmset: "m - (m - n) = n - (n - m)" for m n :: hmultiset
   unfolding minus_hmultiset_def by simp (metis multiset_inter_def subset_mset.inf_aci(1))
 
 lemma diff_plus_sym_hmset: "(c - b) + b = (b - c) + c" for b c :: hmultiset
 proof -
   have f1: "\<And>h ha :: hmultiset. h - (ha + h) = 0"
     by (simp add: add.commute)
   have f2: "\<And>h ha hb :: hmultiset. h + ha - (h - hb) = hb + ha - (hb - h)"
     by (metis (no_types) add_diff_cancel_right minus_diff_sym_hmset)
   have "\<And>h ha hb :: hmultiset. h + (ha + hb) - hb = h + ha"
     by (metis (no_types) add.assoc add_diff_cancel_right')
   then show ?thesis
     using f2 f1 by (metis (no_types) add.commute add.right_neutral diff_diff_add_hmset)
 qed
 
 lemma times_diff_plus_sym_hmset: "a * (c - b) + a * b = a * (b - c) + a * c" for a b c :: hmultiset
   by (metis distrib_left diff_plus_sym_hmset)
 
 lemma times_of_nat_minus_left:
   "(of_nat m - of_nat n) * l = of_nat m * l - of_nat n * l" for l :: hmultiset
   by (induct n m rule: diff_induct) (auto simp: ring_distribs)
 
 lemma times_of_nat_minus_right:
   "l * (of_nat m - of_nat n) = l * of_nat m - l * of_nat n" for l :: hmultiset
   by (metis times_of_nat_minus_left mult.commute)
 
 lemma lt_\<omega>_imp_times_minus_left: "m < \<omega> \<Longrightarrow> n < \<omega> \<Longrightarrow> (m - n) * l = m * l - n * l"
   by (metis lt_\<omega>_imp_ex_of_nat times_of_nat_minus_left)
 
 lemma lt_\<omega>_imp_times_minus_right: "m < \<omega> \<Longrightarrow> n < \<omega> \<Longrightarrow> l * (m - n) = l * m - l * n"
   by (metis lt_\<omega>_imp_ex_of_nat times_of_nat_minus_right)
 
 lemma hmset_pair_decompose:
   "\<exists>k n1 n2. m1 = k + n1 \<and> m2 = k + n2 \<and> (head_\<omega> n1 \<noteq> head_\<omega> n2 \<or> n1 = 0 \<and> n2 = 0)"
 proof -
   define n1 where n1: "n1 = m1 - m2"
   define n2 where n2: "n2 = m2 - m1"
   define k where k1: "k = m1 - n1"
 
   have k2: "k = m2 - n2"
     using k1 unfolding n1 n2 by (simp add: minus_diff_sym_hmset)
 
   have "m1 = k + n1"
     unfolding k1
     by (metis (no_types) n1 add_diff_cancel_left add.commute add_diff_cancel_right' diff_add_zero
       diff_diff_add minus_diff_sym_hmset)
   moreover have "m2 = k + n2"
     unfolding k2
     by (metis n2 add.commute add_diff_cancel_left add_diff_cancel_left' add_diff_cancel_right'
       diff_add_zero diff_diff_add diff_zero k2 minus_diff_sym_hmset)
   moreover have hd_n: "head_\<omega> n1 \<noteq> head_\<omega> n2" if n1_or_n2_nz: "n1 \<noteq> 0 \<or> n2 \<noteq> 0"
   proof (cases "n1 = 0" "n2 = 0" rule: bool.exhaust[case_product bool.exhaust])
     case False_False
     note n1_nz = this(1)[simplified] and n2_nz = this(2)[simplified]
 
     define \<delta>1 where "\<delta>1 = hmsetmset n1"
     define \<delta>2 where "\<delta>2 = hmsetmset n2"
 
     have \<delta>1_inter_\<delta>2: "\<delta>1 \<inter># \<delta>2 = {#}"
       unfolding \<delta>1_def \<delta>2_def n1 n2 minus_hmultiset_def by (simp add: diff_intersect_sym_diff)
 
     have \<delta>1_ne: "\<delta>1 \<noteq> {#}"
       unfolding \<delta>1_def using n1_nz by simp
     have \<delta>2_ne: "\<delta>2 \<noteq> {#}"
       unfolding \<delta>2_def using n2_nz by simp
 
     have max_\<delta>1: "Max (set_mset \<delta>1) \<in># \<delta>1"
       using \<delta>1_ne by simp
     have max_\<delta>2: "Max (set_mset \<delta>2) \<in># \<delta>2"
       using \<delta>2_ne by simp
     have max_\<delta>1_ne_\<delta>2: "Max (set_mset \<delta>1) \<noteq> Max (set_mset \<delta>2)"
       using \<delta>1_inter_\<delta>2 disjunct_not_in max_\<delta>1 max_\<delta>2 by force
 
     show ?thesis
       using n1_nz n2_nz
       by (cases n1 rule: hmultiset.exhaust_sel, cases n2 rule: hmultiset.exhaust_sel,
         auto simp: head_\<omega>_def zero_hmultiset_def max_\<delta>1_ne_\<delta>2[unfolded \<delta>1_def \<delta>2_def])
   qed (use n1_or_n2_nz in \<open>auto simp: head_\<omega>_def\<close>)
   ultimately show ?thesis
     by blast
 qed
 
 lemma hmset_pair_decompose_less:
   assumes m1_lt_m2: "m1 < m2"
   shows "\<exists>k n1 n2. m1 = k + n1 \<and> m2 = k + n2 \<and> head_\<omega> n1 < head_\<omega> n2"
 proof -
   obtain k n1 n2 where
     m1: "m1 = k + n1" and
     m2: "m2 = k + n2" and
     hds: "head_\<omega> n1 \<noteq> head_\<omega> n2 \<or> n1 = 0 \<and> n2 = 0"
     using hmset_pair_decompose[of m1 m2] by blast
 
   {
     assume "n1 = 0" and "n2 = 0"
     hence "m1 = m2"
       unfolding m1 m2 by simp
     hence False
       using m1_lt_m2 by simp
   }
   moreover
   {
     assume "head_\<omega> n1 > head_\<omega> n2"
     hence "n1 > n2"
       by (rule head_\<omega>_lt_imp_lt)
     hence "m1 > m2"
       unfolding m1 m2 by simp
     hence False
       using m1_lt_m2 by simp
   }
   ultimately show ?thesis
     using m1 m2 hds by (blast elim: neqE)
 qed
 
 lemma hmset_pair_decompose_less_eq:
   assumes "m1 \<le> m2"
   shows "\<exists>k n1 n2. m1 = k + n1 \<and> m2 = k + n2 \<and> (head_\<omega> n1 < head_\<omega> n2 \<or> n1 = 0 \<and> n2 = 0)"
   using assms
   by (metis add_cancel_right_right hmset_pair_decompose_less order.not_eq_order_implies_strict)
 
 lemma mono_cross_mult_less_hmset:
   fixes Aa A Ba B :: hmultiset
   assumes A_lt: "A < Aa" and B_lt: "B < Ba"
   shows "A * Ba + B * Aa < A * B + Aa * Ba"
 proof -
   obtain j m1 m2 where A: "A = j + m1" and Aa: "Aa = j + m2" and hd_m: "head_\<omega> m1 < head_\<omega> m2"
     by (metis hmset_pair_decompose_less[OF A_lt])
   obtain k n1 n2 where B: "B = k + n1" and Ba: "Ba = k + n2" and hd_n: "head_\<omega> n1 < head_\<omega> n2"
     by (metis hmset_pair_decompose_less[OF B_lt])
 
   have hd_lt: "head_\<omega> (m1 * n2 + m2 * n1) < head_\<omega> (m1 * n1 + m2 * n2)"
   proof simp
     have "\<And>h ha :: hmultiset. 0 < h \<or> \<not> ha < h"
       by force
     hence "\<not> head_\<omega> m2 * head_\<omega> n2 \<le> sup (head_\<omega> m1 * head_\<omega> n2) (head_\<omega> m2 * head_\<omega> n1)"
       using hd_m hd_n sup_hmultiset_def by auto
     thus "sup (head_\<omega> m1 * head_\<omega> n2) (head_\<omega> m2 * head_\<omega> n1)
       < sup (head_\<omega> m1 * head_\<omega> n1) (head_\<omega> m2 * head_\<omega> n2)"
       by (meson leI sup.bounded_iff)
   qed
   show ?thesis
     unfolding A Aa B Ba ring_distribs by (simp add: algebra_simps head_\<omega>_lt_imp_lt[OF hd_lt])
 qed
 
 lemma triple_cross_mult_hmset:
   "An * (Bn * Cn + Bp * Cp - (Bn * Cp + Cn * Bp))
    + (Cn * (An * Bp + Bn * Ap - (An * Bn + Ap * Bp))
       + (Ap * (Bn * Cp + Cn * Bp - (Bn * Cn + Bp * Cp))
          + Cp * (An * Bn + Ap * Bp - (An * Bp + Bn * Ap)))) =
    An * (Bn * Cp + Cn * Bp - (Bn * Cn + Bp * Cp))
    + (Cn * (An * Bn + Ap * Bp - (An * Bp + Bn * Ap))
       + (Ap * (Bn * Cn + Bp * Cp - (Bn * Cp + Cn * Bp))
          + Cp * (An * Bp + Bn * Ap - (An * Bn + Ap * Bp))))"
   for Ap An Bp Bn Cp Cn Dp Dn :: hmultiset
   apply (simp add: algebra_simps)
   apply (unfold add.assoc[symmetric])
 
   apply (rule add_right_cancel[THEN iffD1, of _ "Cp * (An * Bp + Ap * Bn)"])
   apply (unfold add.assoc)
   apply (subst times_diff_plus_sym_hmset)
   apply (unfold add.assoc[symmetric])
   apply (subst (12) add.commute)
   apply (subst (11) add.commute)
   apply (unfold add.assoc[symmetric])
 
   apply (rule add_right_cancel[THEN iffD1, of _ "Cn * (An * Bn + Ap * Bp)"])
   apply (unfold add.assoc)
   apply (subst times_diff_plus_sym_hmset)
   apply (unfold add.assoc[symmetric])
   apply (subst (14) add.commute)
   apply (subst (13) add.commute)
   apply (unfold add.assoc[symmetric])
 
   apply (rule add_right_cancel[THEN iffD1, of _ "Ap * (Bn * Cn + Bp * Cp)"])
   apply (unfold add.assoc)
   apply (subst times_diff_plus_sym_hmset)
   apply (unfold add.assoc[symmetric])
   apply (subst (16) add.commute)
   apply (subst (15) add.commute)
   apply (unfold add.assoc[symmetric])
 
   apply (rule add_right_cancel[THEN iffD1, of _ "An * (Bn * Cp + Bp * Cn)"])
   apply (unfold add.assoc)
   apply (subst times_diff_plus_sym_hmset)
   apply (unfold add.assoc[symmetric])
   apply (subst (18) add.commute)
   apply (subst (17) add.commute)
   apply (unfold add.assoc[symmetric])
 
   by (simp add: algebra_simps)
 
 
 subsection \<open>Conversions to Natural Numbers\<close>
 
 definition offset_hmset :: "hmultiset \<Rightarrow> nat" where
   "offset_hmset M = count (hmsetmset M) 0"
 
 lemma offset_hmset_of_nat[simp]: "offset_hmset (of_nat n) = n"
   unfolding offset_hmset_def of_nat_hmset by simp
 
 lemma offset_hmset_numeral[simp]: "offset_hmset (numeral n) = numeral n"
   unfolding offset_hmset_def by (metis offset_hmset_def offset_hmset_of_nat of_nat_numeral)
 
 definition sum_coefs :: "hmultiset \<Rightarrow> nat" where
   "sum_coefs M = size (hmsetmset M)"
 
 lemma sum_coefs_distrib_plus[simp]: "sum_coefs (M + N) = sum_coefs M + sum_coefs N"
   unfolding plus_hmultiset_def sum_coefs_def by simp
 
 lemma sum_coefs_gt_0: "sum_coefs M > 0 \<longleftrightarrow> M > 0"
   by (auto simp: sum_coefs_def zero_hmultiset_def hmsetmset_less[symmetric] less_multiset_ext\<^sub>D\<^sub>M_less
     nonempty_has_size[symmetric])
 
 
 subsection \<open>An Example\<close>
 
 text \<open>
 The following proof is based on an informal proof by Uwe Waldmann, inspired by
 a similar argument by Michel Ludwig.
 \<close>
 
 lemma ludwig_waldmann_less:
   fixes \<alpha>1 \<alpha>2 \<beta>1 \<beta>2 \<gamma> \<delta> :: hmultiset
   assumes
     \<alpha>\<beta>2\<gamma>_lt_\<alpha>\<beta>1\<gamma>: "\<alpha>2 + \<beta>2 * \<gamma> < \<alpha>1 + \<beta>1 * \<gamma>" and
     \<beta>2_le_\<beta>1: "\<beta>2 \<le> \<beta>1" and
     \<gamma>_lt_\<delta>: "\<gamma> < \<delta>"
   shows "\<alpha>2 + \<beta>2 * \<delta> < \<alpha>1 + \<beta>1 * \<delta>"
 proof -
   obtain \<beta>0 \<beta>2a \<beta>1a where
     \<beta>1: "\<beta>1 = \<beta>0 + \<beta>1a" and
     \<beta>2: "\<beta>2 = \<beta>0 + \<beta>2a" and
     hd_\<beta>2a_vs_\<beta>1a: "head_\<omega> \<beta>2a < head_\<omega> \<beta>1a \<or> \<beta>2a = 0 \<and> \<beta>1a = 0"
     using hmset_pair_decompose_less_eq[OF \<beta>2_le_\<beta>1] by blast
 
   obtain \<eta> \<gamma>a \<delta>a where
     \<gamma>: "\<gamma> = \<eta> + \<gamma>a" and
     \<delta>: "\<delta> = \<eta> + \<delta>a" and
     hd_\<gamma>a_lt_\<delta>a: "head_\<omega> \<gamma>a < head_\<omega> \<delta>a"
     using hmset_pair_decompose_less[OF \<gamma>_lt_\<delta>] by blast
 
   have "\<alpha>2 + \<beta>0 * \<gamma> + \<beta>2a * \<gamma> = \<alpha>2 + \<beta>2 * \<gamma>"
     unfolding \<beta>2 by (simp add: add.commute add.left_commute distrib_left mult.commute)
   also have "\<dots> < \<alpha>1 + \<beta>1 * \<gamma>"
     by (rule \<alpha>\<beta>2\<gamma>_lt_\<alpha>\<beta>1\<gamma>)
   also have "\<dots> = \<alpha>1 + \<beta>0 * \<gamma> + \<beta>1a * \<gamma>"
     unfolding \<beta>1 by (simp add: add.commute add.left_commute distrib_left mult.commute)
   finally have *: "\<alpha>2 + \<beta>2a * \<gamma> < \<alpha>1 + \<beta>1a * \<gamma>"
     by (metis add_less_cancel_right semiring_normalization_rules(23))
 
   have "\<alpha>2 + \<beta>2 * \<delta> = \<alpha>2 + \<beta>0 * \<delta> + \<beta>2a * \<delta>"
     unfolding \<beta>2 by (simp add: ab_semigroup_add_class.add_ac(1) distrib_right)
   also have "\<dots> = \<alpha>2 + \<beta>0 * \<delta> + \<beta>2a * \<eta> + \<beta>2a * \<delta>a"
     unfolding \<delta> by (simp add: distrib_left semiring_normalization_rules(25))
   also have "\<dots> \<le> \<alpha>2 + \<beta>0 * \<delta> + \<beta>2a * \<eta> + \<beta>2a * \<delta>a + \<beta>2a * \<gamma>a"
     by simp
   also have "\<dots> = \<alpha>2 + \<beta>2a * \<gamma> + \<beta>0 * \<delta> + \<beta>2a * \<delta>a"
     unfolding \<gamma> distrib_left add.assoc[symmetric] by (simp add: semiring_normalization_rules(23))
   also have "\<dots> < \<alpha>1 + \<beta>1a * \<gamma> + \<beta>0 * \<delta> + \<beta>2a * \<delta>a"
     using * by simp
   also have "\<dots> = \<alpha>1 + \<beta>1a * \<eta> + \<beta>1a * \<gamma>a + \<beta>0 * \<eta> + \<beta>0 * \<delta>a + \<beta>2a * \<delta>a"
     unfolding \<gamma> \<delta> distrib_left add.assoc[symmetric] by (rule refl)
   also have "\<dots> \<le> \<alpha>1 + \<beta>1a * \<eta> + \<beta>0 * \<eta> + \<beta>0 * \<delta>a + \<beta>1a * \<delta>a"
   proof -
     have "\<beta>1a * \<gamma>a + \<beta>2a * \<delta>a \<le> \<beta>1a * \<delta>a"
     proof (cases "\<beta>2a = 0 \<and> \<beta>1a = 0")
       case False
       hence "head_\<omega> \<beta>2a < head_\<omega> \<beta>1a"
         using hd_\<beta>2a_vs_\<beta>1a by blast
       hence "head_\<omega> (\<beta>1a * \<gamma>a + \<beta>2a * \<delta>a) < head_\<omega> (\<beta>1a * \<delta>a)"
         using hd_\<gamma>a_lt_\<delta>a by (auto intro: gr_zeroI_hmset simp: sup_hmultiset_def)
       hence "\<beta>1a * \<gamma>a + \<beta>2a * \<delta>a < \<beta>1a * \<delta>a"
         by (rule head_\<omega>_lt_imp_lt)
       thus ?thesis
         by simp
     qed simp
     thus ?thesis
       by simp
   qed
   finally show ?thesis
     unfolding \<beta>1 \<delta>
     by (simp add: distrib_left distrib_right add.assoc[symmetric] semiring_normalization_rules(23))
 qed
 
 end
diff --git a/thys/Ordinary_Differential_Equations/IVP/Flow_Congs.thy b/thys/Ordinary_Differential_Equations/IVP/Flow_Congs.thy
--- a/thys/Ordinary_Differential_Equations/IVP/Flow_Congs.thy
+++ b/thys/Ordinary_Differential_Equations/IVP/Flow_Congs.thy
@@ -1,471 +1,472 @@
 theory Flow_Congs
   imports Reachability_Analysis
 begin
 
 lemma lipschitz_on_congI:
   assumes "L'-lipschitz_on s' g'"
   assumes "s' = s"
   assumes "L' \<le> L"
   assumes "\<And>x y. x \<in> s \<Longrightarrow> g' x = g x"
   shows "L-lipschitz_on s g"
   using assms
   by (auto simp: lipschitz_on_def intro!: order_trans[OF _ mult_right_mono[OF \<open>L' \<le> L\<close>]])
 
 lemma local_lipschitz_congI:
   assumes "local_lipschitz s' t' g'"
   assumes "s' = s"
   assumes "t' = t"
   assumes "\<And>x y. x \<in> s \<Longrightarrow> y \<in> t \<Longrightarrow> g' x y = g x y"
   shows "local_lipschitz s t g"
 proof -
   from assms have "local_lipschitz s t g'"
     by (auto simp: local_lipschitz_def)
   then show ?thesis
     apply (auto simp: local_lipschitz_def)
     apply (drule_tac bspec, assumption)
     apply (drule_tac bspec, assumption)
     apply auto
     subgoal for x y u L
     apply (rule exI[where x=u])
       apply (auto intro!: exI[where x=L])
       apply (drule bspec)
       apply simp
       apply (rule lipschitz_on_congI, assumption, rule refl, rule order_refl)
       using assms
       apply (auto)
       done
     done
 qed
 
 context ll_on_open_it\<comment> \<open>TODO: do this more generically for @{const ll_on_open_it}\<close>
 begin
 
 context fixes S Y g assumes cong: "X = Y" "T = S" "\<And>x t. x \<in> Y \<Longrightarrow> t \<in> S \<Longrightarrow> f t x = g t x"
 begin
 
 lemma ll_on_open_congI: "ll_on_open S g Y"
 proof -
   interpret Y: ll_on_open_it S f Y t0
     apply (subst cong(1)[symmetric])
     apply (subst cong(2)[symmetric])
     by unfold_locales
   show ?thesis
     apply standard
     subgoal
       using local_lipschitz
       apply (rule local_lipschitz_congI)
       using cong by simp_all
     subgoal apply (subst continuous_on_cong) prefer 3 apply (rule cont)
       using cong by (auto)
     subgoal using open_domain by (auto simp: cong)
     subgoal using open_domain by (auto simp: cong)
     done
 qed
 
 lemma existence_ivl_subsetI:
   assumes t: "t \<in> existence_ivl t0 x0"
   shows "t \<in> ll_on_open.existence_ivl S g Y t0 x0"
 proof -
   from assms have \<open>t0 \<in> T\<close> "x0 \<in> X"
     by (rule mem_existence_ivl_iv_defined)+
   interpret Y: ll_on_open S g Y by (rule ll_on_open_congI)
   have "(flow t0 x0 solves_ode f) (existence_ivl t0 x0) X"
     by (rule flow_solves_ode) (auto simp: \<open>x0 \<in> X\<close> \<open>t0 \<in> T\<close>)
   then have "(flow t0 x0 solves_ode f) {t0--t} X"
     by (rule solves_ode_on_subset)
      (auto simp add: t local.closed_segment_subset_existence_ivl)
   then have "(flow t0 x0 solves_ode g) {t0--t} Y"
     apply (rule solves_ode_congI)
        apply (auto intro!: assms cong)
     using \<open>(flow t0 x0 solves_ode f) {t0--t} X\<close> local.cong(1) solves_ode_domainD apply blast
     using \<open>t0 \<in> T\<close> assms closed_segment_subset_domainI general.mem_existence_ivl_subset local.cong(2)
     by blast
   then show ?thesis
     apply (rule Y.existence_ivl_maximal_segment)
     subgoal by (simp add: \<open>t0 \<in> T\<close> \<open>x0 \<in> X\<close>)
     apply (subst cong[symmetric])
     using \<open>t0 \<in> T\<close> assms closed_segment_subset_domainI general.mem_existence_ivl_subset local.cong(2)
     by blast
 qed
 
 lemma existence_ivl_cong:
   shows "existence_ivl t0 x0 = ll_on_open.existence_ivl S g Y t0 x0"
 proof -
   interpret Y: ll_on_open S g Y by (rule ll_on_open_congI)
   show ?thesis
     apply (auto )
     subgoal by (rule existence_ivl_subsetI)
     subgoal
       apply (rule Y.existence_ivl_subsetI)
       using cong
       by auto
     done
 qed
 
 lemma flow_cong:
   assumes "t \<in> existence_ivl t0 x0"
   shows "flow t0 x0 t = ll_on_open.flow S g Y t0 x0 t"
 proof -
   interpret Y: ll_on_open S g Y by (rule ll_on_open_congI)
   from assms have "t0 \<in> T" "x0 \<in> X"
     by (rule mem_existence_ivl_iv_defined)+
   from cong \<open>x0 \<in> X\<close> have "x0 \<in> Y" by auto
   from cong \<open>t0 \<in> T\<close> have "t0 \<in> S" by auto
   show ?thesis
     apply (rule Y.equals_flowI[where T'="existence_ivl t0 x0"])
     subgoal using \<open>t0 \<in> T\<close> \<open>x0 \<in> X\<close>  by auto
     subgoal using \<open>x0 \<in> X\<close> by auto
     subgoal by (auto simp: existence_ivl_cong \<open>x0 \<in> X\<close>)
     subgoal
       apply (rule solves_ode_congI)
           apply (rule flow_solves_ode[OF \<open>t0 \<in> T\<close> \<open>x0 \<in> X\<close>])
       using existence_ivl_subset[of x0]
       by (auto simp: cong(2)[symmetric] cong(1)[symmetric] assms flow_in_domain intro!: cong)
     subgoal using \<open>t0 \<in> S\<close> \<open>t0 \<in> T\<close> \<open>x0 \<in> X\<close> \<open>x0 \<in> Y\<close>
       by (auto simp:)
     subgoal by fact
     done
 qed
 
 end
 
 end
 
 context auto_ll_on_open begin
 
 context fixes Y g assumes cong: "X = Y" "\<And>x t. x \<in> Y \<Longrightarrow> f x = g x"
 begin
 
 lemma auto_ll_on_open_congI: "auto_ll_on_open g Y"
   apply unfold_locales
   subgoal
     using local_lipschitz
     apply (rule local_lipschitz_congI)
     using cong by auto
   subgoal
     using open_domain
     using cong by auto
   done
 
 lemma existence_ivl0_cong:
   shows "existence_ivl0 x0 = auto_ll_on_open.existence_ivl0 g Y x0"
 proof -
   interpret Y: auto_ll_on_open g Y by (rule auto_ll_on_open_congI)
   show ?thesis
     unfolding Y.existence_ivl0_def
     apply (rule existence_ivl_cong)
     using cong by auto
 qed
 
 lemma flow0_cong:
   assumes "t \<in> existence_ivl0 x0"
   shows "flow0 x0 t = auto_ll_on_open.flow0 g Y x0 t"
 proof -
   interpret Y: auto_ll_on_open g Y by (rule auto_ll_on_open_congI)
   show ?thesis
     unfolding Y.flow0_def
     apply (rule flow_cong)
     using cong assms by auto
 qed
 
 end
 
 end
 
 
 context c1_on_open_euclidean begin
 
 context fixes Y g assumes cong: "X = Y" "\<And>x t. x \<in> Y \<Longrightarrow> f x = g x"
 begin
 
 lemma f'_cong: "(g has_derivative blinfun_apply (f' x)) (at x)" if "x \<in> Y"
 proof -
   from derivative_rhs[of x] that cong
   have "(f has_derivative blinfun_apply (f' x)) (at x within Y)"
     by (auto intro!: has_derivative_at_withinI)
   then have "(g has_derivative blinfun_apply (f' x)) (at x within Y)"
     by (rule has_derivative_transform_within[OF _ zero_less_one that])
        (auto simp: cong)
   then show ?thesis
     using at_within_open[OF that] cong open_dom
     by (auto simp: )
 qed
 
 lemma c1_on_open_euclidean_congI: "c1_on_open_euclidean g f' Y"
 proof -
   interpret Y: c1_on_open_euclidean f f' Y unfolding cong[symmetric] by unfold_locales
   show ?thesis
     apply standard
     subgoal using cong by simp
     subgoal by (rule f'_cong)
     subgoal by (simp add: cong[symmetric] continuous_derivative)
     done
 qed
 
 lemma vareq_cong: "vareq x0 t = c1_on_open_euclidean.vareq g f' Y x0 t"
   if "t \<in> existence_ivl0 x0"
 proof -
   interpret Y: c1_on_open_euclidean g f' Y by (rule c1_on_open_euclidean_congI)
   show ?thesis
     unfolding vareq_def Y.vareq_def
     apply (rule arg_cong[where f=f'])
     apply (rule flow0_cong)
     using cong that by auto
 qed
 
 lemma Dflow_cong:
   assumes "t \<in> existence_ivl0 x0"
   shows "Dflow x0 t = c1_on_open_euclidean.Dflow g f' Y x0 t"
 proof -
   interpret Y: c1_on_open_euclidean g f' Y by (rule c1_on_open_euclidean_congI)
   from assms have "x0 \<in> X"
     by (rule mem_existence_ivl_iv_defined)
   from cong \<open>x0 \<in> X\<close> have "x0 \<in> Y" by auto
   show ?thesis
     unfolding Dflow_def Y.Dflow_def
     apply (rule mvar.equals_flowI[symmetric, OF _ _ order_refl])
     subgoal using \<open>x0 \<in> X\<close> by auto
     subgoal using \<open>x0 \<in> X\<close> by auto
     subgoal
       apply (rule solves_ode_congI)
           apply (rule Y.mvar.flow_solves_ode)
            prefer 3 apply (rule refl)
       subgoal using \<open>x0 \<in> X\<close> \<open>x0 \<in> Y\<close> by auto
       subgoal using \<open>x0 \<in> X\<close> \<open>x0 \<in> Y\<close> by auto
       subgoal for t
         apply (subst vareq_cong)
          apply (subst (asm) Y.mvar_existence_ivl_eq_existence_ivl)
         subgoal using \<open>x0 \<in> Y\<close> by simp
         subgoal
           using cong
           by (subst (asm) existence_ivl0_cong[symmetric]) auto
         subgoal using \<open>x0 \<in> Y\<close> by simp
         done
       subgoal using \<open>x0 \<in> X\<close> \<open>x0 \<in> Y\<close>
         apply (subst mvar_existence_ivl_eq_existence_ivl)
         subgoal by simp
         apply (subst Y.mvar_existence_ivl_eq_existence_ivl)
         subgoal by simp
         using cong
         by (subst existence_ivl0_cong[symmetric]) auto
       subgoal by simp
       done
     subgoal using \<open>x0 \<in> X\<close> \<open>x0 \<in> Y\<close> by auto
     subgoal
       apply (subst mvar_existence_ivl_eq_existence_ivl)
        apply auto
        apply fact+
       done
     done
 qed
 
 lemma flowsto_congI1:
   assumes "flowsto A B C D"
   shows "c1_on_open_euclidean.flowsto g f' Y A B C D"
 proof -
   interpret Y: c1_on_open_euclidean g f' Y by (rule c1_on_open_euclidean_congI)
   show ?thesis
     using assms
     unfolding flowsto_def Y.flowsto_def
     apply (auto simp: existence_ivl0_cong[OF cong]  flow0_cong[OF cong])
        apply (drule bspec, assumption)
     apply clarsimp
     apply (rule bexI)
     apply (rule conjI)
        apply assumption
-    apply (subst flow0_cong[symmetric, OF cong])
+     apply (subst flow0_cong[symmetric, OF cong])
      apply auto
       apply (subst existence_ivl0_cong[OF cong])
     apply auto
     apply (subst Dflow_cong[symmetric])
      apply auto
       apply (subst existence_ivl0_cong[OF cong])
     apply auto
     apply (drule bspec, assumption)
     apply (subst flow0_cong[symmetric, OF cong])
      apply auto
       apply (subst existence_ivl0_cong[OF cong])
     apply auto defer
     apply (subst Dflow_cong[symmetric])
      apply auto
-      apply (subst existence_ivl0_cong[OF cong])
+     apply (subst existence_ivl0_cong[OF cong])
     apply auto
-    apply (drule Y.closed_segment_subset_existence_ivl)
-    by (auto simp: open_segment_eq_real_ivl closed_segment_eq_real_ivl split: if_splits)
+     apply (drule Y.closed_segment_subset_existence_ivl;
+        auto simp: open_segment_eq_real_ivl closed_segment_eq_real_ivl split: if_splits)+
+    done
 qed
 
 lemma flowsto_congI2:
   assumes "c1_on_open_euclidean.flowsto g f' Y A B C D"
   shows "flowsto A B C D"
 proof -
   interpret Y: c1_on_open_euclidean g f' Y by (rule c1_on_open_euclidean_congI)
   show ?thesis
     apply (rule Y.flowsto_congI1)
     using assms
     by (auto simp: cong)
 qed
 
 lemma flowsto_congI: "flowsto A B C D = c1_on_open_euclidean.flowsto g f' Y A B C D"
   using flowsto_congI1[of A B C D] flowsto_congI2[of A B C D] by auto
 
 lemma
   returns_to_congI1:
   assumes "returns_to A x"
   shows "auto_ll_on_open.returns_to g Y A x"
 proof -
   interpret Y: c1_on_open_euclidean g f' Y by (rule c1_on_open_euclidean_congI)
   from assms obtain t where t:
     "\<forall>\<^sub>F t in at_right 0. flow0 x t \<notin> A"
     "0 < t" "t \<in> existence_ivl0 x" "flow0 x t \<in> A"
     by (auto simp: returns_to_def)
 
   note t(1)
   moreover
   have "\<forall>\<^sub>F s in at_right 0. s < t"
     using tendsto_ident_at \<open>0 < t\<close>
     by (rule order_tendstoD)
   moreover have "\<forall>\<^sub>F s in at_right 0. 0 < s"
     by (auto simp: eventually_at_topological)
   ultimately have "\<forall>\<^sub>F t in at_right 0. Y.flow0 x t \<notin> A"
     apply eventually_elim
     using ivl_subset_existence_ivl[OF \<open>t \<in> _\<close>]
     apply (subst (asm) flow0_cong[OF cong])
     by (auto simp: )
 
   moreover have "\<exists>t>0. t \<in> Y.existence_ivl0 x \<and> Y.flow0 x t \<in> A"
     using t
     by (auto intro!: exI[where x=t] simp: flow0_cong[OF cong] existence_ivl0_cong[OF cong])
   ultimately show ?thesis
     by (auto simp: Y.returns_to_def)
 qed
 
 lemma
   returns_to_congI2:
   assumes "auto_ll_on_open.returns_to g Y x A"
   shows "returns_to x A"
 proof -
   interpret Y: c1_on_open_euclidean g f' Y by (rule c1_on_open_euclidean_congI)
   show ?thesis
     by (rule Y.returns_to_congI1) (auto simp: assms cong)
 qed
 
 lemma returns_to_cong: "auto_ll_on_open.returns_to g Y A x = returns_to A x"
   using returns_to_congI1 returns_to_congI2 by blast
 
 lemma
   return_time_cong:
   shows "return_time A x = auto_ll_on_open.return_time g Y A x"
 proof -
   interpret Y: c1_on_open_euclidean g f' Y by (rule c1_on_open_euclidean_congI)
   have P_eq: "0 < t \<and> t \<in> existence_ivl0 x \<and> flow0 x t \<in> A \<and> (\<forall>s\<in>{0<..<t}. flow0 x s \<notin> A) \<longleftrightarrow>
     0 < t \<and> t \<in> Y.existence_ivl0 x \<and> Y.flow0 x t \<in> A \<and> (\<forall>s\<in>{0<..<t}. Y.flow0 x s \<notin> A)"
     for t
     using ivl_subset_existence_ivl[of t x]
     apply (auto simp: existence_ivl0_cong[OF cong] flow0_cong[OF cong])
      apply (drule bspec)
       apply force
      apply (subst (asm) flow0_cong[OF cong])
     apply auto
     apply (auto simp: existence_ivl0_cong[OF cong, symmetric] flow0_cong[OF cong])
      apply (subst (asm) flow0_cong[OF cong])
     apply auto
     done
   show ?thesis
     unfolding return_time_def Y.return_time_def
     by (auto simp: returns_to_cong P_eq)
 qed
 
 lemma poincare_mapsto_congI1:
   assumes "poincare_mapsto A B C D E" "closed A"
   shows "c1_on_open_euclidean.poincare_mapsto g Y A B C D E"
 proof -
   interpret Y: c1_on_open_euclidean g f' Y by (rule c1_on_open_euclidean_congI)
   show ?thesis
     using assms
     unfolding poincare_mapsto_def Y.poincare_mapsto_def
     apply auto
     subgoal for a b
       by (rule returns_to_congI1) auto
     subgoal for a b
       by (subst return_time_cong[abs_def, symmetric]) auto
     subgoal for a b
       unfolding poincare_map_def Y.poincare_map_def
       apply (drule bspec, assumption)
       apply safe
       subgoal for D
         apply (auto intro!: exI[where x=D])
         subgoal premises prems
         proof -
           have "\<forall>\<^sub>F y in at a within C. returns_to A y"
             apply (rule eventually_returns_to_continuousI)
               apply fact apply fact
             apply (rule differentiable_imp_continuous_within)
             apply fact
             done
           moreover have "\<forall>\<^sub>F y in at a within C. y \<in> C"
             by (auto simp: eventually_at_filter)
           ultimately have "\<forall>\<^sub>F x' in at a within C. flow0 x' (return_time A x') = Y.flow0 x' (Y.return_time A x')"
           proof eventually_elim
             case (elim x')
             then show ?case
               apply (subst flow0_cong[OF cong, symmetric], force)
                apply (subst return_time_cong[symmetric])
               using prems
                apply (auto intro!: return_time_exivl)
               apply (subst return_time_cong[symmetric])
               apply auto
               done
           qed
           with prems(7)
           show ?thesis
             apply (rule has_derivative_transform_eventually)
             using prems
              apply (subst flow0_cong[OF cong, symmetric], force)
               apply (subst return_time_cong[symmetric])
             using prems
               apply (auto intro!: return_time_exivl)
             apply (subst return_time_cong[symmetric])
             apply auto
             done
         qed
         subgoal
           apply (subst flow0_cong[OF cong, symmetric], force)
            apply (subst return_time_cong[symmetric])
            apply (auto intro!: return_time_exivl)
           apply (subst return_time_cong[symmetric])
           apply auto
           done
         done
       done
     subgoal for a b t
       apply (drule bspec, assumption)
       apply (subst flow0_cong[OF cong, symmetric])
         apply auto
        apply (subst (asm) return_time_cong[symmetric])
        apply (rule less_return_time_imp_exivl)
           apply (rule less_imp_le, assumption)
          apply (auto simp: return_time_cong)
       done
     done
 qed
 
 lemma poincare_mapsto_congI2:
   assumes "c1_on_open_euclidean.poincare_mapsto g Y A B C D E" "closed A"
   shows "poincare_mapsto A B C D E"
 proof -
   interpret Y: c1_on_open_euclidean g f' Y by (rule c1_on_open_euclidean_congI)
   show ?thesis
     apply (rule Y.poincare_mapsto_congI1)
     using assms
     by (auto simp: cong)
 qed
 
 lemma poincare_mapsto_cong: "closed A \<Longrightarrow>
     poincare_mapsto A B C D E = c1_on_open_euclidean.poincare_mapsto g Y A B C D E"
   using poincare_mapsto_congI1[of A B C] poincare_mapsto_congI2[of A B C] by auto
 
 end
 
 end
 
 end
\ No newline at end of file
diff --git a/thys/Valuation/Valuation2.thy b/thys/Valuation/Valuation2.thy
--- a/thys/Valuation/Valuation2.thy
+++ b/thys/Valuation/Valuation2.thy
@@ -1,2833 +1,2833 @@
 (**        Valuation2  
                             author Hidetsune Kobayashi
                             Group You Santo
                             Department of Mathematics
                             Nihon University
                             h_coba@math.cst.nihon-u.ac.jp
                             June 24, 2005
                             July 20  2007
 
    chapter 1. elementary properties of a valuation
      section 8. approximation(continued)
     
    **)
 
 theory Valuation2 
 imports Valuation1
 begin
 
 lemma (in Corps) OstrowskiTr8:"\<lbrakk>valuation K v; x \<in> carrier K; 
       0 < v (1\<^sub>r \<plusminus> -\<^sub>a x)\<rbrakk> \<Longrightarrow>
       0 < (v (1\<^sub>r \<plusminus> -\<^sub>a (x \<cdot>\<^sub>r ((1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x))\<^bsup>\<hyphen>K\<^esup>))))"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"])
 apply (frule aGroup.ag_mOp_closed[of "K" "x"], assumption+,
        frule Ring.ring_one[of "K"],
        frule aGroup.ag_pOp_closed[of "K" "1\<^sub>r" " -\<^sub>a x"], assumption+, 
        frule OstrowskiTr32[of v x], assumption+)
 apply (case_tac "x = 1\<^sub>r\<^bsub>K\<^esub>", simp,
        simp add:aGroup.ag_r_inv1, simp add:Ring.ring_times_x_0,
        simp add:aGroup.ag_r_zero, cut_tac val_field_1_neq_0,
        cut_tac invf_one, simp, simp add:Ring.ring_r_one,
        simp add:aGroup.ag_r_inv1, assumption+)
 apply (frule aGroup.ag_pOp_closed[of K "1\<^sub>r" "x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)"], assumption+, 
        rule Ring.ring_tOp_closed, assumption+)
  apply (cut_tac invf_closed[of "1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)"])
 
  apply (cut_tac field_one_plus_frac3[of x], simp del:npow_suc,
         subst val_t2p[of v], assumption+)
  apply (rule aGroup.ag_pOp_closed, assumption+,
         rule aGroup.ag_mOp_closed, assumption+, rule Ring.npClose, 
         assumption+,
         thin_tac "1\<^sub>r \<plusminus> -\<^sub>a x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x))\<^bsup>\<hyphen> K\<^esup> =
         (1\<^sub>r \<plusminus> -\<^sub>a x^\<^bsup>K (Suc (Suc 0))\<^esup>) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x))\<^bsup>\<hyphen> K\<^esup>",
         subgoal_tac "1\<^sub>r \<plusminus> -\<^sub>a x^\<^bsup>K (Suc (Suc 0))\<^esup> = (1\<^sub>r \<plusminus> x) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)",
         simp del:npow_suc,
         thin_tac "1\<^sub>r \<plusminus> -\<^sub>a x^\<^bsup>K (Suc (Suc 0))\<^esup> = (1\<^sub>r \<plusminus> x) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)")
  apply (subst val_t2p[of v], assumption+,
         rule aGroup.ag_pOp_closed, assumption+,
-        subst value_of_inv[of v "1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)"], assumption+)
+        subst value_of_inv[of v "1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)"], tactic \<open>CHANGED distinct_subgoals_tac\<close>, assumption+)
 
  apply (rule contrapos_pp, simp+,
         frule Ring.ring_tOp_closed[of K x "(1\<^sub>r \<plusminus> -\<^sub>a x)"], assumption+,
         simp add:aGroup.ag_pOp_commute[of K "1\<^sub>r"],
         frule aGroup.ag_eq_diffzero[THEN sym, of K "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r)" "-\<^sub>a 1\<^sub>r"],
         assumption+, rule aGroup.ag_mOp_closed, assumption+)
  apply (simp add:aGroup.ag_inv_inv[of K "1\<^sub>r"],
         frule eq_elems_eq_val[of "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r)" "-\<^sub>a 1\<^sub>r" v],
         thin_tac "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r) = -\<^sub>a 1\<^sub>r",
         simp add:val_minus_eq value_of_one)
         apply (simp add:val_t2p,
                frule aadd_pos_poss[of "v x" "v (-\<^sub>a x \<plusminus> 1\<^sub>r)"], assumption+,
                simp,
                subst value_less_eq[THEN sym, of v "1\<^sub>r" "x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)"],
                assumption+,
                rule Ring.ring_tOp_closed, assumption+,
                simp add:value_of_one, subst val_t2p[of v], assumption+,
                rule aadd_pos_poss[of "v x" "v (1\<^sub>r \<plusminus> -\<^sub>a x)"], assumption+,
                simp add:value_of_one,
                cut_tac aadd_pos_poss[of "v (1\<^sub>r \<plusminus> x)" "v (1\<^sub>r \<plusminus> -\<^sub>a x)"],
                simp add:aadd_0_r, rule val_axiom4, assumption+)
   apply (subst Ring.ring_distrib2, assumption+, simp add:Ring.ring_l_one,
          subst Ring.ring_distrib1, assumption+, simp add:Ring.ring_r_one,
          subst aGroup.pOp_assocTr43, assumption+, 
          rule Ring.ring_tOp_closed, assumption+,
          simp add:aGroup.ag_l_inv1 aGroup.ag_r_zero,
         subst Ring.ring_inv1_2, assumption+, simp, assumption+)
 
  apply simp
 
 apply (rule contrapos_pp, simp+,
        frule Ring.ring_tOp_closed[of K x "(1\<^sub>r \<plusminus> -\<^sub>a x)"], assumption+,
        simp add:aGroup.ag_pOp_commute[of K "1\<^sub>r"],
        frule aGroup.ag_eq_diffzero[THEN sym, of K "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r)" "-\<^sub>a 1\<^sub>r"],
        assumption+, rule aGroup.ag_mOp_closed, assumption+)
  apply (simp add:aGroup.ag_inv_inv[of K "1\<^sub>r"],
         frule eq_elems_eq_val[of "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r)" "-\<^sub>a 1\<^sub>r" v],
         thin_tac "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r) = -\<^sub>a 1\<^sub>r",
         simp add:val_minus_eq value_of_one,
         simp add:val_t2p,
         frule aadd_pos_poss[of "v x" "v (-\<^sub>a x \<plusminus> 1\<^sub>r)"], assumption+,
         simp)
 done
 
 lemma (in Corps) OstrowskiTr9:"\<lbrakk>valuation K v; x \<in> carrier K; 0 < (v x)\<rbrakk> \<Longrightarrow>
                  0 < (v (x \<cdot>\<^sub>r ((1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x))\<^bsup>\<hyphen>K\<^esup>)))"
 apply (subgoal_tac "1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x) \<noteq> \<zero>")
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        frule aGroup.ag_mOp_closed[of "K" "x"], assumption+,
        frule Ring.ring_one[of "K"], 
        frule aGroup.ag_pOp_closed[of "K" "1\<^sub>r" "-\<^sub>a x"], assumption+,
        subst val_t2p, assumption+,
        cut_tac invf_closed1[of "1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)"], simp) 
 apply simp
  apply (rule aGroup.ag_pOp_closed, assumption+,
         rule Ring.ring_tOp_closed, assumption+)
 (* 
  apply (rule contrapos_pp, simp+,
        frule Ring.ring_tOp_closed[of K x "(1\<^sub>r \<plusminus> -\<^sub>a x)"], assumption+) apply (
        simp add:aGroup.ag_pOp_commute[of K "1\<^sub>r"],
        frule aGroup.ag_eq_diffzero[THEN sym, of K "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r)" "-\<^sub>a 1\<^sub>r"])
        apply (rule Ring.ring_tOp_closed, assumption+,
               rule aGroup.ag_mOp_closed, assumption+)
        apply (simp add:aGroup.ag_inv_inv)
        apply (frule eq_elems_eq_val[of "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r)" "-\<^sub>a 1\<^sub>r" v],
         thin_tac "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r) = -\<^sub>a 1\<^sub>r",
         simp add:val_minus_eq value_of_one,
         simp add:val_t2p)
         apply (simp add:aadd_commute[of "v x" "v (-\<^sub>a x \<plusminus> 1\<^sub>r)"])
        apply (cut_tac aadd_pos_poss[of "v (-\<^sub>a x \<plusminus> 1\<^sub>r)" "v x"], simp)
        apply (simp add:val_minus_eq[THEN sym, of v x])
        apply (subst aGroup.ag_pOp_commute, assumption+)
        apply (rule val_axiom4[of v "-\<^sub>a x"], assumption+)
        apply (simp add:aless_imp_le, assumption) *)
  apply (subst value_of_inv[of v "1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)"], assumption+,
         rule aGroup.ag_pOp_closed, assumption+,
                rule Ring.ring_tOp_closed, assumption+,
         frule value_less_eq[THEN sym, of v "1\<^sub>r" "-\<^sub>a x"], assumption+,
         simp add:value_of_one, simp add:val_minus_eq,
         subst value_less_eq[THEN sym, of v "1\<^sub>r" "x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)"],
            assumption+, rule Ring.ring_tOp_closed, assumption+,
            simp add:value_of_one, subst val_t2p, assumption+,
            subst aadd_commute,
        rule aadd_pos_poss[of "v (1\<^sub>r \<plusminus> -\<^sub>a x)" "v x"],
        simp, assumption, simp add:value_of_one,
        simp add:aadd_0_r)
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of K],
        frule Ring.ring_one,
        rule contrapos_pp, simp+,
        frule Ring.ring_tOp_closed[of K x "(1\<^sub>r \<plusminus> -\<^sub>a x)"], assumption+,
        rule aGroup.ag_pOp_closed, assumption+,
        rule aGroup.ag_mOp_closed, assumption+,
        frule aGroup.ag_mOp_closed[of K x], assumption+)
 
 apply (simp add:aGroup.ag_pOp_commute[of K "1\<^sub>r"],
        frule aGroup.ag_eq_diffzero[THEN sym, of K "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r)" "-\<^sub>a 1\<^sub>r"],
        simp add:aGroup.ag_pOp_commute, 
        rule aGroup.ag_mOp_closed, assumption+,
        simp add:aGroup.ag_inv_inv,
        frule eq_elems_eq_val[of "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r)" "-\<^sub>a 1\<^sub>r" v],
         thin_tac "x \<cdot>\<^sub>r (-\<^sub>a x \<plusminus> 1\<^sub>r) = -\<^sub>a 1\<^sub>r",
         simp add:val_minus_eq value_of_one,
         frule_tac aGroup.ag_pOp_closed[of K "-\<^sub>a x" "1\<^sub>r"], assumption+,
         simp add:val_t2p)
   apply (simp add:aadd_commute[of "v x"],
          cut_tac aadd_pos_poss[of "v (-\<^sub>a x \<plusminus> 1\<^sub>r)" "v x"], simp,
          subst aGroup.ag_pOp_commute, assumption+,
          subst value_less_eq[THEN sym, of v "1\<^sub>r" "-\<^sub>a x"], assumption+,
          simp add:value_of_one val_minus_eq, simp add:value_of_one)
    
  apply assumption
 done
 
 lemma (in Corps) OstrowskiTr10:"\<lbrakk>valuation K v; x \<in> carrier K; 
        \<not> 0 \<le> v x\<rbrakk> \<Longrightarrow> 0 < (v (x \<cdot>\<^sub>r ((1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x))\<^bsup>\<hyphen>K\<^esup>)))" 
 apply (frule OstrowskiTr6[of "v" "x"], assumption+,
        cut_tac invf_closed1[of "1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)"], simp,
        erule conjE, simp add:aneg_le, frule val_neg_nonzero[of "v" "x"], 
        (erule conjE)+, assumption+, erule conjE) 
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        frule aGroup.ag_mOp_closed[of "K" "x"], assumption+, 
        frule Ring.ring_one[of "K"],
        frule aGroup.ag_pOp_closed[of "K" "1\<^sub>r" "-\<^sub>a x"], assumption+,
        subst val_t2p, assumption+)
 apply (subst value_of_inv[of "v" "1\<^sub>r \<plusminus> x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)"],
        assumption+, subst aGroup.ag_pOp_commute[of "K" "1\<^sub>r"], assumption+,
        rule Ring.ring_tOp_closed, assumption+,
        subst value_less_eq[THEN sym, of v 
                                       "x \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a x)" "1\<^sub>r"], assumption+)
 apply (rule Ring.ring_tOp_closed, assumption+, simp add:value_of_one,
        frule one_plus_x_nonzero[of "v" "-\<^sub>a x"], assumption,
        simp add:val_minus_eq, erule conjE, simp,
        subst val_t2p[of "v"], assumption+, simp add:aadd_two_negg)
 
 apply (simp add:val_t2p,
        frule value_less_eq[THEN sym, of "v" "-\<^sub>a x" "1\<^sub>r"], assumption+,
        simp add:value_of_one, simp add:val_minus_eq,
        simp add:val_minus_eq, simp add:aGroup.ag_pOp_commute[of "K" "-\<^sub>a x"],
        frule val_nonzero_z[of "v" "x"], assumption+, erule exE,
        simp add:a_zpz aminus, simp add:ant_0[THEN sym] aless_zless,
        assumption)
 done
 
 lemma (in Corps) Ostrowski_first:"vals_nonequiv K (Suc 0) vv
          \<Longrightarrow> \<exists>x\<in>carrier K. Ostrowski_elem K (Suc 0) vv x"  
  apply (simp add:vals_nonequiv_def,
         cut_tac Nset_Suc0, (erule conjE)+,
         simp add:valuations_def)
  apply (rotate_tac -1, 
         frule_tac a = 0 in forall_spec, simp,
         rotate_tac -1,
         drule_tac a = "Suc 0" in forall_spec, simp)
  apply (drule_tac a = "Suc 0" in forall_spec, simp,
         rotate_tac -1,
         drule_tac a = 0 in forall_spec, simp, simp)
  apply (frule_tac a = 0 in forall_spec, simp,
         drule_tac a = "Suc 0" in forall_spec, simp,
         frule_tac v = "vv 0" and v' = "vv (Suc 0)" in 
          nonequiv_ex_Ostrowski_elem, assumption+,
          erule bexE) 
 
  apply (erule conjE,
         frule_tac v = "vv (Suc 0)" and v' = "vv 0" in 
         nonequiv_ex_Ostrowski_elem, assumption+,
         erule bexE,
         thin_tac "\<not> v_equiv K (vv (Suc 0)) (vv 0)",
         thin_tac "\<not> v_equiv K (vv 0) (vv (Suc 0))")
 
  apply (rename_tac s t) (* we show s and t are non-zero in the following 4
                           lines *) 
  apply (erule conjE,
         frule_tac x = t and v = "vv 0" in val_neg_nonzero, assumption+) 
 apply (simp add:less_ant_def, (erule conjE)+,
        frule_tac x = s and v = "vv (Suc 0)" in val_neg_nonzero,
        assumption+, unfold less_ant_def) 
 apply (rule conjI, assumption+)  
 
  apply (frule_tac s = s and t = t and v = "vv 0" in OstrowskiTr2, 
         assumption+, rule ale_neq_less, assumption+)
  apply (frule_tac s = s and t = t and v = "vv (Suc 0)" in OstrowskiTr3,
          assumption+, rule ale_neq_less, assumption+) 
  apply (subgoal_tac "t \<cdot>\<^sub>r (( s \<plusminus> t)\<^bsup>\<hyphen>K\<^esup>) \<in> carrier K",
         simp only:Ostrowski_elem_def,
         simp only: nset_m_m[of "Suc 0"], blast) 
        (* Here simp add:nset_m_m[of "Suc 0"] wouldn't work *)
  apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
         rule Ring.ring_tOp_closed, assumption+,
         frule_tac s = s and t = t and v = "vv 0" in OstrowskiTr1, 
         assumption+, rule ale_neq_less, assumption+,
         frule_tac x = s and y = t in aGroup.ag_pOp_closed[of "K"], assumption+)
     apply (cut_tac x = "s \<plusminus> t" in invf_closed, blast)
     apply assumption     (* in the above two lines, simp wouldn't work *)
 done
 
 (** subsection on inequality **)
 
 lemma (in Corps) Ostrowski:"\<forall>vv. vals_nonequiv K (Suc n) vv \<longrightarrow> 
                         (\<exists>x\<in>carrier K. Ostrowski_elem K (Suc n) vv x)" 
 apply (induct_tac n,
  rule allI, rule impI, simp add:Ostrowski_first)
 (** case (Suc n) **)
  apply (rule allI, rule impI,
        frule_tac n = n and vv = vv in restrict_vals_nonequiv1,
        frule_tac n = n and vv = vv in restrict_vals_nonequiv2,
        frule_tac a = "compose {h. h \<le> Suc n} vv (skip 1)" in forall_spec,
         assumption,
        drule_tac a = "compose {h. h \<le> Suc n} vv (skip 2)" in forall_spec,
          assumption+, (erule bexE)+) 
 apply (rename_tac n vv s t,
        cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"])
 (**  case * * *  **)
  apply (frule_tac x = s and y = t in Ring.ring_tOp_closed[of "K"], assumption+,
         case_tac "0 \<le> vv (Suc 0) s \<and> 0 \<le> vv (Suc (Suc 0)) t",
         frule_tac vv = vv and s = s and t = t in OstrowskiTr5, assumption+) 
  apply blast
 
 
  (** case * * * **)
 apply (simp, 
        case_tac "0 \<le> (vv (Suc 0) s)", simp,
        frule_tac n = "Suc (Suc n)" and m = "Suc (Suc 0)" and vv = vv in 
          vals_nonequiv_valuation,
        simp,
        frule_tac v = "vv (Suc (Suc 0))" and x = t in OstrowskiTr6,
          assumption+,
        frule_tac x = "1\<^sub>r \<plusminus> t \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a t)" in invf_closed1,
        frule_tac x = t and y = "(1\<^sub>r \<plusminus> t \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a t))\<^bsup>\<hyphen>K\<^esup>" in 
                Ring.ring_tOp_closed, assumption+, simp)
 apply (subgoal_tac "Ostrowski_elem K (Suc (Suc n)) vv 
                        (t \<cdot>\<^sub>r ((1\<^sub>r \<plusminus> t \<cdot>\<^sub>r (1\<^sub>r \<plusminus> (-\<^sub>a t)))\<^bsup>\<hyphen>K\<^esup>))",
        blast)
 apply (subst Ostrowski_elem_def,
        rule conjI,
        thin_tac "Ostrowski_elem K (Suc n)
          (compose {h. h \<le> Suc n} vv (skip (Suc 0))) s",
        thin_tac "vals_nonequiv K (Suc n)
          (compose {h. h \<le> Suc n} vv (skip (Suc 0)))",
        thin_tac "vals_nonequiv K (Suc n) (compose {h. h\<le> Suc n} vv (skip 2))",
        thin_tac "0 \<le> (vv (Suc 0) s)",
        frule_tac n = "Suc (Suc n)" and vv = vv and m = 0 in 
                       vals_nonequiv_valuation, simp,
        rule_tac v = "vv 0" and x = t in 
           OstrowskiTr8, assumption+)
 
 apply (simp add:Ostrowski_elem_def, (erule conjE)+,
        thin_tac "\<forall>j\<in>nset (Suc 0) (Suc n).
             0 < (compose {h. h \<le> (Suc n)} vv (skip 2) j t)",
        simp add:compose_def skip_def,
        rule ballI,
        thin_tac "0 \<le> (vv (Suc 0) s)",
        thin_tac "Ostrowski_elem K (Suc n) 
                     (compose {h. h \<le> (Suc n)} vv (skip (Suc 0))) s",
        frule_tac n = "Suc (Suc n)" and vv = vv and m = j in 
                      vals_nonequiv_valuation,
        simp add:nset_def, simp add:Ostrowski_elem_def, (erule conjE)+)
  (** case * * * **)
  apply (case_tac "j = Suc 0", simp,
         drule_tac x = "Suc 0" in bspec,
         simp add:nset_def,
         simp add:compose_def skip_def,
         rule_tac v = "vv (Suc 0)" and x = t in 
          OstrowskiTr9, assumption+,
         frule_tac j = j and n = n in nset_Tr51, assumption+,
         drule_tac x = "j - Suc 0" in bspec, assumption+,
         simp add:compose_def skip_def)
  (** case * * * **) 
  apply (case_tac "j = Suc (Suc 0)", simp) apply (
        rule_tac v = "vv (Suc (Suc 0))" and x = t in OstrowskiTr10, 
        assumption+) apply (
        subgoal_tac "\<not> j - Suc 0 \<le> Suc 0", simp add:nset_def) apply(
        rule_tac v = "vv j" and x = t in 
                     OstrowskiTr9) apply (simp add:nset_def, assumption+) 
 apply (simp add:nset_def, (erule conjE)+, rule nset_Tr52, assumption+,
        thin_tac "vals_nonequiv K (Suc n)
          (compose {h. h \<le> (Suc n)} vv (skip (Suc 0)))",
        thin_tac "vals_nonequiv K (Suc n) 
                    (compose {h. h \<le> (Suc n)} vv (skip 2))",
        thin_tac "Ostrowski_elem K (Suc n) 
                    (compose {h. h \<le>(Suc n)} vv (skip 2)) t")
  apply (subgoal_tac "s \<cdot>\<^sub>r ((1\<^sub>r \<plusminus> s \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a s))\<^bsup>\<hyphen>K\<^esup>) \<in> carrier K",
         subgoal_tac "Ostrowski_elem K (Suc (Suc n)) vv 
                             (s \<cdot>\<^sub>r ((1\<^sub>r \<plusminus> s \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a s))\<^bsup>\<hyphen>K\<^esup>))", blast)
  prefer 2
  apply (frule_tac n = "Suc (Suc n)" and m = "Suc 0" and vv = vv in 
         vals_nonequiv_valuation, simp,
      frule_tac v = "vv (Suc 0)" and x = s in OstrowskiTr6, assumption+,
      rule Ring.ring_tOp_closed, assumption+,
      frule_tac x = "1\<^sub>r \<plusminus> s \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a s)" in invf_closed1, simp,
      simp add:Ostrowski_elem_def)
 apply (rule conjI)
 apply (rule_tac v = "vv 0" and x = s in OstrowskiTr8,
        simp add:vals_nonequiv_valuation, assumption+) 
        apply (
        thin_tac "vals_nonequiv K (Suc (Suc n)) vv",
        (erule conjE)+,
        thin_tac "\<forall>j\<in>nset (Suc 0) (Suc n).
             0 < (compose {h. h \<le> (Suc n)} vv (skip (Suc 0)) j s)",
        simp add:compose_def skip_def,  rule ballI)
  (** case *** *** **)
  apply (case_tac "j = Suc 0", simp,
      rule_tac v = "vv (Suc 0)" and x = s in OstrowskiTr10,
      simp add:vals_nonequiv_valuation, assumption+,
      rule_tac v = "vv j" and x = s in OstrowskiTr9,
      simp add:vals_nonequiv_valuation nset_def, assumption,
      (erule conjE)+, simp add:compose_def skip_def,
      frule_tac j = j in nset_Tr51, assumption+,
      drule_tac x = "j - Suc 0" in bspec, assumption+)
  apply (simp add:nset_def)
 done
 
 lemma (in Corps) val_1_nonzero:"\<lbrakk>valuation K v; x \<in> carrier K; v x = 1\<rbrakk> \<Longrightarrow>
                                x \<noteq> \<zero>"
 apply (rule contrapos_pp, simp+,
        simp add:value_of_zero,
        rotate_tac 3, drule sym, simp only:ant_1[THEN sym],
        simp del:ant_1)
 done
 
 lemma (in Corps) Approximation1_5Tr1:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
  n_val K (vv 0) = vv 0; a \<in> carrier K; vv 0 a = 1; x \<in> carrier K; 
  Ostrowski_elem K (Suc n) vv x\<rbrakk>  \<Longrightarrow> 
         \<forall>m. 2 \<le> m \<longrightarrow> vv 0 ((1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K m\<^esup> \<plusminus> a \<cdot>\<^sub>r (x^\<^bsup>K m\<^esup>)) = 1" 
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        frule Ring.ring_one[of "K"],
        rule allI, rule impI,
        frule vals_nonequiv_valuation[of "Suc n" "vv" "0"],
        simp,
        simp add:Ostrowski_elem_def, frule conjunct1, fold Ostrowski_elem_def,
        frule val_1_nonzero[of "vv 0" "a"], assumption+)
 apply (frule vals_nonequiv_valuation[of "Suc n" "vv" "0"], simp,
        frule val_nonzero_noninf[of "vv 0" "a"], assumption+,
        frule val_unit_cond[of "vv 0" "x"], assumption+,
        frule_tac n = m in Ring.npClose[of "K" "x"], assumption+,
        frule aGroup.ag_mOp_closed[of "K" "x"], assumption+,
        frule aGroup.ag_pOp_closed[of "K" "1\<^sub>r" "-\<^sub>a x"], assumption+) 
 apply (subgoal_tac "0 < m",
        frule_tac x = "a \<cdot>\<^sub>r (x^\<^bsup>K m\<^esup>)" and y = "(1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K m\<^esup>" in 
        value_less_eq[of "vv 0"],
        rule Ring.ring_tOp_closed, assumption+,
        rule Ring.npClose, assumption+, simp add: val_t2p,
        frule value_zero_nonzero[of "vv 0" "x"], assumption+,
        simp add:val_exp_ring[THEN sym], simp add:asprod_n_0 aadd_0_r) 
 apply (case_tac "x = 1\<^sub>r\<^bsub>K\<^esub>", simp add:aGroup.ag_r_inv1,
        frule_tac n = m in Ring.npZero_sub[of "K"], simp,
        simp add:value_of_zero) 
 apply (cut_tac inf_ge_any[of "1"], simp add: less_le)
 apply (rotate_tac -1, drule not_sym,
       frule aGroup.ag_neq_diffnonzero[of "K" "1\<^sub>r" "x"],
       simp add:Ring.ring_one[of "K"], assumption+, simp,
       simp add:val_exp_ring[THEN sym],
       cut_tac n1 = m in of_nat_0_less_iff[THEN sym]) 
 apply (cut_tac a = "0 < m" and b = "0 < int m" in a_b_exchange, simp,
        assumption)
 apply (thin_tac "(0 < m) = (0 < int m)",
       frule val_nonzero_z[of "vv 0" "1\<^sub>r \<plusminus> -\<^sub>a x"], assumption+,
       erule exE, simp, simp add:asprod_amult a_z_z,
       simp only:ant_1[THEN sym], simp only:aless_zless, simp add:ge2_zmult_pos)
 
 apply (subst aGroup.ag_pOp_commute[of "K"], assumption+,
        rule Ring.npClose, assumption+, rule Ring.ring_tOp_closed[of "K"], 
        assumption+,
        rotate_tac -1, drule sym, simp,
        thin_tac "vv 0 (a \<cdot>\<^sub>r x^\<^bsup>K m\<^esup> \<plusminus> (1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K m\<^esup>) = vv 0 (a \<cdot>\<^sub>r x^\<^bsup>K m\<^esup>)") 
 apply (simp add:val_t2p,
        frule value_zero_nonzero[of "vv 0" "x"], assumption+,
        simp add:val_exp_ring[THEN sym], simp add:asprod_n_0,
        simp add:aadd_0_r,
        cut_tac z = m in less_le_trans[of "0" "2"], simp, assumption+)
 done
 
 lemma (in Corps) Approximation1_5Tr3:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
       x \<in> carrier K; Ostrowski_elem K (Suc n) vv x; j \<in> nset (Suc 0) (Suc n)\<rbrakk>
         \<Longrightarrow>  vv j ((1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K m\<^esup>) = 0"
 apply (frule Ostrowski_elem_not_one[of "n" "vv" "x"], assumption+,
        cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        frule Ring.ring_one[of "K"],
        frule aGroup.ag_pOp_closed[of "K" "1\<^sub>r" "-\<^sub>a x"], assumption+)
 apply (simp add:aGroup.ag_mOp_closed, simp add:nset_def,
        frule_tac m = j in vals_nonequiv_valuation[of "Suc n" "vv"],
        simp,
        frule_tac v1 = "vv j" and x1 = "1\<^sub>r \<plusminus> -\<^sub>a x" and n1 = m in 
         val_exp_ring[THEN sym], assumption+) 
 
 apply (frule_tac v = "vv j" and x = "1\<^sub>r" and  y = "-\<^sub>a x" in 
        value_less_eq, assumption+, simp add:aGroup.ag_mOp_closed) 
  apply(simp add:value_of_one, simp add:val_minus_eq,
        simp add:Ostrowski_elem_def nset_def)
 apply (simp add:value_of_one, rotate_tac -1, drule sym,
        simp add:asprod_n_0)
 done
 
 lemma (in Corps) Approximation1_5Tr4:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
      aa \<in> carrier K; x \<in> carrier K;
      Ostrowski_elem K (Suc n) vv x; j \<le> (Suc n)\<rbrakk> \<Longrightarrow>
      vv j (aa \<cdot>\<^sub>r (x^\<^bsup>K m\<^esup>)) = vv j aa + (int m) *\<^sub>a (vv j  x)"
 apply (frule Ostrowski_elem_nonzero[of "n" "vv" "x"],
                                           assumption+,
        cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"])
 apply (frule_tac m = j in vals_nonequiv_valuation[of "Suc n" "vv"], assumption)
 apply (subst val_t2p[of "vv j"], assumption+,
        rule Ring.npClose, assumption+,
        cut_tac field_is_idom,
        frule_tac v1 = "vv j" and x1 = x and n1 = m in 
        val_exp_ring[THEN sym], assumption+, simp)
 done
 
 lemma (in Corps) Approximation1_5Tr5:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
      a \<in> carrier K; a \<noteq> \<zero>; x \<in> carrier K;
      Ostrowski_elem K (Suc n) vv x; j \<in> nset (Suc 0) (Suc n)\<rbrakk> \<Longrightarrow>
                \<exists>l. \<forall>m. l < m \<longrightarrow> 0 < (vv j (a \<cdot>\<^sub>r (x^\<^bsup>K m\<^esup>)))"
 apply (frule Ostrowski_elem_nonzero[of "n" "vv" "x"], assumption+,
       subgoal_tac "\<forall>n. vv j (a \<cdot>\<^sub>r (x^\<^bsup>K n\<^esup>)) = vv j a + (int n) *\<^sub>a (vv j  x)",
       simp,
       thin_tac "\<forall>n. vv j (a \<cdot>\<^sub>r x^\<^bsup>K n\<^esup>) = vv j a + int n *\<^sub>a vv j x")
 prefer 2
 apply (rule allI, rule Approximation1_5Tr4[of _ vv a x j],
          assumption+, simp add:nset_def)
 apply (frule_tac m = j in vals_nonequiv_valuation[of "Suc n" "vv"], 
        simp add:nset_def,
        frule val_nonzero_z[of "vv j" "a"], assumption+, erule exE,
        simp add:Ostrowski_elem_def,
        frule conjunct2, fold Ostrowski_elem_def,
        drule_tac x = j in bspec, assumption) 
 apply (frule Ostrowski_elem_nonzero[of "n" "vv" "x"], assumption+,
        frule val_nonzero_z[of "vv j" "x"], assumption+, erule exE, simp,
        frule_tac a = za and x = z in zmult_pos_bignumTr,
        simp add:asprod_amult a_z_z a_zpz)
 done  
 
 lemma (in Corps) Approximation1_5Tr6:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
       a \<in> carrier K; a \<noteq> \<zero>; x \<in> carrier K;
       Ostrowski_elem K (Suc n) vv x; j \<in> nset (Suc 0) (Suc n)\<rbrakk> \<Longrightarrow>
         \<exists>l. \<forall>m. l < m \<longrightarrow> vv j ((1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K m\<^esup> \<plusminus> a \<cdot>\<^sub>r (x^\<^bsup>K m\<^esup>)) = 0" 
 apply (frule vals_nonequiv_valuation[of "Suc n" "vv" "j"], 
        simp add:nset_def, 
        frule Approximation1_5Tr5[of "n" "vv" "a" "x" "j"],
                assumption+, erule exE,
        cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        subgoal_tac "\<forall>m. l < m \<longrightarrow> vv j ((1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K m\<^esup> \<plusminus> a \<cdot>\<^sub>r (x^\<^bsup>K m\<^esup>)) = 
        vv j ((1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K m\<^esup>)")
  apply (simp add:Approximation1_5Tr3, blast)
  apply (rule allI, rule impI, 
         drule_tac a = m in forall_spec, assumption,
         frule_tac x = "(1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K m\<^esup>" and y = "a \<cdot>\<^sub>r (x^\<^bsup>K m\<^esup>)" in 
            value_less_eq[of "vv j"],
         rule Ring.npClose, assumption+,
         rule aGroup.ag_pOp_closed, assumption+, simp add:Ring.ring_one,
         simp add:aGroup.ag_mOp_closed)
  apply (rule Ring.ring_tOp_closed, assumption+,
         rule Ring.npClose, assumption+,
         simp add:Approximation1_5Tr3,
         frule sym, assumption)
 done 
 
 lemma (in Corps) Approximation1_5Tr7:"\<lbrakk>a \<in> carrier K; vv 0 a = 1; 
       x \<in> carrier K\<rbrakk> \<Longrightarrow> 
       vals_nonequiv K (Suc n) vv  \<and> Ostrowski_elem K (Suc n) vv x \<longrightarrow> 
       (\<exists>l. \<forall>m. l < m \<longrightarrow> (\<forall>j\<in>nset (Suc 0) (Suc n). 
                 (vv j ((1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K m\<^esup> \<plusminus> a \<cdot>\<^sub>r (x^\<^bsup>K m\<^esup>)) = 0)))"
 apply (induct_tac n,
        rule impI, erule conjE, simp add:nset_m_m[of "Suc 0"],
        frule vals_nonequiv_valuation[of "Suc 0" "vv" "Suc 0"], simp,
        frule Approximation1_5Tr6[of "0" "vv" "a" "x" "Suc 0"], assumption+) 
 apply (frule vals_nonequiv_valuation[of "Suc 0" "vv" "0"], simp,
        frule val_1_nonzero[of "vv 0" "a"], assumption+, simp add:nset_def,
        assumption)
 (** case n **) 
 apply (rule impI, erule conjE,
        frule_tac n = n in  restrict_vals_nonequiv[of _ "vv"],
        frule_tac n = n in restrict_Ostrowski_elem[of "x"  _ "vv"],
           assumption, simp,
        erule exE,
        frule_tac n = "Suc n" and j = "Suc (Suc n)" in Approximation1_5Tr6 
         [of _ "vv" "a" "x"], assumption+,
        frule_tac n = "Suc (Suc n)" in vals_nonequiv_valuation[of _ "vv" 
         "0"],simp,
        rule val_1_nonzero[of "vv 0" "a"], assumption+,
        simp add:nset_def)
 apply (erule exE,
        subgoal_tac "\<forall>m. (max l la) < m \<longrightarrow> (\<forall>j\<in>nset (Suc 0) (Suc (Suc n)).
          vv j ((1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K m\<^esup> \<plusminus> a \<cdot>\<^sub>r (x^\<^bsup>K m\<^esup>)) = 0)",
        blast,
       simp add:nset_Suc)
 done   
 
 lemma (in Corps) Approximation1_5P:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
     n_val K (vv 0) = vv 0\<rbrakk> \<Longrightarrow> 
     \<exists>x\<in>carrier K. ((vv 0 x = 1) \<and> (\<forall>j\<in>nset (Suc 0) (Suc n). (vv j x) = 0))"
 apply (frule vals_nonequiv_valuation[of "Suc n" "vv" "0"], simp) apply (
        frule n_val_surj[of "vv 0"], erule bexE) apply ( 
        rename_tac aa) apply ( 
        cut_tac n = n in Ostrowski) apply (
        drule_tac a = vv in forall_spec[of "vals_nonequiv K (Suc n)"], simp)
   apply (
        erule bexE,
        frule_tac a = aa and x = x in Approximation1_5Tr1[of "n" "vv"], 
        assumption+,
        simp, assumption+)
 apply (frule_tac a = aa and x = x in Approximation1_5Tr7[of _ "vv" _ "n"],
        simp, assumption,
        simp, erule exE,
        cut_tac b = "Suc l" in max.cobounded1[of "2"],
        cut_tac b = "Suc l" in max.cobounded2[of _ "2"],
        cut_tac n = l in lessI,
        frule_tac x = l and y = "Suc l" and z = "max 2 (Suc l)" in 
          less_le_trans, assumption+,
        thin_tac "Suc l \<le> max 2 (Suc l)", thin_tac "l < Suc l",
        drule_tac a = "max 2 (Suc l)" in forall_spec, simp,
        drule_tac a = "max 2 (Suc l)" in forall_spec, assumption) 
  apply (subgoal_tac "(1\<^sub>r \<plusminus> -\<^sub>a x)^\<^bsup>K (max 2 (Suc l))\<^esup> \<plusminus> aa \<cdot>\<^sub>r (x^\<^bsup>K (max 2 (Suc l))\<^esup>) \<in> 
        carrier K",
        blast,
        cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        rule aGroup.ag_pOp_closed, assumption+, rule Ring.npClose, assumption+,
        rule aGroup.ag_pOp_closed, assumption+, simp add:Ring.ring_one,
        simp add:aGroup.ag_mOp_closed, rule Ring.ring_tOp_closed, assumption+,
        rule Ring.npClose, assumption+)
 done
 
 lemma K_gamma_hom:"k \<le> n \<Longrightarrow> \<forall>j \<le> n. (\<lambda>l. \<gamma>\<^bsub>k l\<^esub>) j \<in> Zset"
 apply (simp add:Zset_def) 
 done
 
 lemma transpos_eq:"(\<tau>\<^bsub>0 0\<^esub>) k = k"
 by (simp add:transpos_def)
 
 lemma (in Corps) transpos_vals_nonequiv:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
       j \<le> (Suc n)\<rbrakk> \<Longrightarrow> vals_nonequiv K (Suc n) (vv \<circ> (\<tau>\<^bsub>0 j\<^esub>))"
 apply (simp add:vals_nonequiv_def)
  apply (frule conjunct1, fold vals_nonequiv_def)
  apply (simp add:valuations_def, rule conjI)
  apply (rule allI, rule impI) 
  apply (case_tac "ja = 0", simp,
         case_tac "j = 0", simp add:transpos_eq)
  apply (subst transpos_ij_1[of "0" "Suc n" "j"], simp, assumption+,
         rule not_sym, assumption, simp)
 
  apply (case_tac "ja = j", simp) 
  apply (subst transpos_ij_2[of "0" "Suc n" "j"], simp, assumption, simp,
         simp add:vals_nonequiv_valuation)
  apply (case_tac "j = 0", simp add:transpos_eq) 
  apply (cut_tac x = ja in transpos_id_1[of 0 "Suc n" j], simp, assumption+,
         rule not_sym, assumption+)
  apply (simp add:vals_nonequiv_valuation,
         (rule allI, rule impI)+, rule impI)
  apply (case_tac "j = 0", simp add:transpos_eq,
         simp add:vals_nonequiv_def,
         cut_tac transpos_inj[of "0" "Suc n" "j"], simp) 
  apply (frule_tac x = ja and y = l in injective[of "transpos 0 j" 
                        "{j. j \<le> (Suc n)}"], simp, simp, assumption+)
  apply (cut_tac l = ja in transpos_mem[of "0" "Suc n" "j"], simp, assumption+,
         simp, assumption,
        cut_tac l = l in transpos_mem[of "0" "Suc n" "j"], simp, assumption+,
         simp, assumption) 
  apply (simp add:vals_nonequiv_def,
         simp, assumption, rule not_sym, assumption)
 done
 
 definition
   Ostrowski_base :: "[_, nat \<Rightarrow> 'b \<Rightarrow> ant, nat] \<Rightarrow> (nat \<Rightarrow> 'b)"
                              ("(\<Omega>\<^bsub>_ _ _\<^esub>)" [90,90,91]90) where
   "Ostrowski_base K vv n = (\<lambda>j\<in>{h. h \<le> n}. (SOME x. x\<in>carrier K \<and>
                             (Ostrowski_elem K n (vv \<circ> (\<tau>\<^bsub>0 j\<^esub>)) x)))"
 
 definition
   App_base :: "[_, nat \<Rightarrow> 'b \<Rightarrow> ant, nat] \<Rightarrow> (nat \<Rightarrow> 'b)" where
   "App_base K vv n = (\<lambda>j\<in>{h. h \<le> n}. (SOME x. x\<in>carrier K \<and> (((vv \<circ> \<tau>\<^bsub>0 j\<^esub>) 0 x 
                       = 1) \<and> (\<forall>k\<in>nset (Suc 0) n. ((vv \<circ> \<tau>\<^bsub>0 j\<^esub>) k x) = 0))))"
   (* Approximation base. *)
 
 lemma (in Corps) Ostrowski_base_hom:"vals_nonequiv K (Suc n) vv \<Longrightarrow> 
       Ostrowski_base K vv (Suc n) \<in> {h. h \<le> (Suc n)} \<rightarrow> carrier K"
 apply (rule Pi_I, rename_tac l,
        simp add:Ostrowski_base_def,
        frule_tac j = l in transpos_vals_nonequiv[of n vv], simp,
        cut_tac Ostrowski[of n]) 
 apply (drule_tac a = "vv \<circ> \<tau>\<^bsub>0 l\<^esub>" in forall_spec, simp,
        rule someI2_ex, blast, simp)
 done
 
 lemma (in Corps) Ostrowski_base_mem:"vals_nonequiv K (Suc n) vv \<Longrightarrow> 
          \<forall>j \<le> (Suc n). Ostrowski_base K vv (Suc n) j \<in> carrier K"
 by (rule allI, rule impI,
        frule Ostrowski_base_hom[of "n" "vv"],
        simp add:funcset_mem del:Pi_I')
 
 lemma (in Corps)  Ostrowski_base_mem_1:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
        j \<le> (Suc n)\<rbrakk> \<Longrightarrow> Ostrowski_base K vv (Suc n) j \<in> carrier K"
 by (simp add:Ostrowski_base_mem)
 
 lemma (in Corps) Ostrowski_base_nonzero:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
        j \<le> Suc n\<rbrakk>  \<Longrightarrow> (\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j \<noteq> \<zero>"
 apply (simp add:Ostrowski_base_def,
        frule_tac j = j in transpos_vals_nonequiv[of "n" "vv"],
                       assumption+,
        cut_tac Ostrowski[of "n"],
        drule_tac a = "vv \<circ> \<tau>\<^bsub>0 j\<^esub>" in forall_spec, assumption,
        rule someI2_ex, blast) 
 apply (thin_tac "\<exists>x\<in>carrier K. Ostrowski_elem K (Suc n) (vv \<circ> \<tau>\<^bsub>0 j\<^esub>) x",
        erule conjE)
 apply (rule_tac vv = "vv \<circ> \<tau>\<^bsub>0 j\<^esub>" and x = x in Ostrowski_elem_nonzero[of "n"],
        assumption+)
 done
 
 lemma (in Corps) Ostrowski_base_pos:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
       j \<le> Suc n; ja \<le> Suc n; ja \<noteq> j\<rbrakk> \<Longrightarrow> 0 < ((vv j) ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja))"
 apply (simp add:Ostrowski_base_def,
        frule_tac j = ja in transpos_vals_nonequiv[of "n" "vv"],
        assumption+,
        cut_tac Ostrowski[of "n"],
        drule_tac a = "vv \<circ> \<tau>\<^bsub>0 ja\<^esub>" in forall_spec, assumption+) 
 apply (rule someI2_ex, blast,
        thin_tac "\<exists>x\<in>carrier K. Ostrowski_elem K (Suc n) (vv \<circ> \<tau>\<^bsub>0 ja\<^esub>) x",
        simp add:Ostrowski_elem_def, (erule conjE)+)
 apply (case_tac "ja = 0", simp, cut_tac transpos_eq[of "j"],
        simp add:nset_def, frule Suc_leI[of "0" "j"],
        frule_tac a = j in forall_spec, simp, simp)
 apply (case_tac "j = 0", simp,
        frule_tac x = ja in bspec, simp add:nset_def,
        cut_tac  transpos_ij_2[of "0" "Suc n" "ja"], simp, simp+) 
 apply (frule_tac x = j in bspec, simp add:nset_def,
        cut_tac transpos_id[of "0" "Suc n" "ja" "j"], simp+) 
 done
 
 lemma (in Corps) App_base_hom:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
       \<forall>j \<le> (Suc n). n_val K (vv j) = vv j\<rbrakk> \<Longrightarrow>
         \<forall>j \<le> (Suc n). App_base K vv (Suc n) j \<in> carrier K"
 apply (rule allI, rule impI,
        rename_tac k,
        subst App_base_def)
  apply (case_tac "k = 0", simp, simp add:transpos_eq,
         frule Approximation1_5P[of "n" "vv"], simp,
         rule someI2_ex, blast, simp)
  apply (frule_tac j = k in transpos_vals_nonequiv[of "n" "vv"],
                  simp add:nset_def,
         frule_tac vv = "vv \<circ> \<tau>\<^bsub>0 k\<^esub>" in Approximation1_5P[of "n"])
  apply (simp add:cmp_def, subst transpos_ij_1[of "0" "Suc n"], simp+,
         subst transpos_ij_1[of 0 "Suc n" k], simp+)
  apply (rule someI2_ex, blast, simp)
 done
 
 lemma (in Corps) Approzimation1_5P2:"\<lbrakk>vals_nonequiv K (Suc n) vv;
            \<forall>l\<in>{h. h \<le> Suc n}. n_val K (vv l) = vv l; i \<le> Suc n; j \<le> Suc n\<rbrakk>
           \<Longrightarrow> vv i (App_base K vv (Suc n) j) = \<delta>\<^bsub>i j\<^esub> "
 apply (simp add:App_base_def) 
 apply (case_tac "j = 0", simp add:transpos_eq,
        rule someI2_ex,
        frule Approximation1_5P[of "n" "vv"], simp , blast,
        simp add:Kronecker_delta_def, rule impI, (erule conjE)+,
        frule_tac x = i in bspec, simp add:nset_def, assumption) 
 
 apply (frule_tac j = j in transpos_vals_nonequiv[of "n" "vv"], simp,
        frule Approximation1_5P[of "n" "vv \<circ> \<tau>\<^bsub>0 j\<^esub>"],
        simp add:cmp_def, simp add:transpos_ij_1[of 0 "Suc n" j])
        
 apply (simp add:cmp_def,
          case_tac "i = 0", simp add:transpos_eq,
          simp add:transpos_ij_1, simp add:Kronecker_delta_def,
          rule someI2_ex, blast,
          thin_tac "\<exists>x\<in>carrier K.
             vv j x = 1 \<and> (\<forall>ja\<in>nset (Suc 0) (Suc n). vv ((\<tau>\<^bsub>0 j\<^esub>) ja) x = 0)",
         (erule conjE)+,
          drule_tac x = j in bspec, simp add:nset_def,
          simp add:transpos_ij_2)
 
 apply (simp add:Kronecker_delta_def,
        case_tac "i = j", simp add:transpos_ij_1, rule someI2_ex, blast, simp)
 
 apply (simp, rule someI2_ex, blast,
        thin_tac "\<exists>x\<in>carrier K. vv ((\<tau>\<^bsub>0 j\<^esub>) 0) x = 1 \<and> 
                      (\<forall>ja\<in>nset (Suc 0) (Suc n). vv ((\<tau>\<^bsub>0 j\<^esub>) ja) x = 0)",
        (erule conjE)+,
        drule_tac x = i in bspec, simp add:nset_def,
        cut_tac transpos_id[of 0 "Suc n" j i], simp+)
 done
 
 (*
 lemma (in Corps) Approximation1_5:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
   \<forall>j \<le> (Suc n)}. n_val K (vv j) = vv j\<rbrakk> \<Longrightarrow>
   \<exists>x\<in>{h. h \<le> (Suc n)} \<rightarrow> carrier K. \<forall>i \<le> (Suc n). \<forall>j \<le> (Suc n). 
                               ((vv i)  (x j) = \<delta>\<^bsub>i j\<^esub>)" *)
 
 lemma (in Corps) Approximation1_5:"\<lbrakk>vals_nonequiv K (Suc n) vv;
   \<forall>j \<le> (Suc n). n_val K (vv j) = vv j\<rbrakk> \<Longrightarrow>
   \<exists>x. (\<forall>j \<le> (Suc n). x j \<in> carrier K) \<and> (\<forall>i \<le> (Suc n). \<forall>j \<le> (Suc n). 
                               ((vv i)  (x j) = \<delta>\<^bsub>i j\<^esub>))" 
 apply (frule App_base_hom[of n vv], rule allI, simp)
  apply (subgoal_tac "(\<forall>i \<le> (Suc n). \<forall>j \<le> (Suc n). 
                  (vv i) ((App_base K vv (Suc n)) j)  = (\<delta>\<^bsub>i j\<^esub>))",
         blast) 
  apply (rule allI, rule impI)+ 
  apply (rule Approzimation1_5P2, assumption+, simp+) 
 done
 
 lemma (in Corps) Ostrowski_baseTr0:"\<lbrakk>vals_nonequiv K (Suc n) vv; l \<le> (Suc n) \<rbrakk>
    \<Longrightarrow>   0 < ((vv l) (1\<^sub>r \<plusminus> -\<^sub>a (Ostrowski_base K vv (Suc n) l))) \<and>
   (\<forall>m\<in>{h. h \<le> (Suc n)} - {l}. 0 < ((vv m) (Ostrowski_base K vv (Suc n) l)))"
 apply (simp add:Ostrowski_base_def,
        frule_tac j = l in transpos_vals_nonequiv[of "n" "vv"], assumption,
        cut_tac Ostrowski[of "n"],
        drule_tac a = "vv \<circ> \<tau>\<^bsub>0 l\<^esub>" in forall_spec, assumption) 
 apply (erule bexE,
        unfold Ostrowski_elem_def, frule conjunct1,
        fold Ostrowski_elem_def, 
        rule conjI, simp add:Ostrowski_elem_def)
 apply (case_tac "l = 0", simp, simp add:transpos_eq,
        rule someI2_ex, blast, simp,
        simp add:transpos_ij_1,
        rule someI2_ex, blast, simp)
 
 apply (simp add:Ostrowski_elem_def,
        case_tac "l = 0", simp, simp add:transpos_eq,
        rule someI2_ex, blast,
        thin_tac "0 < vv 0 (1\<^sub>r \<plusminus> -\<^sub>a x) \<and> 
                       (\<forall>j\<in>nset (Suc 0) (Suc n). 0 < vv j x)",
        rule ballI, simp add:nset_def) 
 
 apply (rule ballI, erule conjE,
        rule someI2_ex, blast,
        thin_tac "\<forall>j\<in>nset (Suc 0) (Suc n). 0 < vv ((\<tau>\<^bsub>0 l\<^esub>) j) x",
        (erule conjE)+)
 
 apply (case_tac "m = 0", simp,
        drule_tac x = l in bspec, simp add:nset_def,
        simp add:transpos_ij_2,
        drule_tac x = m in bspec, simp add:nset_def,
        simp add:transpos_id)
 done  
 
 lemma (in Corps) Ostrowski_baseTr1:"\<lbrakk>vals_nonequiv K (Suc n) vv; l \<le> (Suc n)\<rbrakk>
      \<Longrightarrow> 0 < ((vv l) (1\<^sub>r \<plusminus> -\<^sub>a (Ostrowski_base K vv (Suc n) l)))"
 by (simp add:Ostrowski_baseTr0)
 
 lemma (in Corps) Ostrowski_baseTr2:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
         l \<le> (Suc n); m \<le> (Suc n); l \<noteq> m\<rbrakk> \<Longrightarrow>
         0 < ((vv m) (Ostrowski_base K vv (Suc n) l))"   
 apply (frule Ostrowski_baseTr0[of "n" "vv" "l"], assumption+) 
 apply simp
 done
 
 lemma Nset_have_two:"j \<in>{h. h \<le> (Suc n)} \<Longrightarrow> \<exists>m \<in> {h. h \<le> (Suc n)}. j \<noteq> m"
 apply (rule contrapos_pp, simp+,
        case_tac "j = Suc n", simp,
        drule_tac a = 0 in forall_spec, simp, arith) 
  apply (drule_tac a = "Suc n" in forall_spec, simp, simp)
 done  
 
 lemma (in Corps) Ostrowski_base_npow_not_one:"\<lbrakk>0 < N; j \<le> Suc n;
        vals_nonequiv K (Suc n) vv\<rbrakk>  \<Longrightarrow>  
                               1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>) \<noteq> \<zero>"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        rule contrapos_pp, simp+,
        frule Ostrowski_base_mem_1[of "n" "vv" "j"], assumption,
        frule Ring.npClose[of "K" "(\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j" "N"], assumption+,
        frule Ring.ring_one[of "K"],
        frule aGroup.ag_mOp_closed[of K "(\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>"], assumption+,
        frule aGroup.ag_pOp_closed[of "K" "1\<^sub>r" "-\<^sub>a ((\<Omega>\<^bsub>K  vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>)"],
        assumption+) 
 apply (frule  aGroup.ag_pOp_add_r[of "K" "1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>)" "\<zero>" 
            "(\<Omega>\<^bsub>K  vv  (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>"], assumption+,
         simp add:aGroup.ag_inc_zero, assumption+, 
         thin_tac "1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>) = \<zero>")
  apply (simp add:aGroup.ag_pOp_assoc[of "K" "1\<^sub>r" "-\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>)"])
  apply (simp add:aGroup.ag_l_inv1, simp add:aGroup.ag_r_zero aGroup.ag_l_zero)
   apply (subgoal_tac "\<forall>m \<le> (Suc n). (j \<noteq> m \<longrightarrow> 
                                  0 < (vv m ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)))") 
  apply (cut_tac Nset_have_two[of "j" "n"],
         erule bexE, drule_tac a = m in forall_spec, simp,
        thin_tac "(\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup> \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>) \<in> carrier K",
        frule_tac f = "vv m" in eq_elems_eq_val[of "1\<^sub>r" "(\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>"],
        thin_tac "1\<^sub>r = (\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>", simp)
  apply (frule_tac m = m in vals_nonequiv_valuation[of "Suc n" "vv"],
         assumption+, 
         frule_tac v1 = "vv m" and n1 = N in val_exp_ring[THEN sym, 
          of  _ "(\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j"], assumption+,
         simp add:Ostrowski_base_nonzero, simp, simp add:value_of_one)
  apply (subgoal_tac "int N \<noteq> 0",
         frule_tac x = "vv m ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)" in asprod_0[of "int N"],
         assumption, simp add:less_ant_def, simp, simp,
         rule allI, rule impI, rule impI,
         rule Ostrowski_baseTr2, assumption+)
 done
 
 abbreviation
   CHOOSE :: "[nat, nat] \<Rightarrow> nat"  ("(\<^bsub>_\<^esub>C\<^bsub>_\<^esub>)" [80, 81]80) where
   "\<^bsub>n\<^esub>C\<^bsub>i\<^esub> == n choose i"
 
 lemma (in Ring) expansion_of_sum1:"x \<in> carrier R \<Longrightarrow> 
                 (1\<^sub>r \<plusminus> x)^\<^bsup>R n\<^esup> = nsum R (\<lambda>i. \<^bsub>n\<^esub>C\<^bsub>i\<^esub> \<times>\<^bsub>R\<^esub> x^\<^bsup>R i\<^esup>) n"
 apply (cut_tac ring_one, frule npeSum2[of "1\<^sub>r" "x" "n"], assumption+,
        simp add:npOne, subgoal_tac "\<forall>(j::nat). (x^\<^bsup>R j\<^esup>) \<in> carrier R")
 apply (simp add:ring_l_one, rule allI, simp add:npClose)
 done 
 
 lemma (in Ring) tail_of_expansion:"x \<in> carrier R \<Longrightarrow> (1\<^sub>r \<plusminus> x)^\<^bsup>R (Suc n)\<^esup> = 
              (nsum R (\<lambda> i. (\<^bsub>(Suc n)\<^esub>C\<^bsub>(Suc i)\<^esub> \<times>\<^bsub>R\<^esub> x^\<^bsup>R (Suc i)\<^esup>)) n) \<plusminus> 1\<^sub>r"
 apply (cut_tac ring_is_ag)
 apply (frule expansion_of_sum1[of "x" "Suc n"],
        simp del:nsum_suc binomial_Suc_Suc npow_suc,
        thin_tac "(1\<^sub>r \<plusminus> x)^\<^bsup>R (Suc n)\<^esup> = \<Sigma>\<^sub>e R (\<lambda>i. \<^bsub>(Suc n)\<^esub>C\<^bsub>i\<^esub> \<times>\<^bsub>R\<^esub> x^\<^bsup>R i\<^esup>) (Suc n)")
 apply (subst aGroup.nsumTail[of R n "\<lambda>i. \<^bsub>(Suc n)\<^esub>C\<^bsub>i\<^esub> \<times>\<^bsub>R\<^esub> x^\<^bsup>R i\<^esup>"], assumption,
        rule allI, rule impI, rule nsClose, rule npClose, assumption)
 apply (cut_tac ring_one,
        simp del:nsum_suc binomial_Suc_Suc npow_suc add:aGroup.ag_l_zero) 
 done
 
 lemma (in Ring) tail_of_expansion1:"x \<in> carrier R \<Longrightarrow>
   (1\<^sub>r \<plusminus> x)^\<^bsup>R (Suc n)\<^esup>  = x \<cdot>\<^sub>r (nsum R (\<lambda> i. (\<^bsub>(Suc n)\<^esub>C\<^bsub>(Suc i)\<^esub> \<times>\<^bsub>R\<^esub> x^\<^bsup>R i\<^esup>)) n) \<plusminus> 1\<^sub>r"
 apply (frule tail_of_expansion[of "x" "n"], 
        simp del:nsum_suc binomial_Suc_Suc npow_suc,
        subgoal_tac "\<forall>i.  \<^bsub>Suc n\<^esub>C\<^bsub>Suc i\<^esub> \<times>\<^bsub>R\<^esub> x^\<^bsup>R i\<^esup> \<in> carrier R",
        cut_tac ring_one, cut_tac ring_is_ag)
 prefer 2  apply(simp add: nsClose npClose)
 apply (rule aGroup.ag_pOp_add_r[of "R" _ _ "1\<^sub>r"], assumption+,
        rule aGroup.nsum_mem, assumption+, rule allI, rule impI,
        rule nsClose, rule npClose, assumption)
 apply (rule ring_tOp_closed, assumption+,
        rule aGroup.nsum_mem, assumption+, blast, simp add:ring_one)
 apply (subst nsumMulEleL[of "\<lambda>i. \<^bsub>Suc n\<^esub>C\<^bsub>Suc i\<^esub> \<times>\<^bsub>R\<^esub> x^\<^bsup>R i\<^esup>" "x"], assumption+)
 apply (rule aGroup.nsum_eq, assumption, rule allI, rule impI, rule nsClose,
        rule npClose, assumption, rule allI, rule impI,
        rule ring_tOp_closed, assumption+, rule nsClose, rule npClose,
        assumption) 
 apply (rule allI, rule impI)
 apply (subst nsMulDistrL, assumption, simp add:npClose, 
        frule_tac n = j in npClose[of x], simp add:ring_tOp_commute[of x])
 done 
 
 lemma (in Corps) nsum_in_VrTr:"valuation K v \<Longrightarrow> 
        (\<forall>j \<le> n. f j \<in> carrier K) \<and> (\<forall>j \<le> n. 
        0 \<le> (v (f j))) \<longrightarrow> (nsum K f n) \<in> carrier (Vr K v)"
 apply (induct_tac n)
  apply (rule impI, erule conjE, simp add:val_pos_mem_Vr)
 apply (rule impI, erule conjE)
 apply (frule Vr_ring[of v], frule Ring.ring_is_ag[of "Vr K v"],
        frule_tac  x = "f (Suc n)" and y = "nsum K f n" in 
          aGroup.ag_pOp_closed[of "Vr K v"],
        subst val_pos_mem_Vr[THEN sym, of  "v"], assumption+,
        simp, simp, simp) 
 apply (simp, subst Vr_pOp_f_pOp[of "v", THEN sym], assumption+,
        subst val_pos_mem_Vr[THEN sym, of v], assumption+,
        simp+)
 apply (subst aGroup.ag_pOp_commute, assumption+, simp add:val_pos_mem_Vr,
        assumption)
 done
 
 lemma (in Corps) nsum_in_Vr:"\<lbrakk>valuation K v; \<forall>j \<le> n. f j \<in> carrier K; 
        \<forall>j \<le> n.  0 \<le> (v (f j))\<rbrakk> \<Longrightarrow> (nsum K f n) \<in> carrier (Vr K v)"
 apply (simp add:nsum_in_VrTr)
 done
 
 lemma (in Corps) nsum_mem_in_Vr:"\<lbrakk>valuation K v; 
        \<forall>j \<le> n. (f j) \<in> carrier K; \<forall>j \<le> n. 0 \<le> (v (f j))\<rbrakk> \<Longrightarrow>
          (nsum K f n) \<in> carrier (Vr K v)"
 by (rule nsum_in_Vr)
 
 lemma (in Corps) val_nscal_ge_selfTr:"\<lbrakk>valuation K v; x \<in> carrier K; 0 \<le> v x\<rbrakk>
        \<Longrightarrow>  v x \<le>  v (n \<times>\<^bsub>K\<^esub> x)"
 apply (cut_tac field_is_ring, induct_tac n, simp)  
 apply (simp add:value_of_zero,
        simp,
        frule_tac y = "n \<times>\<^bsub>K\<^esub> x" in amin_le_plus[of "v" "x"], assumption+,
        rule Ring.nsClose, assumption+) 
 apply (simp add:amin_def,
        frule Ring.ring_is_ag[of K],
        frule_tac n = n in Ring.nsClose[of K x], assumption+,
        simp add:aGroup.ag_pOp_commute)
 done
 
 lemma (in Corps) ApproximationTr:"\<lbrakk>valuation K v; x \<in> carrier K; 0 \<le> (v x)\<rbrakk> \<Longrightarrow>
              v x \<le> (v (1\<^sub>r \<plusminus> -\<^sub>a ((1\<^sub>r \<plusminus> x)^\<^bsup>K (Suc n)\<^esup>)))"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        case_tac "x = \<zero>\<^bsub>K\<^esub>",
        simp, frule Ring.ring_one[of "K"], simp add:aGroup.ag_r_zero,
        simp add:Ring.npOne, simp add:Ring.ring_l_one,simp add:aGroup.ag_r_inv1,
        subst Ring.tail_of_expansion1[of "K" "x"], assumption+, 
        frule Ring.ring_one[of "K"])
 apply (subgoal_tac "(nsum K (\<lambda>i. \<^bsub>Suc n\<^esub>C\<^bsub>Suc i\<^esub> \<times>\<^bsub>K\<^esub> x^\<^bsup>K i\<^esup>) n)\<in>carrier (Vr K v)",
        frule Vr_mem_f_mem[of "v" "(nsum K (\<lambda>i. \<^bsub>Suc n\<^esub>C\<^bsub>Suc i\<^esub> \<times>\<^bsub>K\<^esub> x^\<^bsup>K i\<^esup>) n)"],
        assumption+,
        frule_tac x = x and y = "nsum K (\<lambda>i. \<^bsub>Suc n\<^esub>C\<^bsub>Suc i\<^esub> \<times>\<^bsub>K\<^esub> x^\<^bsup>K i\<^esup>) n" in 
        Ring.ring_tOp_closed[of "K"], assumption+,
        subst aGroup.ag_pOp_commute[of "K" _ "1\<^sub>r"], assumption+,
        subst aGroup.ag_p_inv[of "K" "1\<^sub>r"], assumption+,
        subst aGroup.ag_pOp_assoc[THEN sym], assumption+,
        simp add:aGroup.ag_mOp_closed, rule aGroup.ag_mOp_closed, assumption+,
        simp del:binomial_Suc_Suc add:aGroup.ag_r_inv1, subst aGroup.ag_l_zero,
        assumption+,
        rule aGroup.ag_mOp_closed, assumption+, simp add:val_minus_eq)
 
 apply (subst val_t2p[of v], assumption+) apply (
        simp add:val_pos_mem_Vr[THEN sym, of v 
                   "nsum K (\<lambda>i.(\<^bsub>n\<^esub>C\<^bsub>i\<^esub> + \<^bsub>n\<^esub>C\<^bsub>Suc i\<^esub>) \<times>\<^bsub>K\<^esub> x^\<^bsup>K i\<^esup>) n"],
        frule aadd_le_mono[of "0" "v (nsum K (\<lambda>i.(\<^bsub>n\<^esub>C\<^bsub>i\<^esub> + \<^bsub>n\<^esub>C\<^bsub>Suc i\<^esub>) \<times>\<^bsub>K\<^esub> x^\<^bsup>K i\<^esup>) n)" 
          "v x"], simp add:aadd_0_l, simp add:aadd_commute[of "v x"])
 
 apply (rule nsum_mem_in_Vr[of v n "\<lambda>i.\<^bsub>Suc n\<^esub>C\<^bsub>Suc i\<^esub> \<times>\<^bsub>K\<^esub> x^\<^bsup>K i\<^esup>"], assumption, 
        rule allI, rule impI) apply (rule Ring.nsClose, assumption+) apply (simp add:Ring.npClose)
 
 apply (rule allI, rule impI)
 apply (cut_tac i = 0 and j = "v (x^\<^bsup>K j\<^esup>)" and k = "v (\<^bsub>Suc n\<^esub>C\<^bsub>Suc j\<^esub> \<times>\<^bsub>K\<^esub> x^\<^bsup>K j\<^esup>)"
        in ale_trans)
  apply (case_tac "j = 0", simp add:value_of_one)
  apply (simp add: val_exp_ring[THEN sym],
         frule val_nonzero_z[of v x], assumption+,
         erule exE,
         cut_tac m1 = 0 and n1 = j in of_nat_less_iff[THEN sym],
         frule_tac a = "0 < j" and b = "int 0 < int j" in a_b_exchange,
         assumption, thin_tac "0 < j", thin_tac "(0 < j) = (int 0 < int j)")
 apply (simp del: of_nat_0_less_iff)
 
 apply (frule_tac w1 = "int j" and x1 = 0 and y1 = "ant z" in 
          asprod_pos_mono[THEN sym],
         simp only:asprod_n_0) 
 
  apply(rule_tac x = "x^\<^bsup>K j\<^esup>" and n = "\<^bsub>Suc n\<^esub>C\<^bsub>Suc j\<^esub>" in 
        val_nscal_ge_selfTr[of v], assumption+,
        simp add:Ring.npClose, simp add:val_exp_ring[THEN sym],
        frule val_nonzero_z[of "v" "x"], assumption+, erule exE, simp)
  apply (case_tac "j = 0", simp)
  apply (subst asprod_amult, simp, simp add:a_z_z)
 apply(
         simp only:ant_0[THEN sym], simp only:ale_zle,
         cut_tac m1 = 0 and n1 = j in of_nat_less_iff[THEN sym])
 apply (        frule_tac a = "0 < j" and b = "int 0 < int j" in a_b_exchange, 
         assumption+, thin_tac "0 < j", thin_tac "(0 < j) = (int 0 < int j)",
         frule_tac z = "int 0" and z' = "int j" in zless_imp_zle,
         frule_tac i = "int 0" and j = "int j" and k = z in int_mult_le,
          assumption+, simp add:mult.commute )
  apply assumption
 done
 
 lemma (in Corps) ApproximationTr0:"aa \<in> carrier K \<Longrightarrow>
             (1\<^sub>r \<plusminus> -\<^sub>a (aa^\<^bsup>K N\<^esup>))^\<^bsup>K N\<^esup> \<in> carrier K"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        rule Ring.npClose, assumption+, 
        rule aGroup.ag_pOp_closed, assumption+, simp add:Ring.ring_one,
        rule aGroup.ag_mOp_closed, assumption+, rule Ring.npClose, assumption+)
 done
 
 lemma (in Corps) ApproximationTr1:"aa \<in> carrier K \<Longrightarrow>
             1\<^sub>r \<plusminus> -\<^sub>a ((1\<^sub>r \<plusminus> -\<^sub>a (aa^\<^bsup>K N\<^esup>))^\<^bsup>K N\<^esup>) \<in> carrier K"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        frule ApproximationTr0[of aa N],
        frule Ring.ring_one[of "K"], rule aGroup.ag_pOp_closed, assumption+,
        rule aGroup.ag_mOp_closed, assumption+)
 done
 
 lemma (in Corps) ApproximationTr2:"\<lbrakk>valuation K v; aa \<in> carrier K; aa \<noteq> \<zero>; 
      0 \<le> (v aa)\<rbrakk> \<Longrightarrow> (int N) *\<^sub>a(v aa) \<le> (v (1\<^sub>r \<plusminus> -\<^sub>a ((1\<^sub>r \<plusminus> -\<^sub>a (aa^\<^bsup>K N\<^esup>))^\<^bsup>K N\<^esup>)))"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"],
        case_tac "N = 0",
        frule val_nonzero_z[of v "aa"], assumption+, erule exE, simp) 
  apply(frule Ring.ring_one[of "K"], simp add:aGroup.ag_r_inv1,
        simp add:value_of_zero)
 
 apply (frule_tac n = N in Ring.npClose[of "K" "aa"], assumption+,
        frule ApproximationTr[of v "-\<^sub>a (aa^\<^bsup>K N\<^esup>)" "N - Suc 0"],
        rule aGroup.ag_mOp_closed, assumption+, simp add:val_minus_eq,
        subst val_exp_ring[THEN sym, of v], assumption+,
        simp add:asprod_pos_pos)
 apply (simp add:val_minus_eq, simp add:val_exp_ring[THEN sym])
 done
 
 lemma (in Corps) eSum_tr:"
 ( \<forall>j \<le> n. (x j) \<in> carrier K) \<and> 
  ( \<forall>j \<le> n. (b j) \<in> carrier K) \<and> l \<le> n \<and> 
  ( \<forall>j\<in>({h. h \<le> n} -{l}). (g j = (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (b j)))) \<and> 
   g l = (x l) \<cdot>\<^sub>r (-\<^sub>a (b l))
 \<longrightarrow> (nsum K (\<lambda>j \<in> {h. h \<le> n}. (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (b j))) n) \<plusminus> (-\<^sub>a (x l)) = 
                        nsum K g n"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"])
 apply (induct_tac n)
  apply (simp, rule impI, (erule conjE)+, 
        simp, frule Ring.ring_one[of "K"], subst Ring.ring_distrib1, 
        assumption+,
        simp add:aGroup.ag_mOp_closed, simp add:Ring.ring_r_one,
        frule aGroup.ag_mOp_closed[of K "b 0"], assumption+,
        frule Ring.ring_tOp_closed[of "K" "x 0" "-\<^sub>a (b 0)"], assumption+,
        subst aGroup.ag_pOp_commute[of "K" "x 0" _], assumption+,
        subst aGroup.ag_pOp_assoc, assumption+, 
        frule aGroup.ag_mOp_closed[of "K"], 
        assumption+) 
  apply (simp add:aGroup.ag_r_inv1, subst aGroup.ag_r_zero, assumption+, simp)
 apply (rule impI, (erule conjE)+)
  apply (subgoal_tac "\<forall>j \<le> (Suc n).  ((x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (b j))) \<in> carrier K")
 apply (case_tac "l = Suc n", simp)
  apply (subgoal_tac "\<Sigma>\<^sub>e K g n \<in> carrier K",
         subgoal_tac "{h. h \<le> (Suc n)} - {Suc n} = {h. h \<le> n}", simp,
         subgoal_tac "\<forall>j. j \<le> n \<longrightarrow> j \<le> (Suc n)",
         frule_tac f = "\<lambda>u. if u \<le> Suc n then (x u) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (b u)) else 
         undefined" and n = n in aGroup.nsum_eq[of "K" _ _ "g"])
  apply (rule allI, rule impI, simp,
         rule allI, simp, rule allI, rule impI, simp, simp)
 
  apply (cut_tac a = "x (Suc n) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (b (Suc n))) \<plusminus> -\<^sub>a (x (Suc n))" and 
        b = "x (Suc n) \<cdot>\<^sub>r (-\<^sub>a (b (Suc n)))" and 
        c = "\<Sigma>\<^sub>e K g n" in aGroup.ag_pOp_add_l[of K], assumption)
  apply (rule aGroup.ag_pOp_closed, assumption+,
         rule Ring.ring_tOp_closed, assumption+, simp,
         rule aGroup.ag_pOp_closed, assumption+, simp add:Ring.ring_one,
         rule aGroup.ag_mOp_closed, assumption, simp,
         rule aGroup.ag_mOp_closed, assumption, simp,
         rule Ring.ring_tOp_closed, assumption+, simp,
         rule aGroup.ag_mOp_closed, assumption+, simp, assumption)
 
  apply (subst Ring.ring_distrib1, assumption+, simp, simp add:Ring.ring_one,
         simp add:aGroup.ag_mOp_closed,
         simp add:Ring.ring_r_one) apply (
         frule_tac x = "x (Suc n)" and y = "x (Suc n) \<cdot>\<^sub>r (-\<^sub>a (b (Suc n)))" in
         aGroup.ag_pOp_commute [of "K"], simp,
         simp add:Ring.ring_tOp_closed aGroup.ag_mOp_closed,
         simp) apply (
         subst aGroup.ag_pOp_assoc[of "K"], assumption+,
         rule Ring.ring_tOp_closed, assumption+, simp, 
         (simp add:aGroup.ag_mOp_closed)+,
         subst aGroup.ag_r_inv1, assumption+, simp,
         subst aGroup.ag_r_zero, assumption+,
         simp add:Ring.ring_tOp_closed aGroup.ag_mOp_closed, simp,
         rotate_tac -1, drule sym, simp) apply (
         thin_tac "\<Sigma>\<^sub>e K g n \<plusminus> x (Suc n) \<cdot>\<^sub>r (-\<^sub>a (b (Suc n))) =
          \<Sigma>\<^sub>e K g n \<plusminus> (x (Suc n) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (b (Suc n))) \<plusminus> -\<^sub>a (x (Suc n)))")
    apply (subst aGroup.ag_pOp_assoc[THEN sym], assumption+,
           rule Ring.ring_tOp_closed, assumption+, simp, 
           rule aGroup.ag_pOp_closed, assumption+, simp add:Ring.ring_one,
           rule aGroup.ag_mOp_closed, assumption+, simp,
           rule aGroup.ag_mOp_closed, assumption+, simp, simp,
           simp, rule equalityI, rule subsetI, simp, rule subsetI, simp)
   apply (rule aGroup.nsum_mem, assumption+,
          rule allI, rule impI, simp)
 defer
   apply (rule allI, rule impI)
   apply (case_tac "j = l", simp,
          rule Ring.ring_tOp_closed, assumption, simp,
          rule aGroup.ag_pOp_closed, assumption+, simp add:Ring.ring_one,
          rule aGroup.ag_mOp_closed, assumption, simp, simp,
          rule Ring.ring_tOp_closed, assumption, simp,
          rule aGroup.ag_pOp_closed, assumption+, simp add:Ring.ring_one,
          rule aGroup.ag_mOp_closed, assumption, simp, simp) (* end defer *)
 
  apply (subst aGroup.ag_pOp_assoc, assumption+,
         rule aGroup.nsum_mem, assumption+,
         rule allI, simp, rule Ring.ring_tOp_closed, assumption+, simp,
         rule aGroup.ag_pOp_closed, assumption+, simp add:Ring.ring_one,
         rule aGroup.ag_mOp_closed, assumption, simp,
         rule aGroup.ag_mOp_closed, assumption, simp,
         subst aGroup.ag_pOp_commute[of K _ "-\<^sub>a (x l)"], assumption+,
         rule Ring.ring_tOp_closed, assumption, simp,
         rule aGroup.ag_pOp_closed, assumption+, simp add:Ring.ring_one)
  apply (rule aGroup.ag_mOp_closed, assumption+, simp,
         rule aGroup.ag_mOp_closed, assumption+, simp,
         subst aGroup.ag_pOp_assoc[THEN sym], assumption+,
         rule aGroup.nsum_mem, assumption+,
         rule allI, rule impI, simp,
         rule aGroup.ag_mOp_closed, assumption, simp, 
         rule Ring.ring_tOp_closed, assumption, simp,
          rule aGroup.ag_pOp_closed, assumption+, simp add:Ring.ring_one,
          rule aGroup.ag_mOp_closed, assumption, simp)
   apply (subgoal_tac "\<Sigma>\<^sub>e K (\<lambda>a. if a \<le> (Suc n) then x a \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (b a)) 
          else undefined) n \<plusminus> -\<^sub>a (x l) = 
          \<Sigma>\<^sub>e K (\<lambda>a. if a \<le> n then x a \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (b a)) else undefined) n \<plusminus>
          -\<^sub>a (x l)", simp,
          rule aGroup.ag_pOp_add_r[of K _ _ "-\<^sub>a (x l)"], assumption+,
          rule aGroup.nsum_mem, assumption+,
          rule allI, rule impI, simp, 
          rule aGroup.nsum_mem, assumption+,
          rule allI, rule impI, simp,
          rule aGroup.ag_mOp_closed, assumption, simp,
          rule aGroup.nsum_eq, assumption+,
          rule allI, rule impI, simp, rule allI, rule impI) 
    apply simp
    apply (rule allI, rule impI, simp) 
 done
 
 lemma (in Corps) eSum_minus_x:"\<lbrakk>\<forall>j \<le> n. (x j) \<in> carrier K; 
        \<forall>j \<le> n. (b j) \<in> carrier K; l \<le> n; 
        \<forall>j\<in>({h. h \<le> n} -{l}). (g j = (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (b j))); 
        g l = (x l) \<cdot>\<^sub>r (-\<^sub>a (b l)) \<rbrakk> \<Longrightarrow>
        (nsum K (\<lambda>j\<in>{h. h \<le> n}. (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (b j))) n) \<plusminus> (-\<^sub>a (x l)) = 
                         nsum K g n"
 by (cut_tac eSum_tr[of "n" "x" "b" "l" "g"], simp) 
 
 lemma (in Ring) one_m_x_times:"x \<in> carrier R \<Longrightarrow>
  (1\<^sub>r \<plusminus> -\<^sub>a x) \<cdot>\<^sub>r (nsum R (\<lambda>j. x^\<^bsup>R j\<^esup>) n) = 1\<^sub>r \<plusminus> -\<^sub>a (x^\<^bsup>R (Suc n)\<^esup>)"
 apply (cut_tac ring_one, cut_tac ring_is_ag,
        frule aGroup.ag_mOp_closed[of "R" "x"], assumption+,
        frule aGroup.ag_pOp_closed[of "R" "1\<^sub>r" "-\<^sub>a x"], assumption+)
 
 apply (induct_tac n)
  apply (simp add:ring_r_one ring_l_one)
  apply (simp del:npow_suc,
         frule_tac n = "Suc n" in npClose[of "x"],
         subst ring_distrib1, assumption+)
  apply (rule aGroup.nsum_mem, assumption, rule allI, rule impI,
         simp add:npClose, rule npClose, assumption+,
         simp del:npow_suc,
         thin_tac "(1\<^sub>r \<plusminus> -\<^sub>a x) \<cdot>\<^sub>r \<Sigma>\<^sub>e R (npow R x) n = 1\<^sub>r \<plusminus> -\<^sub>a (x^\<^bsup>R (Suc n)\<^esup>)")
  apply (subst ring_distrib2, assumption+,
         simp del:npow_suc add:ring_l_one,
         subst aGroup.pOp_assocTr43[of R], assumption+,
         rule_tac x = "x^\<^bsup>R (Suc n)\<^esup>" in aGroup.ag_mOp_closed[of R], assumption+,
         rule ring_tOp_closed, rule aGroup.ag_mOp_closed, assumption+)
  apply (subst aGroup.ag_l_inv1, assumption+, simp del:npow_suc 
         add:aGroup.ag_r_zero,
         frule_tac x = "-\<^sub>a x" and y = "x^\<^bsup>R (Suc n)\<^esup>" in ring_tOp_closed,
         assumption+)
  apply (rule aGroup.ag_pOp_add_l[of R _ _ "1\<^sub>r"], assumption+,
         rule aGroup.ag_mOp_closed, assumption+,
         rule npClose, assumption+,
         subst ring_inv1_1[THEN sym, of x], assumption,
         rule npClose, assumption,
         simp,
         subst ring_tOp_commute[of x], assumption+, simp)
 done
 
 lemma (in Corps) x_pow_fSum_in_Vr:"\<lbrakk>valuation K v; x \<in> carrier (Vr K v)\<rbrakk> \<Longrightarrow>
    (nsum K (npow K x) n) \<in> carrier (Vr K v)" 
 apply (frule Vr_ring[of v])
 apply (induct_tac n)
  apply simp
  apply (frule Ring.ring_one[of "Vr K v"])
  apply (simp add:Vr_1_f_1)
 apply (simp del:npow_suc)
  apply (frule Ring.ring_is_ag[of "Vr K v"])
 
  apply (subst Vr_pOp_f_pOp[THEN sym, of v], assumption+)
  apply (subst Vr_exp_f_exp[THEN sym, of v], assumption+)
  apply (rule Ring.npClose[of "Vr K v"], assumption+)
  apply (rule aGroup.ag_pOp_closed[of "Vr K v"], assumption+)
  apply (subst Vr_exp_f_exp[THEN sym, of v], assumption+)
  apply (rule Ring.npClose[of "Vr K v"], assumption+)
 done
 
 lemma (in Corps) val_1mx_pos:"\<lbrakk>valuation K v; x \<in> carrier K; 
          0 < (v (1\<^sub>r \<plusminus> -\<^sub>a x))\<rbrakk> \<Longrightarrow>  v x = 0"
 apply (cut_tac field_is_ring, frule Ring.ring_one[of "K"], 
        frule Ring.ring_is_ag[of "K"])
  apply (frule aGroup.ag_mOp_closed[of "K" "x"], assumption+)
  apply (frule aGroup.ag_pOp_closed[of "K" "1\<^sub>r" "-\<^sub>a x"], assumption+)
  apply (frule aGroup.ag_mOp_closed[of "K" "1\<^sub>r \<plusminus> -\<^sub>a x"], assumption+)
  apply (cut_tac x = x and y = "1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a x)" and f = v in 
         eq_elems_eq_val)
 apply (subst aGroup.ag_p_inv, assumption+,
        subst aGroup.ag_pOp_assoc[THEN sym], assumption+,
        rule aGroup.ag_mOp_closed, assumption+,
        subst aGroup.ag_inv_inv, assumption+,
        subst aGroup.ag_r_inv1, assumption+,
        subst aGroup.ag_l_zero, assumption+,
        (simp add:aGroup.ag_inv_inv)+,
        frule  value_less_eq[of v  "1\<^sub>r" "-\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a x)"],
         assumption+)
  apply (simp add:val_minus_eq value_of_one,
         simp add:value_of_one)
 done 
 
 lemma (in Corps) val_1mx_pow:"\<lbrakk>valuation K v; x \<in> carrier K; 
        0 < (v (1\<^sub>r \<plusminus> -\<^sub>a x))\<rbrakk> \<Longrightarrow> 0 < (v (1\<^sub>r \<plusminus> -\<^sub>a x^\<^bsup>K (Suc n)\<^esup>))"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"])
 apply (subst Ring.one_m_x_times[THEN sym, of K x n], assumption+)
  apply (frule Ring.ring_one[of "K"],
         frule x_pow_fSum_in_Vr[of v x n],
         subst val_pos_mem_Vr[THEN sym], assumption+,
         frule val_1mx_pos[of "v" "x"], assumption+,
         simp)
 
  apply (subst val_t2p, assumption+,
         rule aGroup.ag_pOp_closed, assumption+,
         simp add:aGroup.ag_mOp_closed, simp add:Vr_mem_f_mem,
         frule val_pos_mem_Vr[THEN sym, of v "nsum K (npow K x) n"],
         simp add:Vr_mem_f_mem, simp)
  apply(frule aadd_le_mono[of "0" "v (nsum K (npow K x) n)" "v (1\<^sub>r \<plusminus> -\<^sub>a x)"],
        simp add:aadd_0_l, simp add:aadd_commute)
 done
 
 lemma (in Corps) ApproximationTr3:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
       \<forall>l \<le> (Suc n). x l \<in> carrier K; j \<le> (Suc n)\<rbrakk> \<Longrightarrow> 
      \<exists>L.(\<forall>N. L < N \<longrightarrow> (an m) \<le> (vv j ((\<Sigma>\<^sub>e K (\<lambda>k\<in>{h. h \<le> (Suc n)}. 
         (x k) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a ((1\<^sub>r \<plusminus> -\<^sub>a (((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) k)^\<^bsup>K N\<^esup>))^\<^bsup>K N\<^esup>))) 
         (Suc n)) \<plusminus> -\<^sub>a (x j))))"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"])
  apply (frule_tac vals_nonequiv_valuation[of "Suc n" "vv" j], assumption+) 
 apply (subgoal_tac "\<forall>N. \<Sigma>\<^sub>e K (\<lambda>j\<in>{h. h \<le> (Suc n)}. (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> 
  -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>)) (Suc n) \<plusminus> -\<^sub>a (x j) = 
  \<Sigma>\<^sub>e K (\<lambda>l\<in>{h. h\<le> (Suc n)}. (if l \<noteq> j then (x l) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a 
  ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>) else (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus>
         -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>  \<plusminus> -\<^sub>a 1\<^sub>r))) (Suc n)")
  apply (simp del:nsum_suc)
 apply (thin_tac "\<forall>N. \<Sigma>\<^sub>e K (\<lambda>j\<in>{h. h \<le> (Suc n)}. (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> 
  -\<^sub>a (\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>)) (Suc n) \<plusminus> -\<^sub>a (x j) = \<Sigma>\<^sub>e K (\<lambda>l\<in>{h. h \<le> (Suc n)}. if l \<noteq> j then (x l) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a (\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>) else (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a (\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup> \<plusminus> -\<^sub>a 1\<^sub>r)) (Suc n)")
 prefer 2 apply (rule allI) 
  apply (rule eSum_minus_x, assumption+)
  apply (rule allI, rule impI) apply (rule ApproximationTr0)
  apply (simp add:Ostrowski_base_mem) apply assumption
  apply (rule ballI, simp)
  apply simp  
  apply (frule Ring.ring_one[of "K"]) 
  apply (cut_tac aa = "(\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j" and N = N in 
                                                ApproximationTr0)
  apply (simp add:Ostrowski_base_mem)
  apply (subst aGroup.ag_pOp_assoc, assumption+)
  apply (rule aGroup.ag_mOp_closed, assumption+)+
  apply (subst aGroup.ag_pOp_commute[of "K" _ "-\<^sub>a 1\<^sub>r"], assumption+)
  apply (rule aGroup.ag_mOp_closed, assumption+)+
 
  apply (subst aGroup.ag_pOp_assoc[THEN sym], assumption+)
  apply (rule aGroup.ag_mOp_closed, assumption+)+
  apply (simp add:aGroup.ag_r_inv1)
  apply (subst aGroup.ag_l_zero, assumption+) apply (simp add:aGroup.ag_mOp_closed)
  apply simp (* subgoal 2 done **)
 
  apply (subgoal_tac "\<exists>L. \<forall>N. L < N \<longrightarrow> 
   (\<forall>ja \<le> (Suc n). (an m) \<le> ((vv j \<circ> (\<lambda>l\<in>{h. h \<le> (Suc n)}. if l \<noteq> j then (x l) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>) else (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup> \<plusminus> -\<^sub>a 1\<^sub>r))) ja))")
 
 (*
  apply (subgoal_tac "\<exists>L. \<forall>N. L < N \<longrightarrow> (an m) \<le> Amin (Suc n) (vv j \<circ> (\<lambda>l\<in>Nset (Suc n). if l\<noteq>j then (x l) \<cdot>\<^sub>K (1\<^sub>K +\<^sub>K -\<^sub>K (1\<^sub>K +\<^sub>K -\<^sub>K ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l)^\<^sup>K\<^sup> \<^sup>N)^\<^sup>K\<^sup> \<^sup>N)
  else (x j) \<cdot>\<^sub>K (1\<^sub>K +\<^sub>K  -\<^sub>K (1\<^sub>K +\<^sub>K -\<^sub>K ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l)^\<^sup>K\<^sup> \<^sup>N)^\<^sup>K\<^sup> \<^sup>N
 +\<^sub>K -\<^sub>K 1\<^sub>K)))")
  apply (erule exE)
  apply (subgoal_tac "\<forall>N. L < N \<longrightarrow>
   ((an m) \<le> ((vv j) (e\<Sigma> K (\<lambda>l\<in>Nset (Suc n). (if l \<noteq> j then (x l) \<cdot>\<^sub>K
 (1\<^sub>K +\<^sub>K -\<^sub>K (1\<^sub>K +\<^sub>K -\<^sub>K ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l)^\<^sup>K\<^sup> \<^sup>N)^\<^sup>K\<^sup> \<^sup>N) else (x j) \<cdot>\<^sub>K (1\<^sub>K +\<^sub>K -\<^sub>K 
 (1\<^sub>K +\<^sub>K -\<^sub>K ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l)^\<^sup>K\<^sup> \<^sup>N)^\<^sup>K\<^sup> \<^sup>N +\<^sub>K -\<^sub>K 1\<^sub>K))) (Suc n))))")
 apply blast
 *)
 
 apply (erule exE)
 apply (rename_tac M)
  apply (subgoal_tac "\<forall>N. M < (N::nat) \<longrightarrow>
    (an m) \<le> (vv j (\<Sigma>\<^sub>e K (\<lambda>l\<in>{h. h \<le> (Suc n)}. (if l \<noteq> j then 
    (x l) \<cdot>\<^sub>r  (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>)
    else (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) l)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>
    \<plusminus> -\<^sub>a 1\<^sub>r))) (Suc n)))")
  apply blast
  apply (rule allI, rule impI)  
 apply (drule_tac a = N in forall_spec, assumption)
  apply (rule value_ge_add[of "vv j" "Suc n" _ "an m"], assumption+)
  
 apply (rule allI, rule impI)
  apply (frule Ring.ring_one[of "K"])
  apply (case_tac "ja = j", simp)
  apply (rule Ring.ring_tOp_closed, assumption+, simp)
  apply (rule aGroup.ag_pOp_closed, assumption+)+
  apply (rule aGroup.ag_mOp_closed, assumption+)
  apply (rule Ring.npClose, assumption)
  apply (rule aGroup.ag_pOp_closed, assumption+)
  apply (rule aGroup.ag_mOp_closed, assumption)
  apply (rule Ring.npClose, assumption)
  apply (simp add:Ostrowski_base_mem)
  apply (rule aGroup.ag_mOp_closed, assumption+)
 
 apply simp
  apply (rule Ring.ring_tOp_closed, assumption+, simp)
  apply (rule aGroup.ag_pOp_closed, assumption+)+
  apply (rule aGroup.ag_mOp_closed, assumption+)
  apply (rule Ring.npClose, assumption)
  apply (rule aGroup.ag_pOp_closed, assumption+)
  apply (rule aGroup.ag_mOp_closed, assumption)
  apply (rule Ring.npClose, assumption)
  apply (simp add:Ostrowski_base_mem) 
 
 apply assumption
 
  apply (subgoal_tac "\<forall>N. \<forall>ja \<le> (Suc n). (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a 
  ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>) \<in> carrier K")
  apply (subgoal_tac "\<forall>N. (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>
                          \<plusminus> -\<^sub>a 1\<^sub>r) \<in> carrier K")
  apply (simp add:val_t2p) 
  apply (cut_tac multi_inequalityTr0[of "Suc n" "(vv j) \<circ> x" "m"])
  apply (subgoal_tac "\<forall>ja \<le> (Suc n). (vv j \<circ> x) ja \<noteq> - \<infinity>", simp)
  apply (erule exE)
  apply (subgoal_tac "\<forall>N. L < N \<longrightarrow> (\<forall>ja \<le> (Suc n). (ja \<noteq> j \<longrightarrow>
 an m \<le> vv j (x ja) + (vv j (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>)))
  \<and> (ja = j \<longrightarrow> (an m) \<le> vv j (x j) +  (vv j (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> 
   -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup> \<plusminus> -\<^sub>a (1\<^sub>r)))))")
  apply blast
  apply (rule allI, rule impI)+
 
 apply (case_tac "ja = j", simp)
  apply (thin_tac "\<forall>N. 1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a (\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup> \<plusminus> -\<^sub>a 1\<^sub>r \<in> 
         carrier K")
  apply (thin_tac "\<forall>l\<le>Suc n. x l \<in> carrier K")
  apply (drule_tac x = N in spec)
  apply (drule_tac a = j in forall_spec, assumption,
         thin_tac "\<forall>ja\<le>Suc n. 1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a (\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup> 
         \<in> carrier K")
 apply (cut_tac N = N in ApproximationTr0 [of "(\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j"])
  apply (simp add:Ostrowski_base_mem)
  apply (frule Ring.ring_one[of "K"], frule aGroup.ag_mOp_closed[of "K" "1\<^sub>r"],
          assumption) apply (
         frule_tac x = "(1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>" in  
         aGroup.ag_mOp_closed[of "K"], assumption+)
  apply (simp only:aGroup.ag_pOp_assoc) 
  apply (simp only:aGroup.ag_pOp_commute[of "K" _ "-\<^sub>a 1\<^sub>r"])
  apply (simp only:aGroup.ag_pOp_assoc[THEN sym])
  apply (simp add:aGroup.ag_r_inv1)
  apply (simp add:aGroup.ag_l_zero) apply (simp only:val_minus_eq) 
   apply (thin_tac "(1\<^sub>r \<plusminus> -\<^sub>a (\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup> \<in> carrier K",
          thin_tac "-\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a (\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup> \<in> carrier K")
  apply (subst val_exp_ring[THEN sym, of "vv j"], assumption+)
   apply (rule aGroup.ag_pOp_closed[of "K"], assumption+)
   apply (rule aGroup.ag_mOp_closed[of "K"], assumption)
   apply (rule Ring.npClose, assumption+) apply (simp add:Ostrowski_base_mem)
  apply (rule Ostrowski_base_npow_not_one) apply simp apply assumption+
  apply (drule_tac a = N in forall_spec, assumption) 
  apply (drule_tac a = j in forall_spec, assumption) 
  apply (frule Ostrowski_baseTr1[of "n" "vv" "j"], assumption+)
  apply (frule_tac n = "N - Suc 0" in val_1mx_pow[of "vv j" "(\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j"])
  apply (simp add:Ostrowski_base_mem) apply assumption
  apply (thin_tac "vv j (x j) \<noteq> - \<infinity>")  apply (simp only:Suc_pred)
  apply (thin_tac "0 < vv j (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j))")
  apply (cut_tac b = "vv j (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K N\<^esup>)" and N = N in 
         asprod_ge) apply assumption apply simp
  apply (cut_tac x = "an N" and y = "int N *\<^sub>a vv j (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K N\<^esup>)" in aadd_le_mono[of _ _ "vv j (x j)"], assumption) 
  apply (simp add:aadd_commute)
 
 apply simp
 apply (frule_tac aa = "(\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja" and N = N in 
        ApproximationTr2[of "vv j"])
    apply (simp add:Ostrowski_base_mem)
    apply (rule Ostrowski_base_nonzero, assumption+) 
 apply (frule_tac l = ja in Ostrowski_baseTr0[of "n" "vv"], assumption+,
        erule conjE) 
  apply (rotate_tac -1, frule_tac a = j in forall_spec) apply assumption
  apply (frule_tac x = j in bspec, simp)
  apply (rule aless_imp_le) apply blast
  apply (rotate_tac -5, 
         drule_tac a = N in forall_spec, assumption)
  apply (rotate_tac -2, 
         drule_tac a = ja in forall_spec, assumption)  apply (
         drule_tac a = ja in forall_spec, assumption)
  apply (frule_tac l = ja in Ostrowski_baseTr0[of  "n" "vv"], assumption+)
  apply (erule conjE, rotate_tac -1, 
         frule_tac a = j in forall_spec, assumption+)
   apply (thin_tac "vv j (x ja) \<noteq> - \<infinity>")
  apply (cut_tac b = "vv j ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja)" and N = N in asprod_ge)
  apply simp apply simp
  apply (frule_tac x = "an N" and y = "int N *\<^sub>a vv j ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja)" and 
         z = "vv j (x ja)" in aadd_le_mono)
  apply (frule_tac x = "int N *\<^sub>a vv j ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja)" and y = "(vv j)
      (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>)" and z = "vv j (x ja)"
       in aadd_le_mono)
  apply (frule_tac i = "an N + vv j (x ja)" and 
        j = "int N *\<^sub>a vv j ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja) + vv j (x ja)" and 
        k = "vv j (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>) +
           vv j (x ja)" in ale_trans, assumption+)
  apply (subst aadd_commute)
  apply (frule_tac x = "an m" and y = "vv j (x ja) + an N" in aless_imp_le)
  apply (rule_tac j = "vv j (x ja) + an N" in ale_trans[of "an m"],
                   assumption) 
  apply (simp add:aadd_commute)
  apply (rule allI, rule impI, subst comp_def)
  apply (frule_tac a = ja in forall_spec, assumption)
  apply (frule_tac x = "x ja" in value_in_aug_inf[of "vv j"], assumption+)
  apply (simp add:aug_inf_def)
 
 apply (rule allI) 
   apply (rule aGroup.ag_pOp_closed, assumption+) apply blast
  apply (rule aGroup.ag_mOp_closed, assumption, rule Ring.ring_one, assumption)
 
 apply ((rule allI)+, rule impI)
 apply (rule_tac aa = "(\<Omega>\<^bsub>K vv (Suc n)\<^esub>) ja" in ApproximationTr1,
        simp add:Ostrowski_base_mem)
 done
  
 definition
   app_lb :: "[_ , nat, nat \<Rightarrow> 'b \<Rightarrow> ant, nat \<Rightarrow> 'b, nat] \<Rightarrow> 
             (nat \<Rightarrow> nat)"   ("(5\<Psi>\<^bsub>_ _ _ _ _\<^esub>)" [98,98,98,98,99]98) where
   "\<Psi>\<^bsub>K n vv x m\<^esub> = (\<lambda>j\<in>{h. h \<le> n}. (SOME L. (\<forall>N. L < N \<longrightarrow>
   (an m) \<le> (vv j (\<Sigma>\<^sub>e K (\<lambda>j\<in>{h. h \<le> n}. (x j) \<cdot>\<^sub>r\<^bsub>K\<^esub> (1\<^sub>r\<^bsub>K\<^esub> \<plusminus>\<^bsub>K\<^esub> -\<^sub>a\<^bsub>K\<^esub>
   (1\<^sub>r\<^bsub>K\<^esub> \<plusminus>\<^bsub>K\<^esub> -\<^sub>a\<^bsub>K\<^esub> ((\<Omega>\<^bsub>K vv n\<^esub>) j)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>)) n \<plusminus>\<^bsub>K\<^esub> -\<^sub>a\<^bsub>K\<^esub> (x j))))))"
  (** Approximation lower bound **)
 
 lemma (in Corps) app_LB:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
       \<forall>l\<le> (Suc n). x l \<in> carrier K; j \<le> (Suc n)\<rbrakk> \<Longrightarrow>
         \<forall>N. (\<Psi>\<^bsub>K (Suc n) vv x m\<^esub>) j < N \<longrightarrow> (an m) \<le> 
   (vv j (\<Sigma>\<^sub>e K (\<lambda>j\<in>{h. h \<le> (Suc n)}. (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> 
   -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>)) (Suc n) \<plusminus> -\<^sub>a (x j)))"
 apply (frule ApproximationTr3[of "n" "vv" "x" "j" "m"], 
                                assumption+)
 apply (simp del:nsum_suc add:app_lb_def)  apply (rule allI)
 apply (rule someI2_ex) apply assumption+
 apply (rule impI) apply blast
 done
 
 lemma (in Corps) ApplicationTr4:"\<lbrakk>vals_nonequiv K (Suc n) vv;  
  \<forall>j\<in>{h. h \<le> (Suc n)}. x j \<in> carrier K\<rbrakk> \<Longrightarrow> 
  \<exists>l. \<forall>N. l < N \<longrightarrow> (\<forall>j \<le> (Suc n).  (an m) \<le> 
   (vv j (\<Sigma>\<^sub>e K (\<lambda>j\<in>{h. h \<le> (Suc n)}. (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> 
   -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>)) (Suc n) \<plusminus> -\<^sub>a (x j))))"
 apply (subgoal_tac "\<forall>N. (m_max (Suc n) (\<Psi>\<^bsub>K (Suc n) vv x m\<^esub>)) < N \<longrightarrow> 
   (\<forall>j\<le> (Suc n).  (an m) \<le> 
   (vv j (\<Sigma>\<^sub>e K (\<lambda>j\<in>{h. h \<le> (Suc n)}. (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus>  
   -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>)) (Suc n) \<plusminus> -\<^sub>a (x j))))")
 apply blast
  apply (rule allI, rule impI)+ 
 apply (frule_tac j = j in  app_LB[of  "n" "vv" "x" _ "m"],
        simp, assumption,
        subgoal_tac "(\<Psi>\<^bsub>K (Suc n) vv x m\<^esub>) j < N", blast)
 apply (frule_tac l = j and n = "Suc n" and f = "\<Psi>\<^bsub>K (Suc n) vv x m\<^esub>" in m_max_gt,
        frule_tac x = "(\<Psi>\<^bsub>K (Suc n) vv x m\<^esub>) j" and 
        y = "m_max (Suc n) (\<Psi>\<^bsub>K (Suc n) vv x m\<^esub>)" and z = N in le_less_trans, 
        assumption+)
 done
 
 theorem (in Corps) Approximation_thm:"\<lbrakk>vals_nonequiv K (Suc n) vv; 
 \<forall>j\<le> (Suc n). (x j) \<in> carrier K\<rbrakk>  \<Longrightarrow>
 \<exists>y\<in>carrier K. \<forall>j\<le> (Suc n). (an m) \<le> (vv j (y \<plusminus> -\<^sub>a (x j)))"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"]) 
 apply (subgoal_tac "\<exists>l. (\<forall>N. l < N \<longrightarrow> (\<forall>j \<le> (Suc n). (an m) \<le> ((vv j) ((nsum K (\<lambda>j\<in>{h. h \<le> (Suc n)}. (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K N\<^esup>)^\<^bsup>K N\<^esup>)) (Suc n)) \<plusminus> -\<^sub>a (x j)))))") 
  apply (erule exE)
  apply (rename_tac M)
  apply (subgoal_tac "\<forall>j\<le> (Suc n). (an m) \<le>
  (vv j ( (\<Sigma>\<^sub>e K (\<lambda>j\<in>{h. h \<le> (Suc n)}. (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> -\<^sub>a (1\<^sub>r \<plusminus> 
   -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K (Suc M)\<^esup>)^\<^bsup>K (Suc M)\<^esup>)) (Suc n)) \<plusminus> -\<^sub>a (x j)))")
  apply (subgoal_tac "\<Sigma>\<^sub>e K (\<lambda>j\<in>{h. h \<le> (Suc n)}. (x j) \<cdot>\<^sub>r (1\<^sub>r \<plusminus> 
  -\<^sub>a (1\<^sub>r \<plusminus> -\<^sub>a ((\<Omega>\<^bsub>K vv (Suc n)\<^esub>) j)^\<^bsup>K (Suc M)\<^esup>)^\<^bsup>K (Suc M)\<^esup>)) (Suc n) \<in> carrier K")
  apply blast
  apply (rule aGroup.nsum_mem[of "K" "Suc n"], assumption+)
  apply (rule allI, rule impI, simp del:nsum_suc npow_suc)
  apply (rule Ring.ring_tOp_closed, assumption+, simp,
         rule ApproximationTr1, simp add:Ostrowski_base_mem)
 
  apply (subgoal_tac "M < Suc M") apply blast
  apply simp
  apply (rule ApplicationTr4[of n vv x], assumption+)
  apply simp
 done
 
 definition
   distinct_pds :: "[_, nat, nat \<Rightarrow> ('b \<Rightarrow> ant) set] \<Rightarrow> bool" where
   "distinct_pds K n P \<longleftrightarrow> (\<forall>j\<le> n. P j \<in> Pds\<^bsub> K\<^esub>) \<and> 
           (\<forall>l\<le> n. \<forall>m\<le> n. l \<noteq> m \<longrightarrow> P l \<noteq> P m)"
 
  (** pds --- prime divisors **)
 lemma (in Corps) distinct_pds_restriction:"\<lbrakk>distinct_pds K (Suc n) P\<rbrakk> \<Longrightarrow> 
        distinct_pds K n P"  
 apply (simp add:distinct_pds_def) 
 done
 
 lemma (in Corps) ring_n_distinct_prime_divisors:"distinct_pds K n P \<Longrightarrow>
        Ring (Sr K {x. x\<in>carrier K \<and> (\<forall>j\<le> n. 0 \<le> ((\<nu>\<^bsub> K (P j)\<^esub>) x))})"
 apply (simp add:distinct_pds_def) apply (erule conjE)
 apply (cut_tac field_is_ring)
 apply (rule Ring.Sr_ring, assumption+)
 apply (subst sr_def)
  apply (rule conjI)
  apply (rule subsetI) apply simp
  apply (rule conjI)
  apply (simp add:Ring.ring_one)
 apply (rule allI, rule impI) 
  apply (cut_tac P = "P j" in representative_of_pd_valuation, simp,
         simp add:value_of_one) 
 apply (rule ballI)+
  apply simp
  apply (frule Ring.ring_is_ag[of "K"]) apply (erule conjE)+
  apply (frule_tac x = y in aGroup.ag_mOp_closed[of "K"], assumption+)
  apply (frule_tac x = x and y = "-\<^sub>a y" in aGroup.ag_pOp_closed[of "K"], 
         assumption+)
  apply simp
  apply (rule conjI)
  apply (rule allI, rule impI)
  apply (rotate_tac -4, frule_tac a = j in forall_spec, assumption,
         rotate_tac -3,
         drule_tac a = j in forall_spec, assumption)
  apply (cut_tac P = "P j" in representative_of_pd_valuation, simp)
  apply (frule_tac v = "\<nu>\<^bsub>K (P j)\<^esub>" and x = x and y = "-\<^sub>a y" in amin_le_plus, 
         assumption+) 
  apply (simp add:val_minus_eq)
  apply (frule_tac x = "(\<nu>\<^bsub>K (P j)\<^esub>) x" and y = "(\<nu>\<^bsub>K (P j)\<^esub>) y" in amin_ge1[of "0"])
         apply simp
  apply (rule_tac j = "amin ((\<nu>\<^bsub>K (P j)\<^esub>) x) ((\<nu>\<^bsub>K (P j)\<^esub>) y)" and k = "(\<nu>\<^bsub>K (P j)\<^esub>) (x \<plusminus> -\<^sub>a y)" in ale_trans[of "0"], assumption+)
  apply (simp add:Ring.ring_tOp_closed)
  
 apply (rule allI, rule impI,
        cut_tac P = "P j" in representative_of_pd_valuation, simp,
        subst val_t2p [where v="\<nu>\<^bsub>K P j\<^esub>"], assumption+,
        rule aadd_two_pos, simp+)
 done
 
 lemma (in Corps) distinct_pds_valuation:"\<lbrakk>j \<le> (Suc n);
        distinct_pds K (Suc n) P\<rbrakk> \<Longrightarrow>  valuation K (\<nu>\<^bsub>K (P j)\<^esub>)"
  apply (rule_tac P = "P j" in representative_of_pd_valuation) 
  apply (simp add:distinct_pds_def)
 done
 
 lemma (in Corps) distinct_pds_valuation1:"\<lbrakk>0 < n; j \<le> n; distinct_pds K n P\<rbrakk>
  \<Longrightarrow>  valuation K (\<nu>\<^bsub>K (P j)\<^esub>)"
 apply (rule distinct_pds_valuation[of "j" "n - Suc 0" "P"]) 
 apply simp+
 done
 
 lemma (in Corps) distinct_pds_valuation2:"\<lbrakk>j \<le> n; distinct_pds K n P\<rbrakk> \<Longrightarrow> 
           valuation K (\<nu>\<^bsub>K (P j)\<^esub>)"
 apply (case_tac "n = 0",
        simp add:distinct_pds_def,
        subgoal_tac "0 \<in> {0::nat}",
        simp add:representative_of_pd_valuation[of "P 0"],
        simp)
  
  apply (simp add:distinct_pds_valuation1[of "n"])
 done
 
 definition
   ring_n_pd :: "[('b, 'm) Ring_scheme, nat \<Rightarrow> ('b \<Rightarrow> ant) set,
                              nat ] \<Rightarrow> ('b, 'm) Ring_scheme"
                  ("(3O\<^bsub>_ _ _\<^esub>)" [98,98,99]98) where
   "O\<^bsub>K P n\<^esub> = Sr K {x. x \<in> carrier K \<and>
            (\<forall>j \<le> n. 0 \<le> ((\<nu>\<^bsub>K (P j)\<^esub>) x))}" 
   (** ring defined by n prime divisors **)
 
 lemma (in Corps) ring_n_pd:"distinct_pds K n P \<Longrightarrow> Ring (O\<^bsub>K P n\<^esub>)"
 by (simp add:ring_n_pd_def, simp add:ring_n_distinct_prime_divisors)
 
 lemma (in Corps) ring_n_pd_Suc:"distinct_pds K (Suc n) P \<Longrightarrow> 
           carrier (O\<^bsub> K P (Suc n)\<^esub>) \<subseteq> carrier (O\<^bsub>K P n\<^esub>)"
 apply (rule subsetI)
  apply (simp add:ring_n_pd_def Sr_def)
 done
 
 lemma (in Corps) ring_n_pd_pOp_K_pOp:"\<lbrakk>distinct_pds K n P; x\<in>carrier (O\<^bsub>K P n\<^esub>);
  y \<in> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk>  \<Longrightarrow> x \<plusminus>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub> y = x \<plusminus> y" 
 apply (simp add:ring_n_pd_def Sr_def)
 done
 
 lemma (in Corps) ring_n_pd_tOp_K_tOp:"\<lbrakk>distinct_pds K n P; x \<in>carrier (O\<^bsub>K P n\<^esub>);
       y \<in> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk> \<Longrightarrow>  x \<cdot>\<^sub>r\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub> y = x \<cdot>\<^sub>r y" 
 apply (simp add:ring_n_pd_def Sr_def)
 done
 
 lemma (in Corps) ring_n_eSum_K_eSumTr:"distinct_pds K n P \<Longrightarrow> 
   (\<forall>j\<le>m. f j \<in> carrier (O\<^bsub>K P n\<^esub>)) \<longrightarrow> nsum (O\<^bsub>K P n\<^esub>) f m = nsum K f m"
 apply (induct_tac m)
  apply (rule impI, simp)
 
  apply (rule impI, simp,
         subst ring_n_pd_pOp_K_pOp, assumption+,
         frule_tac n = n in ring_n_pd[of _ "P"],
         frule_tac Ring.ring_is_ag, drule sym, simp)
  apply (rule aGroup.nsum_mem, assumption+, simp+)
 done
 
 lemma (in Corps) ring_n_eSum_K_eSum:"\<lbrakk>distinct_pds K n P; 
       \<forall>j \<le> m. f j \<in> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk> \<Longrightarrow> nsum (O\<^bsub>K P n\<^esub>) f m = nsum K f m"
 apply (simp add:ring_n_eSum_K_eSumTr)
 done
 
 lemma (in Corps) ideal_eSum_closed:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
       \<forall>j \<le> m. f j \<in> I\<rbrakk> \<Longrightarrow>  nsum K f m \<in> I"
 apply (frule ring_n_pd[of "n" "P"]) thm Ring.ideal_nsum_closed
  apply (frule_tac n = m in 
        Ring.ideal_nsum_closed[of "(O\<^bsub>K P n\<^esub>)" "I" _ "f"], assumption+)
  apply (subst ring_n_eSum_K_eSum [THEN sym, of n P m f], assumption+,
         rule allI, simp add:Ring.ideal_subset)
  apply assumption
 done
 
 definition
   prime_n_pd :: "[_, nat \<Rightarrow> ('b \<Rightarrow> ant) set,
                              nat, nat] \<Rightarrow> 'b set"
                  ("(4P\<^bsub>_ _ _\<^esub> _)" [98,98,98,99]98) where
   "P\<^bsub>K P n\<^esub> j = {x. x \<in> (carrier (O\<^bsub>K P n\<^esub>)) \<and> 0 < ((\<nu>\<^bsub>K (P j)\<^esub>) x)}"
 
 lemma (in Corps) zero_in_ring_n_pd_zero_K:"distinct_pds K n P \<Longrightarrow> 
                                \<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub> = \<zero>\<^bsub>K\<^esub>"
 apply (simp add:ring_n_pd_def Sr_def)
 done
 
 lemma (in Corps) one_in_ring_n_pd_one_K:"distinct_pds K n P \<Longrightarrow>
                                       1\<^sub>r\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub> = 1\<^sub>r"
 apply (simp add:ring_n_pd_def Sr_def)
 done
 
 lemma (in Corps) mem_ring_n_pd_mem_K:"\<lbrakk>distinct_pds K n P; x \<in>carrier (O\<^bsub>K P n\<^esub>)\<rbrakk>
  \<Longrightarrow> x \<in> carrier K" 
 apply (simp add:ring_n_pd_def Sr_def)
 done
 
 lemma (in Corps) ring_n_tOp_K_tOp:"\<lbrakk>distinct_pds K n P; x \<in> carrier (O\<^bsub>K P n\<^esub>); 
       y \<in> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk>  \<Longrightarrow> x \<cdot>\<^sub>r\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub> y = x \<cdot>\<^sub>r y"
 apply (simp add:ring_n_pd_def Sr_def)
 done
 
 lemma (in Corps) ring_n_exp_K_exp:"\<lbrakk>distinct_pds K n P; x \<in> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk>
         \<Longrightarrow> x^\<^bsup>K m\<^esup> = x^\<^bsup>(O\<^bsub>K P n\<^esub>) m\<^esup>" 
 apply (frule ring_n_pd[of "n" "P"])
 apply (induct_tac m) apply simp
  apply (simp add:one_in_ring_n_pd_one_K)
 
 apply simp
  apply (frule_tac n = na in Ring.npClose[of "O\<^bsub>K P n\<^esub>" "x"], assumption+)
  apply (simp add:ring_n_tOp_K_tOp)
 done   
 
 lemma (in Corps) prime_n_pd_prime:"\<lbrakk>distinct_pds K n P; j \<le> n\<rbrakk> \<Longrightarrow>  
               prime_ideal (O\<^bsub>K P n\<^esub>) (P\<^bsub>K P n\<^esub> j)"
 apply (subst prime_ideal_def)
  apply (rule conjI)
  apply (simp add:ideal_def)
  apply (rule conjI)
  apply (rule aGroup.asubg_test)
  apply (frule ring_n_pd[of "n" "P"], simp add:Ring.ring_is_ag)
  apply (rule subsetI, simp add:prime_n_pd_def)
  apply (subgoal_tac "\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub> \<in> P\<^bsub>K P n\<^esub> j")
  apply blast
  
  apply (simp add:zero_in_ring_n_pd_zero_K)
  apply (simp add:prime_n_pd_def)
  apply (simp add: ring_n_pd_def Sr_def) 
  apply (cut_tac field_is_ring, simp add:Ring.ring_zero)
  apply (rule conjI) apply (rule allI, rule impI)
  apply (cut_tac P = "P ja" in representative_of_pd_valuation,
         simp add:distinct_pds_def, simp add:value_of_zero)
  apply (cut_tac P = "P j" in representative_of_pd_valuation,
         simp add:distinct_pds_def, simp add:value_of_zero)
  apply (simp add:ant_0[THEN sym]) 
 
  apply (rule ballI)+  
  apply (simp add:prime_n_pd_def) apply (erule conjE)+ 
  apply (frule ring_n_pd [of "n" "P"], frule Ring.ring_is_ag[of "O\<^bsub>K P n\<^esub>"])
  apply (frule_tac x = b in aGroup.ag_mOp_closed[of "O\<^bsub>K P n\<^esub>"], assumption+)
  apply (simp add:aGroup.ag_pOp_closed)
   apply (thin_tac "Ring (O\<^bsub>K P n\<^esub>)") apply (thin_tac "aGroup (O\<^bsub>K P n\<^esub>)")
  apply (simp add:ring_n_pd_def Sr_def)
  apply (erule conjE)+
  apply (cut_tac v = "\<nu>\<^bsub>K (P j)\<^esub>" and x = a and y = "-\<^sub>a b" in 
         amin_le_plus) 
  apply (rule_tac P = "P j" in representative_of_pd_valuation, 
         simp add:distinct_pds_def)
  apply assumption+
  apply (cut_tac P = "P j" in representative_of_pd_valuation) 
  apply (simp add:distinct_pds_def)
  apply (frule_tac x = "(\<nu>\<^bsub>K (P j)\<^esub>) a" and y = "(\<nu>\<^bsub>K (P j)\<^esub>) (-\<^sub>a b)" in 
          amin_gt[of "0"])
  apply (simp add:val_minus_eq)
 
 apply (frule_tac y = "amin ((\<nu>\<^bsub>K (P j)\<^esub>) a) ((\<nu>\<^bsub>K (P j)\<^esub>) (-\<^sub>a b))" and
  z = "(\<nu>\<^bsub>K (P j)\<^esub>) ( a \<plusminus> -\<^sub>a b)" in aless_le_trans[of "0"], assumption+)
 
 apply (rule ballI)+
  apply (frule ring_n_pd [of "n" "P"])
  apply (frule_tac x = r and y = x in Ring.ring_tOp_closed[of "O\<^bsub>K P n\<^esub>"], 
         assumption+)
  apply (simp add:prime_n_pd_def)
  apply (cut_tac P = "P j" in representative_of_pd_valuation,
         simp add:distinct_pds_def)
  apply (thin_tac "Ring (O\<^bsub>K P n\<^esub>)") 
  apply (simp add:prime_n_pd_def ring_n_pd_def Sr_def, (erule conjE)+,
         simp add:val_t2p)
  apply (subgoal_tac "0 \<le> ((\<nu>\<^bsub>K (P j)\<^esub>) r)")
  apply (simp add:aadd_pos_poss, simp) 
 
  apply (rule conjI,
         rule contrapos_pp, simp+,
         simp add:prime_n_pd_def,
         (erule conjE)+, simp add: one_in_ring_n_pd_one_K,
         simp add:distinct_pds_def, (erule conjE)+,
         cut_tac representative_of_pd_valuation[of "P j"],
         simp add:value_of_one, simp) 
 
 apply ((rule ballI)+, rule impI)
  apply (rule contrapos_pp, simp+, erule conjE,
         simp add:prime_n_pd_def, (erule conjE)+,
         simp add:ring_n_pd_def Sr_def, (erule conjE)+, 
         simp add:aneg_less,
         frule_tac x = "(\<nu>\<^bsub>K (P j)\<^esub>) x" in ale_antisym[of _ "0"], simp,
         frule_tac x = "(\<nu>\<^bsub>K (P j)\<^esub>) y" in ale_antisym[of _ "0"], simp)
 
  apply (simp add:distinct_pds_def, (erule conjE)+,
         cut_tac representative_of_pd_valuation[of "P j"],
         simp add:val_t2p aadd_0_l,
         simp)
 done 
 
 lemma (in Corps) n_eq_val_eq_idealTr:
 "\<lbrakk>distinct_pds K n P; x \<in> carrier (O\<^bsub>K P n\<^esub>); y \<in> carrier (O\<^bsub>K P n\<^esub>); 
 \<forall>j \<le> n. ((\<nu>\<^bsub>K (P j)\<^esub>) x) \<le> ((\<nu>\<^bsub>K (P j)\<^esub>) y)\<rbrakk> \<Longrightarrow> Rxa (O\<^bsub>K P n\<^esub>) y \<subseteq> Rxa (O\<^bsub>K P n\<^esub>) x"
 apply (subgoal_tac "\<forall>j \<le> n. valuation K (\<nu>\<^bsub>K (P j)\<^esub>)")
  apply (case_tac "x = \<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>",
         simp add:zero_in_ring_n_pd_zero_K)
  apply (simp add:value_of_zero)
  apply (subgoal_tac "y = \<zero>", simp,
         drule_tac a = n in forall_spec, simp,
         drule_tac a=n in forall_spec, simp)
  apply (cut_tac inf_ge_any[of "(\<nu>\<^bsub>K (P n)\<^esub>) y"],
         frule ale_antisym[of "(\<nu>\<^bsub>K (P n)\<^esub>) y" "\<infinity>"], assumption+)
  apply (rule value_inf_zero, assumption+)
  apply (simp add:mem_ring_n_pd_mem_K, assumption)
        
 apply (frule ring_n_pd[of n P])
  apply (subgoal_tac "\<forall>j\<le>n. 0 \<le> ((\<nu>\<^bsub>K (P j)\<^esub>) (y \<cdot>\<^sub>r (x\<^bsup>\<hyphen>K\<^esup>)))")
  apply (subgoal_tac "(y \<cdot>\<^sub>r (x\<^bsup>\<hyphen>K\<^esup>)) \<in> carrier (O\<^bsub>K P n\<^esub>)")
  apply (cut_tac field_frac_mul[of "y" "x"],
         frule Ring.rxa_in_Rxa[of "O\<^bsub>K P n\<^esub>" "x" "y \<cdot>\<^sub>r (x\<^bsup>\<hyphen>K\<^esup>)"], assumption+, 
         simp add:ring_n_pd_tOp_K_tOp[THEN sym],
         frule Ring.principal_ideal[of "O\<^bsub>K P n\<^esub>" "x"], assumption+) 
  
  apply (cut_tac Ring.ideal_cont_Rxa[of "O\<^bsub>K P n\<^esub>" "(O\<^bsub>K P n\<^esub>) \<diamondsuit>\<^sub>p x" "y"],
         assumption+,
         simp add:mem_ring_n_pd_mem_K,
         simp add:mem_ring_n_pd_mem_K,
         simp add:zero_in_ring_n_pd_zero_K) 
  apply (frule Ring.rxa_in_Rxa[of "O\<^bsub>K P n\<^esub>" "x" "y \<cdot>\<^sub>r (x\<^bsup>\<hyphen>K\<^esup>)"], assumption+,
         simp add:ring_n_pd_def Sr_def,
         (erule conjE)+,
         cut_tac field_is_ring, rule Ring.ring_tOp_closed, assumption+,
         cut_tac invf_closed1[of x], simp, simp,
         simp add:ring_n_pd_def Sr_def)
  apply (cut_tac Ring.ring_tOp_closed, assumption+,
         cut_tac field_is_ring, assumption+, simp+,
         cut_tac invf_closed1[of x], simp, simp)
 
  apply (rule allI, rule impI, drule_tac a = j in forall_spec, assumption+,
         cut_tac invf_closed1[of x], simp, erule conjE)
  apply (subst val_t2p [where v="\<nu>\<^bsub>K P j\<^esub>"], simp,
         rule mem_ring_n_pd_mem_K[of "n" "P" "y"], assumption+,
         frule_tac x = j in spec, simp,
         simp add:zero_in_ring_n_pd_zero_K)
  apply (subst value_of_inv [where v="\<nu>\<^bsub>K P j\<^esub>"], simp,
         simp add:ring_n_pd_def Sr_def, assumption+)
  apply (frule_tac x = "(\<nu>\<^bsub>K (P j)\<^esub>) x" and y = "(\<nu>\<^bsub>K (P j)\<^esub>) y" in ale_diff_pos,
         simp add:diff_ant_def,
         simp add:mem_ring_n_pd_mem_K[of "n" "P" "x"] zero_in_ring_n_pd_zero_K)
 
 apply (rule allI, rule impI,
        simp add:distinct_pds_def, (erule conjE)+,
        rule_tac P = "P j" in representative_of_pd_valuation, simp)
 done
  
 lemma (in Corps) n_eq_val_eq_ideal:"\<lbrakk>distinct_pds K n P; x \<in> carrier (O\<^bsub>K P n\<^esub>);
       y \<in> carrier (O\<^bsub>K P n\<^esub>); \<forall>j \<le> n.((\<nu>\<^bsub>K (P j)\<^esub>) x) = ((\<nu>\<^bsub>K (P j)\<^esub>) y)\<rbrakk> \<Longrightarrow>  
                  Rxa (O\<^bsub>K P n\<^esub>) x = Rxa (O\<^bsub>K P n\<^esub>) y"
 apply (rule equalityI)
  apply (subgoal_tac "\<forall>j\<le> n. (\<nu>\<^bsub>K (P j)\<^esub>) y \<le> ((\<nu>\<^bsub>K (P j)\<^esub>) x)")
  apply (rule n_eq_val_eq_idealTr, assumption+)
  apply (rule allI, rule impI, simp)
 
  apply (subgoal_tac "\<forall>j\<le> n. (\<nu>\<^bsub>K (P j)\<^esub>) x \<le> ((\<nu>\<^bsub>K (P j)\<^esub>) y)")
  apply (rule n_eq_val_eq_idealTr, assumption+)
  apply (rule allI, rule impI)
  apply simp
 done  
  
 definition
   mI_gen :: "[_ , nat \<Rightarrow> ('r \<Rightarrow> ant) set, nat, 'r set] \<Rightarrow> 'r" where
   "mI_gen K P n I = (SOME x. x \<in> I \<and> 
                              (\<forall>j \<le> n. (\<nu>\<^bsub>K (P j)\<^esub>) x = LI K (\<nu>\<^bsub>K (P j)\<^esub>) I))"
 
 definition
   mL :: "[_, nat \<Rightarrow> ('r \<Rightarrow> ant) set, 'r set, nat] \<Rightarrow> int" where
   "mL K P I j = tna (LI K (\<nu>\<^bsub>K (P j)\<^esub>) I)"
 
 lemma (in Corps) mI_vals_nonempty:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; j\<le>n\<rbrakk>
     \<Longrightarrow> (\<nu>\<^bsub>K (P j)\<^esub>) ` I \<noteq> {}"
 apply (frule ring_n_pd[of "n" "P"])
 apply (frule Ring.ideal_zero [of "O\<^bsub>K P n\<^esub>" "I"], assumption+)
 
 apply (simp add:image_def)
 apply blast
 done
 
 lemma (in Corps) mI_vals_LB:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; j \<le> n\<rbrakk> \<Longrightarrow>
        ((\<nu>\<^bsub>K (P j)\<^esub>) `I) \<subseteq> LBset (ant 0)"
 apply (rule subsetI)
 apply (simp add:image_def, erule bexE)
  apply (frule ring_n_pd[of "n" "P"])
  apply (frule_tac h = xa in Ring.ideal_subset[of "O\<^bsub>K P n\<^esub>" "I"], assumption+)
  apply (thin_tac "ideal (O\<^bsub>K P n\<^esub>) I")
  apply (thin_tac "Ring (O\<^bsub>K P n\<^esub>)")
  apply (simp add: ring_n_pd_def Sr_def) apply (erule conjE)+ 
  apply (drule_tac a = j in forall_spec, simp)
  
 apply (simp add:LBset_def ant_0)
 done
 
 lemma (in Corps) mL_hom:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
       I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk> \<Longrightarrow> 
       \<forall>j \<le> n. mL K P I j \<in> Zset" 
 apply (rule allI, rule impI)
  apply (simp add:mL_def LI_def)
  apply (simp add:Zset_def)
 done
 
 lemma (in Corps) ex_Zleast_in_mI:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; j \<le> n\<rbrakk>
       \<Longrightarrow> \<exists>x\<in>I. (\<nu>\<^bsub>K (P j)\<^esub>) x = LI K (\<nu>\<^bsub>K (P j)\<^esub>) I"
 apply (frule_tac j = j in mI_vals_nonempty[of "n" "P" "I"], assumption+)
  apply (frule_tac j = j in mI_vals_LB[of "n" "P" "I"], assumption+)
  apply (frule_tac A = "(\<nu>\<^bsub>K (P j)\<^esub>) ` I" and z = 0 in AMin_mem, assumption+)
  apply (simp add:LI_def)
  apply (thin_tac "(\<nu>\<^bsub>K (P j)\<^esub>) ` I \<subseteq> LBset (ant 0)")
  apply (simp add:image_def, erule bexE)
  apply (drule sym)
  apply blast
 done 
 
 lemma (in Corps) val_LI_pos:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
        I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; j \<le> n\<rbrakk> \<Longrightarrow> 0 \<le> LI K (\<nu>\<^bsub>K (P j)\<^esub>) I"
 apply (frule_tac j = j in mI_vals_nonempty[of n P I], assumption+)
  apply (frule_tac j = j in mI_vals_LB[of n P I], assumption+)
  apply (frule_tac A = "(\<nu>\<^bsub>K (P j)\<^esub>) ` I" and z = 0 in AMin_mem, assumption+)
  apply (simp add:LI_def)
 apply (frule subsetD[of "(\<nu>\<^bsub>K (P j)\<^esub>) ` I" "LBset (ant 0)" "AMin ((\<nu>\<^bsub>K (P j)\<^esub>) ` I)"], assumption+)
 apply (simp add:LBset_def ant_0)
 done
 
 lemma (in Corps) val_LI_noninf:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
        I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; j \<le> n\<rbrakk> \<Longrightarrow> LI K (\<nu>\<^bsub>K (P j)\<^esub>) I \<noteq> \<infinity>"
  apply (frule_tac j = j in mI_vals_nonempty[of "n" "P" "I"], assumption+)
  apply (frule_tac j = j in mI_vals_LB[of "n" "P" "I"], assumption+)
  apply (frule_tac A = "(\<nu>\<^bsub>K (P j)\<^esub>) ` I" and z = 0 in AMin, assumption+)
  apply (thin_tac "(\<nu>\<^bsub>K (P j)\<^esub>) ` I \<subseteq> LBset (ant 0)", 
         thin_tac "(\<nu>\<^bsub>K (P j)\<^esub> ) ` I \<noteq> {}")
  apply (frule ring_n_pd[of "n" "P"])
  apply (frule Ring.ideal_zero[of "O\<^bsub>K P n\<^esub>" "I"], assumption+)
  apply (erule conjE, simp add:LI_def)
  apply (frule singleton_sub[of "\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>" "I"])
  apply (frule sets_not_eq[of "I" "{\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>}"],
         assumption+, erule bexE)
  apply (simp add:zero_in_ring_n_pd_zero_K)
  apply (subgoal_tac "\<exists>x\<in>I. AMin ((\<nu>\<^bsub>K (P j)\<^esub>) ` I) = (\<nu>\<^bsub>K (P j)\<^esub>) x",
         erule bexE) apply simp
  apply (drule_tac x = a in bspec, assumption)
  apply (thin_tac "AMin ((\<nu>\<^bsub>K (P j)\<^esub>) ` I) = (\<nu>\<^bsub>K (P j)\<^esub>) x")
 
  apply (frule_tac h = a in Ring.ideal_subset[of "O\<^bsub>K P n\<^esub>" "I"], assumption+)
  apply (frule_tac x = a in mem_ring_n_pd_mem_K[of n P], assumption+)
  apply (simp add:distinct_pds_def, (erule conjE)+)
  apply (cut_tac representative_of_pd_valuation[of "P j"])
  defer apply simp apply blast
  apply (frule_tac x = a in val_nonzero_z[of "\<nu>\<^bsub>K (P j)\<^esub>"], assumption+,
         erule exE, simp)
  apply (thin_tac "\<forall>l \<le> n. \<forall>m \<le> n. l \<noteq> m \<longrightarrow> P l \<noteq> P m",
         thin_tac "(\<nu>\<^bsub>K (P j)\<^esub>) a = ant z")
 
  apply (rule contrapos_pp, simp+)
  apply (cut_tac x = "ant z" in inf_ge_any) 
  apply (frule_tac x = "ant z" in ale_antisym[of _ "\<infinity>"], assumption+)
  apply simp 
 done 
 
 lemma (in Corps) Zleast_in_mI_pos:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
        I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; j \<le> n\<rbrakk> \<Longrightarrow> 0 \<le> mL K P I j"
 apply (simp add:mL_def)
 apply (frule ex_Zleast_in_mI[of "n" "P" "I" "j"], assumption+,
        erule bexE, frule sym, thin_tac "(\<nu>\<^bsub>K (P j)\<^esub>) x = LI K (\<nu>\<^bsub>K (P j)\<^esub>) I")
 apply (subgoal_tac "LI K (\<nu>\<^bsub>K (P j)\<^esub>) I \<noteq> \<infinity>", simp)
 apply (thin_tac "LI K (\<nu>\<^bsub>K (P j)\<^esub>) I = (\<nu>\<^bsub>K (P j)\<^esub>) x")
 
  apply (frule ring_n_pd[of "n" "P"])
  apply (frule_tac h = x in Ring.ideal_subset[of "O\<^bsub>K P n\<^esub>" "I"], assumption+)
  apply (thin_tac "ideal (O\<^bsub>K P n\<^esub>) I")
  apply (thin_tac "Ring (O\<^bsub>K P n\<^esub>)")
  apply (simp add: ring_n_pd_def Sr_def) apply (erule conjE)
  apply (drule_tac a = j in forall_spec, assumption)
  apply (simp add:apos_tna_pos)
 apply (rule val_LI_noninf, assumption+)
 done 
 
 lemma (in Corps) Zleast_mL_I:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; j \<le> n;
    I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; x \<in> I\<rbrakk> \<Longrightarrow> ant (mL K P I j) \<le> ((\<nu>\<^bsub>K (P j)\<^esub>) x)"
 apply (frule val_LI_pos[of "n" "P" "I" "j"], assumption+)
 apply (frule apos_neq_minf[of "LI K (\<nu>\<^bsub>K (P j)\<^esub>) I"])
 apply (frule val_LI_noninf[of "n" "P" "I" "j"], assumption+)
 apply (simp add:mL_def LI_def)
 apply (simp add:ant_tna)
 apply (frule Zleast_in_mI_pos[of "n" "P" "I" "j"], assumption+)
 
 apply (frule mI_vals_nonempty[of "n" "P" "I" "j"], assumption+)
 apply (frule mI_vals_LB[of "n" "P" "I" "j"], assumption+)
 apply (frule AMin[of "(\<nu>\<^bsub>K (P j)\<^esub>) `I" "0"], assumption+)
  apply (erule conjE)
 apply (frule Zleast_in_mI_pos[of "n" "P" "I" "j"], assumption+)
  apply (simp add:mL_def LI_def)
 done 
 
 lemma (in Corps) Zleast_LI:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; j \<le> n;
    I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; x \<in> I\<rbrakk> \<Longrightarrow> (LI K (\<nu>\<^bsub>K (P j)\<^esub>) I) \<le> ((\<nu>\<^bsub>K (P j)\<^esub>) x)"
 apply (frule mI_vals_nonempty[of "n" "P" "I" "j"], assumption+)
 apply (frule mI_vals_LB[of "n" "P" "I" "j"], assumption+)
 apply (frule AMin[of "(\<nu>\<^bsub>K (P j)\<^esub>) `I" "0"], assumption+)
  apply (erule conjE)
 apply (simp add:LI_def)
 done
 
 lemma (in Corps) mpdiv_vals_nonequiv:"distinct_pds K n P \<Longrightarrow> 
              vals_nonequiv K n (\<lambda>j. \<nu>\<^bsub>K (P j)\<^esub>) "  
 apply (simp add:vals_nonequiv_def)
  apply (rule conjI)
  apply (simp add:valuations_def)
  apply (rule allI, rule impI)
  apply (rule representative_of_pd_valuation, 
         simp add:distinct_pds_def) 
 apply  ((rule allI, rule impI)+, rule impI)
  apply (simp add:distinct_pds_def, erule conjE)
  apply (rotate_tac 4) apply (
         drule_tac a = j in forall_spec, assumption)
  apply (rotate_tac -1,
         drule_tac a = l in forall_spec, assumption, simp)
  apply (simp add:distinct_p_divisors)
 done
 
 definition
   KbaseP :: "[_, nat \<Rightarrow> ('r \<Rightarrow> ant) set, nat] \<Rightarrow> 
                                           (nat \<Rightarrow> 'r) \<Rightarrow> bool"  where
   "KbaseP K P n f \<longleftrightarrow> (\<forall>j \<le> n. f j \<in> carrier K) \<and> 
      (\<forall>j \<le> n. \<forall>l \<le> n. (\<nu>\<^bsub>K (P j)\<^esub>) (f l) =  (\<delta>\<^bsub>j l\<^esub>))"
 
 definition
   Kbase :: "[_, nat, nat \<Rightarrow> ('r \<Rightarrow> ant) set] 
                \<Rightarrow> (nat \<Rightarrow> 'r)" ("(3Kb\<^bsub>_ _ _\<^esub>)" [95,95,96]95) where
   "Kb\<^bsub>K n P \<^esub> = (SOME f. KbaseP K P n f)"
 
 lemma (in Corps) KbaseTr:"distinct_pds K n P \<Longrightarrow>  \<exists>f. KbaseP K P n f"
 apply (simp add: KbaseP_def)
  apply (frule mpdiv_vals_nonequiv[of "n" "P"])
  apply (case_tac "n = 0")
   apply (simp add:vals_nonequiv_def valuations_def)
   apply (simp add:distinct_pds_def) 
   apply (frule n_val_n_val1[of "P 0"])
   apply (frule n_val_surj[of "\<nu>\<^bsub>K (P 0)\<^esub>"])
   apply (erule bexE)
   apply (subgoal_tac " ((\<lambda>j\<in>{0::nat}. x) (0::nat)) \<in> carrier K \<and> 
          (\<nu>\<^bsub>K (P 0)\<^esub>) ((\<lambda>j\<in>{0::nat}. x) (0::nat)) = (\<delta>\<^bsub>0 0\<^esub>)") 
   apply blast
   apply (rule conjI)
  apply simp apply (simp add:Kronecker_delta_def)
  apply (cut_tac Approximation1_5[of "n - Suc 0" "\<lambda>j. \<nu>\<^bsub>K (P j)\<^esub>"])
  apply simp 
  apply simp+
  apply (rule allI, rule impI)
  apply (rule n_val_n_val1 )
  apply (simp add:distinct_pds_def)
 done
 
 lemma (in Corps) KbaseTr1:"distinct_pds K n P \<Longrightarrow>  KbaseP K P n (Kb\<^bsub>K n P \<^esub>)"
 apply (subst Kbase_def)
 apply (frule KbaseTr[of n P])
 apply (erule exE)
 apply (simp add:someI)
 done 
 
 lemma (in Corps) Kbase_hom:"distinct_pds K n P \<Longrightarrow> 
                        \<forall>j \<le> n. (Kb\<^bsub>K n P\<^esub>) j \<in> carrier K"       
 apply (frule KbaseTr1[of "n" "P"])
 apply (simp add:KbaseP_def)
 done
 
 lemma (in Corps) Kbase_Kronecker:"distinct_pds K n P \<Longrightarrow> 
       \<forall>j \<le> n. \<forall>l \<le> n. (\<nu>\<^bsub>K (P j)\<^esub>) ((Kb\<^bsub>K n P\<^esub>) l) = \<delta>\<^bsub>j l\<^esub>"     
 apply (frule KbaseTr1[of n P])
 apply (simp add:KbaseP_def)
 done   
 
 lemma (in Corps) Kbase_nonzero:"distinct_pds K n P \<Longrightarrow> 
                         \<forall>j \<le> n. (Kb\<^bsub>K n P\<^esub>) j \<noteq> \<zero>"
 apply (rule allI, rule impI)
  apply (frule Kbase_Kronecker[of n P])
  apply (subgoal_tac "(\<nu>\<^bsub>K (P j)\<^esub>) ((Kb\<^bsub>K n P\<^esub>) j) = \<delta>\<^bsub>j j\<^esub>")
  apply (thin_tac "\<forall>j\<le>n. (\<forall>l\<le>n. ((\<nu>\<^bsub>K P j\<^esub>) ((Kb\<^bsub>K n P\<^esub>) l)) = \<delta>\<^bsub>j l\<^esub>)")
  apply (simp add:Kronecker_delta_def)
  apply (rule contrapos_pp, simp+)
  apply (cut_tac P = "P j" in representative_of_pd_valuation)  
  apply (simp add:distinct_pds_def)
  apply (simp only:value_of_zero, simp only:ant_1[THEN sym],
         frule sym, thin_tac " \<infinity> = ant 1", simp del:ant_1)
 apply simp
 done
 
 lemma (in Corps) Kbase_hom1:"distinct_pds K n P \<Longrightarrow> 
                     \<forall>j \<le> n. (Kb\<^bsub>K n P\<^esub>) j \<in> carrier K - {\<zero>}"
 by(simp add:Kbase_nonzero Kbase_hom)
 
 definition
   Zl_mI :: "[_, nat \<Rightarrow> ('b \<Rightarrow> ant) set, 'b set]
                          \<Rightarrow> nat \<Rightarrow> 'b" where
   "Zl_mI K P I j = (SOME x. (x \<in> I \<and> ( (\<nu>\<^bsub>K (P j)\<^esub>) x = LI K (\<nu>\<^bsub>K (P j)\<^esub>) I)))"
 
 lemma (in Corps) value_Zl_mI:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; j \<le> n\<rbrakk>
  \<Longrightarrow>  (Zl_mI K P I j \<in> I) \<and> (\<nu>\<^bsub>K (P j)\<^esub>) (Zl_mI K P I j) = LI K (\<nu>\<^bsub>K (P j)\<^esub>) I"
 apply (subgoal_tac "\<exists>x. (x \<in> I \<and> ((\<nu>\<^bsub>K (P j)\<^esub>) x = LI K (\<nu>\<^bsub>K (P j)\<^esub>) I))")
 apply (subst Zl_mI_def)+
 apply (rule someI2_ex, assumption+) 
 apply (frule ex_Zleast_in_mI[of "n" "P" "I" "j"], assumption+)
 apply (erule bexE, blast) 
 done
 
 lemma (in Corps) Zl_mI_nonzero:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
       I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; j \<le> n\<rbrakk> \<Longrightarrow>  Zl_mI K P I j \<noteq> \<zero>"
 apply (case_tac "n = 0")
 apply (simp add:distinct_pds_def) 
  apply (frule representative_of_pd_valuation[of "P 0"])
  apply (subgoal_tac "O\<^bsub>K P 0\<^esub> = Vr K (\<nu>\<^bsub>K (P 0)\<^esub>)")
  apply (subgoal_tac "Zl_mI K P I 0 = Ig K (\<nu>\<^bsub>K (P 0)\<^esub>) I")  
  apply simp apply (simp add:Ig_nonzero)
  apply (simp add:Ig_def Zl_mI_def)
  apply (simp add:ring_n_pd_def Vr_def)
 
  apply (simp)
  apply (frule value_Zl_mI[of n P I j], assumption+)
  apply (erule conjE)
  apply (rule contrapos_pp, simp+)
  apply (frule distinct_pds_valuation1[of n j P], assumption+)
  apply (simp add:value_of_zero)
  apply (simp add:zero_in_ring_n_pd_zero_K)
  apply (frule singleton_sub[of "\<zero>" "I"], 
         frule sets_not_eq[of "I" "{\<zero>}"], assumption,
         erule bexE, simp)
  apply (frule_tac x = a in Zleast_mL_I[of "n" "P" "I" "j"], assumption+)
  apply (frule_tac x = a in val_nonzero_z[of "\<nu>\<^bsub>K (P j)\<^esub>"])
  apply (frule ring_n_pd[of "n" "P"])
  apply (frule_tac h = a in Ring.ideal_subset[of "O\<^bsub>K P n\<^esub>" "I"], assumption+)
  apply (simp add:mem_ring_n_pd_mem_K) apply assumption
 
 apply (simp add:zero_in_ring_n_pd_zero_K) apply assumption
 apply (frule val_LI_noninf[THEN not_sym, of "n" "P" "I" "j"], assumption+)
  apply (simp add:zero_in_ring_n_pd_zero_K) apply assumption
  apply simp
 done
  
 lemma (in Corps) Zl_mI_mem_K:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; l \<le> n\<rbrakk>
        \<Longrightarrow> (Zl_mI K P I l) \<in> carrier K"
 apply (frule value_Zl_mI[of "n" "P" "I" "l"], assumption+)
 apply (erule conjE) 
  apply (frule ring_n_pd[of "n" "P"])
  apply (frule Ring.ideal_subset[of "O\<^bsub>K P n\<^esub>" "I" "Zl_mI K P I l"], assumption+)
  apply (simp add:mem_ring_n_pd_mem_K[of "n" "P" "Zl_mI K P I l"])
 done
 
 definition
   mprod_exp :: "[_, nat \<Rightarrow> int, nat \<Rightarrow> 'b, nat] 
               \<Rightarrow> 'b" where
   "mprod_exp K e f n = nprod K (\<lambda>j. ((f j)\<^bsub>K\<^esub>\<^bsup>(e j)\<^esup>)) n"
 
 lemma (in Corps) mprod_expR_memTr:"(\<forall>j\<le>n. f j \<in> carrier K)  \<longrightarrow>  
                       mprod_expR K e f n \<in> carrier K"
 apply (cut_tac field_is_ring)
 apply (induct_tac n)
  apply (rule impI, simp) 
  apply (simp add:mprod_expR_def)
  apply (cut_tac Ring.npClose[of K "f 0" "e 0"], assumption+)
 
 apply (rule impI) 
  apply simp
  apply (subst Ring.mprodR_Suc, assumption+)
  apply (simp)
  apply (simp)
  apply (rule Ring.ring_tOp_closed[of K], assumption+)
  apply (rule Ring.npClose, assumption+) 
  apply simp 
 done
 
 lemma (in Corps) mprod_expR_mem:"\<forall>j \<le> n. f j \<in> carrier K \<Longrightarrow> 
            mprod_expR K e f n \<in> carrier K"
 apply (cut_tac field_is_ring) 
 apply (cut_tac Ring.mprod_expR_memTr[of K e n f])
 apply simp
 apply (subgoal_tac "f \<in> {j. j \<le> n} \<rightarrow> carrier K", simp+)
 done 
 
 lemma (in Corps) mprod_Suc:"\<lbrakk> \<forall>j\<le>(Suc n). e j \<in> Zset; 
                 \<forall>j \<le> (Suc n). f j \<in> (carrier K - {\<zero>})\<rbrakk> \<Longrightarrow> 
  mprod_exp K e f (Suc n) = (mprod_exp K e f n) \<cdot>\<^sub>r ((f (Suc n))\<^bsub>K\<^esub>\<^bsup>(e (Suc n))\<^esup>)"
 apply (simp add:mprod_exp_def)
 done
 
 lemma (in Corps) mprod_memTr:"
  (\<forall>j \<le> n. e j \<in> Zset) \<and> (\<forall>j \<le> n. f j \<in> ((carrier K) - {\<zero>})) \<longrightarrow> 
        (mprod_exp K e f n) \<in> ((carrier K) - {\<zero>})" 
 apply (induct_tac n)
  apply (simp, rule impI, (erule conjE)+,
         simp add:mprod_exp_def, simp add:npowf_mem,
         simp add:field_potent_nonzero1) 
 apply (rule impI, simp, erule conjE,
        cut_tac field_is_ring, cut_tac field_is_idom,
        erule conjE, simp add:mprod_Suc)
  apply (rule conjI)
  apply (rule Ring.ring_tOp_closed[of "K"], assumption+,
         simp add:npowf_mem)
  apply (rule Idomain.idom_tOp_nonzeros, assumption+,
         simp add:npowf_mem, assumption,
         simp add:field_potent_nonzero1) 
 done
 
 lemma (in Corps) mprod_mem:"\<lbrakk>\<forall>j \<le> n. e j \<in> Zset; \<forall>j \<le> n. f j \<in> ((carrier K) - {\<zero>})\<rbrakk> \<Longrightarrow>  (mprod_exp K e f n) \<in> ((carrier K) - {\<zero>})"
 apply (cut_tac mprod_memTr[of n e f]) apply simp
 done
 
 lemma (in Corps) mprod_mprodR:"\<lbrakk>\<forall>j \<le> n. e j \<in> Zset; \<forall>j \<le> n. 0 \<le> (e j); 
  \<forall>j \<le> n. f j \<in> ((carrier K) - {\<zero>})\<rbrakk> \<Longrightarrow> 
               mprod_exp K e f n = mprod_expR K (nat o e) f n"
 apply (cut_tac field_is_ring)
 apply (simp add:mprod_exp_def mprod_expR_def) 
 apply (rule Ring.nprod_eq, assumption+)
  apply (rule allI, rule impI, simp add:npowf_mem)
  apply (rule allI, rule impI, rule Ring.npClose, assumption+, simp)
 apply (rule allI, rule impI)
  apply (simp add:npowf_def)
 done
 
 subsection "Representation of an ideal I as a product of prime ideals"
 
 lemma (in Corps) ring_n_mprod_mprodRTr:"distinct_pds K n P \<Longrightarrow> 
        (\<forall>j \<le> m. e j \<in> Zset) \<and> (\<forall>j \<le> m. 0 \<le> (e j)) \<and> 
        (\<forall>j \<le> m. f j \<in> carrier (O\<^bsub>K P n\<^esub>)-{\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}) \<longrightarrow> 
         mprod_exp K e f m = mprod_expR (O\<^bsub>K P n\<^esub>) (nat o e) f m"
 apply (frule ring_n_pd[of n P])
 apply (induct_tac m) 
  apply (rule impI, (erule conjE)+,
         simp add:mprod_exp_def mprod_expR_def)
  apply (erule conjE, simp add:npowf_def, simp add:ring_n_exp_K_exp) 
 
 apply (rule impI, (erule conjE)+, simp)  
  apply (subst mprod_Suc, assumption+,
         rule allI, rule impI,
         simp add:mem_ring_n_pd_mem_K,
         simp add:zero_in_ring_n_pd_zero_K)
   apply (subst Ring.mprodR_Suc, assumption+,
          simp add:cmp_def,
          simp)
   apply (simp add:ring_n_pd, simp add:npowf_def, 
          simp add:ring_n_exp_K_exp) 
  apply (subst ring_n_tOp_K_tOp, assumption+,
         rule Ring.mprod_expR_mem, simp add:ring_n_pd,
         simp,
         simp)
  apply (rule Ring.npClose, simp add:ring_n_pd, simp, simp)
 done
 
 lemma (in Corps) ring_n_mprod_mprodR:"\<lbrakk>distinct_pds K n P; \<forall>j \<le> m. e j \<in> Zset;
  \<forall>j \<le> m. 0 \<le> (e j); \<forall>j \<le> m. f j \<in> carrier (O\<^bsub>K P n\<^esub>)-{\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}\<rbrakk> 
  \<Longrightarrow>  mprod_exp K e f m = mprod_expR (O\<^bsub>K P n\<^esub>) (nat o e) f m"
 apply (simp add:ring_n_mprod_mprodRTr)
 done
 
 lemma (in Corps) value_mprod_expTr:"valuation K v  \<Longrightarrow> 
  (\<forall>j \<le> n. e j \<in> Zset) \<and> (\<forall>j \<le> n. f j \<in> (carrier K - {\<zero>})) \<longrightarrow>
  v (mprod_exp K e f n) =  ASum  (\<lambda>j. (e j) *\<^sub>a (v (f j))) n"  
 apply (induct_tac n)
  apply simp
  apply (rule impI, erule conjE)
  apply(simp add:mprod_exp_def val_exp) 
 
 apply (rule impI, erule conjE)
  apply simp
  apply (subst mprod_Suc, assumption+)
  apply (rule allI, rule impI, simp)
  apply (subst val_t2p[of v], assumption+)
  apply (cut_tac n = "n" in mprod_mem[of _ e f],
         (rule allI, rule impI, simp)+, simp)
  apply (simp add:npowf_mem, simp add:field_potent_nonzero1)
  apply (simp add:val_exp[THEN sym, of "v"]) 
 done 
 
 lemma (in Corps) value_mprod_exp:"\<lbrakk>valuation K v; \<forall>j \<le> n. e j \<in> Zset; 
        \<forall>j \<le> n. f j \<in> (carrier K - {\<zero>})\<rbrakk> \<Longrightarrow> 
      v (mprod_exp K e f n) = ASum (\<lambda>j. (e j) *\<^sub>a (v (f j))) n"  
 apply (simp add:value_mprod_expTr)
 done
 
 lemma (in Corps) mgenerator0_1:"\<lbrakk>distinct_pds K (Suc n) P; 
  ideal (O\<^bsub>K P (Suc n)\<^esub>) I; I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P (Suc n)\<^esub>)\<^esub>}; 
  I \<noteq> carrier (O\<^bsub>K P (Suc n)\<^esub>); j \<le> (Suc n)\<rbrakk> \<Longrightarrow>
 ((\<nu>\<^bsub>K (P j)\<^esub>) (mprod_exp K (mL K P I) (Kb\<^bsub>K (Suc n) P\<^esub>) (Suc n))) = 
                    ((\<nu>\<^bsub>K (P j)\<^esub>) (Zl_mI K P I j))" 
 apply (frule distinct_pds_valuation[of j n P], assumption+)
  apply (frule mL_hom[of "Suc n" "P" "I"], assumption+)
  apply (frule Kbase_hom1[of "Suc n" "P"]) 
  apply (frule value_mprod_exp[of "\<nu>\<^bsub>K (P j)\<^esub>" "Suc n" "mL K P I" 
            "Kb\<^bsub>K (Suc n) P\<^esub>"], assumption+)
 
  apply (simp del:ASum_Suc)
  apply (thin_tac "(\<nu>\<^bsub>K (P j)\<^esub>) (mprod_exp K (mL K P I) (Kb\<^bsub>K (Suc n) P\<^esub>) (Suc n)) =
      ASum (\<lambda>ja. (mL K P I ja) *\<^sub>a (\<nu>\<^bsub>K (P j)\<^esub>) ((Kb\<^bsub>K (Suc n) P\<^esub>) ja)) (Suc n)")
 apply (subgoal_tac "ASum (\<lambda>ja. (mL K P I ja) *\<^sub>a 
       ((\<nu>\<^bsub>K (P j)\<^esub>) ((Kb\<^bsub>K (Suc n) P\<^esub>) ja))) (Suc n) = 
                 ASum (\<lambda>ja. (mL K P I ja) *\<^sub>a (\<delta>\<^bsub>j ja\<^esub>)) (Suc n)")
 apply (simp del:ASum_Suc)
 apply (subgoal_tac "\<forall>h \<le> (Suc n). (\<lambda>ja. (mL K P I ja) *\<^sub>a (\<delta>\<^bsub>j ja\<^esub>)) h \<in> Z\<^sub>\<infinity>")
 apply (cut_tac eSum_single[of "Suc n" "\<lambda>ja. (mL K P I ja) *\<^sub>a (\<delta>\<^bsub>j ja\<^esub>)" "j"])
  apply simp
  apply (simp add:Kronecker_delta_def asprod_n_0)
  apply (rotate_tac -1, drule not_sym) 
 apply (simp add:mL_def[of "K" "P" "I" "j"])
 
 apply (frule val_LI_noninf[of "Suc n" "P" "I" "j"], assumption+)
  apply (rule not_sym, simp, simp)
 apply (frule val_LI_pos[of "Suc n" "P" "I" "j"], assumption+,
        rotate_tac -2, frule not_sym, simp, simp)
 
 apply (frule apos_neq_minf[of "LI K (\<nu>\<^bsub>K (P j)\<^esub>) I"])
 apply (simp add:ant_tna) 
 apply (simp add:value_Zl_mI[of "Suc n" "P" "I" "j"])
 apply (rule allI, rule impI)
  apply (simp add:Kdelta_in_Zinf, simp)
  apply (rule ballI, simp)
  apply (simp add:Kronecker_delta_def, erule conjE)
  apply (simp add:asprod_n_0)
 
 apply (rule allI, rule impI) 
  apply (simp add:Kdelta_in_Zinf)
 
 apply (frule  Kbase_Kronecker[of "Suc n" "P"])
  apply (rule ASum_eq,
         rule allI, rule impI,
         simp add:Kdelta_in_Zinf,
         rule allI, rule impI,
         simp add:Kdelta_in_Zinf)
 apply (rule allI, rule impI) apply simp
 done
 
 lemma (in Corps) mgenerator0_2:"\<lbrakk> 0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
  I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>); j \<le> n\<rbrakk>  \<Longrightarrow>
 ((\<nu>\<^bsub>K (P j)\<^esub>) (mprod_exp K (mL K P I) (Kb\<^bsub>K n P\<^esub>) n)) =  ((\<nu>\<^bsub>K (P j)\<^esub>) (Zl_mI K P I j))"
 apply (cut_tac mgenerator0_1[of  "n - Suc 0" "P" "I" "j"])
  apply simp+
 done
 
 lemma (in Corps) mgenerator1:"\<lbrakk>distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
  I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>); j \<le> n\<rbrakk> \<Longrightarrow>
 ((\<nu>\<^bsub>K (P j)\<^esub>) (mprod_exp K (mL K P I) (Kb\<^bsub>K n P\<^esub>) n)) = ((\<nu>\<^bsub>K (P j)\<^esub>) (Zl_mI K P I j))"
 apply (case_tac "n = 0",
        frule value_Zl_mI[of "n" "P" "I" "j"], assumption+,
        frule val_LI_noninf[of "n" "P" "I" "j"], assumption+,
        frule val_LI_pos[of  "n" "P" "I" "j"], assumption+,
        frule apos_neq_minf[of "LI K (\<nu>\<^bsub>K (P j)\<^esub>) I"],
        simp add:distinct_pds_def, erule conjE)  
  apply (cut_tac representative_of_pd_valuation[of "P j"], simp+,
         simp add:mprod_exp_def,
         subst val_exp[THEN sym, of "\<nu>\<^bsub>K (P 0)\<^esub>" "(Kb\<^bsub>K 0 P\<^esub>) 0"], assumption+,
         cut_tac Kbase_hom[of "0" "P"], simp,
         simp add:distinct_pds_def,
         cut_tac Kbase_nonzero[of "0" "P"], simp+,
         simp add:distinct_pds_def) 
  apply (cut_tac Kbase_nonzero[of "0" "P"], simp add:distinct_pds_def) 
  apply (cut_tac Kbase_Kronecker[of "0" "P"], simp add:distinct_pds_def) 
  apply (simp add:Kronecker_delta_def, simp add:mL_def, simp add:ant_tna)
  apply (simp add:distinct_pds_def)+
 apply (cut_tac mgenerator0_2[of "n" "P" "I" "j"], simp+)
  apply (simp add:distinct_pds_def) apply simp+
 done
     
 lemma (in Corps) mgenerator2Tr1:"\<lbrakk>0 < n; j \<le> n; k \<le> n; distinct_pds K n P\<rbrakk> \<Longrightarrow>
       (\<nu>\<^bsub>K (P j)\<^esub>) (mprod_exp K (\<lambda>l. \<gamma>\<^bsub>k l\<^esub> ) (Kb\<^bsub>K n P\<^esub>) n) = (\<gamma>\<^bsub>k j\<^esub>) *\<^sub>a (\<delta>\<^bsub>j j\<^esub>)"
 apply (frule distinct_pds_valuation1[of "n" "j" "P"], assumption+)
 apply (frule K_gamma_hom[of k n]) 
 apply (subgoal_tac "\<forall>j \<le> n. (Kb\<^bsub>K n P\<^esub>) j \<in> carrier K - {\<zero>}")
 apply (simp add:value_mprod_exp[of "\<nu>\<^bsub>K (P j)\<^esub>" n "K_gamma k" "(Kb\<^bsub>K n P\<^esub>)"])
 apply (subgoal_tac "ASum (\<lambda>ja. (\<gamma>\<^bsub>k ja\<^esub>) *\<^sub>a (\<nu>\<^bsub>K (P j)\<^esub>) ((Kb\<^bsub>K n P\<^esub>) ja)) n
        = ASum (\<lambda>ja. (((\<gamma>\<^bsub>k ja\<^esub>) *\<^sub>a (\<delta>\<^bsub>j ja\<^esub>)))) n")
  apply simp
  apply (subgoal_tac "\<forall>j \<le> n. (\<lambda>ja. (\<gamma>\<^bsub>k ja\<^esub>) *\<^sub>a (\<delta>\<^bsub>j ja\<^esub>)) j \<in> Z\<^sub>\<infinity>")
  apply (cut_tac eSum_single[of n "\<lambda>ja. ((\<gamma>\<^bsub>k ja\<^esub>) *\<^sub>a (\<delta>\<^bsub>j ja\<^esub>))"  "j"], simp)
  apply (rule allI, rule impI, simp add:Kronecker_delta_def, 
         rule impI, simp add:asprod_n_0 Zero_in_aug_inf, assumption+)
  apply (rule ballI, simp)
   apply (simp add:K_gamma_def, rule impI, simp add:Kronecker_delta_def) 
   apply (rule allI, rule impI)
   apply (simp add:Kronecker_delta_def, simp add:K_gamma_def)
  apply (simp add:ant_0 Zero_in_aug_inf)
  apply (cut_tac z_in_aug_inf[of 1], simp add:ant_1) 
 
  apply (rule ASum_eq)
   apply (rule allI, rule impI)
   apply (simp add:K_gamma_def, simp add:Zero_in_aug_inf) 
   apply (rule impI, rule value_in_aug_inf, assumption+, simp)
   apply (simp add:K_gamma_def Zero_in_aug_inf Kdelta_in_Zinf1)
   apply (rule allI, rule impI)
   apply (simp add:Kbase_Kronecker[of "n" "P"])
   apply (rule Kbase_hom1, assumption+)
 done
 
 lemma (in Corps) mgenerator2Tr2:"\<lbrakk>0 < n; j \<le> n; k \<le> n; distinct_pds K n P\<rbrakk> \<Longrightarrow>
      (\<nu>\<^bsub>K (P j)\<^esub>) ((mprod_exp K (\<lambda>l. \<gamma>\<^bsub>k l\<^esub> ) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>m\<^esup>)= ant (m * (\<gamma>\<^bsub>k j\<^esub>))"
 
 apply (frule K_gamma_hom[of k n])
 apply (frule Kbase_hom1[of "n" "P"])
 apply (frule mprod_mem[of n "K_gamma k" "Kb\<^bsub>K n P\<^esub>"], assumption+)
 apply (frule distinct_pds_valuation1[of "n" "j" "P"], assumption+)
 apply (simp, erule conjE)
 apply (simp add:val_exp[THEN sym])
 apply (simp add:mgenerator2Tr1)
  apply (simp add:K_gamma_def Kronecker_delta_def)
  apply (rule impI)
  apply (simp add:asprod_def a_z_z)
 done
 
 lemma (in Corps) mgenerator2Tr3_1:"\<lbrakk>0 < n; j \<le> n; k \<le> n; j = k; 
       distinct_pds K n P\<rbrakk> \<Longrightarrow>
           (\<nu>\<^bsub>K (P j)\<^esub>) ((mprod_exp K (\<lambda>l. (\<gamma>\<^bsub>k l\<^esub>)) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>m\<^esup>) = 0"
 apply (simp add:mgenerator2Tr2) apply (simp add:K_gamma_def)
 done
 
 lemma (in Corps) mgenerator2Tr3_2:"\<lbrakk>0 < n; j \<le> n; k \<le> n; j \<noteq> k; 
       distinct_pds K n P\<rbrakk> \<Longrightarrow>
       (\<nu>\<^bsub>K (P j)\<^esub>) ((mprod_exp K (\<lambda>l. (\<gamma>\<^bsub>k l\<^esub>)) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>m\<^esup>) = ant m"
 apply (simp add:mgenerator2Tr2) apply (simp add:K_gamma_def)
 done
 
 lemma (in Corps) mgeneratorTr4:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
       I \<noteq> {\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk> \<Longrightarrow> 
        mprod_exp K (mL K P I) (Kb\<^bsub>K n P\<^esub>) n \<in> carrier (O\<^bsub>K P n\<^esub>)"
 apply (subst ring_n_pd_def)
 apply (simp add:Sr_def)
  apply (frule mL_hom[of  "n" "P" "I"], assumption+)
  apply (frule mprod_mem[of n "mL K P I" "Kb\<^bsub>K n P\<^esub>"])
  apply (rule Kbase_hom1, assumption+)
 
  apply (simp add:mprod_mem)
 
 apply (rule allI, rule impI)
  apply (simp add:mgenerator1)
  apply (simp add:value_Zl_mI)
  apply (simp add:val_LI_pos)
 done
 
 definition
   m_zmax_pdsI_hom :: "[_, nat \<Rightarrow> ('b \<Rightarrow> ant) set, 'b set] \<Rightarrow> nat \<Rightarrow> int" where
   "m_zmax_pdsI_hom K P I = (\<lambda>j. tna (AMin ((\<nu>\<^bsub>K (P j)\<^esub>) ` I)))"
 
 definition
   m_zmax_pdsI :: "[_, nat, nat \<Rightarrow> ('b \<Rightarrow> ant) set, 'b set] \<Rightarrow> int" where
   "m_zmax_pdsI K n P I = (m_zmax n (m_zmax_pdsI_hom K P I)) + 1"
  
 lemma (in Corps) value_Zl_mI_pos:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I;
      I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>); j \<le> n; l \<le> n\<rbrakk> \<Longrightarrow>
      0 \<le> ((\<nu>\<^bsub>K (P j)\<^esub>) (Zl_mI K P I l))"
 apply (frule value_Zl_mI[of "n" "P" "I" "l"], assumption+)
 apply (erule conjE) 
  apply (frule ring_n_pd[of "n" "P"])
  apply (frule Ring.ideal_subset[of "O\<^bsub>K P n\<^esub>" "I" "Zl_mI K P I l"], assumption+)
  apply (thin_tac "ideal (O\<^bsub>K P n\<^esub>) I")
  apply (thin_tac "I \<noteq> {\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>}")
  apply (thin_tac "I \<noteq> carrier (O\<^bsub>K P n\<^esub>)")
  apply (thin_tac "Ring (O\<^bsub>K P n\<^esub>)")
  apply (simp add:ring_n_pd_def Sr_def) 
 done
 
 lemma (in Corps) value_mI_genTr1:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I;
  I \<noteq> {\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>); j \<le> n\<rbrakk> \<Longrightarrow>
  (mprod_exp K (K_gamma j) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>(m_zmax_pdsI K n P I)\<^esup> \<in> carrier K"
 apply (frule K_gamma_hom[of "j" "n"])
 apply (frule mprod_mem[of n "K_gamma j" "Kb\<^bsub>K n P\<^esub>"])
  apply (rule Kbase_hom1, assumption+)
 apply (rule npowf_mem)
  apply simp+
 done
 
 lemma (in Corps) value_mI_genTr1_0:"\<lbrakk>0 < n; distinct_pds K n P; 
  ideal (O\<^bsub>K P n\<^esub>) I; I \<noteq> {\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>); j \<le> n\<rbrakk>
  \<Longrightarrow> (mprod_exp K (K_gamma j) (Kb\<^bsub>K n P\<^esub>) n) \<in> carrier K" 
 apply (frule K_gamma_hom[of "j" "n"])
 apply (frule mprod_mem[of n "K_gamma j" "Kb\<^bsub>K n P\<^esub>"])
  apply (rule Kbase_hom1, assumption+)
  apply simp
 done
 
 
 lemma (in Corps) value_mI_genTr2:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I;
  I \<noteq> {\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>); j \<le> n\<rbrakk> \<Longrightarrow>
  (mprod_exp K (K_gamma j) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>(m_zmax_pdsI K n P I)\<^esup> \<noteq> \<zero>"
  apply (frule K_gamma_hom[of "j" "n"])
  apply (frule mprod_mem[of n "K_gamma j" "Kb\<^bsub>K n P\<^esub>"])
  apply (rule Kbase_hom1, assumption+) apply simp apply (erule conjE)
  apply (simp add: field_potent_nonzero1)
 done
 
 lemma (in Corps) value_mI_genTr3:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I;
  I \<noteq> {\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>); j \<le> n\<rbrakk> \<Longrightarrow>
  (Zl_mI K P I j) \<cdot>\<^sub>r ((mprod_exp K (K_gamma j) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>(m_zmax_pdsI K n P I)\<^esup>)
   \<in> carrier K"
 apply (cut_tac field_is_ring)
 apply (rule Ring.ring_tOp_closed, assumption+)
 apply (simp add:Zl_mI_mem_K)
 apply (simp add:value_mI_genTr1)
 done
 
 lemma (in Corps) value_mI_gen:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I;
  I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>); j \<le> n\<rbrakk> \<Longrightarrow>  
 (\<nu>\<^bsub>K (P j)\<^esub>) (nsum K (\<lambda>k. ((Zl_mI K P I k) \<cdot>\<^sub>r ((mprod_exp K (\<lambda>l. (\<gamma>\<^bsub>k l\<^esub>)) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>(m_zmax_pdsI K n P I)\<^esup>))) n) = LI K (\<nu>\<^bsub>K (P j)\<^esub>) I"
 apply (cut_tac field_is_ring, frule Ring.ring_is_ag[of "K"])
 apply (case_tac "j = n", simp) 
  apply (cut_tac nsum_suc[of K "\<lambda>k. Zl_mI K P I k \<cdot>\<^sub>r 
         mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>" "n - Suc 0"], 
         simp,
         thin_tac "\<Sigma>\<^sub>e K (\<lambda>k. Zl_mI K P I k \<cdot>\<^sub>r
                mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>) n =
      \<Sigma>\<^sub>e K (\<lambda>k. Zl_mI K P I k \<cdot>\<^sub>r
                mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>)
                 n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>) (n - Suc 0) \<plusminus>
      Zl_mI K P I n \<cdot>\<^sub>r
      mprod_exp K (K_gamma n) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>")
  apply (cut_tac distinct_pds_valuation[of "n" "n - Suc 0" "P"])
 prefer 2 apply simp 
 prefer 2 apply simp 
  apply (subst value_less_eq1[THEN sym, of "\<nu>\<^bsub>K (P n)\<^esub>" 
  "(Zl_mI K P I n)\<cdot>\<^sub>r (mprod_exp K (K_gamma n) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>)"
  "nsum K (\<lambda>k.(Zl_mI K P I k)\<cdot>\<^sub>r (mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>)) (n - Suc 0)"], assumption+) 
 
  apply (simp add:value_mI_genTr3)
  apply (frule Ring.ring_is_ag[of K])
  apply (rule aGroup.nsum_mem[of _ "n - Suc 0"], assumption+)
  apply (rule allI, rule impI)
  apply (simp add:value_mI_genTr3) 
 
  apply (subst val_t2p[of "\<nu>\<^bsub>K (P n)\<^esub>"], assumption+)
  apply (simp add:Zl_mI_mem_K)
  apply (simp add:value_mI_genTr1) 
 
  apply (simp add:mgenerator2Tr3_1[of "n" "n" "n" "P"])
  apply (simp add:aadd_0_r) 
 apply (frule value_Zl_mI[of "n" "P" "I" "n"], assumption+, simp)
  apply (erule conjE) 
  apply (frule_tac f = "\<lambda>k. (Zl_mI K P I k) \<cdot>\<^sub>r 
        (mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>)" in 
        value_ge_add[of "\<nu>\<^bsub>K (P n)\<^esub>" "n - Suc 0" _ 
       "ant (m_zmax_pdsI K n P I)"])
  apply (rule allI, rule impI) 
  apply (rule Ring.ring_tOp_closed, assumption+)
  apply (simp add:Zl_mI_mem_K)
  apply (simp add:value_mI_genTr1)  
 
  apply (rule allI, rule impI) apply (simp add:cmp_def)
  apply (subst val_t2p [where v="\<nu>\<^bsub>K P n\<^esub>"], assumption+)
  apply (simp add:Zl_mI_mem_K)
  apply (simp add:value_mI_genTr1) 
 
  apply (cut_tac e = "K_gamma ja" in mprod_mem[of n  _  "Kb\<^bsub>K n P\<^esub>"])
  apply (simp add:Zset_def) apply (rule Kbase_hom1, assumption+)
  apply (subst val_exp[of "\<nu>\<^bsub>K (P n)\<^esub>", THEN sym], assumption+) 
  apply simp+ 
 
  apply (subst mgenerator2Tr1[of "n" "n" _ "P"], assumption+, simp, simp,
         assumption+) 
  apply (simp add:K_gamma_def Kronecker_delta_def)
  apply (frule_tac l = ja in value_Zl_mI_pos[of "n" "P" "I" "n"],
         assumption+, simp, simp)
  apply (simp add:Nset_preTr1)
  apply (frule_tac y = "(\<nu>\<^bsub>K (P n)\<^esub>) (Zl_mI K P I ja)" in 
   aadd_le_mono[of "0" _ "ant (m_zmax_pdsI K n P I)"]) apply (simp add:aadd_0_l)
  apply (subgoal_tac "LI K (\<nu>\<^bsub>K (P n)\<^esub>) I < ant (m_zmax_pdsI K n P I)")
  apply simp
  apply (rule aless_le_trans[of "LI K (\<nu>\<^bsub>K (P n)\<^esub>) I" 
                            "ant (m_zmax_pdsI K n P I)"])
 
  apply (simp add:m_zmax_pdsI_def)
  apply (cut_tac aless_zless[of "tna (LI K (\<nu>\<^bsub>K (P n)\<^esub>) I)" 
                    "m_zmax n (m_zmax_pdsI_hom K P I) + 1"])
 apply (frule val_LI_noninf[of "n" "P" "I" "n"], assumption+, simp, simp) 
 apply (frule val_LI_pos[of "n" "P" "I" "n"], assumption+, simp,
        frule apos_neq_minf[of "LI K (\<nu>\<^bsub>K (P n)\<^esub>) I"], simp add:ant_tna)
  apply (subst m_zmax_pdsI_hom_def)
  apply (subst LI_def)
  apply (cut_tac m_zmax_gt_each[of n "\<lambda>u.(tna (AMin ((\<nu>\<^bsub>K (P u)\<^esub>) ` I)))"])
  apply simp
 
  apply (rule allI, rule impI)
  apply (simp add:Zset_def, simp) 
 
  apply (subst val_t2p[of "\<nu>\<^bsub>K (P n)\<^esub>"], assumption+)
  apply (rule Zl_mI_mem_K, assumption+, simp)
  apply (simp add:value_mI_genTr1)
  apply (simp add:mgenerator2Tr3_1[of "n" "n" "n" "P" "m_zmax_pdsI K n P I"])
  apply (simp add:aadd_0_r)
  apply (simp add:value_Zl_mI[of "n" "P" "I" "n"])
 
 (*** case j = n done ***)
  apply (frule aGroup.addition3[of "K" "n - Suc 0" "\<lambda>k. (Zl_mI K P I k) \<cdot>\<^sub>r
 ((mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>(m_zmax_pdsI K n P I)\<^esup>)" "j"])
  
  apply simp
  apply (rule allI, rule impI) 
  apply (simp add:value_mI_genTr3) apply simp+
 
  apply (thin_tac "\<Sigma>\<^sub>e K (\<lambda>k. Zl_mI K P I k \<cdot>\<^sub>r
      mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>) n =
      \<Sigma>\<^sub>e K (cmp (\<lambda>k. Zl_mI K P I k \<cdot>\<^sub>r
             mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>) (\<tau>\<^bsub>j n\<^esub>)) n")
  apply (cut_tac nsum_suc[of K "cmp (\<lambda>k. Zl_mI K P I k \<cdot>\<^sub>r
      mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>) (\<tau>\<^bsub>j n\<^esub>)" "n - Suc 0"])
  apply (simp del:nsum_suc) apply (
         thin_tac "\<Sigma>\<^sub>e K (cmp (\<lambda>k. Zl_mI K P I k \<cdot>\<^sub>r
          mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>) (\<tau>\<^bsub>j n\<^esub>)) n =
      \<Sigma>\<^sub>e K (cmp (\<lambda>k. Zl_mI K P I k \<cdot>\<^sub>r
         mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>) (\<tau>\<^bsub>j n\<^esub>))
          (n - Suc 0) \<plusminus>  (cmp (\<lambda>k. Zl_mI K P I k \<cdot>\<^sub>r
          mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>) (\<tau>\<^bsub>j n\<^esub>)) n")
  apply (cut_tac distinct_pds_valuation[of "j" "n - Suc 0" "P"])
  prefer 2 apply simp prefer 2 apply simp
  apply (simp add:cmp_def)
 
  apply (cut_tac n_in_Nsetn[of "n"])
  apply (simp add:transpos_ij_2)
  apply (subst value_less_eq1[THEN sym, of "\<nu>\<^bsub>K (P j)\<^esub>"
  "(Zl_mI K P I j) \<cdot>\<^sub>r (mprod_exp K (K_gamma j) (Kb\<^bsub>K n P\<^esub>)
   n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>)" "\<Sigma>\<^sub>e K (\<lambda>x.(Zl_mI K P I ((\<tau>\<^bsub>j n\<^esub>) x)) \<cdot>\<^sub>r
  (mprod_exp K (K_gamma ((\<tau>\<^bsub>j n\<^esub>) x)) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>)) (n - Suc 0)"], assumption+)
  apply (simp add:value_mI_genTr3)
  apply (rule aGroup.nsum_mem[of "K" "n - Suc 0"], assumption+)
  apply (rule allI, rule impI) 
  apply (frule_tac l = ja in transpos_mem[of "j" "n" "n"], simp+)
  apply (simp add:value_mI_genTr3) 
 
  apply (subst val_t2p[of "\<nu>\<^bsub>K (P j)\<^esub>"], assumption+)
  apply (simp add:Zl_mI_mem_K) 
  apply (simp add:value_mI_genTr1)
 
  apply (simp add:mgenerator2Tr3_1[of "n" "j" "j" "P"])
 
  apply (frule value_Zl_mI[of "n" "P" "I" "j"], assumption+)
  apply (erule conjE)
  apply (simp add:aadd_0_r)
  apply (cut_tac f = "\<lambda>x. (Zl_mI K P I ((\<tau>\<^bsub>j n\<^esub>) x)) \<cdot>\<^sub>r
        (mprod_exp K (K_gamma ((\<tau>\<^bsub>j n\<^esub>) x)) (Kb\<^bsub>K n P\<^esub>) n\<^bsub>K\<^esub>\<^bsup>m_zmax_pdsI K n P I\<^esup>)" in 
         value_ge_add[of "\<nu>\<^bsub>K (P j)\<^esub>"
         "n - Suc 0" _ "ant (m_zmax_pdsI K n P I)"], assumption+)
  apply (rule allI, rule impI) 
  apply (frule_tac l = ja in transpos_mem[of "j" "n" "n"], simp+)
  apply (simp add:value_mI_genTr3)
  apply (rule allI, rule impI) apply (simp add:cmp_def)
 
  apply (frule_tac l = ja in transpos_mem[of "j" "n" "n"], simp+)
 
  apply (subst val_t2p [where v="\<nu>\<^bsub>K P j\<^esub>"], assumption+) 
  apply (simp add:Zl_mI_mem_K)
  apply (simp add:value_mI_genTr1)
  apply (cut_tac k = ja in transpos_noteqTr[of "n" _ "j"], simp+) 
  apply (subst mgenerator2Tr3_2[of "n" "j" _ "P"], simp+)
  apply (cut_tac l = "(\<tau>\<^bsub>j n\<^esub>) ja" in value_Zl_mI_pos[of "n" "P" "I" "j"],
         simp+)
  apply (frule_tac y = "(\<nu>\<^bsub>K (P j)\<^esub>) (Zl_mI K P I ((\<tau>\<^bsub>j n\<^esub>) ja))" in 
  aadd_le_mono[of "0"  _ "ant (m_zmax_pdsI K n P I)"])
  apply (simp add:aadd_0_l)
 apply (subgoal_tac "LI K (\<nu>\<^bsub>K (P j)\<^esub>) I < ant (m_zmax_pdsI K n P I)")
  apply (rule aless_le_trans[of "LI K (\<nu>\<^bsub>K (P j)\<^esub>) I" 
                            "ant (m_zmax_pdsI K n P I)"], assumption+)
 
  apply (simp add:m_zmax_pdsI_def)
  apply (cut_tac aless_zless[of "tna (LI K (\<nu>\<^bsub>K (P j)\<^esub>) I)" 
                    "m_zmax n (m_zmax_pdsI_hom K P I) + 1"])
 apply (frule val_LI_noninf[of  "n" "P" "I" "j"], assumption+,
        frule val_LI_pos[of  "n" "P" "I" "j"], assumption+,
        frule apos_neq_minf[of "LI K (\<nu>\<^bsub>K (P j)\<^esub>) I"], simp add:ant_tna)
  apply (subst m_zmax_pdsI_hom_def)
  apply (subst LI_def)
  apply (subgoal_tac "\<forall>h \<le> n. (\<lambda>u. (tna (AMin ((\<nu>\<^bsub>K (P u)\<^esub>) ` I)))) h \<in> Zset")
  apply (frule m_zmax_gt_each[of n "\<lambda>u.(tna (AMin ((\<nu>\<^bsub>K (P u)\<^esub>) ` I)))"])
  apply simp
  apply (rule allI, rule impI)
  apply (simp add:Zset_def)
 apply (subst val_t2p[of "\<nu>\<^bsub>K (P j)\<^esub>"], assumption+)
  apply (rule Zl_mI_mem_K, assumption+)
  apply (simp add:value_mI_genTr1)
   
  apply (simp add:mgenerator2Tr3_1[of  "n" "j" "j" "P" 
                                          "m_zmax_pdsI K n P I"])
  apply (simp add:aadd_0_r)
  apply (simp add:value_Zl_mI[of "n" "P" "I" "j"])
 done
 
 lemma (in Corps) mI_gen_in_I:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
   I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk> \<Longrightarrow>
   (nsum K (\<lambda>k. ((Zl_mI K P I k) \<cdot>\<^sub>r 
   ((mprod_exp K (\<lambda>l. (\<gamma>\<^bsub>k l\<^esub>)) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>(m_zmax_pdsI K n P I)\<^esup>))) n) \<in> I"
 apply (cut_tac field_is_ring, frule ring_n_pd[of n P])
 apply (rule ideal_eSum_closed[of n P I n], assumption+)
 apply (rule allI, rule impI)
  apply (frule_tac j = j in value_Zl_mI[of  "n" "P" "I"], assumption+) 
  apply (erule conjE)
  apply (thin_tac "(\<nu>\<^bsub>K (P j)\<^esub>) (Zl_mI K P I j) = LI K (\<nu>\<^bsub>K (P j)\<^esub>) I")
  apply (subgoal_tac "(mprod_exp K (K_gamma j) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>(m_zmax_pdsI K n P I)\<^esup>
  \<in> carrier (O\<^bsub>K P n\<^esub>)") 
  apply (frule_tac x = "Zl_mI K P I j" and 
    r = "(mprod_exp K (K_gamma j) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>(m_zmax_pdsI K n P I)\<^esup>"
    in Ring.ideal_ring_multiple1[of "(O\<^bsub>K P n\<^esub>)" "I"], assumption+) 
  apply (frule_tac h = "Zl_mI K P I j" in 
                Ring.ideal_subset[of "O\<^bsub>K P n\<^esub>" "I"], assumption+)
  apply (simp add:ring_n_pd_tOp_K_tOp[of "n" "P"])
  
 apply (subst ring_n_pd_def) apply (simp add:Sr_def)
  apply (simp add:value_mI_genTr1)
 
  apply (rule allI, rule impI)
  apply (case_tac "j = ja") 
  apply (simp add:mgenerator2Tr3_1)
 
  apply (simp add:mgenerator2Tr3_2)
  apply (simp add:m_zmax_pdsI_def) apply (simp add:m_zmax_pdsI_hom_def)
  apply (simp only:ant_0[THEN sym])
  apply (simp add:aless_zless)
  apply (subgoal_tac "\<forall>l \<le> n. (\<lambda>j. tna (AMin ((\<nu>\<^bsub>K (P j)\<^esub>) ` I))) l \<in> Zset")
  apply (frule m_zmax_gt_each[of n "\<lambda>j. tna (AMin ((\<nu>\<^bsub>K (P j)\<^esub>) ` I))"]) 
  apply (rotate_tac -1, drule_tac a = ja in forall_spec, simp+)
  apply (frule_tac j = ja in val_LI_pos[of  "n" "P" "I"], assumption+) 
  apply (cut_tac j = "tna (LI K (\<nu>\<^bsub>K (P ja)\<^esub>) I)" in ale_zle[of "0"]) 
 apply (frule_tac j = ja in val_LI_noninf[of "n" "P" "I"], assumption+,
        frule_tac j = ja in val_LI_pos[of "n" "P" "I"], assumption+,
        frule_tac a = "LI K (\<nu>\<^bsub>K (P ja)\<^esub>) I" in apos_neq_minf, simp add:ant_tna,
        simp add:ant_0) apply (unfold LI_def)
  apply (frule_tac y = "tna (AMin (\<nu>\<^bsub>K (P ja)\<^esub> ` I))" and z = "m_zmax n (\<lambda>j. tna (AMin (\<nu>\<^bsub>K (P j)\<^esub> ` I)))" in order_trans[of "0"], assumption+)
  apply (rule_tac y = "m_zmax n (\<lambda>j. tna (AMin (\<nu>\<^bsub>K (P j)\<^esub> ` I)))" and 
         z = "m_zmax n (\<lambda>j. tna (AMin (\<nu>\<^bsub>K (P j)\<^esub> ` I))) + 1" in order_trans[of "0"],
         assumption+) apply simp
 
  apply (rule allI, rule impI) apply (simp add:Zset_def)
 done
 
 
 text\<open>We write the element 
         \<open>e\<Sigma> K (\<lambda>k. (Zl_mI K P I k) \<cdot>\<^sub>K ((mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>)
                     n)\<^sub>K\<^sup>(m_zmax_pdsI K n P I))) n\<close>
       as \<open>mIg\<^bsub>K G a i n P I\<^esub>\<close>\<close>
 
 definition
   mIg :: "[_, nat, nat \<Rightarrow> ('b \<Rightarrow> ant) set,
              'b set] \<Rightarrow> 'b" ("(4mIg\<^bsub> _ _ _ _\<^esub>)" [82,82,82,83]82) where
   "mIg\<^bsub>K n P I\<^esub> = \<Sigma>\<^sub>e K (\<lambda>k. (Zl_mI K P I k) \<cdot>\<^sub>r\<^bsub>K\<^esub>
              ((mprod_exp K (K_gamma k) (Kb\<^bsub>K n P\<^esub>) n)\<^bsub>K\<^esub>\<^bsup>(m_zmax_pdsI K n P I)\<^esup>)) n"
 
 text\<open>We can rewrite above two lemmas by using \<open>mIg\<^bsub>K G a i n P I\<^esub>\<close>\<close> 
 
 lemma (in Corps) value_mI_gen1:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I;
  I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk> \<Longrightarrow> 
                 \<forall>j \<le> n.(\<nu>\<^bsub>K (P j)\<^esub>) (mIg\<^bsub>K n P I\<^esub>) = LI K (\<nu>\<^bsub>K (P j)\<^esub>) I" 
 apply (rule allI, rule impI)
  apply (simp add:mIg_def value_mI_gen)
 done
 
 lemma (in Corps) mI_gen_in_I1:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
   I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk> \<Longrightarrow>  (mIg\<^bsub>K n P I\<^esub>) \<in> I"
 apply (simp add:mIg_def mI_gen_in_I)
 done
 
 lemma (in Corps) mI_principalTr:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
   I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>); x \<in> I\<rbrakk> \<Longrightarrow> 
  \<forall>j \<le> n. ((\<nu>\<^bsub>K (P j)\<^esub>) (mIg\<^bsub>K n P I\<^esub>)) \<le> ((\<nu>\<^bsub>K (P j)\<^esub>) x)" 
 apply (simp add:value_mI_gen1)
  apply (rule allI, rule impI)
  apply (rule Zleast_LI, assumption+)
 done
 
 lemma (in Corps) mI_principal:"\<lbrakk>0 < n; distinct_pds K n P; ideal (O\<^bsub>K P n\<^esub>) I; 
  I \<noteq> {\<zero>\<^bsub>(O\<^bsub>K P n\<^esub>)\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk> \<Longrightarrow> 
                                         I = Rxa (O\<^bsub>K P n\<^esub>) (mIg\<^bsub>K n P I\<^esub>)"
 apply (frule ring_n_pd[of "n" "P"]) 
 apply (rule equalityI)
  apply (rule subsetI)
  apply (frule_tac x = x in mI_principalTr[of "n" "P" "I"],
                  assumption+)
  apply (frule_tac y = x in n_eq_val_eq_idealTr[of "n" "P" "mIg\<^bsub>K n P I\<^esub>"])
  apply (frule mI_gen_in_I1[of "n" "P" "I"], assumption+)
  apply (simp add:Ring.ideal_subset)+
  apply (thin_tac "\<forall>j\<le>n. (\<nu>\<^bsub>K (P j)\<^esub>) (mIg\<^bsub> K n P I\<^esub>) \<le> (\<nu>\<^bsub>K (P j)\<^esub>) x")
  apply (frule_tac h = x in Ring.ideal_subset[of "O\<^bsub>K P n\<^esub>" "I"], assumption+)
  apply (frule_tac a = x in Ring.a_in_principal[of "O\<^bsub>K P n\<^esub>"], assumption+)
  apply (simp add:subsetD)
  apply (rule Ring.ideal_cont_Rxa[of "O\<^bsub>K P n\<^esub>" "I" "mIg\<^bsub> K n P I\<^esub>"], assumption+)
  apply (rule mI_gen_in_I1[of  "n" "P" "I"], assumption+)
 done
 
 subsection \<open>\<open>prime_n_pd\<close>\<close>
 
 lemma (in Corps) prime_n_pd_principal:"\<lbrakk>distinct_pds K n P; j \<le> n\<rbrakk> \<Longrightarrow>  
        (P\<^bsub>K P n\<^esub> j) = Rxa (O\<^bsub>K P n\<^esub>) (((Kb\<^bsub>K n P\<^esub>) j))"
 apply (frule ring_n_pd[of "n" "P"])
 apply (frule prime_n_pd_prime[of "n" "P" "j"], assumption+)
 apply (simp add:prime_ideal_def, frule conjunct1)
  apply (fold prime_ideal_def)
  apply (thin_tac "prime_ideal (O\<^bsub>K P n\<^esub>) (P\<^bsub>K P n\<^esub> j)")
 apply (rule equalityI)
  apply (rule subsetI)
  apply (frule_tac y = x in n_eq_val_eq_idealTr[of n P "(Kb\<^bsub>K n P\<^esub>) j"])
  apply (thin_tac "Ring (O\<^bsub>K P n\<^esub>)", thin_tac "ideal (O\<^bsub>K P n\<^esub>) (P\<^bsub>K P n\<^esub> j)")
  apply (simp add:ring_n_pd_def Sr_def)
  apply (frule Kbase_hom[of  "n" "P"], simp)
  apply (rule allI, rule impI)
  apply (frule Kbase_Kronecker[of "n" "P"])
  apply (simp add:Kronecker_delta_def, rule impI)
  apply (simp only:ant_0[THEN sym], simp only:ant_1[THEN sym])
  apply (simp del:ant_1)
  apply (simp add:prime_n_pd_def)
 
 
  apply (rule allI, rule impI)
  apply (frule Kbase_Kronecker[of "n" "P"])
  apply simp
  apply (thin_tac "\<forall>j\<le>n. \<forall>l\<le>n. (\<nu>\<^bsub>K (P j)\<^esub>) ((Kb\<^bsub>K n P\<^esub>) l) = \<delta>\<^bsub>j l\<^esub>")
  apply (case_tac "ja = j", simp add:Kronecker_delta_def)
  apply (thin_tac "ideal (O\<^bsub>K P n\<^esub>) (P\<^bsub>K P n\<^esub> j)")
  apply (simp add:prime_n_pd_def, erule conjE)
  apply (frule_tac x = x in  mem_ring_n_pd_mem_K[of "n" "P"],
                                          assumption+)
  apply (case_tac "x = \<zero>\<^bsub>K\<^esub>")
  apply (frule distinct_pds_valuation2[of "j" "n" "P"], assumption+)
  apply (rule gt_a0_ge_1, assumption)+
 
  apply (simp add:Kronecker_delta_def)
  apply (frule_tac j = ja in distinct_pds_valuation2[of  _ "n" "P"],
          assumption+)
  apply (simp add:prime_n_pd_def, erule conjE)
  apply (thin_tac "ideal (O\<^bsub>K P n\<^esub>) {x. x \<in> carrier (O\<^bsub>K P n\<^esub>) \<and> 0 < (\<nu>\<^bsub>K (P j)\<^esub>) x}")
  apply (simp add:ring_n_pd_def Sr_def)
  apply (cut_tac h = x in Ring.ideal_subset[of "O\<^bsub>K P n\<^esub>" "P\<^bsub>K P n\<^esub> j"])
  apply (frule_tac a = x in Ring.a_in_principal[of "O\<^bsub>K P n\<^esub>"])
  apply (simp add:Ring.ideal_subset, assumption+)
 
 
 apply (rule_tac c = x and A = "(O\<^bsub>K P n\<^esub>) \<diamondsuit>\<^sub>p x" and B = "(O\<^bsub>K P n\<^esub>) \<diamondsuit>\<^sub>p (Kb\<^bsub>K n P\<^esub>) j"
        in subsetD, assumption+)
 apply (simp add:Ring.a_in_principal)
  apply (rule Ring.ideal_cont_Rxa[of "O\<^bsub>K P n\<^esub>" "P\<^bsub>K P n\<^esub> j" "(Kb\<^bsub>K n P\<^esub>) j"], assumption+)
  apply (subst prime_n_pd_def, simp)
  apply (frule Kbase_Kronecker[of "n" "P"])
  apply (simp add:Kronecker_delta_def) 
  apply (simp only:ant_1[THEN sym], simp only:ant_0[THEN sym])
  apply (simp del:ant_1 add:aless_zless)
 apply (subst ring_n_pd_def, simp add:Sr_def)
  apply (frule Kbase_hom[of "n" "P"])
  apply simp
  apply (rule allI) 
  apply (simp add:ant_0)
  apply (rule impI)
   apply (simp only:ant_1[THEN sym], simp only:ant_0[THEN sym])
   apply (simp del:ant_1)
 done
 
 lemma (in Corps) ring_n_prod_primesTr:"\<lbrakk>0 < n; distinct_pds K n P; 
  ideal (O\<^bsub>K P n\<^esub>) I; I \<noteq> {\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk> \<Longrightarrow>
  \<forall>j \<le> n.(\<nu>\<^bsub>K (P j)\<^esub>) (mprod_exp K (mL K P I) (Kb\<^bsub>K n P\<^esub>) n) = 
                    (\<nu>\<^bsub>K (P j)\<^esub>) (mIg\<^bsub>K n P I\<^esub>)"
 apply (rule allI, rule impI)
  apply (simp add:mgenerator1)
  apply (simp add:value_mI_gen1)
 
  apply (simp add:value_Zl_mI)
 done
 
 lemma (in Corps) ring_n_prod_primesTr1:"\<lbrakk>0 < n; distinct_pds K n P;  
       ideal (O\<^bsub>K P n\<^esub>) I; I \<noteq> {\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>)\<rbrakk> \<Longrightarrow> 
        I = (O\<^bsub>K P n\<^esub>) \<diamondsuit>\<^sub>p (mprod_exp K (mL K P I) (Kb\<^bsub>K n P\<^esub>) n)"
 apply (frule ring_n_pd[of "n" "P"])
 apply (subst n_eq_val_eq_ideal[of "n" "P" "mprod_exp K (mL K P I)
        (Kb\<^bsub>K n P\<^esub>) n" "mIg\<^bsub>K n P I\<^esub>"], assumption+)
 apply (simp add:mgeneratorTr4) 
 apply (frule mI_gen_in_I1[of "n" "P" "I"], assumption+)
 apply (simp add:Ring.ideal_subset)
 apply (simp add:ring_n_prod_primesTr)
 apply (simp add:mI_principal)
 done
 
 lemma (in Corps) ring_n_prod_primes:"\<lbrakk>0 < n; distinct_pds K n P;  
       ideal (O\<^bsub>K P n\<^esub>) I; I \<noteq> {\<zero>\<^bsub>O\<^bsub>K P n\<^esub>\<^esub>}; I \<noteq> carrier (O\<^bsub>K P n\<^esub>); 
      \<forall>k \<le> n. J k = (P\<^bsub>K P n\<^esub> k)\<^bsup>\<diamondsuit>(O\<^bsub>K P n\<^esub>) (nat ((mL K P I) k))\<^esup>\<rbrakk> \<Longrightarrow> 
        I = i\<Pi>\<^bsub>(O\<^bsub>K P n\<^esub>),n\<^esub> J" 
 apply (simp add:prime_n_pd_principal[of "n" "P"])
 apply (subst ring_n_prod_primesTr1[of "n" "P" "I"], assumption+)
 apply (frule ring_n_pd[of "n" "P"])
 apply (frule Ring.prod_n_principal_ideal[of "O\<^bsub>K P n\<^esub>" "nat o (mL K P I)" "n" 
        "Kb\<^bsub>K n P\<^esub>" "J"])
  apply (frule Kbase_hom[of "n" "P"])
  apply (simp add:nat_def)
  apply (subst ring_n_pd_def) apply (simp add:Sr_def) 
  apply (rule Pi_I, simp)
  apply (simp add:Kbase_Kronecker[of  "n" "P"])
  apply (simp add:Kronecker_delta_def) 
   apply (simp only:ant_1[THEN sym], simp only:ant_0[THEN sym])
   apply (simp del:ant_1)
   apply (simp add:Kbase_hom) apply simp 
 
  apply simp
  apply (frule ring_n_mprod_mprodR[of "n" "P" n "mL K P I"  "Kb\<^bsub>K n P\<^esub>"])
   apply (rule allI, rule impI, simp add:Zset_def)
   apply (rule allI, rule impI) 
   apply (simp add: Zleast_in_mI_pos)
 
  apply (rule allI, rule impI)
  apply (subst ring_n_pd_def) apply (simp add:Sr_def)
  apply (frule Kbase_hom1[of  "n" "P"], simp)
  apply (simp add:zero_in_ring_n_pd_zero_K)
  apply (frule Kbase_Kronecker[of  "n" "P"])
  apply (simp add:Kronecker_delta_def) 
   apply (simp only:ant_1[THEN sym], simp only:ant_0[THEN sym])
   apply (simp del:ant_1)
 apply simp
 done
 
 end