
diff -r 466bcb20f2d7 -r 486223010ea8 src/Tools/isac/Build_Isac.thy
--- a/src/Tools/isac/Build_Isac.thy	Fri Sep 16 12:13:23 2022 +0200
+++ b/src/Tools/isac/Build_Isac.thy	Mon Sep 26 10:57:53 2022 +0200
@@ -175,7 +175,2699 @@
 ML \<open>
 \<close> ML \<open>
 \<close> ML \<open>
+\<close> ML \<open> (* \<rightarrow> termC.sml*)
+\<close> ML \<open> (* \<rightarrow> model-pattern.sml*)
+\<close> ML \<open>
+Model_Pattern.adapt_term_to_type: Proof.context -> term -> term ;
+Model_Pattern.adapt_to_type: Proof.context -> Model_Pattern.single -> Model_Pattern.single
+\<close> ML \<open>
+\<close> ML \<open> (* \<rightarrow> problem.sml*)
+\<close> ML \<open>
+val id = ["univariate", "equation", "test"]
+\<close> ML \<open>
+Problem.from_store_PIDE: Proof.context -> Problem.id -> Problem.T
+\<close> ML \<open>
+\<close> ML \<open> (* \<rightarrow> refine.sml*)
+\<close> ML \<open>
+\<close> text \<open>  local
+refin_PIDE
+\<close> ML \<open>
+\<close> text \<open>  \<isac_test>
+refine_PIDE
+\<close> ML \<open>
+\<close> ML \<open>
+\<close> ML \<open>(*---------------------------- why "real" in pbl? ----------------------------*)
+Test_Tool.show_ptyps ();
+\<close> ML \<open>
+KEStore_Elems.get_pbls @{theory Poly}; (*! real ! due to Simplify :: "real => real" etc*)
+\<close> ML \<open>
+Problem.from_store_PIDE @{context} ["polynomial", "simplification"]
+\<close> ML \<open>
+val input = (["polynomial", "simplification"], 
+  [("#Given", ["Simplify t_t"]), ("#Find", ["normalform n_n"])], 
+  Rule_Set.empty, NONE (*cas*), 
+  [["simplification","for_polynomials"]]) : Problem.input
+\<close> ML \<open>
+Problem.prep_input_PIDE @{theory Poly} "guh" ["math-author-1"] ["polynomial", "simplification"]
+  input; (*! real !*)
+\<close> ML \<open>
+\<close> ML \<open>
+\<close> ML \<open>
+"~~~~~ fun prep_input_PIDE , args:"; val (thy, guh, maa, init, (pblID, dsc_dats, ev, ca, metIDs)) =
+  (@{theory Poly}, "guh", ["math-author-1"], ["polynomial", "simplification"], input);
+\<close> ML \<open>
+      fun eq f (f', _) = f = f';
+\<close> ML \<open>
+      val gi = filter (eq "#Given") dsc_dats;
+\<close> ML \<open>
+        val (_, gi') :: [] = (*case*) gi (*of*);
+\<close> ML \<open>
+      map (Problem.split_did_PIDE o (Syntax.read_term_global thy)) gi'
+\<close> ML \<open>
+\<close> ML \<open>
+(*+*)Syntax.read_term_global thy "Simplify t_t" (*Simplify :: "real => real"*)
+\<close> ML \<open>
+(*+*)TermC.parse_patt thy "matches (?a = 0) e_e"
+(* = Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ 
+  
+Var (("a", 0), "real") $ Const ("Groups.zero_class.zero", "real")) $ Free ("e_e", "bool")*)
+\<close> ML \<open>
+(*+*)TermC.parse_patt_PIDE thy "matches (?a = 0) e_e"
+(*t = Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ 
+  Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool")*)
+\<close> ML \<open>
+\<close> ML \<open>
+\<close> ML \<open>
+\<close> ML \<open>
+KEStore_Elems.get_pbls @{theory Isac_Knowledge}; (*! real ! due to Simplify :: "real => real" etc*)
+(*val it =
+   [Node ("empty_probl_id", [{cas = NONE, guh = "pbl_empty", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls = Empty, thy = {Pure}, where_ = []}], []),
+    Node
+     ("simplification",
+      [{cas = SOME (Const ("Simplify.Simplify", "real \<Rightarrow> real") $ Free ("t_t", "real")), guh = "pbl_simp", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+        [("#Given", (Const ("Simplify.Term", "real \<Rightarrow> una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \<Rightarrow> una"), Free ("n_n", "real")))], prls =
+        Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify:30},
+        where_ = []}],
+      [Node
+        ("polynomial",
+         [{cas = SOME (Const ("Simplify.Simplify", "real \<Rightarrow> real") $ Free ("t_t", "real")), guh = "pbl_simp_poly", init = ["empty_probl_id"], mathauthors = [], met = [["simplification", "for_polynomials"]],
+           ppc = [("#Given", (Const ("Simplify.Term", "real \<Rightarrow> una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \<Rightarrow> una"), Free ("n_n", "real")))], prls =
+           Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [Eval ("Poly.is_polyexp", fn)], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly:734},
+           where_ = [Const ("Poly.is_polyexp", "real \<Rightarrow> bool") $ Free ("t_t", "real")]}],
+         []),
+       Node
+        ("rational",
+         [{cas = SOME (Const ("Simplify.Simplify", "real \<Rightarrow> real") $ Free ("t_t", "real")), guh = "pbl_simp_rat", init = ["empty_probl_id"], mathauthors = [], met = [["simplification", "of_rationals"]], ppc =
+           [("#Given", (Const ("Simplify.Term", "real \<Rightarrow> una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \<Rightarrow> una"), Free ("n_n", "real")))], prls =
+           Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational:315},
+           where_ = [Const ("Rational.is_ratpolyexp", "real \<Rightarrow> bool") $ Free ("t_t", "real")]}],
+         [Node
+           ("partial_fraction",
+            [{cas = NONE, guh = "pbl_simp_rat_partfrac", init = ["empty_probl_id"], mathauthors = [], met = [["simplification", "of_rationals", "to_partial_fraction"]], ppc =
+              [("#Given", (Const ("Input_Descript.functionTerm", "real \<Rightarrow> una"), Free ("t_t", "real"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Find", (Const ("Partial_Fractions.decomposedFunction", "real \<Rightarrow> una"), Free ("p_p'''", "real")))],
+              prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.Partial_Fractions:136},
+              where_ = []}],
+            [])])]),
+    Node
+     ("vereinfachen",
+      [{cas = SOME (Const ("Simplify.Vereinfache", "real \<Rightarrow> real") $ Free ("t_t", "real")), guh = "pbl_vereinfache", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+        [("#Given", (Const ("Simplify.Term", "real \<Rightarrow> una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \<Rightarrow> una"), Free ("n_n", "real")))], prls =
+        Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify:40},
+        where_ = []}],
+      [Node
+        ("polynom",
+         [{cas = NONE, guh = "pbl_vereinf_poly", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls = Empty, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational, Isac.PolyMinus:199},
+           where_ = []}],
+         [Node
+           ("plus_minus",
+            [{cas = SOME (Const ("Simplify.Vereinfache", "real \<Rightarrow> real") $ Free ("t_t", "real")), guh = "pbl_vereinf_poly_minus", init = ["empty_probl_id"], mathauthors = [], met =
+              [["simplification", "for_polynomials", "with_minus"]], ppc =
+              [("#Given", (Const ("Simplify.Term", "real \<Rightarrow> una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \<Rightarrow> una"), Free ("n_n", "real")))], prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "prls_pbl_vereinf_poly", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Eval ("Poly.is_polyexp", fn), Eval ("Prog_Expr.matchsub", fn), Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a"), Thm ("not_true", "(\<not> True) = False"),
+                 Thm ("not_false", "(\<not> False) = True")],
+                scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational, Isac.PolyMinus:209},
+              where_ =
+              [Const ("Poly.is_polyexp", "real \<Rightarrow> bool") $ Free ("t_t", "real"),
+               Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                 (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                   (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                     (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("a", 0), "?'a1") $
+                       (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $
+                     Free ("t_t", "?'a1")) $
+                   (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                     (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                       (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("a", 0), "?'a1") $
+                         (Const ("Groups.minus_class.minus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $
+                       Free ("t_t", "?'a1")) $
+                     (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                       (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                         (Const ("Groups.minus_class.minus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("a", 0), "?'a1") $
+                           (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $
+                         Free ("t_t", "?'a1")) $
+                       (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                         (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("a", 0), "?'a1") $
+                           (Const ("Groups.minus_class.minus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $
+                         Free ("t_t", "?'a1"))))),
+               Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                 (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                   (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                     (Const ("Groups.times_class.times", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("a", 0), "?'a1") $
+                       (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $
+                     Free ("t_t", "?'a1")) $
+                   (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                     (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                       (Const ("Groups.times_class.times", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("a", 0), "?'a1") $
+                         (Const ("Groups.minus_class.minus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $
+                       Free ("t_t", "?'a1")) $
+                     (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                       (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                         (Const ("Groups.times_class.times", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1")) $
+                           Var (("a", 0), "?'a1")) $
+                         Free ("t_t", "?'a1")) $
+                       (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                         (Const ("Groups.times_class.times", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ (Const ("Groups.minus_class.minus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1")) $
+                           Var (("a", 0), "?'a1")) $
+                         Free ("t_t", "?'a1")))))]}],
+            []),
+          Node
+           ("klammer",
+            [{cas = SOME (Const ("Simplify.Vereinfache", "real \<Rightarrow> real") $ Free ("t_t", "real")), guh = "pbl_vereinf_poly_klammer", init = ["empty_probl_id"], mathauthors = [], met =
+              [["simplification", "for_polynomials", "with_parentheses"]], ppc =
+              [("#Given", (Const ("Simplify.Term", "real \<Rightarrow> una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \<Rightarrow> una"), Free ("n_n", "real")))], prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "prls_pbl_vereinf_poly_klammer", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Eval ("Poly.is_polyexp", fn), Eval ("Prog_Expr.matchsub", fn), Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a"), Thm ("not_true", "(\<not> True) = False"),
+                 Thm ("not_false", "(\<not> False) = True")],
+                scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational, Isac.PolyMinus:219},
+              where_ =
+              [Const ("Poly.is_polyexp", "real \<Rightarrow> bool") $ Free ("t_t", "real"),
+               Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                 (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                   (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                     (Const ("Groups.times_class.times", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("a", 0), "?'a1") $
+                       (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $
+                     Free ("t_t", "?'a1")) $
+                   (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                     (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                       (Const ("Groups.times_class.times", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("a", 0), "?'a1") $
+                         (Const ("Groups.minus_class.minus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $
+                       Free ("t_t", "?'a1")) $
+                     (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                       (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                         (Const ("Groups.times_class.times", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1")) $
+                           Var (("a", 0), "?'a1")) $
+                         Free ("t_t", "?'a1")) $
+                       (Const ("Prog_Expr.matchsub", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                         (Const ("Groups.times_class.times", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ (Const ("Groups.minus_class.minus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1")) $
+                           Var (("a", 0), "?'a1")) $
+                         Free ("t_t", "?'a1")))))]}],
+            []),
+          Node
+           ("binom_klammer",
+            [{cas = SOME (Const ("Simplify.Vereinfache", "real \<Rightarrow> real") $ Free ("t_t", "real")), guh = "pbl_vereinf_poly_klammer_mal", init = ["empty_probl_id"], mathauthors = [], met =
+              [["simplification", "for_polynomials", "with_parentheses_mult"]], ppc =
+              [("#Given", (Const ("Simplify.Term", "real \<Rightarrow> una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \<Rightarrow> una"), Free ("n_n", "real")))], prls =
+              Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [Eval ("Poly.is_polyexp", fn)], scr = Empty_Prog, srls = Empty}, thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational, Isac.PolyMinus:229},
+              where_ = [Const ("Poly.is_polyexp", "real \<Rightarrow> bool") $ Free ("t_t", "real")]}],
+            [])])]),
+    Node
+     ("probe",
+      [{cas = NONE, guh = "pbl_probe", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls = Empty, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational,
+          Isac.PolyMinus:239},
+        where_ = []}],
+      [Node
+        ("polynom",
+         [{cas = SOME (Const ("PolyMinus.Probe", "bool \<Rightarrow> bool list \<Rightarrow> bool") $ Free ("e_e", "bool") $ Free ("w_w", "bool list")), guh = "pbl_probe_poly", init = ["empty_probl_id"], mathauthors = [], met =
+           [["probe", "fuer_polynom"]], ppc =
+           [("#Given", (Const ("PolyMinus.Pruefe", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("PolyMinus.mitWert", "bool list \<Rightarrow> tobooll"), Free ("w_w", "bool list"))),
+            ("#Find", (Const ("PolyMinus.Geprueft", "bool \<Rightarrow> una"), Free ("p_p", "bool")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "prls_pbl_probe_poly", preconds = [], rew_ord = ("dummy_ord", fn), rules = [Eval ("Poly.is_polyexp", fn)], scr = Empty_Prog, srls = Empty},
+           thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational, Isac.PolyMinus:249},
+           where_ = [Const ("Poly.is_polyexp", "real \<Rightarrow> bool") $ Free ("e_e", "real")]}],
+         []),
+       Node
+        ("bruch",
+         [{cas = SOME (Const ("PolyMinus.Probe", "bool \<Rightarrow> bool list \<Rightarrow> bool") $ Free ("e_e", "bool") $ Free ("w_w", "bool list")), guh = "pbl_probe_bruch", init = ["empty_probl_id"], mathauthors = [], met =
+           [["probe", "fuer_bruch"]], ppc =
+           [("#Given", (Const ("PolyMinus.Pruefe", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("PolyMinus.mitWert", "bool list \<Rightarrow> tobooll"), Free ("w_w", "bool list"))),
+            ("#Find", (Const ("PolyMinus.Geprueft", "bool \<Rightarrow> una"), Free ("p_p", "bool")))],
+           prls =
+           Repeat {calc = [], erls = Empty, errpatts = [], id = "prls_pbl_probe_bruch", preconds = [], rew_ord = ("dummy_ord", fn), rules = [Eval ("Rational.is_ratpolyexp", fn)], scr = Empty_Prog, srls = Empty},
+           thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational, Isac.PolyMinus:259},
+           where_ = [Const ("Rational.is_ratpolyexp", "real \<Rightarrow> bool") $ Free ("e_e", "real")]}],
+         [])]),
+    Node
+     ("equation",
+      [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh = "pbl_equ", init =
+        ["empty_probl_id"], mathauthors = [], met = [], ppc =
+        [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+         ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+        prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "equation_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules = [Eval ("Prog_Expr.matches", fn)], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Equation:50},
+        where_ = [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Var (("b", 0), "?'a1")) $ Free ("e_e", "bool")]}],
+      [Node
+        ("univariate",
+         [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh = "pbl_equ_univ",
+           init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+           [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+            ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+           prls =
+           Repeat {calc = [], erls = Empty, errpatts = [], id = "univariate_equation_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules = [Eval ("Prog_Expr.matches", fn)], scr = Empty_Prog, srls = Empty},
+           thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Equation:60},
+           where_ = [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Var (("b", 0), "?'a1")) $ Free ("e_e", "bool")]}],
+         [Node
+           ("rootX",
+            [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+              "pbl_equ_univ_root", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+              [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+              prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "RootEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("RootEq.is_sqrtTerm_in", fn), Eval ("RootEq.is_rootTerm_in", fn),
+                 Eval ("RootEq.is_normSqrtTerm_in", fn), Eval ("HOL.eq", fn), Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"),
+                 Thm ("and_false", "(?a \<and> False) = False"), Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.RootEq:252},
+              where_ =
+              [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("RootEq.is_rootTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                 (Const ("RootEq.is_rootTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.rhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"))]}],
+            [Node
+              ("sq",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_equ_univ_root_sq", init = ["empty_probl_id"], mathauthors = [], met = [["RootEq", "solve_sq_root_equation"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls = Empty, errpatts = [], id = "RootEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                   [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("RootEq.is_sqrtTerm_in", fn), Eval ("RootEq.is_rootTerm_in", fn),
+                    Eval ("RootEq.is_normSqrtTerm_in", fn), Eval ("HOL.eq", fn), Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"),
+                    Thm ("and_false", "(?a \<and> False) = False"), Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.RootEq:262},
+                 where_ =
+                 [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                    (Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                      (Const ("RootEq.is_sqrtTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                      (Const ("RootEq.is_normSqrtTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"))) $
+                    (Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                      (Const ("RootEq.is_sqrtTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.rhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                      (Const ("RootEq.is_normSqrtTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.rhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")))]}],
+               [Node
+                 ("rat",
+                  [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                    "pbl_equ_univ_root_sq_rat", init = ["empty_probl_id"], mathauthors = [], met = [["RootRatEq", "elim_rootrat_equation"]], ppc =
+                    [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                     ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                    prls =
+                    Repeat
+                     {calc = [], erls = Empty, errpatts = [], id = "RootRatEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                      [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("RootEq.is_rootTerm_in", fn),
+                       Eval ("RootRatEq.is_rootRatAddTerm_in", fn), Eval ("HOL.eq", fn), Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"),
+                       Thm ("and_false", "(?a \<and> False) = False"), Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                      scr = Empty_Prog, srls = Empty},
+                    thy =
+                    {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                      HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                      HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base,
+                      HOL.BNF_Def, HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power,
+                      HOL.Groups_Big, HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big,
+                      HOL.Euclidean_Division, HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer,
+                      HOL.Lifting_Set, HOL.List, HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence,
+                      HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick,
+                      HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main,
+                      HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series,
+                      HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac,
+                      Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine,
+                      Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq,
+                      Isac.RootRat, Isac.RootRatEq:108},
+                    where_ =
+                    [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                       (Const ("RootRatEq.is_rootRatAddTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                       (Const ("RootRatEq.is_rootRatAddTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.rhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"))]}],
+                  [])]),
+             Node
+              ("normalise",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_equ_univ_root_norm", init = ["empty_probl_id"], mathauthors = [], met = [["RootEq", "norm_sq_root_equation"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls = Empty, errpatts = [], id = "RootEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                   [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("RootEq.is_sqrtTerm_in", fn), Eval ("RootEq.is_rootTerm_in", fn),
+                    Eval ("RootEq.is_normSqrtTerm_in", fn), Eval ("HOL.eq", fn), Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"),
+                    Thm ("and_false", "(?a \<and> False) = False"), Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.RootEq:272},
+                 where_ =
+                 [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                    (Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                      (Const ("RootEq.is_sqrtTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                      (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                        (Const ("RootEq.is_normSqrtTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")))) $
+                    (Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                      (Const ("RootEq.is_sqrtTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.rhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                      (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                        (Const ("RootEq.is_normSqrtTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.rhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"))))]}],
+               [])]),
+          Node
+           ("LINEAR",
+            [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+              "pbl_equ_univ_lin", init = ["empty_probl_id"], mathauthors = [], met = [["LinEq", "solve_lineq_equation"]], ppc =
+              [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+              prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "LinEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Eval ("HOL.eq", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn),
+                 Eval ("Prog_Expr.occurs_in", fn), Eval ("Prog_Expr.ident", fn), Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"),
+                 Thm ("and_false", "(?a \<and> False) = False"), Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Equation, Isac.LinEq:107},
+              where_ =
+              [Const ("HOL.False", "bool"),
+               Const ("HOL.Not", "bool \<Rightarrow> bool") $ (Const ("Poly.is_polyrat_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")),
+               Const ("HOL.Not", "bool \<Rightarrow> bool") $ (Const ("Poly.is_polyrat_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.rhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")),
+               Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Poly.has_degree_in", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                 Const ("Groups.one_class.one", "real"),
+               Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Poly.has_degree_in", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Prog_Expr.rhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                 Const ("Groups.one_class.one", "real")]}],
+            []),
+          Node
+           ("rational",
+            [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+              "pbl_equ_univ_rat", init = ["empty_probl_id"], mathauthors = [], met = [["RatEq", "solve_rat_equation"]], ppc =
+              [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+              prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "RatEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("RatEq.is_ratequation_in", fn), Eval ("HOL.eq", fn),
+                 Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                 Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.GCD_Poly_ML, Isac.Equation, Isac.Rational, Isac.LinEq, Isac.RatEq:163},
+              where_ = [Const ("RatEq.is_ratequation_in", "bool \<Rightarrow> real \<Rightarrow> bool") $ Free ("e_e", "bool") $ Free ("v_v", "real")]}],
+            []),
+          Node
+           ("polynomial",
+            [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+              "pbl_equ_univ_poly", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+              [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+              prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                 Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                 Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                 Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:502},
+              where_ =
+              [Const ("HOL.Not", "bool \<Rightarrow> bool") $ (Const ("RatEq.is_ratequation_in", "bool \<Rightarrow> real \<Rightarrow> bool") $ Free ("e_e", "bool") $ Free ("v_v", "real")),
+               Const ("HOL.Not", "bool \<Rightarrow> bool") $ (Const ("RootEq.is_rootTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")),
+               Const ("HOL.Not", "bool \<Rightarrow> bool") $ (Const ("RootEq.is_rootTerm_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.rhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"))]}],
+            [Node
+              ("degree_0",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_equ_univ_poly_deg0", init = ["empty_probl_id"], mathauthors = [], met = [["PolyEq", "solve_d0_polyeq_equation"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                   [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                    Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                    Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                    Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:512},
+                 where_ =
+                 [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"),
+                  Const ("Poly.is_poly_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"),
+                  Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Poly.has_degree_in", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                    Const ("Groups.zero_class.zero", "real")]}],
+               []),
+             Node
+              ("degree_1",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_equ_univ_poly_deg1", init = ["empty_probl_id"], mathauthors = [], met = [["PolyEq", "solve_d1_polyeq_equation"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                   [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                    Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                    Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                    Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:522},
+                 where_ =
+                 [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"),
+                  Const ("Poly.is_poly_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"),
+                  Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Poly.has_degree_in", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                    Const ("Groups.one_class.one", "real")]}],
+               []),
+             Node
+              ("degree_2",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_equ_univ_poly_deg2", init = ["empty_probl_id"], mathauthors = [], met = [["PolyEq", "solve_d2_polyeq_equation"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                   [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                    Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                    Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                    Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:532},
+                 where_ =
+                 [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"),
+                  Const ("Poly.is_poly_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"),
+                  Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Poly.has_degree_in", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                    (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))]}],
+               [Node
+                 ("sq_only",
+                  [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                    "pbl_equ_univ_poly_deg2_sqonly", init = ["empty_probl_id"], mathauthors = [], met = [["PolyEq", "solve_d2_polyeq_sqonly_equation"]], ppc =
+                    [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                     ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                    prls =
+                    Repeat
+                     {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                      [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                       Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                       Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                       Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                      scr = Empty_Prog, srls = Empty},
+                    thy =
+                    {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                      HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                      HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base,
+                      HOL.BNF_Def, HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power,
+                      HOL.Groups_Big, HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big,
+                      HOL.Euclidean_Division, HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer,
+                      HOL.Lifting_Set, HOL.List, HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence,
+                      HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick,
+                      HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main,
+                      HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series,
+                      HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac,
+                      Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine,
+                      Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq,
+                      Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:542},
+                    where_ =
+                    [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                       (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                         (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                           (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $
+                             (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                               (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                           Const ("Groups.zero_class.zero", "real")) $
+                         Free ("e_e", "bool")) $
+                       (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                         (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                           (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                             (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $
+                               (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $
+                                 (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                   (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))))) $
+                             Const ("Groups.zero_class.zero", "real")) $
+                           Free ("e_e", "bool")) $
+                         (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                           (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                             (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                               (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))) $
+                               Const ("Groups.zero_class.zero", "real")) $
+                             Free ("e_e", "bool")) $
+                           (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                             (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                               (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $
+                                 (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                   (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                               Const ("Groups.zero_class.zero", "real")) $
+                             Free ("e_e", "bool")))),
+                     Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                       (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                         (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                           (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                             (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $ Var (("v_", 0), "real")) $
+                               (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                             Const ("Groups.zero_class.zero", "real")) $
+                           Free ("e_e", "bool"))) $
+                       (Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                         (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                           (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                             (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                               (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                 (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $
+                                   (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $ Var (("v_", 0), "real"))) $
+                                 (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                   (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                               Const ("Groups.zero_class.zero", "real")) $
+                             Free ("e_e", "bool"))) $
+                         (Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                           (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                             (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                               (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                 (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $ Var (("v_", 0), "real")) $
+                                   (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("c", 0), "real") $
+                                     (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                       (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))))) $
+                                 Const ("Groups.zero_class.zero", "real")) $
+                               Free ("e_e", "bool"))) $
+                           (Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                             (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                               (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                                 (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                   (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                     (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $
+                                       (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $ Var (("v_", 0), "real"))) $
+                                     (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("c", 0), "real") $
+                                       (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                         (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))))) $
+                                   Const ("Groups.zero_class.zero", "real")) $
+                                 Free ("e_e", "bool"))) $
+                             (Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                               (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                                 (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                                   (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                     (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                       (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                         (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                                     Const ("Groups.zero_class.zero", "real")) $
+                                   Free ("e_e", "bool"))) $
+                               (Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                                 (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                                   (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                                     (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                       (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $ Var (("v_", 0), "real")) $
+                                         (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                           (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                                       Const ("Groups.zero_class.zero", "real")) $
+                                     Free ("e_e", "bool"))) $
+                                 (Const ("HOL.conj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                                   (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                                     (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                                       (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                         (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                           (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("c", 0), "real") $
+                                             (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                               (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))))) $
+                                         Const ("Groups.zero_class.zero", "real")) $
+                                       Free ("e_e", "bool"))) $
+                                   (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                                     (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                                       (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                         (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                           (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $ Var (("v_", 0), "real")) $
+                                           (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("c", 0), "real") $
+                                             (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                               (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))))) $
+                                         Const ("Groups.zero_class.zero", "real")) $
+                                       Free ("e_e", "bool")))))))))]}],
+                  []),
+                Node
+                 ("bdv_only",
+                  [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                    "pbl_equ_univ_poly_deg2_bdvonly", init = ["empty_probl_id"], mathauthors = [], met = [["PolyEq", "solve_d2_polyeq_bdvonly_equation"]], ppc =
+                    [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                     ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                    prls =
+                    Repeat
+                     {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                      [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                       Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                       Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                       Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                      scr = Empty_Prog, srls = Empty},
+                    thy =
+                    {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                      HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                      HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base,
+                      HOL.BNF_Def, HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power,
+                      HOL.Groups_Big, HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big,
+                      HOL.Euclidean_Division, HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer,
+                      HOL.Lifting_Set, HOL.List, HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence,
+                      HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick,
+                      HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main,
+                      HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series,
+                      HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac,
+                      Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine,
+                      Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq,
+                      Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:552},
+                    where_ =
+                    [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                       (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                         (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                           (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $ Var (("v_", 0), "real")) $
+                             (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                               (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                           Const ("Groups.zero_class.zero", "real")) $
+                         Free ("e_e", "bool")) $
+                       (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                         (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                           (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                             (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                               (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                             Const ("Groups.zero_class.zero", "real")) $
+                           Free ("e_e", "bool")) $
+                         (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                           (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                             (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                               (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                 (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $
+                                   (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                     (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))))) $
+                               Const ("Groups.zero_class.zero", "real")) $
+                             Free ("e_e", "bool")) $
+                           (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                             (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                               (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                 (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $ Var (("v_", 0), "real")) $
+                                   (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $
+                                     (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                       (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))))) $
+                                 Const ("Groups.zero_class.zero", "real")) $
+                               Free ("e_e", "bool")) $
+                             (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                               (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                                 (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                   (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                     (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))) $
+                                   Const ("Groups.zero_class.zero", "real")) $
+                                 Free ("e_e", "bool")) $
+                               (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                                 (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                   (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $
+                                     (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                       (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                                   Const ("Groups.zero_class.zero", "real")) $
+                                 Free ("e_e", "bool"))))))]}],
+                  []),
+                Node
+                 ("pqFormula",
+                  [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                    "pbl_equ_univ_poly_deg2_pq", init = ["empty_probl_id"], mathauthors = [], met = [["PolyEq", "solve_d2_polyeq_pq_equation"]], ppc =
+                    [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                     ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                    prls =
+                    Repeat
+                     {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                      [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                       Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                       Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                       Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                      scr = Empty_Prog, srls = Empty},
+                    thy =
+                    {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                      HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                      HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base,
+                      HOL.BNF_Def, HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power,
+                      HOL.Groups_Big, HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big,
+                      HOL.Euclidean_Division, HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer,
+                      HOL.Lifting_Set, HOL.List, HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence,
+                      HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick,
+                      HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main,
+                      HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series,
+                      HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac,
+                      Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine,
+                      Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq,
+                      Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:562},
+                    where_ =
+                    [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                       (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                         (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                           (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $
+                             (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Const ("Groups.one_class.one", "real") $
+                               (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))))) $
+                           Const ("Groups.zero_class.zero", "real")) $
+                         Free ("e_e", "bool")) $
+                       (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                         (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                           (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $
+                             (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                               (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                           Const ("Groups.zero_class.zero", "real")) $
+                         Free ("e_e", "bool"))]}],
+                  []),
+                Node
+                 ("abcFormula",
+                  [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                    "pbl_equ_univ_poly_deg2_abc", init = ["empty_probl_id"], mathauthors = [], met = [["PolyEq", "solve_d2_polyeq_abc_equation"]], ppc =
+                    [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                     ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                    prls =
+                    Repeat
+                     {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                      [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                       Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                       Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                       Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                      scr = Empty_Prog, srls = Empty},
+                    thy =
+                    {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                      HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                      HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base,
+                      HOL.BNF_Def, HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power,
+                      HOL.Groups_Big, HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big,
+                      HOL.Euclidean_Division, HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer,
+                      HOL.Lifting_Set, HOL.List, HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence,
+                      HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick,
+                      HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main,
+                      HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series,
+                      HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac,
+                      Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine,
+                      Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq,
+                      Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:572},
+                    where_ =
+                    [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                       (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                         (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                           (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $
+                             (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                               (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                           Const ("Groups.zero_class.zero", "real")) $
+                         Free ("e_e", "bool")) $
+                       (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                         (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                           (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $
+                             (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $
+                               (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("v_", 0), "real") $
+                                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))))) $
+                           Const ("Groups.zero_class.zero", "real")) $
+                         Free ("e_e", "bool"))]}],
+                  [])]),
+             Node
+              ("degree_3",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_equ_univ_poly_deg3", init = ["empty_probl_id"], mathauthors = [], met = [["PolyEq", "solve_d3_polyeq_equation"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                   [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                    Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                    Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                    Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:582},
+                 where_ =
+                 [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"),
+                  Const ("Poly.is_poly_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"),
+                  Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Poly.has_degree_in", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                    (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit1", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))]}],
+               []),
+             Node
+              ("degree_4",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_equ_univ_poly_deg4", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                   [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                    Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                    Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                    Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:592},
+                 where_ =
+                 [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"),
+                  Const ("Poly.is_poly_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"),
+                  Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Poly.has_degree_in", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                    (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))]}],
+               []),
+             Node
+              ("normalise",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_equ_univ_poly_norm", init = ["empty_probl_id"], mathauthors = [], met = [["PolyEq", "normalise_poly"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                   [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                    Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                    Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                    Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:602},
+                 where_ =
+                 [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                    (Const ("HOL.Not", "bool \<Rightarrow> bool") $
+                      (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $
+                        Free ("e_e", "bool"))) $
+                    (Const ("HOL.Not", "bool \<Rightarrow> bool") $ (Const ("Poly.is_poly_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")))]}],
+               [])]),
+          Node
+           ("expanded",
+            [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+              "pbl_equ_univ_expand", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+              [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+              prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                 Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                 Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                 Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:612},
+              where_ =
+              [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"),
+               Const ("Poly.is_expanded_in", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")]}],
+            [Node
+              ("degree_2",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_equ_univ_expand_deg2", init = ["empty_probl_id"], mathauthors = [], met = [["PolyEq", "complete_square"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                   [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                    Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                    Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                    Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq:622},
+                 where_ =
+                 [Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("Poly.has_degree_in", "real \<Rightarrow> real \<Rightarrow> real") $ (Const ("Prog_Expr.lhs", "bool \<Rightarrow> real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $
+                    (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))]}],
+               [])]),
+          Node
+           ("logarithmic",
+            [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+              "pbl_test_equ_univ_log", init = ["empty_probl_id"], mathauthors = [], met = [["Equation", "solve_log"]], ppc =
+              [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+              prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "PolyEq_prls", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn), Eval ("Prog_Expr.lhs", fn), Eval ("Prog_Expr.rhs", fn), Eval ("Poly.is_expanded_in", fn), Eval ("Poly.is_poly_in", fn),
+                 Eval ("Poly.has_degree_in", fn), Eval ("Poly.is_polyrat_in", fn), Eval ("HOL.eq", fn), Eval ("RootEq.is_rootTerm_in", fn), Eval ("RatEq.is_ratequation_in", fn),
+                 Thm ("not_true", "(\<not> True) = False"), Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"),
+                 Thm ("or_true", "(?a \<or> True) = True"), Thm ("or_false", "(?a \<or> False) = ?a")],
+                scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.LogExp:48},
+              where_ =
+              [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                 (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("LogExp.alog", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $ Var (("v_v", 0), "real")) $ Var (("b", 0), "real")) $
+                 Free ("e_e", "bool")]}],
+            [])]),
+       Node
+        ("makeFunctionTo",
+         [{cas = NONE, guh = "pbl_equ_fromfun", init = ["empty_probl_id"], mathauthors = [], met = [["Equation", "fromFunction"]], ppc =
+           [("#Given", (Const ("Input_Descript.functionEq", "bool \<Rightarrow> una"), Free ("fu_n", "bool"))), ("#Given", (Const ("Equation.substitution", "bool \<Rightarrow> una"), Free ("su_b", "bool"))),
+            ("#Find", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("equ'''", "bool")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Integrate, Isac.EqSystem, Isac.Biegelinie:144},
+           where_ = []}],
+         []),
+       Node
+        ("diophantine",
+         [{cas =
+           SOME
+            (
+               Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $
+                 (Const ("Product_Type.prod.case_prod", "(bool \<Rightarrow> int \<Rightarrow> bool \<times> real) \<Rightarrow> bool \<times> int \<Rightarrow> bool \<times> real") $
+                   Abs ("x", "bool", Abs ("y", "int", Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Bound 1 $ (Const ("Int.ring_1_class.of_int", "int \<Rightarrow> real") $ Bound 0))) $
+                   (Const ("Product_Type.Pair", "bool \<Rightarrow> int \<Rightarrow> bool \<times> int") $ Free ("e_e", "bool") $ Free ("v_v", "int")))
+               ),
+           guh = "pbl_equ_dio", init = ["empty_probl_id"], mathauthors = [], met = [["LinEq", "solve_lineq_equation"]], ppc =
+           [("#Given", (Const ("Input_Descript.boolTestGiven", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.intTestGiven", "int \<Rightarrow> una"), Free ("v_v", "int"))),
+            ("#Find", (Const ("Input_Descript.boolTestFind", "bool \<Rightarrow> una"), Free ("s_s", "bool")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Test, Isac.DiophantEq:34},
+           where_ = []}],
+         [])]),
+    Node
+     ("function",
+      [{cas = NONE, guh = "pbl_fun", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls =
+        Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation,
+          Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff:184},
+        where_ = []}],
+      [Node
+        ("derivative_of",
+         [{cas = SOME (Const ("Diff.Diff", "real \<times> real \<Rightarrow> real") $ (Const ("Product_Type.Pair", "real \<Rightarrow> real \<Rightarrow> real \<times> real") $ Free ("f_f", "real") $ Free ("v_v", "real"))), guh = "pbl_fun_deriv", init =
+           ["empty_probl_id"], mathauthors = [], met = [["diff", "differentiate_on_R"], ["diff", "after_simplification"]], ppc =
+           [("#Given", (Const ("Input_Descript.functionTerm", "real \<Rightarrow> una"), Free ("f_f", "real"))), ("#Given", (Const ("Input_Descript.differentiateFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+            ("#Find", (Const ("Input_Descript.derivative", "real \<Rightarrow> una"), Free ("f_f'", "real")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff:194},
+           where_ = []}],
+         [Node
+           ("named",
+            [{cas = SOME (Const ("Diff.Differentiate", "bool \<times> real \<Rightarrow> bool") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("f_f", "bool") $ Free ("v_v", "real"))), guh =
+              "pbl_fun_deriv_nam", init = ["empty_probl_id"], mathauthors = [], met = [["diff", "differentiate_equality"]], ppc =
+              [("#Given", (Const ("Input_Descript.functionEq", "bool \<Rightarrow> una"), Free ("f_f", "bool"))), ("#Given", (Const ("Input_Descript.differentiateFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Find", (Const ("Diff.derivativeEq", "bool \<Rightarrow> una"), Free ("f_f'", "bool")))],
+              prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+                Isac.Diff:204},
+              where_ = []}],
+            [])]),
+       Node
+        ("integrate",
+         [{cas = SOME (Const ("Integrate.Integrate", "real \<times> real \<Rightarrow> real") $ (Const ("Product_Type.Pair", "real \<Rightarrow> real \<Rightarrow> real \<times> real") $ Free ("f_f", "real") $ Free ("v_v", "real"))), guh = "pbl_fun_integ",
+           init = ["empty_probl_id"], mathauthors = [], met = [["diff", "integration"]], ppc =
+           [("#Given", (Const ("Input_Descript.functionTerm", "real \<Rightarrow> una"), Free ("f_f", "real"))), ("#Given", (Const ("Integrate.integrateBy", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+            ("#Find", (Const ("Integrate.antiDerivative", "real \<Rightarrow> una"), Free ("F_F", "real")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Integrate:127},
+           where_ = []}],
+         [Node
+           ("named",
+            [{cas = SOME (Const ("Integrate.Integrate", "real \<times> real \<Rightarrow> real") $ (Const ("Product_Type.Pair", "real \<Rightarrow> real \<Rightarrow> real \<times> real") $ Free ("f_f", "real") $ Free ("v_v", "real"))), guh =
+              "pbl_fun_integ_nam", init = ["empty_probl_id"], mathauthors = [], met = [["diff", "integration", "named"]], ppc =
+              [("#Given", (Const ("Input_Descript.functionTerm", "real \<Rightarrow> una"), Free ("f_f", "real"))), ("#Given", (Const ("Integrate.integrateBy", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Find", (Const ("Integrate.antiDerivativeName", "(real \<Rightarrow> real) \<Rightarrow> una"), Free ("F_F", "real \<Rightarrow> real")))],
+              prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+                Isac.Diff, Isac.Integrate:137},
+              where_ = []}],
+            [])]),
+       Node
+        ("maximum_of",
+         [{cas = NONE, guh = "pbl_fun_max", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+           [("#Given", (Const ("Input_Descript.fixedValues", "bool list \<Rightarrow> nam"), Free ("f_ix", "bool list"))), ("#Find", (Const ("Input_Descript.maximum", "real \<Rightarrow> toreal"), Free ("m_m", "real"))),
+            ("#Find", (Const ("Input_Descript.valuesFor", "real list \<Rightarrow> toreall"), Free ("v_s", "real list"))), ("#Relate", (Const ("Input_Descript.relations", "bool list \<Rightarrow> una"), Free ("r_s", "bool list")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Diff_App:255},
+           where_ = []}],
+         [Node
+           ("on_interval",
+            [{cas = NONE, guh = "pbl_fun_max_interv", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+              [("#Given", (Const ("Input_Descript.functionEq", "bool \<Rightarrow> una"), Free ("t_t", "bool"))), ("#Given", (Const ("Input_Descript.boundVariable", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Given", (Const ("Input_Descript.interval", "real set \<Rightarrow> una"), Free ("i_tv", "real set"))), ("#Find", (Const ("Input_Descript.maxArgument", "bool \<Rightarrow> toreal"), Free ("v_0", "bool")))],
+              prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+                Isac.Diff, Isac.Diff_App:295},
+              where_ = []}],
+            [])]),
+       Node
+        ("make",
+         [{cas = NONE, guh = "pbl_fun_make", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+           [("#Given", (Const ("Input_Descript.functionOf", "real \<Rightarrow> una"), Free ("f_f", "real"))), ("#Given", (Const ("Input_Descript.boundVariable", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+            ("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("eqs", "bool list"))), ("#Find", (Const ("Input_Descript.functionEq", "bool \<Rightarrow> una"), Free ("f_1", "bool")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Diff_App:265},
+           where_ = []}],
+         [Node
+           ("by_explicit",
+            [{cas = NONE, guh = "pbl_fun_max_expl", init = ["empty_probl_id"], mathauthors = [], met = [["Diff_App", "make_fun_by_explicit"]], ppc =
+              [("#Given", (Const ("Input_Descript.functionOf", "real \<Rightarrow> una"), Free ("f_f", "real"))), ("#Given", (Const ("Input_Descript.boundVariable", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("eqs", "bool list"))), ("#Find", (Const ("Input_Descript.functionEq", "bool \<Rightarrow> una"), Free ("f_1", "bool")))],
+              prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+                Isac.Diff, Isac.Diff_App:275},
+              where_ = []}],
+            []),
+          Node
+           ("by_new_variable",
+            [{cas = NONE, guh = "pbl_fun_max_newvar", init = ["empty_probl_id"], mathauthors = [], met = [["Diff_App", "make_fun_by_new_variable"]], ppc =
+              [("#Given", (Const ("Input_Descript.functionOf", "real \<Rightarrow> una"), Free ("f_f", "real"))), ("#Given", (Const ("Input_Descript.boundVariable", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("eqs", "bool list"))), ("#Find", (Const ("Input_Descript.functionEq", "bool \<Rightarrow> una"), Free ("f_1", "bool")))],
+              prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+                Isac.Diff, Isac.Diff_App:285},
+              where_ = []}],
+            [])])]),
+    Node
+     ("system",
+      [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \<Rightarrow> real list \<Rightarrow> bool list") $ Free ("e_s", "bool list") $ Free ("v_s", "real list")), guh = "pbl_equsys", init = ["empty_probl_id"], mathauthors =
+        [], met = [], ppc =
+        [("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("e_s", "bool list"))), ("#Given", (Const ("EqSystem.solveForVars", "real list \<Rightarrow> toreall"), Free ("v_s", "real list"))),
+         ("#Find", (Const ("EqSystem.solution", "bool list \<Rightarrow> toreall"), Free ("ss'''", "bool list")))],
+        prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation,
+          Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Integrate, Isac.EqSystem:188},
+        where_ = []}],
+      [Node
+        ("LINEAR",
+         [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \<Rightarrow> real list \<Rightarrow> bool list") $ Free ("e_s", "bool list") $ Free ("v_s", "real list")), guh = "pbl_equsys_lin", init = ["empty_probl_id"],
+           mathauthors = [], met = [], ppc =
+           [("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("e_s", "bool list"))), ("#Given", (Const ("EqSystem.solveForVars", "real list \<Rightarrow> toreall"), Free ("v_s", "real list"))),
+            ("#Find", (Const ("EqSystem.solution", "bool list \<Rightarrow> toreall"), Free ("ss'''", "bool list")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Integrate, Isac.EqSystem:198},
+           where_ = []}],
+         [Node
+           ("2x2",
+            [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \<Rightarrow> real list \<Rightarrow> bool list") $ Free ("e_s", "bool list") $ Free ("v_s", "real list")), guh = "pbl_equsys_lin_2x2", init = ["empty_probl_id"],
+              mathauthors = [], met = [], ppc =
+              [("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("e_s", "bool list"))),
+               ("#Given", (Const ("EqSystem.solveForVars", "real list \<Rightarrow> toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \<Rightarrow> toreall"), Free ("ss'''", "bool list")))],
+              prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "prls_2x2_linear_system", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Thm ("LENGTH_CONS", "Length (?x # ?xs) = 1 + Length ?xs"), Thm ("LENGTH_NIL", "Length [] = 0"), Eval ("Groups.plus_class.plus", fn), Eval ("HOL.eq", fn)], scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+                Isac.Diff, Isac.Integrate, Isac.EqSystem:208},
+              where_ =
+              [Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("ListC.Length", "bool list \<Rightarrow> real") $ Free ("e_s", "bool list")) $
+                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))),
+               Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("ListC.Length", "?'a list \<Rightarrow> real") $ Free ("v_s", "?'a list")) $
+                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))]}],
+            [Node
+              ("triangular",
+               [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \<Rightarrow> real list \<Rightarrow> bool list") $ Free ("e_s", "bool list") $ Free ("v_s", "real list")), guh = "pbl_equsys_lin_2x2_tri", init =
+                 ["empty_probl_id"], mathauthors = [], met = [["EqSystem", "top_down_substitution", "2x2"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("e_s", "bool list"))),
+                  ("#Given", (Const ("EqSystem.solveForVars", "real list \<Rightarrow> toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \<Rightarrow> toreall"), Free ("ss'''", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls =
+                   Repeat
+                    {calc = [], erls = Empty, errpatts = [], id = "erls_prls_triangular", preconds = [], rew_ord = ("Rewrite_Ord.id_empty", fn), rules =
+                     [Eval ("Orderings.ord_class.less", fn), Eval ("Groups.plus_class.plus", fn), Eval ("EqSystem.occur_exactly_in", fn)], scr = Empty_Prog, srls = Empty},
+                   errpatts = [], id = "prls_triangular", preconds = [], rew_ord = ("Rewrite_Ord.id_empty", fn), rules =
+                   [Thm ("NTH_CONS", "1 < ?n \<Longrightarrow> NTH ?n (?x # ?xs) = NTH (?n + - 1) ?xs"), Eval ("Groups.plus_class.plus", fn), Thm ("NTH_NIL", "NTH 1 (?x # ?xs) = ?x"), Thm ("tl_Cons", "tl (?x # ?xs) = ?xs"),
+                    Thm ("tl_Nil", "tl [] = []"), Eval ("EqSystem.occur_exactly_in", fn)],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq,
+                   Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Integrate, Isac.EqSystem:218},
+                 where_ =
+                 [Const ("EqSystem.occur_exactly_in", "real list \<Rightarrow> real list \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("List.list.tl", "real list \<Rightarrow> real list") $ Free ("v_s", "real list")) $ Free ("v_s", "real list") $
+                    (Const ("ListC.NTH", "real \<Rightarrow> bool list \<Rightarrow> bool") $ Const ("Groups.one_class.one", "real") $ Free ("e_s", "bool list")),
+                  Const ("EqSystem.occur_exactly_in", "real list \<Rightarrow> real list \<Rightarrow> bool \<Rightarrow> bool") $ Free ("v_s", "real list") $ Free ("v_s", "real list") $
+                    (Const ("ListC.NTH", "real \<Rightarrow> bool list \<Rightarrow> bool") $ (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))) $
+                      Free ("e_s", "bool list"))]}],
+               []),
+             Node
+              ("normalise",
+               [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \<Rightarrow> real list \<Rightarrow> bool list") $ Free ("e_s", "bool list") $ Free ("v_s", "real list")), guh = "pbl_equsys_lin_2x2_norm", init =
+                 ["empty_probl_id"], mathauthors = [], met = [["EqSystem", "normalise", "2x2"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("e_s", "bool list"))),
+                  ("#Given", (Const ("EqSystem.solveForVars", "real list \<Rightarrow> toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \<Rightarrow> toreall"), Free ("ss'''", "bool list")))],
+                 prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq,
+                   Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Integrate, Isac.EqSystem:228},
+                 where_ = []}],
+               [])]),
+          Node
+           ("3x3",
+            [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \<Rightarrow> real list \<Rightarrow> bool list") $ Free ("e_s", "bool list") $ Free ("v_s", "real list")), guh = "pbl_equsys_lin_3x3", init = ["empty_probl_id"],
+              mathauthors = [], met = [], ppc =
+              [("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("e_s", "bool list"))),
+               ("#Given", (Const ("EqSystem.solveForVars", "real list \<Rightarrow> toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \<Rightarrow> toreall"), Free ("ss'''", "bool list")))],
+              prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "prls_3x3_linear_system", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Thm ("LENGTH_CONS", "Length (?x # ?xs) = 1 + Length ?xs"), Thm ("LENGTH_NIL", "Length [] = 0"), Eval ("Groups.plus_class.plus", fn), Eval ("HOL.eq", fn)], scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+                Isac.Diff, Isac.Integrate, Isac.EqSystem:238},
+              where_ =
+              [Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("ListC.Length", "bool list \<Rightarrow> real") $ Free ("e_s", "bool list")) $
+                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit1", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))),
+               Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("ListC.Length", "?'a list \<Rightarrow> real") $ Free ("v_s", "?'a list")) $
+                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit1", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))]}],
+            []),
+          Node
+           ("4x4",
+            [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \<Rightarrow> real list \<Rightarrow> bool list") $ Free ("e_s", "bool list") $ Free ("v_s", "real list")), guh = "pbl_equsys_lin_4x4", init = ["empty_probl_id"],
+              mathauthors = [], met = [], ppc =
+              [("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("e_s", "bool list"))),
+               ("#Given", (Const ("EqSystem.solveForVars", "real list \<Rightarrow> toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \<Rightarrow> toreall"), Free ("ss'''", "bool list")))],
+              prls =
+              Repeat
+               {calc = [], erls = Empty, errpatts = [], id = "prls_4x4_linear_system", preconds = [], rew_ord = ("dummy_ord", fn), rules =
+                [Thm ("LENGTH_CONS", "Length (?x # ?xs) = 1 + Length ?xs"), Thm ("LENGTH_NIL", "Length [] = 0"), Eval ("Groups.plus_class.plus", fn), Eval ("HOL.eq", fn)], scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+                Isac.Diff, Isac.Integrate, Isac.EqSystem:248},
+              where_ =
+              [Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("ListC.Length", "bool list \<Rightarrow> real") $ Free ("e_s", "bool list")) $
+                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))),
+               Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $ (Const ("ListC.Length", "?'a list \<Rightarrow> real") $ Free ("v_s", "?'a list")) $
+                 (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))]}],
+            [Node
+              ("triangular",
+               [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \<Rightarrow> real list \<Rightarrow> bool list") $ Free ("e_s", "bool list") $ Free ("v_s", "real list")), guh = "pbl_equsys_lin_4x4_tri", init =
+                 ["empty_probl_id"], mathauthors = [], met = [["EqSystem", "top_down_substitution", "4x4"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("e_s", "bool list"))),
+                  ("#Given", (Const ("EqSystem.solveForVars", "real list \<Rightarrow> toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \<Rightarrow> toreall"), Free ("ss'''", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc = [], erls =
+                   Repeat
+                    {calc = [], erls = Empty, errpatts = [], id = "erls_prls_triangular", preconds = [], rew_ord = ("Rewrite_Ord.id_empty", fn), rules =
+                     [Eval ("Orderings.ord_class.less", fn), Eval ("Groups.plus_class.plus", fn), Eval ("EqSystem.occur_exactly_in", fn)], scr = Empty_Prog, srls = Empty},
+                   errpatts = [], id = "prls_tri_4x4_lin_sys", preconds = [], rew_ord = ("Rewrite_Ord.id_empty", fn), rules =
+                   [Thm ("NTH_CONS", "1 < ?n \<Longrightarrow> NTH ?n (?x # ?xs) = NTH (?n + - 1) ?xs"), Eval ("Groups.plus_class.plus", fn), Thm ("NTH_NIL", "NTH 1 (?x # ?xs) = ?x"), Thm ("tl_Cons", "tl (?x # ?xs) = ?xs"),
+                    Thm ("tl_Nil", "tl [] = []"), Eval ("EqSystem.occur_exactly_in", fn), Eval ("Prog_Expr.occurs_in", fn)],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq,
+                   Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Integrate, Isac.EqSystem:258},
+                 where_ =
+                 [Const ("Prog_Expr.occurs_in", "real \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("ListC.NTH", "real \<Rightarrow> real list \<Rightarrow> real") $ Const ("Groups.one_class.one", "real") $ Free ("v_s", "real list")) $
+                    (Const ("ListC.NTH", "real \<Rightarrow> bool list \<Rightarrow> bool") $ Const ("Groups.one_class.one", "real") $ Free ("e_s", "bool list")),
+                  Const ("Prog_Expr.occurs_in", "real \<Rightarrow> bool \<Rightarrow> bool") $
+                    (Const ("ListC.NTH", "real \<Rightarrow> real list \<Rightarrow> real") $ (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))) $
+                      Free ("v_s", "real list")) $
+                    (Const ("ListC.NTH", "real \<Rightarrow> bool list \<Rightarrow> bool") $ (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))) $
+                      Free ("e_s", "bool list")),
+                  Const ("Prog_Expr.occurs_in", "real \<Rightarrow> bool \<Rightarrow> bool") $
+                    (Const ("ListC.NTH", "real \<Rightarrow> real list \<Rightarrow> real") $ (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit1", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))) $
+                      Free ("v_s", "real list")) $
+                    (Const ("ListC.NTH", "real \<Rightarrow> bool list \<Rightarrow> bool") $ (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit1", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))) $
+                      Free ("e_s", "bool list")),
+                  Const ("Prog_Expr.occurs_in", "real \<Rightarrow> bool \<Rightarrow> bool") $
+                    (Const ("ListC.NTH", "real \<Rightarrow> real list \<Rightarrow> real") $
+                      (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))) $
+                      Free ("v_s", "real list")) $
+                    (Const ("ListC.NTH", "real \<Rightarrow> bool list \<Rightarrow> bool") $
+                      (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))) $
+                      Free ("e_s", "bool list"))]}],
+               []),
+             Node
+              ("normalise",
+               [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \<Rightarrow> real list \<Rightarrow> bool list") $ Free ("e_s", "bool list") $ Free ("v_s", "real list")), guh = "pbl_equsys_lin_4x4_norm", init =
+                 ["empty_probl_id"], mathauthors = [], met = [["EqSystem", "normalise", "4x4"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equalities", "bool list \<Rightarrow> tobooll"), Free ("e_s", "bool list"))),
+                  ("#Given", (Const ("EqSystem.solveForVars", "real list \<Rightarrow> toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \<Rightarrow> toreall"), Free ("ss'''", "bool list")))],
+                 prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq,
+                   Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Integrate, Isac.EqSystem:268},
+                 where_ = []}],
+               [])])])]),
+    Node
+     ("Biegelinien",
+      [{cas = NONE, guh = "pbl_bieg", init = ["empty_probl_id"], mathauthors = [], met = [["IntegrierenUndKonstanteBestimmen2"]], ppc =
+        [("#Given", (Const ("Biegelinie.Traegerlaenge", "real \<Rightarrow> una"), Free ("l_l", "real"))), ("#Given", (Const ("Biegelinie.Streckenlast", "real \<Rightarrow> una"), Free ("q_q", "real"))),
+         ("#Find", (Const ("Biegelinie.Biegelinie", "(real \<Rightarrow> real) \<Rightarrow> una"), Free ("b_b", "real \<Rightarrow> real"))), ("#Relate", (Const ("Biegelinie.Randbedingungen", "bool list \<Rightarrow> una"), Free ("r_b", "bool list")))],
+        prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation,
+          Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Integrate, Isac.EqSystem,
+          Isac.Biegelinie:74},
+        where_ = []}],
+      [Node
+        ("MomentBestimmte",
+         [{cas = NONE, guh = "pbl_bieg_mom", init = ["empty_probl_id"], mathauthors = [], met = [["IntegrierenUndKonstanteBestimmen"]], ppc =
+           [("#Given", (Const ("Biegelinie.Traegerlaenge", "real \<Rightarrow> una"), Free ("l_l", "real"))), ("#Given", (Const ("Biegelinie.Streckenlast", "real \<Rightarrow> una"), Free ("q_q", "real"))),
+            ("#Find", (Const ("Biegelinie.Biegelinie", "(real \<Rightarrow> real) \<Rightarrow> una"), Free ("b_b", "real \<Rightarrow> real"))),
+            ("#Relate", (Const ("Biegelinie.RandbedingungenBiegung", "bool list \<Rightarrow> una"), Free ("r_b", "bool list"))),
+            ("#Relate", (Const ("Biegelinie.RandbedingungenMoment", "bool list \<Rightarrow> una"), Free ("r_m", "bool list")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Integrate, Isac.EqSystem, Isac.Biegelinie:84},
+           where_ = []}],
+         []),
+       Node
+        ("MomentGegebene",
+         [{cas = NONE, guh = "pbl_bieg_momg", init = ["empty_probl_id"], mathauthors = [], met = [["IntegrierenUndKonstanteBestimmen", "2xIntegrieren"]], ppc = [], prls =
+           Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Integrate, Isac.EqSystem, Isac.Biegelinie:94},
+           where_ = []}],
+         []),
+       Node
+        ("einfache",
+         [{cas = NONE, guh = "pbl_bieg_einf", init = ["empty_probl_id"], mathauthors = [], met = [["IntegrierenUndKonstanteBestimmen", "4x4System"]], ppc = [], prls =
+           Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Integrate, Isac.EqSystem, Isac.Biegelinie:104},
+           where_ = []}],
+         []),
+       Node
+        ("QuerkraftUndMomentBestimmte",
+         [{cas = NONE, guh = "pbl_bieg_momquer", init = ["empty_probl_id"], mathauthors = [], met = [["IntegrierenUndKonstanteBestimmen", "1xIntegrieren"]], ppc = [], prls =
+           Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Integrate, Isac.EqSystem, Isac.Biegelinie:114},
+           where_ = []}],
+         []),
+       Node
+        ("vonBelastungZu",
+         [{cas = NONE, guh = "pbl_bieg_vonq", init = ["empty_probl_id"], mathauthors = [], met = [["Biegelinien", "ausBelastung"]], ppc =
+           [("#Given", (Const ("Biegelinie.Streckenlast", "real \<Rightarrow> una"), Free ("q_q", "real"))), ("#Given", (Const ("Biegelinie.FunktionsVariable", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+            ("#Find", (Const ("Biegelinie.Funktionen", "bool list \<Rightarrow> una"), Free ("funs'''", "bool list")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Integrate, Isac.EqSystem, Isac.Biegelinie:124},
+           where_ = []}],
+         []),
+       Node
+        ("setzeRandbedingungen",
+         [{cas = NONE, guh = "pbl_bieg_randbed", init = ["empty_probl_id"], mathauthors = [], met = [["Biegelinien", "setzeRandbedingungenEin"]], ppc =
+           [("#Given", (Const ("Biegelinie.Funktionen", "bool list \<Rightarrow> una"), Free ("fun_s", "bool list"))), ("#Given", (Const ("Biegelinie.Randbedingungen", "bool list \<Rightarrow> una"), Free ("r_b", "bool list"))),
+            ("#Find", (Const ("Biegelinie.Gleichungen", "bool list \<Rightarrow> una"), Free ("equs'''", "bool list")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Integrate, Isac.EqSystem, Isac.Biegelinie:134},
+           where_ = []}],
+         [])]),
+    Node
+     ("Berechnung",
+      [{cas = NONE, guh = "pbl_algein", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls =
+        Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational,
+          Isac.AlgEin:30},
+        where_ = []}],
+      [Node
+        ("numerischSymbolische",
+         [{cas = NONE, guh = "pbl_algein_numsym", init = ["empty_probl_id"], mathauthors = [], met = [["Berechnung", "erstNumerisch"], ["Berechnung", "erstSymbolisch"]], ppc =
+           [("#Given", (Const ("AlgEin.KantenLaenge", "bool \<Rightarrow> una"), Free ("k_k", "bool"))), ("#Given", (Const ("AlgEin.Querschnitt", "bool \<Rightarrow> una"), Free ("q__q", "bool"))),
+            ("#Given", (Const ("AlgEin.KantenUnten", "bool list \<Rightarrow> una"), Free ("u_u", "bool list"))), ("#Given", (Const ("AlgEin.KantenSenkrecht", "bool list \<Rightarrow> una"), Free ("s_s", "bool list"))),
+            ("#Given", (Const ("AlgEin.KantenOben", "bool list \<Rightarrow> una"), Free ("o_o", "bool list"))), ("#Find", (Const ("AlgEin.GesamtLaenge", "real \<Rightarrow> una"), Free ("l_l", "real")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational, Isac.AlgEin:40},
+           where_ = []}],
+         [])]),
+    Node
+     ("Programming",
+      [{cas = NONE, guh = "pbl_Programming", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls =
+        Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational,
+          Isac.InsSort:124},
+        where_ = []}],
+      [Node
+        ("SORT",
+         [{cas = NONE, guh = "pbl_Prog_sort", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls =
+           Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational, Isac.InsSort:134},
+           where_ = []}],
+         [Node
+           ("insertion",
+            [{cas = SOME (Const ("InsSort.Sort", "int xlist \<Rightarrow> int xlist") $ Free ("u_u", "int xlist")), guh = "pbl_Prog_sort_ins", init = ["empty_probl_id"], mathauthors = [], met =
+              [["Programming", "SORT", "insertion_steps"]], ppc =
+              [("#Given", (Const ("InsSort.unsorted", "int xlist \<Rightarrow> unl"), Free ("u_u", "int xlist"))), ("#Find", (Const ("InsSort.sorted", "int xlist \<Rightarrow> unl"), Free ("s_s", "int xlist")))], prls =
+              Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.GCD_Poly_ML, Isac.Rational, Isac.InsSort:144},
+              where_ = []}],
+            [])])]),
+    Node
+     ("test",
+      [{cas = NONE, guh = "pbl_test", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls =
+        Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation,
+          Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Test:397},
+        where_ = []}],
+      [Node
+        ("equation",
+         [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh = "pbl_test_equ",
+           init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+           [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+            ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+           prls =
+           Repeat
+            {calc =
+             [("is_num", ("Prog_Expr.is_num", fn)), ("matches", ("Prog_Expr.matches", fn)), ("PLUS", ("Groups.plus_class.plus", fn)), ("TIMES", ("Groups.times_class.times", fn)),
+              ("POWER", ("BaseDefinitions.realpow", fn)), ("le", ("Orderings.ord_class.less", fn)), ("leq", ("Orderings.ord_class.less_eq", fn)), ("ident", ("Prog_Expr.ident", fn))],
+             erls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, errpatts = [], id = "matches",
+             preconds = [], rew_ord = ("termlessI", fn), rules =
+             [Thm ("refl", "?t = ?t"), Thm ("order_refl", "?x \<le> ?x"), Thm ("radd_left_cancel_le", "(?k + ?m \<le> ?k + ?n) = (?m \<le> ?n)"), Thm ("not_true", "(\<not> True) = False"),
+              Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"), Thm ("or_true", "(?a \<or> True) = True"),
+              Thm ("or_false", "(?a \<or> False) = ?a"), Thm ("and_commute", "(?a \<and> ?b) = (?b \<and> ?a)"), Thm ("or_commute", "(?a \<or> ?b) = (?b \<or> ?a)"), Eval ("Prog_Expr.is_num", fn), Eval ("Prog_Expr.matches", fn),
+              Eval ("Groups.plus_class.plus", fn), Eval ("Groups.times_class.times", fn), Eval ("BaseDefinitions.realpow", fn), Eval ("Orderings.ord_class.less", fn), Eval ("Orderings.ord_class.less_eq", fn),
+              Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn)],
+             scr = Empty_Prog, srls = Empty},
+           thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Test:407},
+           where_ = [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Var (("b", 0), "?'a1")) $ Free ("e_e", "bool")]}],
+         [Node
+           ("univariate",
+            [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh = "pbl_test_uni",
+              init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+              [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+               ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+              prls =
+              Repeat
+               {calc =
+                [("is_num", ("Prog_Expr.is_num", fn)), ("matches", ("Prog_Expr.matches", fn)), ("PLUS", ("Groups.plus_class.plus", fn)), ("TIMES", ("Groups.times_class.times", fn)),
+                 ("POWER", ("BaseDefinitions.realpow", fn)), ("le", ("Orderings.ord_class.less", fn)), ("leq", ("Orderings.ord_class.less_eq", fn)), ("ident", ("Prog_Expr.ident", fn))],
+                erls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, errpatts = [], id = "matches",
+                preconds = [], rew_ord = ("termlessI", fn), rules =
+                [Thm ("refl", "?t = ?t"), Thm ("order_refl", "?x \<le> ?x"), Thm ("radd_left_cancel_le", "(?k + ?m \<le> ?k + ?n) = (?m \<le> ?n)"), Thm ("not_true", "(\<not> True) = False"),
+                 Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"), Thm ("or_true", "(?a \<or> True) = True"),
+                 Thm ("or_false", "(?a \<or> False) = ?a"), Thm ("and_commute", "(?a \<and> ?b) = (?b \<and> ?a)"), Thm ("or_commute", "(?a \<or> ?b) = (?b \<or> ?a)"), Eval ("Prog_Expr.is_num", fn), Eval ("Prog_Expr.matches", fn),
+                 Eval ("Groups.plus_class.plus", fn), Eval ("Groups.times_class.times", fn), Eval ("BaseDefinitions.realpow", fn), Eval ("Orderings.ord_class.less", fn), Eval ("Orderings.ord_class.less_eq", fn),
+                 Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn)],
+                scr = Empty_Prog, srls = Empty},
+              thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+                Isac.Diff, Isac.Test:417},
+              where_ = [Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Var (("a", 0), "?'a1") $ Var (("b", 0), "?'a1")) $ Free ("e_e", "bool")]}],
+            [Node
+              ("LINEAR",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_test_uni_lin", init = ["empty_probl_id"], mathauthors = [], met = [["Test", "solve_linear"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc =
+                   [("is_num", ("Prog_Expr.is_num", fn)), ("matches", ("Prog_Expr.matches", fn)), ("PLUS", ("Groups.plus_class.plus", fn)), ("TIMES", ("Groups.times_class.times", fn)),
+                    ("POWER", ("BaseDefinitions.realpow", fn)), ("le", ("Orderings.ord_class.less", fn)), ("leq", ("Orderings.ord_class.less_eq", fn)), ("ident", ("Prog_Expr.ident", fn))],
+                   erls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, errpatts = [], id = "matches",
+                   preconds = [], rew_ord = ("termlessI", fn), rules =
+                   [Thm ("refl", "?t = ?t"), Thm ("order_refl", "?x \<le> ?x"), Thm ("radd_left_cancel_le", "(?k + ?m \<le> ?k + ?n) = (?m \<le> ?n)"), Thm ("not_true", "(\<not> True) = False"),
+                    Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"), Thm ("or_true", "(?a \<or> True) = True"),
+                    Thm ("or_false", "(?a \<or> False) = ?a"), Thm ("and_commute", "(?a \<and> ?b) = (?b \<and> ?a)"), Thm ("or_commute", "(?a \<or> ?b) = (?b \<or> ?a)"), Eval ("Prog_Expr.is_num", fn),
+                    Eval ("Prog_Expr.matches", fn), Eval ("Groups.plus_class.plus", fn), Eval ("Groups.times_class.times", fn), Eval ("BaseDefinitions.realpow", fn), Eval ("Orderings.ord_class.less", fn),
+                    Eval ("Orderings.ord_class.less_eq", fn), Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn)],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq,
+                   Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Test:427},
+                 where_ =
+                 [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                    (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $ (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ Free ("v_v", "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool")) $
+                    (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                      (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                        (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ (Const ("Groups.times_class.times", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Free ("v_v", "?'a1")) $
+                          Const ("Groups.zero_class.zero", "?'a1")) $
+                        Free ("e_e", "bool")) $
+                      (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                        (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                          (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $ (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("a", 0), "?'a1") $ Free ("v_v", "?'a1")) $
+                            Const ("Groups.zero_class.zero", "?'a1")) $
+                          Free ("e_e", "bool")) $
+                        (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                          (Const ("HOL.eq", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> bool") $
+                            (Const ("Groups.plus_class.plus", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("a", 0), "?'a1") $
+                              (Const ("Groups.times_class.times", "?'a1 \<Rightarrow> ?'a1 \<Rightarrow> ?'a1") $ Var (("b", 0), "?'a1") $ Free ("v_v", "?'a1"))) $
+                            Const ("Groups.zero_class.zero", "?'a1")) $
+                          Free ("e_e", "bool"))))]}],
+               []),
+             Node
+              ("plain_square",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_test_uni_plain2", init = ["empty_probl_id"], mathauthors = [], met = [["Test", "solve_plain_square"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat
+                  {calc =
+                   [("is_num", ("Prog_Expr.is_num", fn)), ("matches", ("Prog_Expr.matches", fn)), ("PLUS", ("Groups.plus_class.plus", fn)), ("TIMES", ("Groups.times_class.times", fn)),
+                    ("POWER", ("BaseDefinitions.realpow", fn)), ("le", ("Orderings.ord_class.less", fn)), ("leq", ("Orderings.ord_class.less_eq", fn)), ("ident", ("Prog_Expr.ident", fn))],
+                   erls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, errpatts = [], id = "matches",
+                   preconds = [], rew_ord = ("termlessI", fn), rules =
+                   [Thm ("refl", "?t = ?t"), Thm ("order_refl", "?x \<le> ?x"), Thm ("radd_left_cancel_le", "(?k + ?m \<le> ?k + ?n) = (?m \<le> ?n)"), Thm ("not_true", "(\<not> True) = False"),
+                    Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"), Thm ("or_true", "(?a \<or> True) = True"),
+                    Thm ("or_false", "(?a \<or> False) = ?a"), Thm ("and_commute", "(?a \<and> ?b) = (?b \<and> ?a)"), Thm ("or_commute", "(?a \<or> ?b) = (?b \<or> ?a)"), Eval ("Prog_Expr.is_num", fn),
+                    Eval ("Prog_Expr.matches", fn), Eval ("Groups.plus_class.plus", fn), Eval ("Groups.times_class.times", fn), Eval ("BaseDefinitions.realpow", fn), Eval ("Orderings.ord_class.less", fn),
+                    Eval ("Orderings.ord_class.less_eq", fn), Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.matches", fn)],
+                   scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq,
+                   Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Test:475},
+                 where_ =
+                 [Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                    (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                      (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                        (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $
+                          (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $
+                            (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("v_v", "real") $
+                              (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))))) $
+                        Const ("Groups.zero_class.zero", "real")) $
+                      Free ("e_e", "bool")) $
+                    (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                      (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                        (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                          (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("b", 0), "real") $
+                            (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("v_v", "real") $
+                              (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                          Const ("Groups.zero_class.zero", "real")) $
+                        Free ("e_e", "bool")) $
+                      (Const ("HOL.disj", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                        (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                          (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                            (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $ Var (("a", 0), "real") $
+                              (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("v_v", "real") $
+                                (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                            Const ("Groups.zero_class.zero", "real")) $
+                          Free ("e_e", "bool")) $
+                        (Const ("Prog_Expr.matches", "bool \<Rightarrow> bool \<Rightarrow> bool") $
+                          (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                            (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("v_v", "real") $
+                              (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))) $
+                            Const ("Groups.zero_class.zero", "real")) $
+                          Free ("e_e", "bool"))))]}],
+               []),
+             Node
+              ("polynomial",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_test_uni_poly", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+                 [("#Given",
+                   (Const ("Input_Descript.equality", "bool \<Rightarrow> una"),
+                    Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                      (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                        (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                          (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("v_v", "real") $
+                            (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))) $
+                          (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("p_p", "real") $ Free ("v_v", "real"))) $
+                        Free ("q__q", "real")) $
+                      Const ("Groups.zero_class.zero", "real"))),
+                  ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))), ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq,
+                   Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Test:485},
+                 where_ = [Const ("HOL.False", "bool")]}],
+               [Node
+                 ("degree_two",
+                  [{cas =
+                    SOME
+                     (
+                        Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $
+                          (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $
+                            (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                              (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                  (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("v_v", "real") $
+                                    (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))) $
+                                  (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("p_p", "real") $ Free ("v_v", "real"))) $
+                                Free ("q__q", "real")) $
+                              Const ("Groups.zero_class.zero", "real")) $
+                            Free ("v_v", "real"))
+                        ),
+                    guh = "pbl_test_uni_poly_deg2", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+                    [("#Given",
+                      (Const ("Input_Descript.equality", "bool \<Rightarrow> una"),
+                       Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                         (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                           (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                             (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("v_v", "real") $
+                               (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))) $
+                             (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("p_p", "real") $ Free ("v_v", "real"))) $
+                           Free ("q__q", "real")) $
+                         Const ("Groups.zero_class.zero", "real"))),
+                     ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))), ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                    prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+                    {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                      HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                      HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base,
+                      HOL.BNF_Def, HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power,
+                      HOL.Groups_Big, HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big,
+                      HOL.Euclidean_Division, HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer,
+                      HOL.Lifting_Set, HOL.List, HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence,
+                      HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick,
+                      HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main,
+                      HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series,
+                      HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac,
+                      Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine,
+                      Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq,
+                      Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Test:495},
+                    where_ = []}],
+                  [Node
+                    ("pq_formula",
+                     [{cas =
+                       SOME
+                        (
+                           Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $
+                             (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $
+                               (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                 (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                   (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                     (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("v_v", "real") $
+                                       (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))) $
+                                     (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("p_p", "real") $ Free ("v_v", "real"))) $
+                                   Free ("q__q", "real")) $
+                                 Const ("Groups.zero_class.zero", "real")) $
+                               Free ("v_v", "real"))
+                           ),
+                       guh = "pbl_test_uni_poly_deg2_pq", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+                       [("#Given",
+                         (Const ("Input_Descript.equality", "bool \<Rightarrow> una"),
+                          Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                            (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                              (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("v_v", "real") $
+                                  (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num")))) $
+                                (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("p_p", "real") $ Free ("v_v", "real"))) $
+                              Free ("q__q", "real")) $
+                            Const ("Groups.zero_class.zero", "real"))),
+                        ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                        ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                       prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+                       {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                         HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                         HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base,
+                         HOL.BNF_Def, HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power,
+                         HOL.Groups_Big, HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big,
+                         HOL.Euclidean_Division, HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer,
+                         HOL.Lifting_Set, HOL.List, HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence,
+                         HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick,
+                         HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main,
+                         HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series,
+                         HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program,
+                         Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret,
+                         Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq,
+                         Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Test:505},
+                       where_ = []}],
+                     []),
+                   Node
+                    ("abc_formula",
+                     [{cas =
+                       SOME
+                        (
+                           Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $
+                             (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $
+                               (Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                                 (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                   (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                     (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("a_a", "real") $
+                                       (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("x", "real") $
+                                         (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                                     (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("b_b", "real") $ Free ("x", "real"))) $
+                                   Free ("c_c", "real")) $
+                                 Const ("Groups.zero_class.zero", "real")) $
+                               Free ("v_v", "real"))
+                           ),
+                       guh = "pbl_test_uni_poly_deg2_abc", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+                       [("#Given",
+                         (Const ("Input_Descript.equality", "bool \<Rightarrow> una"),
+                          Const ("HOL.eq", "real \<Rightarrow> real \<Rightarrow> bool") $
+                            (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                              (Const ("Groups.plus_class.plus", "real \<Rightarrow> real \<Rightarrow> real") $
+                                (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("a_a", "real") $
+                                  (Const ("BaseDefinitions.realpow", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("x", "real") $
+                                    (Const ("Num.numeral_class.numeral", "num \<Rightarrow> real") $ (Const ("Num.num.Bit0", "num \<Rightarrow> num") $ Const ("Num.num.One", "num"))))) $
+                                (Const ("Groups.times_class.times", "real \<Rightarrow> real \<Rightarrow> real") $ Free ("b_b", "real") $ Free ("x", "real"))) $
+                              Free ("c_c", "real")) $
+                            Const ("Groups.zero_class.zero", "real"))),
+                        ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                        ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                       prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+                       {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                         HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                         HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base,
+                         HOL.BNF_Def, HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power,
+                         HOL.Groups_Big, HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big,
+                         HOL.Euclidean_Division, HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer,
+                         HOL.Lifting_Set, HOL.List, HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence,
+                         HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick,
+                         HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main,
+                         HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series,
+                         HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program,
+                         Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret,
+                         Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq,
+                         Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Test:515},
+                       where_ = []}],
+                     [])])]),
+             Node
+              ("squareroot",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_test_uni_root", init = ["empty_probl_id"], mathauthors = [], met = [["Test", "square_equation"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls =
+                 Repeat {calc = [], erls = Empty, errpatts = [], id = "contains_root", preconds = [], rew_ord = ("dummy_ord", fn), rules = [Eval ("Test.contains_root", fn)], scr = Empty_Prog, srls = Empty},
+                 thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq,
+                   Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Test:525},
+                 where_ = [Const ("Test.precond_rootpbl", "?'a \<Rightarrow> bool") $ Free ("v_v", "?'a")]}],
+               []),
+             Node
+              ("normalise",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_test_uni_norm", init = ["empty_probl_id"], mathauthors = [], met = [["Test", "norm_univar_equation"]], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq,
+                   Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Test:535},
+                 where_ = []}],
+               []),
+             Node
+              ("sqroot-test",
+               [{cas = SOME (Const ("Equation.solve", "bool \<times> real \<Rightarrow> bool list") $ (Const ("Product_Type.Pair", "bool \<Rightarrow> real \<Rightarrow> bool \<times> real") $ Free ("e_e", "bool") $ Free ("v_v", "real"))), guh =
+                 "pbl_test_uni_roottest", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+                 [("#Given", (Const ("Input_Descript.equality", "bool \<Rightarrow> una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \<Rightarrow> una"), Free ("v_v", "real"))),
+                  ("#Find", (Const ("Input_Descript.solutions", "bool list \<Rightarrow> toreall"), Free ("v_v'i'", "bool list")))],
+                 prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+                 {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive,
+                   HOL.Rings, HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                   HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                   HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                   HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                   HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                   HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                   HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                   HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull,
+                   HOL.Modules, HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex,
+                   HOL.MacLaurin, Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr,
+                   Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle,
+                   Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq,
+                   Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Test:545},
+                 where_ = [Const ("Test.precond_rootpbl", "?'a \<Rightarrow> bool") $ Free ("v_v", "?'a")]}],
+               [])])]),
+       Node
+        ("inttype",
+         [{cas = NONE, guh = "pbl_test_intsimp", init = ["empty_probl_id"], mathauthors = [], met = [["Test", "intsimp"]], ppc =
+           [("#Given", (Const ("Input_Descript.intTestGiven", "int \<Rightarrow> una"), Free ("t_t", "int"))), ("#Find", (Free ("intTestFind", "'a \<Rightarrow> 'b"), Free ("s_s", "'a")))], prls =
+           Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Test:555},
+           where_ = []}],
+         [])]),
+    Node
+     ("tool",
+      [{cas = NONE, guh = "pbl_tool", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls =
+        Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation,
+          Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Diff_App:305},
+        where_ = []}],
+      [Node
+        ("find_values",
+         [{cas = NONE, guh = "pbl_tool_findvals", init = ["empty_probl_id"], mathauthors = [], met = [], ppc =
+           [("#Given", (Const ("Input_Descript.maxArgument", "bool \<Rightarrow> toreal"), Free ("m_ax", "bool"))), ("#Given", (Const ("Input_Descript.functionEq", "bool \<Rightarrow> una"), Free ("f_f", "bool"))),
+            ("#Given", (Const ("Input_Descript.boundVariable", "real \<Rightarrow> una"), Free ("v_v", "real"))), ("#Find", (Const ("Input_Descript.valuesFor", "real list \<Rightarrow> toreall"), Free ("v_ls", "real list"))),
+            ("#Relate", (Const ("Input_Descript.additionalRels", "bool list \<Rightarrow> una"), Free ("r_s", "bool list")))],
+           prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Diff_App:315},
+           where_ = []}],
+         [])]),
+    Node
+     ("Optimisation",
+      [{cas = NONE, guh = "pbl_opti", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls =
+        Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation,
+          Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Diff_App:325},
+        where_ = []}],
+      [Node
+        ("univariate_calculus",
+         [{cas = NONE, guh = "pbl_opti_univ", init = ["empty_probl_id"], mathauthors = [], met = [["Optimisation", "by_univariate_calculus"]], ppc =
+           [("#Given", (Const ("Input_Descript.Constants", "bool list \<Rightarrow> nam"), Free ("fixes", "bool list"))), ("#Find", (Const ("Input_Descript.Maximum", "real \<Rightarrow> toreal"), Free ("maxx", "real"))),
+            ("#Find", (Const ("Input_Descript.AdditionalValues", "real list \<Rightarrow> toreall"), Free ("vals", "real list"))), ("#Relate", (Const ("Input_Descript.Extremum", "bool \<Rightarrow> toreal"), Free ("extr", "bool"))),
+            ("#Relate", (Const ("Input_Descript.SideConditions", "bool list \<Rightarrow> una"), Free ("sideconds", "bool list")))],
+           prls =
+           Repeat
+            {calc =
+             [("le", ("Orderings.ord_class.less", fn)), ("leq", ("Orderings.ord_class.less_eq", fn)), ("ident", ("Prog_Expr.ident", fn)), ("is_num", ("Prog_Expr.is_num", fn)),
+              ("occurs_in", ("Prog_Expr.occurs_in", fn)), ("matches", ("Prog_Expr.matches", fn))],
+             erls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, errpatts = [], id = "eval_rls",
+             preconds = [], rew_ord = ("termlessI", fn), rules =
+             [Thm ("refl", "?t = ?t"), Thm ("order_refl", "?x \<le> ?x"), Thm ("radd_left_cancel_le", "(?k + ?m \<le> ?k + ?n) = (?m \<le> ?n)"), Thm ("not_true", "(\<not> True) = False"),
+              Thm ("not_false", "(\<not> False) = True"), Thm ("and_true", "(?a \<and> True) = ?a"), Thm ("and_false", "(?a \<and> False) = False"), Thm ("or_true", "(?a \<or> True) = True"),
+              Thm ("or_false", "(?a \<or> False) = ?a"), Thm ("and_commute", "(?a \<and> ?b) = (?b \<and> ?a)"), Thm ("or_commute", "(?a \<or> ?b) = (?b \<or> ?a)"), Eval ("Orderings.ord_class.less", fn),
+              Eval ("Orderings.ord_class.less_eq", fn), Eval ("Prog_Expr.ident", fn), Eval ("Prog_Expr.is_num", fn), Eval ("Prog_Expr.occurs_in", fn), Eval ("Prog_Expr.matches", fn)],
+             scr = Empty_Prog, srls = Empty},
+           thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Diff_App:335},
+           where_ = []}],
+         [])]),
+    Node
+     ("SignalProcessing",
+      [{cas = NONE, guh = "pbl_SP", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls =
+        Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+        {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+          HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+          HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+          HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+          HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+          HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List, HOL.Groups_List,
+          HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation, HOL.Quickcheck_Random,
+          HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing, HOL.Mirabelle, HOL.Extraction,
+          HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules, HOL.Real, HOL.Topological_Spaces,
+          HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin, Complex_Main, Specify.Know_Store,
+          Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog, Specify.ProgLang, Specify.Input_Descript,
+          Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify, Isac.Poly, Isac.Root, Isac.Equation,
+          Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp, Isac.Diff, Isac.Diff_App, Isac.Partial_Fractions,
+          Isac.Inverse_Z_Transform:96},
+        where_ = []}],
+      [Node
+        ("Z_Transform",
+         [{cas = NONE, guh = "pbl_SP_Ztrans", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = [], prls =
+           Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+           {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+             HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+             HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+             HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+             HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+             HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+             HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+             HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+             HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+             HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+             Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+             Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+             Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+             Isac.Diff, Isac.Diff_App, Isac.Partial_Fractions, Isac.Inverse_Z_Transform:106},
+           where_ = []}],
+         [Node
+           ("Inverse",
+            [{cas = NONE, guh = "pbl_SP_Ztrans_inv", init = ["empty_probl_id"], mathauthors = [], met = [["SignalProcessing", "Z_Transform", "Inverse"]], ppc =
+              [("#Given", (Const ("Inverse_Z_Transform.filterExpression", "bool \<Rightarrow> una"), Free ("X_eq", "bool"))), ("#Find", (Const ("Inverse_Z_Transform.stepResponse", "bool \<Rightarrow> una"), Free ("n_eq", "bool")))],
+              prls = Repeat {calc = [], erls = Empty, errpatts = [], id = "empty", preconds = [], rew_ord = ("dummy_ord", fn), rules = [], scr = Empty_Prog, srls = Empty}, thy =
+              {Pure, Tools.Code_Generator, HOL.HOL, HOL.Orderings, HOL.Groups, HOL.Lattices, HOL.Boolean_Algebras, HOL.Set, HOL.Fun, HOL.Complete_Lattices, HOL.Ctr_Sugar, HOL.Typedef, HOL.Inductive, HOL.Rings,
+                HOL.Nat, HOL.Product_Type, HOL.Sum_Type, HOL.Fields, HOL.Finite_Set, HOL.Relation, HOL.Transitive_Closure, HOL.Wellfounded, HOL.Wfrec, HOL.Order_Relation, HOL.Hilbert_Choice,
+                HOL.BNF_Wellorder_Relation, HOL.BNF_Wellorder_Embedding, HOL.Zorn, HOL.BNF_Wellorder_Constructions, HOL.BNF_Cardinal_Order_Relation, HOL.BNF_Cardinal_Arithmetic, HOL.Fun_Def_Base, HOL.BNF_Def,
+                HOL.BNF_Composition, HOL.Basic_BNFs, HOL.BNF_Fixpoint_Base, HOL.BNF_Least_Fixpoint, HOL.Meson, HOL.ATP, HOL.Basic_BNF_LFPs, HOL.Metis, HOL.Transfer, HOL.Num, HOL.Power, HOL.Groups_Big,
+                HOL.Equiv_Relations, HOL.Lifting, HOL.Complete_Partial_Order, HOL.Option, HOL.Argo, HOL.Partial_Function, HOL.SAT, HOL.Quotient, HOL.Fun_Def, HOL.Int, HOL.Lattices_Big, HOL.Euclidean_Division,
+                HOL.Parity, HOL.Divides, HOL.Numeral_Simprocs, HOL.Semiring_Normalization, HOL.Groebner_Basis, HOL.Set_Interval, HOL.Presburger, HOL.SMT, HOL.Sledgehammer, HOL.Lifting_Set, HOL.List,
+                HOL.Groups_List, HOL.Bit_Operations, HOL.Code_Numeral, HOL.Map, HOL.Enum, HOL.String, HOL.Predicate, HOL.Lazy_Sequence, HOL.Typerep, HOL.Limited_Sequence, HOL.Random, HOL.Code_Evaluation,
+                HOL.Quickcheck_Random, HOL.Random_Pred, HOL.Random_Sequence, HOL.Quickcheck_Exhaustive, HOL.Predicate_Compile, HOL.Record, HOL.GCD, HOL.Nitpick, HOL.Factorial, HOL.Quickcheck_Narrowing,
+                HOL.Mirabelle, HOL.Extraction, HOL.Nunchaku, HOL.BNF_Greatest_Fixpoint, HOL.Filter, HOL.Conditionally_Complete_Lattices, HOL.Binomial, Main, HOL.Archimedean_Field, HOL.Rat, HOL.Hull, HOL.Modules,
+                HOL.Real, HOL.Topological_Spaces, HOL.Vector_Spaces, HOL.Real_Vector_Spaces, HOL.Limits, HOL.Inequalities, HOL.Deriv, HOL.Series, HOL.NthRoot, HOL.Transcendental, HOL.Complex, HOL.MacLaurin,
+                Complex_Main, Specify.Know_Store, Specify.BaseDefinitions, Specify.Calc_Binop, Specify.ListC, Specify.Program, Specify.Prog_Tac, Specify.Tactical, Specify.Prog_Expr, Specify.Auto_Prog,
+                Specify.ProgLang, Specify.Input_Descript, Specify.MathEngBasic, Specify.Specify, Interpret.Interpret, Isac.MathEngine, Isac.Test_Code, Isac.BridgeLibisabelle, Isac.Base_Tools, Isac.Simplify,
+                Isac.Poly, Isac.Root, Isac.Equation, Isac.GCD_Poly_ML, Isac.Rational, Isac.LinEq, Isac.RootEq, Isac.RatEq, Isac.RootRat, Isac.RootRatEq, Isac.PolyEq, Isac.Calculus, Isac.Trig, Isac.LogExp,
+                Isac.Diff, Isac.Diff_App, Isac.Partial_Fractions, Isac.Inverse_Z_Transform:116},
+              where_ = []}],
+            [])])])]:
+   Probl_Def.store*)
+\<close> text \<open>
+("thy1", ["aaa", "bbb"], ["ccc", "ddd"]) |> References.select_input References.empty |> #1 |> ThyC.get_theory |> Proof_Context.init_global
+\<close> text \<open>
+Proof_Context.init_global (References.select_input speco spec |> #1 |> ThyC.get_theory)
+\<close> ML \<open>
+\<close> ML \<open>
+\<close> ML \<open>
+\<close> ML \<open>
+\<close> ML \<open>
+\<close> ML \<open>
+\<close> ML \<open>
 \<close>
+(*\----- end delete -----------------------------------------------------------------------/*)
 ML \<open>Eval.adhoc_thm; (*from "ProgLang/evaluate.sml" *)\<close>
 ML \<open>Rewrite.rewrite_; (*from "ProgLang/rewrite.sml" *)\<close>
 ML \<open>Input_Descript.for_real_list; (*from "Input_Descript.thy" *)\<close>




