Quellcode-Bibliothek Dense_Linear_Order.thy   Sprache: Isabelle

(*  Title       : HOL/Decision_Procs/Dense_Linear_Order.thy
    Author      : Amine Chaieb, TU Muenchen
*)

section ‹Dense linear order without endpoints
  and a quantifier elimination procedure in Ferrante and Rackoff style›

theory Dense_Linear_Order
imports Main
begin

ML_file java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "nextword" is null
\open.\close>

context<.(<> <> <x\><><>U x )\andx<u🚫y 🚫 ∀ (insert)   )\and  )
begin

lemma less_not_permute\.(<> <>L  )\and \forally\in    )\and <andjava.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "nextword" is null
  by (simp add: not_less linear)

lemma gather_simps[no_atp]:
  "(\x. (\y \ L. y < x) \ (\y \ U. x < y) \ x < u \ P x) \
    (∃x. (∀y ∈ L. y < x) ∧ (∀y ∈ (insert u U). x < y) ∧
  "(\x. (\
    \>.🚫    )and
  "(\x.<)
    >. (🚫 \forall (insert u )x<y"
"<>x \<>y L yy\in>U y)\and l < x) \
    (∃x. (∀lemmano_atp\ez <x   < x<t< )
   

lemma blast
  by

textTheorems for ‹ \>x.x<z\ Px\>P🚫\infinity\close<>
lemma[o_atp\><.< < < <True
  lemma[no_atp \>\>    <t< \>)
mma] \z\>    >t  <)
 ( : ) ( [ =t, simp )

lemmalemma  simp:less_le )
  by simp )
lemmano_atp< .< >\>\"
 byauto:   not_le
lemma minf_eqlemma[no_atp \>Longrightarrow <\   U>  
  by auto
lemma minf_neq[no_atp]: "\z. \x. x < z \ (x \ t \ True)" 
  by auto
lemma minf_P[no_atp]: "\z. \x. x < z \ (P \ P)" 
   blast

text‹∃z. ∀ x <z \longrightarrowP x \longleftrightarrow> P🚫+<^sub>∞)›<close>
lemma pinf_gt[no_atp]:  "\z. \x. z < x \ (t < x \ True)" 
  by auto
lemma pinf_lt[no_atplemmanmi_eqno_atp:"t <> U \Longrightarrow forall>x \notFalse \existsu\in U u < ) by auto
  by (simp :not_lessruleexI x=t]  simp:less_le

lemma)
 :less_le
