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 \ \ ML \ \ ML \ +\ ML \ (* \ termC.sml*) +\ ML \ (* \ model-pattern.sml*) +\ ML \ +Model_Pattern.adapt_term_to_type: Proof.context -> term -> term ; +Model_Pattern.adapt_to_type: Proof.context -> Model_Pattern.single -> Model_Pattern.single +\ ML \ +\ ML \ (* \ problem.sml*) +\ ML \ +val id = ["univariate", "equation", "test"] +\ ML \ +Problem.from_store_PIDE: Proof.context -> Problem.id -> Problem.T +\ ML \ +\ ML \ (* \ refine.sml*) +\ ML \ +\ text \ local +refin_PIDE +\ ML \ +\ text \ \ +refine_PIDE +\ ML \ +\ ML \ +\ ML \(*---------------------------- why "real" in pbl? ----------------------------*) +Test_Tool.show_ptyps (); +\ ML \ +KEStore_Elems.get_pbls @{theory Poly}; (*! real ! due to Simplify :: "real => real" etc*) +\ ML \ +Problem.from_store_PIDE @{context} ["polynomial", "simplification"] +\ ML \ +val input = (["polynomial", "simplification"], + [("#Given", ["Simplify t_t"]), ("#Find", ["normalform n_n"])], + Rule_Set.empty, NONE (*cas*), + [["simplification","for_polynomials"]]) : Problem.input +\ ML \ +Problem.prep_input_PIDE @{theory Poly} "guh" ["math-author-1"] ["polynomial", "simplification"] + input; (*! real !*) +\ ML \ +\ ML \ +\ ML \ +"~~~~~ 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); +\ ML \ + fun eq f (f', _) = f = f'; +\ ML \ + val gi = filter (eq "#Given") dsc_dats; +\ ML \ + val (_, gi') :: [] = (*case*) gi (*of*); +\ ML \ + map (Problem.split_did_PIDE o (Syntax.read_term_global thy)) gi' +\ ML \ +\ ML \ +(*+*)Syntax.read_term_global thy "Simplify t_t" (*Simplify :: "real => real"*) +\ ML \ +(*+*)TermC.parse_patt thy "matches (?a = 0) e_e" +(* = Const ("Prog_Expr.matches", "bool \ bool \ bool") $ (Const ("HOL.eq", "real \ real \ bool") $ + +Var (("a", 0), "real") $ Const ("Groups.zero_class.zero", "real")) $ Free ("e_e", "bool")*) +\ ML \ +(*+*)TermC.parse_patt_PIDE thy "matches (?a = 0) e_e" +(*t = Const ("Prog_Expr.matches", "bool \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ + Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool")*) +\ ML \ +\ ML \ +\ ML \ +\ ML \ +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 \ real") $ Free ("t_t", "real")), guh = "pbl_simp", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = + [("#Given", (Const ("Simplify.Term", "real \ una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \ 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 \ real") $ Free ("t_t", "real")), guh = "pbl_simp_poly", init = ["empty_probl_id"], mathauthors = [], met = [["simplification", "for_polynomials"]], + ppc = [("#Given", (Const ("Simplify.Term", "real \ una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \ 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 \ bool") $ Free ("t_t", "real")]}], + []), + Node + ("rational", + [{cas = SOME (Const ("Simplify.Simplify", "real \ real") $ Free ("t_t", "real")), guh = "pbl_simp_rat", init = ["empty_probl_id"], mathauthors = [], met = [["simplification", "of_rationals"]], ppc = + [("#Given", (Const ("Simplify.Term", "real \ una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \ 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 \ 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 \ una"), Free ("t_t", "real"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Partial_Fractions.decomposedFunction", "real \ 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 \ real") $ Free ("t_t", "real")), guh = "pbl_vereinfache", init = ["empty_probl_id"], mathauthors = [], met = [], ppc = + [("#Given", (Const ("Simplify.Term", "real \ una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \ 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 \ 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 \ una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \ 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 \ True) = True"), Thm ("or_false", "(?a \ False) = ?a"), Thm ("not_true", "(\ True) = False"), + Thm ("not_false", "(\ 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 \ bool") $ Free ("t_t", "real"), + Const ("HOL.Not", "bool \ bool") $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("a", 0), "?'a1") $ + (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $ + Free ("t_t", "?'a1")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("a", 0), "?'a1") $ + (Const ("Groups.minus_class.minus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $ + Free ("t_t", "?'a1")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.minus_class.minus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("a", 0), "?'a1") $ + (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $ + Free ("t_t", "?'a1")) $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("a", 0), "?'a1") $ + (Const ("Groups.minus_class.minus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $ + Free ("t_t", "?'a1"))))), + Const ("HOL.Not", "bool \ bool") $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.times_class.times", "?'a1 \ ?'a1 \ ?'a1") $ Var (("a", 0), "?'a1") $ + (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $ + Free ("t_t", "?'a1")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.times_class.times", "?'a1 \ ?'a1 \ ?'a1") $ Var (("a", 0), "?'a1") $ + (Const ("Groups.minus_class.minus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $ + Free ("t_t", "?'a1")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.times_class.times", "?'a1 \ ?'a1 \ ?'a1") $ (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1")) $ + Var (("a", 0), "?'a1")) $ + Free ("t_t", "?'a1")) $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.times_class.times", "?'a1 \ ?'a1 \ ?'a1") $ (Const ("Groups.minus_class.minus", "?'a1 \ ?'a1 \ ?'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 \ 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 \ una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \ 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 \ True) = True"), Thm ("or_false", "(?a \ False) = ?a"), Thm ("not_true", "(\ True) = False"), + Thm ("not_false", "(\ 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 \ bool") $ Free ("t_t", "real"), + Const ("HOL.Not", "bool \ bool") $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.times_class.times", "?'a1 \ ?'a1 \ ?'a1") $ Var (("a", 0), "?'a1") $ + (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $ + Free ("t_t", "?'a1")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.times_class.times", "?'a1 \ ?'a1 \ ?'a1") $ Var (("a", 0), "?'a1") $ + (Const ("Groups.minus_class.minus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1"))) $ + Free ("t_t", "?'a1")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.times_class.times", "?'a1 \ ?'a1 \ ?'a1") $ (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Var (("c", 0), "?'a1")) $ + Var (("a", 0), "?'a1")) $ + Free ("t_t", "?'a1")) $ + (Const ("Prog_Expr.matchsub", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.times_class.times", "?'a1 \ ?'a1 \ ?'a1") $ (Const ("Groups.minus_class.minus", "?'a1 \ ?'a1 \ ?'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 \ 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 \ una"), Free ("t_t", "real"))), ("#Find", (Const ("Simplify.normalform", "real \ 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 \ 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 \ bool list \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("PolyMinus.mitWert", "bool list \ tobooll"), Free ("w_w", "bool list"))), + ("#Find", (Const ("PolyMinus.Geprueft", "bool \ 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 \ bool") $ Free ("e_e", "real")]}], + []), + Node + ("bruch", + [{cas = SOME (Const ("PolyMinus.Probe", "bool \ bool list \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("PolyMinus.mitWert", "bool list \ tobooll"), Free ("w_w", "bool list"))), + ("#Find", (Const ("PolyMinus.Geprueft", "bool \ 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 \ bool") $ Free ("e_e", "real")]}], + [])]), + Node + ("equation", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Var (("b", 0), "?'a1")) $ Free ("e_e", "bool")]}], + [Node + ("univariate", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Var (("b", 0), "?'a1")) $ Free ("e_e", "bool")]}], + [Node + ("rootX", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), + Thm ("and_false", "(?a \ False) = False"), Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ (Const ("RootEq.is_rootTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + (Const ("RootEq.is_rootTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.rhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"))]}], + [Node + ("sq", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), + Thm ("and_false", "(?a \ False) = False"), Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ + (Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("RootEq.is_sqrtTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + (Const ("RootEq.is_normSqrtTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"))) $ + (Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("RootEq.is_sqrtTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.rhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + (Const ("RootEq.is_normSqrtTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.rhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")))]}], + [Node + ("rat", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), + Thm ("and_false", "(?a \ False) = False"), Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ + (Const ("RootRatEq.is_rootRatAddTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + (Const ("RootRatEq.is_rootRatAddTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.rhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"))]}], + [])]), + Node + ("normalise", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), + Thm ("and_false", "(?a \ False) = False"), Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ + (Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("RootEq.is_sqrtTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("RootEq.is_normSqrtTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")))) $ + (Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("RootEq.is_sqrtTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.rhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("RootEq.is_normSqrtTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.rhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"))))]}], + [])]), + Node + ("LINEAR", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), + Thm ("and_false", "(?a \ False) = False"), Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool") $ (Const ("Poly.is_polyrat_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")), + Const ("HOL.Not", "bool \ bool") $ (Const ("Poly.is_polyrat_in", "real \ real \ bool") $ (Const ("Prog_Expr.rhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")), + Const ("HOL.eq", "real \ real \ bool") $ (Const ("Poly.has_degree_in", "real \ real \ real") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + Const ("Groups.one_class.one", "real"), + Const ("HOL.eq", "real \ real \ bool") $ (Const ("Poly.has_degree_in", "real \ real \ real") $ (Const ("Prog_Expr.rhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + Const ("Groups.one_class.one", "real")]}], + []), + Node + ("rational", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ real \ bool") $ Free ("e_e", "bool") $ Free ("v_v", "real")]}], + []), + Node + ("polynomial", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool") $ (Const ("RatEq.is_ratequation_in", "bool \ real \ bool") $ Free ("e_e", "bool") $ Free ("v_v", "real")), + Const ("HOL.Not", "bool \ bool") $ (Const ("RootEq.is_rootTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")), + Const ("HOL.Not", "bool \ bool") $ (Const ("RootEq.is_rootTerm_in", "real \ real \ bool") $ (Const ("Prog_Expr.rhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"))]}], + [Node + ("degree_0", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"), + Const ("Poly.is_poly_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"), + Const ("HOL.eq", "real \ real \ bool") $ (Const ("Poly.has_degree_in", "real \ real \ real") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + Const ("Groups.zero_class.zero", "real")]}], + []), + Node + ("degree_1", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"), + Const ("Poly.is_poly_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"), + Const ("HOL.eq", "real \ real \ bool") $ (Const ("Poly.has_degree_in", "real \ real \ real") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + Const ("Groups.one_class.one", "real")]}], + []), + Node + ("degree_2", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"), + Const ("Poly.is_poly_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"), + Const ("HOL.eq", "real \ real \ bool") $ (Const ("Poly.has_degree_in", "real \ real \ real") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))]}], + [Node + ("sq_only", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")))), + Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ Var (("v_", 0), "real")) $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool"))) $ + (Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ Var (("v_", 0), "real"))) $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool"))) $ + (Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ Var (("v_", 0), "real")) $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("c", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool"))) $ + (Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ Var (("v_", 0), "real"))) $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("c", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool"))) $ + (Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool"))) $ + (Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ Var (("v_", 0), "real")) $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool"))) $ + (Const ("HOL.conj", "bool \ bool \ bool") $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("c", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool"))) $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ Var (("v_", 0), "real")) $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("c", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ 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 \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("a", 0), "real") $ Var (("v_", 0), "real")) $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("a", 0), "real") $ Var (("v_", 0), "real")) $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool"))))))]}], + []), + Node + ("pqFormula", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Const ("Groups.one_class.one", "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool"))]}], + []), + Node + ("abcFormula", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Var (("v_", 0), "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ 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 \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"), + Const ("Poly.is_poly_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"), + Const ("HOL.eq", "real \ real \ bool") $ (Const ("Poly.has_degree_in", "real \ real \ real") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit1", "num \ num") $ Const ("Num.num.One", "num")))]}], + []), + Node + ("degree_4", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"), + Const ("Poly.is_poly_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real"), + Const ("HOL.eq", "real \ real \ bool") $ (Const ("Poly.has_degree_in", "real \ real \ real") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))]}], + []), + Node + ("normalise", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ + (Const ("HOL.Not", "bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ + Free ("e_e", "bool"))) $ + (Const ("HOL.Not", "bool \ bool") $ (Const ("Poly.is_poly_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")))]}], + [])]), + Node + ("expanded", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool"), + Const ("Poly.is_expanded_in", "real \ real \ bool") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")]}], + [Node + ("degree_2", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ real \ bool") $ (Const ("Poly.has_degree_in", "real \ real \ real") $ (Const ("Prog_Expr.lhs", "bool \ real") $ Free ("e_e", "bool")) $ Free ("v_v", "real")) $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))]}], + [])]), + Node + ("logarithmic", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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", "(\ True) = False"), Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), + Thm ("or_true", "(?a \ True) = True"), Thm ("or_false", "(?a \ 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 \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ (Const ("LogExp.alog", "real \ real \ 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 \ una"), Free ("fu_n", "bool"))), ("#Given", (Const ("Equation.substitution", "bool \ una"), Free ("su_b", "bool"))), + ("#Find", (Const ("Input_Descript.equality", "bool \ 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 \ real \ bool list") $ + (Const ("Product_Type.prod.case_prod", "(bool \ int \ bool \ real) \ bool \ int \ bool \ real") $ + Abs ("x", "bool", Abs ("y", "int", Const ("Product_Type.Pair", "bool \ real \ bool \ real") $ Bound 1 $ (Const ("Int.ring_1_class.of_int", "int \ real") $ Bound 0))) $ + (Const ("Product_Type.Pair", "bool \ int \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.intTestGiven", "int \ una"), Free ("v_v", "int"))), + ("#Find", (Const ("Input_Descript.boolTestFind", "bool \ 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 \ real \ real") $ (Const ("Product_Type.Pair", "real \ real \ real \ 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 \ una"), Free ("f_f", "real"))), ("#Given", (Const ("Input_Descript.differentiateFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.derivative", "real \ 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 \ real \ bool") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("f_f", "bool"))), ("#Given", (Const ("Input_Descript.differentiateFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Diff.derivativeEq", "bool \ 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 \ real \ real") $ (Const ("Product_Type.Pair", "real \ real \ real \ 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 \ una"), Free ("f_f", "real"))), ("#Given", (Const ("Integrate.integrateBy", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Integrate.antiDerivative", "real \ 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 \ real \ real") $ (Const ("Product_Type.Pair", "real \ real \ real \ 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 \ una"), Free ("f_f", "real"))), ("#Given", (Const ("Integrate.integrateBy", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Integrate.antiDerivativeName", "(real \ real) \ una"), Free ("F_F", "real \ 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 \ nam"), Free ("f_ix", "bool list"))), ("#Find", (Const ("Input_Descript.maximum", "real \ toreal"), Free ("m_m", "real"))), + ("#Find", (Const ("Input_Descript.valuesFor", "real list \ toreall"), Free ("v_s", "real list"))), ("#Relate", (Const ("Input_Descript.relations", "bool list \ 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 \ una"), Free ("t_t", "bool"))), ("#Given", (Const ("Input_Descript.boundVariable", "real \ una"), Free ("v_v", "real"))), + ("#Given", (Const ("Input_Descript.interval", "real set \ una"), Free ("i_tv", "real set"))), ("#Find", (Const ("Input_Descript.maxArgument", "bool \ 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 \ una"), Free ("f_f", "real"))), ("#Given", (Const ("Input_Descript.boundVariable", "real \ una"), Free ("v_v", "real"))), + ("#Given", (Const ("Input_Descript.equalities", "bool list \ tobooll"), Free ("eqs", "bool list"))), ("#Find", (Const ("Input_Descript.functionEq", "bool \ 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 \ una"), Free ("f_f", "real"))), ("#Given", (Const ("Input_Descript.boundVariable", "real \ una"), Free ("v_v", "real"))), + ("#Given", (Const ("Input_Descript.equalities", "bool list \ tobooll"), Free ("eqs", "bool list"))), ("#Find", (Const ("Input_Descript.functionEq", "bool \ 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 \ una"), Free ("f_f", "real"))), ("#Given", (Const ("Input_Descript.boundVariable", "real \ una"), Free ("v_v", "real"))), + ("#Given", (Const ("Input_Descript.equalities", "bool list \ tobooll"), Free ("eqs", "bool list"))), ("#Find", (Const ("Input_Descript.functionEq", "bool \ 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 \ real list \ 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 \ tobooll"), Free ("e_s", "bool list"))), ("#Given", (Const ("EqSystem.solveForVars", "real list \ toreall"), Free ("v_s", "real list"))), + ("#Find", (Const ("EqSystem.solution", "bool list \ 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 \ real list \ 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 \ tobooll"), Free ("e_s", "bool list"))), ("#Given", (Const ("EqSystem.solveForVars", "real list \ toreall"), Free ("v_s", "real list"))), + ("#Find", (Const ("EqSystem.solution", "bool list \ 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 \ real list \ 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 \ tobooll"), Free ("e_s", "bool list"))), + ("#Given", (Const ("EqSystem.solveForVars", "real list \ toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \ 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 \ real \ bool") $ (Const ("ListC.Length", "bool list \ real") $ Free ("e_s", "bool list")) $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))), + Const ("HOL.eq", "real \ real \ bool") $ (Const ("ListC.Length", "?'a list \ real") $ Free ("v_s", "?'a list")) $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))]}], + [Node + ("triangular", + [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \ real list \ 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 \ tobooll"), Free ("e_s", "bool list"))), + ("#Given", (Const ("EqSystem.solveForVars", "real list \ toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \ 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 \ 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 \ real list \ bool \ bool") $ (Const ("List.list.tl", "real list \ real list") $ Free ("v_s", "real list")) $ Free ("v_s", "real list") $ + (Const ("ListC.NTH", "real \ bool list \ bool") $ Const ("Groups.one_class.one", "real") $ Free ("e_s", "bool list")), + Const ("EqSystem.occur_exactly_in", "real list \ real list \ bool \ bool") $ Free ("v_s", "real list") $ Free ("v_s", "real list") $ + (Const ("ListC.NTH", "real \ bool list \ bool") $ (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))) $ + Free ("e_s", "bool list"))]}], + []), + Node + ("normalise", + [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \ real list \ 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 \ tobooll"), Free ("e_s", "bool list"))), + ("#Given", (Const ("EqSystem.solveForVars", "real list \ toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \ 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 \ real list \ 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 \ tobooll"), Free ("e_s", "bool list"))), + ("#Given", (Const ("EqSystem.solveForVars", "real list \ toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \ 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 \ real \ bool") $ (Const ("ListC.Length", "bool list \ real") $ Free ("e_s", "bool list")) $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit1", "num \ num") $ Const ("Num.num.One", "num"))), + Const ("HOL.eq", "real \ real \ bool") $ (Const ("ListC.Length", "?'a list \ real") $ Free ("v_s", "?'a list")) $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit1", "num \ num") $ Const ("Num.num.One", "num")))]}], + []), + Node + ("4x4", + [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \ real list \ 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 \ tobooll"), Free ("e_s", "bool list"))), + ("#Given", (Const ("EqSystem.solveForVars", "real list \ toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \ 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 \ real \ bool") $ (Const ("ListC.Length", "bool list \ real") $ Free ("e_s", "bool list")) $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))), + Const ("HOL.eq", "real \ real \ bool") $ (Const ("ListC.Length", "?'a list \ real") $ Free ("v_s", "?'a list")) $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))]}], + [Node + ("triangular", + [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \ real list \ 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 \ tobooll"), Free ("e_s", "bool list"))), + ("#Given", (Const ("EqSystem.solveForVars", "real list \ toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \ 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 \ 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 \ bool \ bool") $ (Const ("ListC.NTH", "real \ real list \ real") $ Const ("Groups.one_class.one", "real") $ Free ("v_s", "real list")) $ + (Const ("ListC.NTH", "real \ bool list \ bool") $ Const ("Groups.one_class.one", "real") $ Free ("e_s", "bool list")), + Const ("Prog_Expr.occurs_in", "real \ bool \ bool") $ + (Const ("ListC.NTH", "real \ real list \ real") $ (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))) $ + Free ("v_s", "real list")) $ + (Const ("ListC.NTH", "real \ bool list \ bool") $ (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))) $ + Free ("e_s", "bool list")), + Const ("Prog_Expr.occurs_in", "real \ bool \ bool") $ + (Const ("ListC.NTH", "real \ real list \ real") $ (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit1", "num \ num") $ Const ("Num.num.One", "num"))) $ + Free ("v_s", "real list")) $ + (Const ("ListC.NTH", "real \ bool list \ bool") $ (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit1", "num \ num") $ Const ("Num.num.One", "num"))) $ + Free ("e_s", "bool list")), + Const ("Prog_Expr.occurs_in", "real \ bool \ bool") $ + (Const ("ListC.NTH", "real \ real list \ real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))) $ + Free ("v_s", "real list")) $ + (Const ("ListC.NTH", "real \ bool list \ bool") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))) $ + Free ("e_s", "bool list"))]}], + []), + Node + ("normalise", + [{cas = SOME (Const ("EqSystem.solveSystem", "bool list \ real list \ 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 \ tobooll"), Free ("e_s", "bool list"))), + ("#Given", (Const ("EqSystem.solveForVars", "real list \ toreall"), Free ("v_s", "real list"))), ("#Find", (Const ("EqSystem.solution", "bool list \ 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 \ una"), Free ("l_l", "real"))), ("#Given", (Const ("Biegelinie.Streckenlast", "real \ una"), Free ("q_q", "real"))), + ("#Find", (Const ("Biegelinie.Biegelinie", "(real \ real) \ una"), Free ("b_b", "real \ real"))), ("#Relate", (Const ("Biegelinie.Randbedingungen", "bool list \ 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 \ una"), Free ("l_l", "real"))), ("#Given", (Const ("Biegelinie.Streckenlast", "real \ una"), Free ("q_q", "real"))), + ("#Find", (Const ("Biegelinie.Biegelinie", "(real \ real) \ una"), Free ("b_b", "real \ real"))), + ("#Relate", (Const ("Biegelinie.RandbedingungenBiegung", "bool list \ una"), Free ("r_b", "bool list"))), + ("#Relate", (Const ("Biegelinie.RandbedingungenMoment", "bool list \ 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 \ una"), Free ("q_q", "real"))), ("#Given", (Const ("Biegelinie.FunktionsVariable", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Biegelinie.Funktionen", "bool list \ 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 \ una"), Free ("fun_s", "bool list"))), ("#Given", (Const ("Biegelinie.Randbedingungen", "bool list \ una"), Free ("r_b", "bool list"))), + ("#Find", (Const ("Biegelinie.Gleichungen", "bool list \ 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 \ una"), Free ("k_k", "bool"))), ("#Given", (Const ("AlgEin.Querschnitt", "bool \ una"), Free ("q__q", "bool"))), + ("#Given", (Const ("AlgEin.KantenUnten", "bool list \ una"), Free ("u_u", "bool list"))), ("#Given", (Const ("AlgEin.KantenSenkrecht", "bool list \ una"), Free ("s_s", "bool list"))), + ("#Given", (Const ("AlgEin.KantenOben", "bool list \ una"), Free ("o_o", "bool list"))), ("#Find", (Const ("AlgEin.GesamtLaenge", "real \ 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 \ 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 \ unl"), Free ("u_u", "int xlist"))), ("#Find", (Const ("InsSort.sorted", "int xlist \ 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 \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ ?x"), Thm ("radd_left_cancel_le", "(?k + ?m \ ?k + ?n) = (?m \ ?n)"), Thm ("not_true", "(\ True) = False"), + Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), Thm ("or_true", "(?a \ True) = True"), + Thm ("or_false", "(?a \ False) = ?a"), Thm ("and_commute", "(?a \ ?b) = (?b \ ?a)"), Thm ("or_commute", "(?a \ ?b) = (?b \ ?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 \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Var (("b", 0), "?'a1")) $ Free ("e_e", "bool")]}], + [Node + ("univariate", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ ?x"), Thm ("radd_left_cancel_le", "(?k + ?m \ ?k + ?n) = (?m \ ?n)"), Thm ("not_true", "(\ True) = False"), + Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), Thm ("or_true", "(?a \ True) = True"), + Thm ("or_false", "(?a \ False) = ?a"), Thm ("and_commute", "(?a \ ?b) = (?b \ ?a)"), Thm ("or_commute", "(?a \ ?b) = (?b \ ?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 \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Var (("a", 0), "?'a1") $ Var (("b", 0), "?'a1")) $ Free ("e_e", "bool")]}], + [Node + ("LINEAR", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ ?x"), Thm ("radd_left_cancel_le", "(?k + ?m \ ?k + ?n) = (?m \ ?n)"), Thm ("not_true", "(\ True) = False"), + Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), Thm ("or_true", "(?a \ True) = True"), + Thm ("or_false", "(?a \ False) = ?a"), Thm ("and_commute", "(?a \ ?b) = (?b \ ?a)"), Thm ("or_commute", "(?a \ ?b) = (?b \ ?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 \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ Free ("v_v", "?'a1") $ Const ("Groups.zero_class.zero", "?'a1")) $ Free ("e_e", "bool")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ (Const ("Groups.times_class.times", "?'a1 \ ?'a1 \ ?'a1") $ Var (("b", 0), "?'a1") $ Free ("v_v", "?'a1")) $ + Const ("Groups.zero_class.zero", "?'a1")) $ + Free ("e_e", "bool")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("a", 0), "?'a1") $ Free ("v_v", "?'a1")) $ + Const ("Groups.zero_class.zero", "?'a1")) $ + Free ("e_e", "bool")) $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "?'a1 \ ?'a1 \ bool") $ + (Const ("Groups.plus_class.plus", "?'a1 \ ?'a1 \ ?'a1") $ Var (("a", 0), "?'a1") $ + (Const ("Groups.times_class.times", "?'a1 \ ?'a1 \ ?'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 \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ ?x"), Thm ("radd_left_cancel_le", "(?k + ?m \ ?k + ?n) = (?m \ ?n)"), Thm ("not_true", "(\ True) = False"), + Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), Thm ("or_true", "(?a \ True) = True"), + Thm ("or_false", "(?a \ False) = ?a"), Thm ("and_commute", "(?a \ ?b) = (?b \ ?a)"), Thm ("or_commute", "(?a \ ?b) = (?b \ ?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 \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("v_v", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Var (("b", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("v_v", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("HOL.disj", "bool \ bool \ bool") $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ Var (("a", 0), "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("v_v", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool")) $ + (Const ("Prog_Expr.matches", "bool \ bool \ bool") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("v_v", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))) $ + Const ("Groups.zero_class.zero", "real")) $ + Free ("e_e", "bool"))))]}], + []), + Node + ("polynomial", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), + Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("v_v", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))) $ + (Const ("Groups.times_class.times", "real \ real \ 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 \ una"), Free ("v_v", "real"))), ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ real \ bool list") $ + (Const ("Product_Type.Pair", "bool \ real \ bool \ real") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("v_v", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))) $ + (Const ("Groups.times_class.times", "real \ real \ 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 \ una"), + Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("v_v", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))) $ + (Const ("Groups.times_class.times", "real \ real \ 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 \ una"), Free ("v_v", "real"))), ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ real \ bool list") $ + (Const ("Product_Type.Pair", "bool \ real \ bool \ real") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("v_v", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))) $ + (Const ("Groups.times_class.times", "real \ real \ 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 \ una"), + Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("v_v", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num")))) $ + (Const ("Groups.times_class.times", "real \ real \ 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 \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ real \ bool list") $ + (Const ("Product_Type.Pair", "bool \ real \ bool \ real") $ + (Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Free ("a_a", "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("x", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + (Const ("Groups.times_class.times", "real \ real \ 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 \ una"), + Const ("HOL.eq", "real \ real \ bool") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.plus_class.plus", "real \ real \ real") $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Free ("a_a", "real") $ + (Const ("BaseDefinitions.realpow", "real \ real \ real") $ Free ("x", "real") $ + (Const ("Num.numeral_class.numeral", "num \ real") $ (Const ("Num.num.Bit0", "num \ num") $ Const ("Num.num.One", "num"))))) $ + (Const ("Groups.times_class.times", "real \ real \ real") $ Free ("b_b", "real") $ Free ("x", "real"))) $ + Free ("c_c", "real")) $ + Const ("Groups.zero_class.zero", "real"))), + ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ bool") $ Free ("v_v", "?'a")]}], + []), + Node + ("normalise", + [{cas = SOME (Const ("Equation.solve", "bool \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ real \ bool list") $ (Const ("Product_Type.Pair", "bool \ real \ bool \ 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 \ una"), Free ("e_e", "bool"))), ("#Given", (Const ("Input_Descript.solveFor", "real \ una"), Free ("v_v", "real"))), + ("#Find", (Const ("Input_Descript.solutions", "bool list \ 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 \ 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 \ una"), Free ("t_t", "int"))), ("#Find", (Free ("intTestFind", "'a \ '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 \ toreal"), Free ("m_ax", "bool"))), ("#Given", (Const ("Input_Descript.functionEq", "bool \ una"), Free ("f_f", "bool"))), + ("#Given", (Const ("Input_Descript.boundVariable", "real \ una"), Free ("v_v", "real"))), ("#Find", (Const ("Input_Descript.valuesFor", "real list \ toreall"), Free ("v_ls", "real list"))), + ("#Relate", (Const ("Input_Descript.additionalRels", "bool list \ 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 \ nam"), Free ("fixes", "bool list"))), ("#Find", (Const ("Input_Descript.Maximum", "real \ toreal"), Free ("maxx", "real"))), + ("#Find", (Const ("Input_Descript.AdditionalValues", "real list \ toreall"), Free ("vals", "real list"))), ("#Relate", (Const ("Input_Descript.Extremum", "bool \ toreal"), Free ("extr", "bool"))), + ("#Relate", (Const ("Input_Descript.SideConditions", "bool list \ 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 \ ?x"), Thm ("radd_left_cancel_le", "(?k + ?m \ ?k + ?n) = (?m \ ?n)"), Thm ("not_true", "(\ True) = False"), + Thm ("not_false", "(\ False) = True"), Thm ("and_true", "(?a \ True) = ?a"), Thm ("and_false", "(?a \ False) = False"), Thm ("or_true", "(?a \ True) = True"), + Thm ("or_false", "(?a \ False) = ?a"), Thm ("and_commute", "(?a \ ?b) = (?b \ ?a)"), Thm ("or_commute", "(?a \ ?b) = (?b \ ?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 \ una"), Free ("X_eq", "bool"))), ("#Find", (Const ("Inverse_Z_Transform.stepResponse", "bool \ 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*) +\ text \ +("thy1", ["aaa", "bbb"], ["ccc", "ddd"]) |> References.select_input References.empty |> #1 |> ThyC.get_theory |> Proof_Context.init_global +\ text \ +Proof_Context.init_global (References.select_input speco spec |> #1 |> ThyC.get_theory) +\ ML \ +\ ML \ +\ ML \ +\ ML \ +\ ML \ +\ ML \ +\ ML \ \ +(*\----- end delete -----------------------------------------------------------------------/*) ML \Eval.adhoc_thm; (*from "ProgLang/evaluate.sml" *)\ ML \Rewrite.rewrite_; (*from "ProgLang/rewrite.sml" *)\ ML \Input_Descript.for_real_list; (*from "Input_Descript.thy" *)\