lemma<P2' \ P2 x \ (\u\ U. u \le x)\<> <>
  by (auto<>.\not' P2' and (P1x<> P2 xP2 <>\exists\in .u <>)  
lemma pinf_eq[no_atp  [no_atp\lbrakk<><P1  x\\exists\>Uu< )
lemma>no_atp<\x <>P1exists>  >  x<'andP2x>existsxe )
lemma  \forallx <>P1 and

lemma\forall>(P1'<> (P1 \existsuin>U. x \ u)" by auto
 no_atpbyauto
     no_atp
  "t \forall  .(<.l    <Ulx\andx< > t< (\forally. l   < < longrightarrowy  )
lemma  nmi_ge[no_atp]: "t \ U \ \x. \False \ t\ x \ (\u\ U. u \x l u. (\t. l < t \ t < u \ t \ U) \ l < x \ x < u
lemma  [] t\in \Longrightarrow>\forallx <notFalseand = t ⟶   
lemma[:t<U>< t<u longrightarrow \otinU and  and<u <>t< \forally  <y and y<u\ongrightarrowt<<)
lemma  nmi_P[no_atp]: "\xlemma lin_dense_conjno_atp by (metis antisym_conv3 order.strict_trans)
lemma  nmi_conj[no_atp] "x.. \\not>P1' \'\and> P1 x \ U. u <>x java.lang.StringIndexOutOfBoundsException: Index 120 out of bounds for length 120
  \longrightarrow\y    <>y <u\ongrightarrow (  \and> )"
  forallx not>(P1'\and P2')\and P1 metis. local local.
  nmi_disj[]  \brakk\>  .\> Longrightarrow  forall u.<t.  t\> <u\>  notin U\l <x\andx< \and>t\> <>\orallyl  \  u\>t \>java.lang.StringIndexOutOfBoundsException: Index 206 out of bounds for length 206
rrow\existsu<> le< <java.lang.StringIndexOutOfBoundsException: Index 112 out of bounds for length 112
  \>. \not('< P1  <>  longrightarrow  \>\nU.u\>x"by auto

lemma    by
lemma[]"<\forall <> MP \>longrightarrow>\xists>u\ Uu lex forall>.<> Px
lemma  npi_le[no_atp]: "t \< "t\in  \Longrightarrow >\>MPand <Px\longrightarrow(existsu∈\exists'\in U u\lex<> >'
lemmanpi_ge] t\in U\Longrightarrow>🚫u∈ ⟶ (∀. l < y ∧ y < u ⟶l < y ∧y <u \longrightarrow> y ≠"
  npi_eq[]:t\U>forall> and>(uinxleuby auto
lemma
lemmaand lin_dense_conjno_atp:
conj:<><P1<>P1 ongrightarrow  <exists\in .x \e>u  \forall>.\not> \and>  \ongrightarrow>  exists\in>U. \le>u<rbrakk
  > P1and ' \( and x)\longrightarrow>(exists>u\inU x \leby auto
lemmaand> \forallyly and y  u\longrightarrow>P2)<>\Longrightarrow>
  <>  \forall> l (forallt l  t <>t< longrightarrowt\>  and l <x\andx  and( x\>P2x)

lemma  <> (<>.<y andy <u longrightarrow(  and )"
in
     
    Mx  ".y\in S \ y \>x}

lemma xM"y. y x \ y}"
  " a " >u.(forall<t>longrightarrownotin <l x \and x<u\and  
    ∀M"
  by .

lemmabyl u.(forall l t\and   u longrightarrowt∉< < x<\and P2x
  "t then have fMx::" Mx
      usingfS finite_subset auto
  byhave:"M \ S""

lemma lin_dense_geno_atp:
  t <>U \Longrightarrow
    a finite_set_intervals[no_atp
  by umes px P finite?"

lemmafromand " le> u"
  "t and linS: "l∈in
    \forall> l .(<>.l< <>t <auinS  \in "
  by blast

lemma lin_dense_neq[no_atp]:
  "t \ U \< xxx"
           fMxby auto
   by

lemma -
  "
  auto

lemma]
  using byblast
  ⟶ "b \in ?xM
  <xlu"
  ⟶ have binShave MxSMx<S
   lu(forall < \and    < t\notin U)\>   <   < (  \>P2x)
  ⟶ (∀then have<a<y <yotinjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  

lemma [no_atp]
  "\sumes px: "P blast
  and:"l \
  ∀t   t\and t  l>t\ and<u<> P2x
  and\S
  <    using finite_subsetbyauto
     and:finite
      andlS \forall>\byb

lemma (<>\byblast
  \Longrightarrow forall.<MP < <PP\andPx\>(exists∈u'x
      using Mxne fMxbyautobymetislocal

lemmafinite_set_intervals[]
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
    and  havehave "?a \\ ?Mx"
    andcontext unbounded_dense_linorder    using Max_inOFfMxMxne  simp
  and linS l<S
    and uinS
    nd: S
    and   by( dest )
    lemmadlo_qe_bndsno_atp]:
  shows "\a \ S. \b \ S. (\y. havehave "?<>
proof-
  let ?Mx = " and neU: "U\noteq>   then "b in>S
  letand    usingxMS byblast
  leta  Mx
  let ?b(using fMx  java.lang.StringIndexOutOfBoundsException: Range [6, 28) out of bounds for length 6
  have blastby
    
  then localdual_order ( uxL by blast
     fS  
  from lx"l<x
    by blast
   have  ?noteq{
    by    andletML= " Ljava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  haveand lS :<< Sl< "
    bya Su"forallx<>S le>u
  thenshows">s\ S. P s <>>(exists> < S existsin \>.a\notin S anda x\and x < and P x)"
    using fS finite_subsetby
  fromxu uinSset_intervals  P=P    lx linS fSlSSu]
    by 
  then
end
  have ax
     Mxne byauto
  have xbby
  moreoverfrom  forallU.w u"
  havebegin
ax_in fMxMxne]bysimp
  then 
    using    lemma interval_empty_iff ".x \
  have
sing[OF xMneby
  then have binS
    using byblast
  have noy: "\y. ?a < y \ y < ?b \ y \< assumes ne: "L java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "nextword" is null
     Mxne fMxfxM local. xMne by fU:"finite U"
ainS noy axxb px show?
    by blast
qedproof  u"l < L" and u: inU for l u

lemma finite_set_intervals2[no_atp]:
  assumes px "P x"
    and lx: "l \
      from e" U. Min U\le> "
    andbysimp
     M "forallx
    and fS:    by(auto intro less_le_trans)
      java.lang.StringIndexOutOfBoundsException: Range [6, 2) out of bounds for length 19
    
  mmaexists_neq]"existsx::'a. x \ t "at\ java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
  using finite_set_intervals    by
      th2H have ? MU
  le_lessneq_iff  
end


section  byfromth3th1' have "\ Lmoreover lemma atoms[no_atp:

contextshow.>inx)<> (\forall<U 
beginauto    and

nterval_empty_iffjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  by dest)

lemma 
  assumes: " {}"
    
    and
         and fU toHOL-togetherwiththe conj_aci_rule  langfordML)
  shows dnfandfU inite"
proof oof 
  proof -
  thenobtain x where xL: "\y\
        "\not P <> Q)java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 73
  have< l l <>"and u "\>U"for lu
    using local.dual_order.strict_trans that(1) u xL xU by blast
  then show "\l\L. \u\ "("(P \ Q) > \
next( <longleftrightarrow
  assume
  let? =Max"
  let ggt_exoft]by auto
  
lemmas[no_atp  less_irreflnot_less not_leexists_neq
  from fU neU have th2  le_less neq_iff linear less_not_permute
    
  fromlemma axiomno_atp] "class
    byauto
  with  mma atomsno_atp:
    by blast
  
    as dnf_simps    and"ERM less_eq :'a\Rightarrow_)"
  moreoverlangfordML\>
    by
  ultimatelydeclare axiom  dlo_qe_bnds  gather_simps]
     dlo_simpslangfordsimp
qed

lemma
assumes Lnoteq
    and
  showssection<Contructive  orders QE  arithmetic   \>
  using

lemma
  assumes 
    and linorder_stupid_syntax linorder
  showsbegin
proof -
  notation
    by blast
  from ne fU have "\x \ U. Min U \ x"
    by simp
  witheq  (<  "(\ (P \and> P not> Q"
uto
  then show ?thesis
    by   less_eq(  (\>Q\longleftrightarrow <>P or"
qed

lemma exists_neq[no_atp]: "(x:'a). x \ t "∃ t\noteq x
  byblast

lemmas dlo_simpsjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  le_less 

lemma
   gt_ex auto

lemma  .succeed('o .)
\close pinf_conj[]]
    and ex1 ∃< P1<longleftrightarrow
    andTERM(:

declare 
declare dlo_simpslangfordsimp

end linorder_stupid_syntaxshows "exists>.<>x. z sqsubset \longrightarrow>(P1 x \and>P2 \longleftrightarrow> ('\nd>P2')

(* FIXME: Move to HOL -- together with the conj_aci_rule in langford.ML *)
lemmasless_eq<>(sqsubseteq\and

lemmas  \open>(sqsubset\close> and

lemma
  
  "(
  "(P \ Q) \ (\ P \exists forallxsqsubsetx \longrightarrow (  \longleftrightarrow P2'"
 ⟷>((P ∧ (¬ ¬ "existsz x> ((P1 x (P1x or P2 x
  "\using gt_exbyauto
  

lemmalemma pinf_ex[no_atp:
  byblast

lemmas dnf_simpsno_atp= nnf_simpsex_distrib

ML_file ‹ ex2:"
method_setup
  
\close text \>Linearorder upperbounds\lose>


section open

text ‹>.🚫

localeby
begin
lemma pinf_exno_atp:
notation   
  less_eqandp1: P1
  less_eq    showsshowsexists
  using
  

end minf_conj]:

locale ex1"exists>z1. \forallx x \ (P1 x \longleftrightarrow> P1')')"
  assumes gt_ex: "\ and ex2: "∃x. x ⊏
begin

lemma :<> forall sqsubset\longrightarrow(xlongleftrightarrow
  usinggt_exby


lemmashowsz\.x\>  longrightarrowxor )longleftrightarrow(\>P2'
    by ( ex1 ex2local.min_less_iff_conj)
    and ex2
  shows  assumesassumes minf_ex[o_atp
    assumesassumes:"z. forall>x..x z P x\ P1))

lemmashows " andand p1 P1
  assumes  shows  by (metis ex1 ex2localin_less_iff_conj
    and  [no_atp
shows 
   and"existsz2 forallx \<\sqsubset>z2 \longrightarrow>( \longleftrightarrow> '

lemmajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 \qsubsetx longrightarrow  x longleftrightarrow"
    andbetween_less"x \Longrightarrow> x between y)\>less between x y)y"
  shows    
  using

end

text<>order upper \lose

locale linorder_no_lb=less x >xbetween )\> lessbetween )
   lt_ex<y  yx"
begin

lemma dlo 
  usinglt_ex by


text   then ?
u between_less[of xy]by
  assumes ex1
    case2
  then  caserule)
  bycase 

 []
   :finite
    and\ (. sqsubset<>\sqsubset<u\and P x
  shows      \longrightarrow>(<>.lsqsubset y <  sqsubsetu\>Py )
  by (metis ex1    and 

lemmaminf_ex[:
     "exists>u\in U. \\existsu in> U between u '
    and p1: P1

  using   rinf_U]

endby blast


locale constr_dense_linorderobtain  'where uU: "u U" uU' "u.. l \t t\<> u \longrightarrow> t <>U and> l x and>x P x
      by auto
  assumes  from<longrightarrow \ <yl \>y <>y\sqsubset u longrightarrowPy)
    and between_same    by auto
egin

sublocale dlohave: "? and nmpiU: ""x\ot>MP \nd notPP\<>P x longrightarrow (u
proof (    and nmi " using fU Une by simp
  case  showshaveuinM: u <in U
  then show -
      from exusingusing Une Unebysimp
next
  case 2
  thenshow ?case
next
  case 3
  then show      Une by auto


lemma
  assumesby
        using uU'UneMu by simp
      ⟶ ? ?=".Min less_eq U"
 nmpiU: \forallx not> <>\ot> andPx\>(\exists>\> U <exists in. \sqsubseteq>  \andx sqsubsetequ"
    and"  and <>PP
  shows \existsu\   t1t2where \in>U t2 < ""<forally  \qsubset  andyy <>t2<>y <>Ut1> "\sqsubset>t2Px
proofby blast
  from  thenthen show    usingUne simp
    by blast  proof cases
    case1then show?
  obtainu 'where uU: "uin>U and uU: ' <><>U"" and:u sqsubseteqx andxu" \sqsubseteq> u'
    byautousing fUby
  have java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    by auto
  let =linorderless_eqUjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  let? "Max less_eq U"
  have     showthesis
Uusing uU Une simp
  have uinM  from
 using where="OFjava.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 72
t<>U.? \sqsubseteq> "
    using Une fUt1 t2where "t1
  have : \forallt🚫
     Une  uto
  have   prooflin_dense \>xlu<tl \>t>t>t> longrightarrowt <notin>  <P
case   thesis
  frombyandnmibnd"forall>x. \notMP U. u >x)
  have th: "u' \ ?u"
     uU' Une Mu by simp
  from order_trans[OF xu' th and mi " next
  from java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 10
  consider u where          is"?E ?"
    byorder t1t2
     between_less t1t2 t1lu t1\sqsubset  
  o Dif:?E
  proofusing""   proof -
    caseconsiderqed
      by    proof
  next      case 1
     ?thesisby blast
    then have t1t2    nextandandlin_dense: \forallxl <t \>t andsqsubset u<> >)and\> and\> and Px
      by
    let: ""∀  < Px\longrightarrow>ufrom[ 
and\  xlongrightarrowexistsUx sqsubseteq
    andOFlin_dense\\not\ <>< ›
       <>.x MP> <>exists<>U.<>'inU. P(betweenu u')
  (" qed
qed

theorem[]:
  assumes   proof  usinglocal . mipi that by blast
        then show thesis
     ⟶ (∀    
    andnmibnd "forall>x. \not MP P x \\<> (existsu\in Uu x"
    and npibnd: "\x. \PP \ P x \
    and       case2
  shows(exists>.P x  (MP \or PP \or>(<>u <in U lemmasnmi_thms     nmi_le nmi_genmi_P
         is?E  lemmas[]== npi_disj npi_neq npi_lenpi_lenpi_genpi_P
proof
  show ?by 
  proof -
    consider "MP qed
    then showshow lemma[no_atp:constr_dense_linorderless
    proof cases
      case 1
      then show
    next
      case 
      from npmibnd[OFlemmas  showsTERMless  _
          and "TERM (less_eq :: ''a \ __)"
       nmi_thmsno_atp=nmi_conj nmi_disj  nmi_ltnmi_le nmi_gt 
        lemmas
    lemmaseferrack_axiom :minf_thmspinf:pinf_thms
  nmi
  showlemma  ferrack_axiom[    lin_dense_thmsqe fr_eq  atomsatoms
    using. locallt_exmi pithat byblast
qed

lemmas[no_atp =
lemmas pinf_thms[no_atp    showsERM( :' \Rightarrow>> "

lemmasno_atp nmi_conjnmi_eq nmi_lt nmi_gt 
lemmas npi_thms[no_atp] = npi_conj npi_disj
lin_dense_thmsno_atp lin_dense_conjlin_dense_disj  lin_dense_neq   lin_dense_gt 

lemmafun npinpi_thms lindense
  bycaseThm.term_of 

lemma atoms[declaration ‹
ess:' Thm.term_of aconv y then Ferrante_Rackoff_Data.Eq
                else fun generic_whatisphi 
    and " val [lt, le] = map (Morphism.term phi\HOL.eq _ for y z\\ =>

declare             Thmx aconvy .
      funelseFerrante_Rackoff_DataNox
    caseThm ifcould_unify b )then

declaration ‹
let
  fun simps phi = map (Morphism.thm phi) [@{thm "not_less"}, @{thm "not_le"}]
  fun generic_whatis phi =
    let
      val [lt, le =mapterm_of   y  Ferrante_Rackoff_DataLt
      fun h      fun h          elseifThm Thmterm_ofxaconvythenFerrante_Rackoff_Data.
 .  Ferrante_Rackoff_Data.Nox <Const_><Notforld_unify (b, le) then
          \^Const_<openHOLeq _foryz\             Thmterm_ofx ythen Ferrante_Rackoff_DataNEq
                        elseelseif Thmterm_ofx aconv then Ferrante_Rackoff_Data.Ge
             Ferrante_Rackoff_DataNox
       | 🍋 bltthen
rm_ofxaconv thenFerrante_Rackoff_Data.NEq
            else Ferrante_Rackoff_Data.Nox
unify,ltthen
                     ifelseFerrante_Rackoff_DataNox  (HOL_ssctxt>. simpsphi)
                     else
                      Ferrante_Rackoff_Data.
                 else if Termif.  @{ ferrack_axiom
                      elseelse ifxaconv thenFerrante_Rackoff_Data.
                     else ifThmxaconv z  Ferrante_Rackoff_DataGe
                     <close>
                 
       | _ => Ferrante_Rackoff_Data.Nox
  ML_file
  fun
    simpset_of ferrack\open
ins ( HOL_ssctxt  Simplifierdd_simps( phi
  sectionFerrante and  orderedfieldsclose
    {
end
›assumes"<0"

end

ML_file ‹ferrante_rackoff.ML› assms mult_less_0_iffmult_neg_negzero_less_mult_pos)

method_setup ferrack=<open
  Scan  fixesc :"a:linordered_field
›


subsection 

lemma neg_prod_lt neg_prod_sum_lt
  fixes 
  assumes    "
  
  by ferrack <>

lemma \close> "Ferrante and Rackoff's algorithm
   c: x  <  0\longleftrightarrow>>x<(1/c *t
   "c > 0
  shows "c
  by (meson  fixesx :java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0

lemma lemma neg_prod_sum_ltneg_prod_le
  fixes c :: " c a:
"
  shows   showscx<<>xge"
by  by  mult_less_0_iffmult_neg_neg zero_less_mult_pos

lemma pos_prod_sum_lt pos_prod_le
  fixes c : fixesc: alinordered_field
  assumes c>"
  shows c*+t <0 java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 17
  using assms by   

lemma  neg_prod_sum_lt
   :aordered_ab_group_add
  shows assmsby(simp . divide_simps


 c:":inordered_field"
  fixesassumesfixes : "a:linordered_field"
  assumes   0longleftrightarrow  1) java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  shows c*\lemmasum_lt
  using assms 

lemma pos_prod_le:
:a:linordered_field
  assumes "c > 0"     less_diff_eqwhere=x  btand bysimp
  shows
  usingassms 

lemma
    :"a fixes c :: "'a:linordered_field
  assumes " x assumes0"0
  usingassmsby 
  using

lemma  :alinordered_field
  fixes c :  assumes c:alinordered_field
   " >0
     shows  *+0longleftrightarrow(-c*"
  

lemma
  fixes   "c 0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  shows  +<0\><le-
  using le_diff_eq[

lemma class_dense_linordered_fieldconstr_dense_linorder
  fixesalinordered_field
  assumes c  
  shows "c * x = 0 \ by unfold_locales (auto simp add: gt_ex)
  using

lemma nz_prod_sum_eq :
  fixes [   
  assumes "c shows "xer h:(,y)=
  usingle_diff_eqwhere and b and0bsimp
  using assms byfun:

lemma
red_ab_group_add
leftrightarrow cx \  
  usingusingGREATER

interpretation  ct
"\
  by\^  c\>"

open
let
   earlier]=false
    | earlier (h::t     Ratof_int(snd(dest_number t)


  fun earlier_ord  <Const_\openplus for‹ _fixes x:"a:ordered_ab_group_add"
    aconvc
    else ifelse "Nox"using[ a=xand bt 
    else GREATER;

fun
  Thm ctof
    🚫Const_  ( simpadd:gt_ex)
      .java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  | 🍋
    >Rat earlier ht(,y)=

fun sum_le  { sum_le}
^>f  vs( y 
     ifneg_prod_sum_lt= mk_meta_eq { }
      "",)
| else vs,y)then LESS
     if y val GREATER
     else (,)
| \^>open  _\close =
  y .(c]
     else ("Nox",[ b\close
t=  Thmterm_of then (java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

local
valsum_lt=@hm
val sum_le = mk_meta_eq 
val =k_meta_eqthm}
val neg_prod_sum_lt =        valifyaconv .term_of x then"x+"(2Thm)Thm)
valval     elseox[
val neg_prod_sum_le = est_arg <>openfor  <>>
val pos_prod_sum_le=mk_meta_eq thm
val neg_prod_lt = mk_meta_eq y aconv Thmaconv. xthenxt,Thm.dest_arg]
val pos_prod_lt"",]
val neg_prod_le = mk_meta_eq\Const_<> _ for_\close 
valelseapply.applycz c)
z_prod_sum_eq                 else)
valt  if aconvThm.term_of then ""[) "ox,)
in
fun xnormalize_conv ctxt []
  | xnormalize_conv ctxt (vs as (xlocal
   case Thm.term_of ct of
st_\openless_ for_\^Const_\open>. \close> sum_lt mk_meta_eq sum_lt
    .)of
    ("cval sum_eq = {thm sum_eq}
       letneg_prod_sum_ltmk_meta_eqthm }
         cr=dest_frac 
        val clt =          mk_meta_eq thm}
        valval pos_prod_sum_le =mk_meta_eq @{thm pos_prod_sum_le
        valneg=cr < 0
        val cthp = Simplifierthmpos_prod_lt
               ( neg_prod_le  mk_meta_eq @thm neg_prod_le}
                  (val(Semiring_Normalizersemiring_normalize_ord_convctxt( vs)) th
                    else Thmeq
        val  . (Thm.symmetriccthp TrueI
        val       let
             (if neg then neg_prod_sum_ltval clt  Thm ct
ruleConvarg_conv Convbinop_conv
                   (Semiring_Normalizer.semiring_normalize_ord_conv ctxt (         neg = fun  xnormalize_convctxt ]ct=reflexive
      inrth
  (.
       let   <Const_openless _  \Const_>openzero_class <><=
            (( whatis x Thmdest_arg1 ct)of
        val th = Thm                    "
        val rth=Conv.fconv_rule  (Convarg_conv Conv       
              semiring_normalize_ord_conv(vs) 
       in
                   
       let(ifnegthen.apply Thmapplycltccz
        val cr =( whatisx Thm. ct)
            "c*x+t val cth Thm.equal_elim (Thmsymmetric ) TrueI
        val cz =                val th java.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 34

        val cthp        val       rth end
               HOLogic
                  (if neg        
                    else        ( neg then Thmapply(. clt)
mequal_elimThm valth Thminstantiate'[]SOME x SOME tSOMEtsum_lt
        val th          cth .(.symmetricjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
             if neg_prod_lt else pos_prod_lt)
        valrth(.ctxt earlier_ord vs) th
      in [])=
    |       let


r_<Const_ "*,[c] >
   (case       =. Conv Conv
    (val  dest_frac c
       let
        val T  Thm
val (",c] >
        let
        val clt = Thm.cterm_of ctxt \        valT=Thmtyp_of_cterm
         cz==. ct
        val neg = cr < racif neg Thmapplyapplyc cz
                             apply(.applycltcz)c)
               (HOLogicval cz =Thmdest_arg
                           valthThm(. [(ctyp_of_cterm)map c)
                    else Thm             val   .ctxt
        val(negthen applyhm.applyclt c cz
        val th = Thm                     Thm
                  negthenpos_prod_sum_le
         th= Thmimplies_elim
                   ( 
hend
    | ("x+t x(. ct) of
   
        val T = Thm.ctyp_of_cterm
        val th = Thm        val T  Thmtyp_of_cterm x
        val rth = Conv          =Thmctyp_of_ctermx
              Semiring_Normalizer. ctxt (earlier_ordvs)) th
       in  rth       let
    |c*x",[c]) =>
       let
        valT  Thmtyp_of_ctermvalval Thm ctxtonst<>less T\close
        val cz Thmdest_fun2ct
                 val  <0
         cthpvalcthp  implifier 
        (.mk_judgment
        val neg             ( negthen ThmapplyThmapply )cz
        else . Thm cltczc
               val valcth=. Thm )
                  ifnegif then Thmapply Thmapplycltcz
                    elseifneg hen neg_prod_sum_le  pos_prod_sum_le)cth
        val cth = val =Convconv_rulearg_convbinop_conv
        valth Thmmplies_elimThm.instantiate OMEctyp_of_cterm] SOME,]
                  (if      int[)>
  valrth rth th
      in rth end
    | _ => Thm.reflexive ctval=Thm.' [SOME T SOME x SOME l

|\Const_<>HOLeq for\^Const_>openzero_class. closeclose =>
   (case whatis x (Thm.dest_arg1 ct) of
    " =Thm.instantiate SOME T OME x,OME tsum_le
       letvalend
alSemiring_Normalizerctxtearlier_ordvs)th
        val cr = dest_frac       in end
        val ceq =Thmdest_fun2 ct
        valT  Thm
        val           .typ_of_cterm java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            (HOLogicvalclt .cterm_of ^>open Tclose
             (Thmval  Thm
        val cth        val neg = cr  @
        val th        valcthp  Simplifierrewritectxt
                 (ThmHOLogicmk_judgment
        val rth                  if cth=.equal_elim.symmetric TrueI
                   (valrth . Thmclt czc)
      in rth                 valcth Thm.(.symmetriccthpTrueI
    | ("x+t",[t]) =>         rth 
       let
           .ctyp_of_cterm x
        
        val rth = Conv.
              
       in  val_>reflexivect
  
       let
        val T  Thmctyp_of_cterm x
        val cr =  val ss=  <>
        
        val cz =funcase x(.dest_arg1)o
        val\open a b\close=
            (   let cacb)cb = Thmdest_binop ct
             Thm.apply 🍋 Thm. ceq)))
   ThmThmsymmetric cthpTrueI
        val ceq =       val nth  .
                  (Convrg1_conv
      val cthp =Simplifierctxt
    | _ =             . nth( ctxtvs (.rhs_of)
end

local
  valless_iff_diff_less_0=mk_meta_eq @thm   val less_iff_diff_less_0 = mk_meta_eq @{thm "less_iff_diff_less_0
  val  =Thmimplies_elim
  val eq_iff_diff_eq_0 = mk_meta_eqval T=Thmctyp_of_cterm ca
   ss  simpset_of 🍋 \^context       valval = Conv.fconv_rule
in

  🍋 ctxt( vs)))th
   let val       |(xtt 
       val        
       valval
     val nth=Conv.fconv_rule
         (Conv   let val(,cb =Thmdest_binopct         =Thm.instantiate OMETSOME  ]sum_eq
              (Semiring_Normalizer.semiring_normalize_ord_conv (put_simpset         valT 
        rth=.transitive nthOMET][ ,SOME cb eq_iff_diff_eq_0
   in rth end       valrthend
| 🍋Conv.
   let(.semiring_normalize_ord_conv ss)) th
       valrthlet
       th .'SOME ] SOME ca, SOME cb] le_iff_diff_le_0
       val nth = Conv.fconv_rule
         Convarg_conv(Const_openeq __ for ab<>›phi vsct
              (Semiring_Normalizer        ceq=Thmdest_fun2 ct
       valendvalcz .dest_arg ct
   in

 \Const_\open>(.mk_judgment
   let  funhxt 
       val  cth Thmequal_elim(. cthp TrueI
       valth\\Const_><HOL_for\close>=
       val nth = Conv.fconv_rule
         Conv (
              (Semiring_Normalizer.semiring_normalize_ord_conv (put_simpset ss ctxt) (earlier_ord vs)))      elseFerrante_Rackoff_Data.Nox
       val rth = Thm.transitive| => Thmreflexivect
   in rth end
| 🍋
| local
end;

fun classfield_whatisphi
 let
  fun h x t =   le_iff_diff_le_0 =mk_meta_eq{ "le_iff_diff_le_0}
   case Thm.term_of   else Ferrante_Rackoff_Data.Nox
     <\openHOLeq _ fory z<>>
      if Thm.term_of xin Thmterm_ofx aconv ythen Ferrante_Rackoff_DataLe
      fun ifThm.term_of x  
   | 🍋.Nox
       =>.Nox
      else inT=hmctyp_of_cterm
   |        phictxt =
              val nth Conv
       else if| (Convarg_convConv.
Ferrante_Rackoff_Data.Nox
   | 🍋
       if Thm.term_of x aconv y then Ferrante_Rackoff_Data { "class_dense_linordered_field.ferrack_axiom"
       else if Thmterm_of x aconv z thenFerrante_Rackoff_Data.
       else Ferrante_Rackoff_Data.Nox
   | _ => Ferrante_Rackoff_Data.Nox
 in h end;
funend
  simpset_of nth =.
    |>         Conv (.
    | fold  . @ abs_split,{ "split_max"} { "split_min}])

in rth Thm.transitive nth (normalize_conv ctxt vs(.rhs_of nth)
Ferrante_Rackoff_Data.funsin rth end
  {isolate_conv = field_isolate_conv, whatis = classfield_whatis\^Const_<>HOLeq_for  \close> >
end
›

end