void initialize_find_cmd() { g_find_max_steps = new name{"find_decl", "max_steps"}; g_find_expensive = new name{"find_decl", "expensive"}; register_unsigned_option(*g_find_max_steps, LEAN_DEFAULT_FIND_MAX_STEPS, "(find_decl) maximum number of steps to be performed when trying to match the type of a declaration"); register_bool_option(*g_find_expensive, LEAN_DEFAULT_FIND_EXPENSIVE, "(find_decl) if true, then matcher will unfold definitions, perform reductions, and higher-order matching"); }
void initialize_options() { g_blast_max_depth = new name{"blast", "max_depth"}; g_blast_init_depth = new name{"blast", "init_depth"}; g_blast_inc_depth = new name{"blast", "inc_depth"}; g_blast_trace = new name{"blast", "trace"}; g_blast_subst = new name{"blast", "subst"}; g_blast_simp = new name{"blast", "simp"}; g_blast_cc = new name{"blast", "cc"}; g_blast_trace_cc = new name{"blast", "trace_cc"}; g_blast_recursor = new name{"blast", "recursor"}; g_blast_show_failure = new name{"blast", "show_failure"}; register_unsigned_option(*blast::g_blast_max_depth, LEAN_DEFAULT_BLAST_MAX_DEPTH, "(blast) max search depth for blast"); register_unsigned_option(*blast::g_blast_init_depth, LEAN_DEFAULT_BLAST_INIT_DEPTH, "(blast) initial search depth for blast (remark: blast uses iteration deepening)"); register_unsigned_option(*blast::g_blast_inc_depth, LEAN_DEFAULT_BLAST_INC_DEPTH, "(blast) search depth increment for blast (remark: blast uses iteration deepening)"); register_bool_option(*blast::g_blast_trace, LEAN_DEFAULT_BLAST_TRACE, "(blast) trace"); register_bool_option(*blast::g_blast_subst, LEAN_DEFAULT_BLAST_SUBST, "(blast) enable subst action"); register_bool_option(*blast::g_blast_simp, LEAN_DEFAULT_BLAST_SIMP, "(blast) enable simplier actions"); register_bool_option(*blast::g_blast_cc, LEAN_DEFAULT_BLAST_CC, "(blast) enable congruence closure"); register_bool_option(*blast::g_blast_trace_cc, LEAN_DEFAULT_BLAST_TRACE_CC, "(blast) (for debugging purposes) trace congruence closure"); register_bool_option(*blast::g_blast_recursor, LEAN_DEFAULT_BLAST_RECURSOR, "(blast) enable recursor action"); register_bool_option(*blast::g_blast_show_failure, LEAN_DEFAULT_BLAST_SHOW_FAILURE, "(blast) show failure state"); }
void initialize_class_instance_elaborator() { g_class_unique_class_instances = new name{"class", "unique_instances"}; g_class_trace_instances = new name{"class", "trace_instances"}; g_class_instance_max_depth = new name{"class", "instance_max_depth"}; g_class_conservative = new name{"class", "conservative"}; register_bool_option(*g_class_unique_class_instances, LEAN_DEFAULT_CLASS_UNIQUE_CLASS_INSTANCES, "(class) generate an error if there is more than one solution " "for a class-instance resolution problem"); register_bool_option(*g_class_trace_instances, LEAN_DEFAULT_CLASS_TRACE_INSTANCES, "(class) display messages showing the class-instances resolution execution trace"); register_unsigned_option(*g_class_instance_max_depth, LEAN_DEFAULT_CLASS_INSTANCE_MAX_DEPTH, "(class) max allowed depth in class-instance resolution"); register_bool_option(*g_class_conservative, LEAN_DEFAULT_CLASS_CONSERVATIVE, "(class) use conservative unification (only unfold reducible definitions, and avoid delta-delta case splits)"); }
void initialize_elaborator_context() { g_elaborator_local_instances = new name{"elaborator", "local_instances"}; g_elaborator_ignore_instances = new name{"elaborator", "ignore_instances"}; g_elaborator_flycheck_goals = new name{"elaborator", "flycheck_goals"}; g_elaborator_fail_missing_field = new name{"elaborator", "fail_if_missing_field"}; g_elaborator_lift_coercions = new name{"elaborator", "lift_coercions"}; register_bool_option(*g_elaborator_local_instances, LEAN_DEFAULT_ELABORATOR_LOCAL_INSTANCES, "(elaborator) use local declarates as class instances"); register_bool_option(*g_elaborator_ignore_instances, LEAN_DEFAULT_ELABORATOR_IGNORE_INSTANCES, "(elaborator) if true, then elaborator does not perform class-instance resolution"); register_bool_option(*g_elaborator_flycheck_goals, LEAN_DEFAULT_ELABORATOR_FLYCHECK_GOALS, "(elaborator) if true, then elaborator display current goals for flycheck before each " "tactic is executed in a `begin ... end` block"); register_bool_option(*g_elaborator_fail_missing_field, LEAN_DEFAULT_ELABORATOR_FAIL_MISSING_FIELD, "(elaborator) if true, then elaborator generates an error for missing fields instead " "of adding placeholders"); register_bool_option(*g_elaborator_lift_coercions, LEAN_DEFAULT_ELABORATOR_LIFT_COERCIONS, "(elaborator) if true, the elaborator will automatically lift coercions from A to B " "into coercions from (C -> A) to (C -> B)"); }
void initialize_apply_tactic() { g_apply_class_instance = new name{"apply", "class_instance"}; register_bool_option(*g_apply_class_instance, LEAN_DEFAULT_APPLY_CLASS_INSTANCE, "(apply tactic) if true apply tactic uses class-instances " "resolution for instance implicit arguments"); register_tac(get_tactic_apply_name(), [](type_checker &, elaborate_fn const & fn, expr const & e, pos_info_provider const *) { check_tactic_expr(app_arg(e), "invalid 'apply' tactic, invalid argument"); return apply_tactic(fn, get_tactic_expr_expr(app_arg(e))); }); register_tac(get_tactic_eapply_name(), [](type_checker &, elaborate_fn const & fn, expr const & e, pos_info_provider const *) { check_tactic_expr(app_arg(e), "invalid 'eapply' tactic, invalid argument"); return eapply_tactic(fn, get_tactic_expr_expr(app_arg(e))); }); register_tac(get_tactic_fapply_name(), [](type_checker &, elaborate_fn const & fn, expr const & e, pos_info_provider const *) { check_tactic_expr(app_arg(e), "invalid 'fapply' tactic, invalid argument"); return fapply_tactic(fn, get_tactic_expr_expr(app_arg(e))); }); }
void initialize_pp_options() { g_pp_max_depth = new name{"pp", "max_depth"}; g_pp_max_steps = new name{"pp", "max_steps"}; g_pp_notation = new name{"pp", "notation"}; g_pp_implicit = new name{"pp", "implicit"}; g_pp_coercions = new name{"pp", "coercions"}; g_pp_universes = new name{"pp", "universes"}; g_pp_full_names = new name{"pp", "full_names"}; g_pp_private_names = new name{"pp", "private_names"}; g_pp_metavar_args = new name{"pp", "metavar_args"}; g_pp_purify_metavars = new name{"pp", "purify_metavars"}; g_pp_purify_locals = new name{"pp", "purify_locals"}; g_pp_beta = new name{"pp", "beta"}; g_pp_numerals = new name{"pp", "numerals"}; g_pp_abbreviations = new name{"pp", "abbreviations"}; g_pp_preterm = new name{"pp", "preterm"}; g_pp_all = new name{"pp", "all"}; g_pp_goal_compact = new name{"pp", "goal", "compact"}; g_pp_goal_max_hyps = new name{"pp", "goal", "max_hypotheses"}; g_pp_binder_types = new name{"pp", "binder_types"}; register_unsigned_option(*g_pp_max_depth, LEAN_DEFAULT_PP_MAX_DEPTH, "(pretty printer) maximum expression depth, after that it will use ellipsis"); register_unsigned_option(*g_pp_max_steps, LEAN_DEFAULT_PP_MAX_STEPS, "(pretty printer) maximum number of visited expressions, after that it will use ellipsis"); register_bool_option(*g_pp_notation, LEAN_DEFAULT_PP_NOTATION, "(pretty printer) disable/enable notation (infix, mixfix, postfix operators and unicode characters)"); register_bool_option(*g_pp_implicit, LEAN_DEFAULT_PP_IMPLICIT, "(pretty printer) display implicit parameters"); register_bool_option(*g_pp_coercions, LEAN_DEFAULT_PP_COERCIONS, "(pretty printer) display coercionss"); register_bool_option(*g_pp_universes, LEAN_DEFAULT_PP_UNIVERSES, "(pretty printer) display universes"); register_bool_option(*g_pp_full_names, LEAN_DEFAULT_PP_FULL_NAMES, "(pretty printer) display fully qualified names"); register_bool_option(*g_pp_private_names, LEAN_DEFAULT_PP_PRIVATE_NAMES, "(pretty printer) display internal names assigned to private declarations"); register_bool_option(*g_pp_metavar_args, LEAN_DEFAULT_PP_METAVAR_ARGS, "(pretty printer) display metavariable arguments"); register_bool_option(*g_pp_purify_metavars, LEAN_DEFAULT_PP_PURIFY_METAVARS, "(pretty printer) rename internal metavariable names (with \"user-friendly\" ones) " "before pretty printing"); register_bool_option(*g_pp_purify_locals, LEAN_DEFAULT_PP_PURIFY_LOCALS, "(pretty printer) rename local names to avoid name capture, " "before pretty printing"); register_bool_option(*g_pp_beta, LEAN_DEFAULT_PP_BETA, "(pretty printer) apply beta-reduction when pretty printing"); register_bool_option(*g_pp_numerals, LEAN_DEFAULT_PP_NUMERALS, "(pretty printer) display nat/num numerals in decimal notation"); register_bool_option(*g_pp_abbreviations, LEAN_DEFAULT_PP_ABBREVIATIONS, "(pretty printer) display abbreviations (i.e., revert abbreviation expansion when pretty printing)"); register_bool_option(*g_pp_preterm, LEAN_DEFAULT_PP_PRETERM, "(pretty printer) assume the term is a preterm (i.e., a term before elaboration)"); register_bool_option(*g_pp_goal_compact, LEAN_DEFAULT_PP_GOAL_COMPACT, "(pretty printer) try to display goal in a single line when possible"); register_unsigned_option(*g_pp_goal_max_hyps, LEAN_DEFAULT_PP_GOAL_MAX_HYPS, "(pretty printer) maximum number of hypotheses to be displayed"); register_bool_option(*g_pp_binder_types, LEAN_DEFAULT_PP_BINDER_TYPES, "(pretty printer) display types of lambda and Pi parameters"); register_bool_option(*g_pp_all, LEAN_DEFAULT_PP_ALL, "(pretty printer) display coercions, implicit parameters, fully qualified names, universes, " "and disable abbreviations, beta reduction and notation during pretty printing"); options universes_true(*g_pp_universes, true); options full_names_true(*g_pp_full_names, true); options implicit_true(*g_pp_implicit, true); options coercions_true(*g_pp_coercions, true); options notation_false(*g_pp_notation, false); options implicit_coercions = join(coercions_true, implicit_true); options implicit_notation = join(notation_false, implicit_true); options all = universes_true + implicit_true + coercions_true + notation_false + full_names_true; g_distinguishing_pp_options = new list<options>({implicit_true, full_names_true, coercions_true, implicit_coercions, implicit_notation, universes_true, all}); }
void initialize_elaborator_context() { g_elaborator_local_instances = new name{"elaborator", "local_instances"}; register_bool_option(*g_elaborator_local_instances, LEAN_DEFAULT_ELABORATOR_LOCAL_INSTANCES, "(lean elaborator) use local declarates as class instances"); }
void initialize_pp_options() { g_pp_max_depth = new name{"pp", "max_depth"}; g_pp_max_steps = new name{"pp", "max_steps"}; g_pp_notation = new name{"pp", "notation"}; g_pp_implicit = new name{"pp", "implicit"}; g_pp_proofs = new name{"pp", "proofs"}; g_pp_coercions = new name{"pp", "coercions"}; g_pp_universes = new name{"pp", "universes"}; g_pp_full_names = new name{"pp", "full_names"}; g_pp_private_names = new name{"pp", "private_names"}; g_pp_purify_metavars = new name{"pp", "purify_metavars"}; g_pp_purify_locals = new name{"pp", "purify_locals"}; g_pp_locals_full_names = new name{"pp", "locals_full_names"}; g_pp_beta = new name{"pp", "beta"}; g_pp_numerals = new name{"pp", "numerals"}; g_pp_strings = new name{"pp", "strings"}; g_pp_preterm = new name{"pp", "preterm"}; g_pp_binder_types = new name{"pp", "binder_types"}; g_pp_hide_comp_irrel = new name{"pp", "hide_comp_irrelevant"}; g_pp_all = new name{"pp", "all"}; g_pp_delayed_abstraction = new name{"pp", "delayed_abstraction"}; g_pp_goal_compact = new name{"pp", "goal", "compact"}; g_pp_goal_max_hyps = new name{"pp", "goal", "max_hypotheses"}; g_pp_structure_instances = new name{"pp", "structure_instances"}; g_pp_structure_instances_qualifier = new name{"pp", "structure_instances_qualifier"}; g_pp_structure_projections = new name{"pp", "structure_projections"}; g_pp_instantiate_mvars = new name{"pp", "instantiate_mvars"}; g_pp_use_holes = new name{"pp", "use_holes"}; g_pp_annotations = new name{"pp", "annotations"}; register_unsigned_option(*g_pp_max_depth, LEAN_DEFAULT_PP_MAX_DEPTH, "(pretty printer) maximum expression depth, after that it will use ellipsis"); register_unsigned_option(*g_pp_max_steps, LEAN_DEFAULT_PP_MAX_STEPS, "(pretty printer) maximum number of visited expressions, after that it will use ellipsis"); register_bool_option(*g_pp_notation, LEAN_DEFAULT_PP_NOTATION, "(pretty printer) disable/enable notation (infix, mixfix, postfix operators and unicode characters)"); register_bool_option(*g_pp_implicit, LEAN_DEFAULT_PP_IMPLICIT, "(pretty printer) display implicit parameters"); register_bool_option(*g_pp_proofs, LEAN_DEFAULT_PP_PROOFS, "(pretty printer) if set to false, the type will be displayed instead of the value for every proof appearing as an argument to a function"); register_bool_option(*g_pp_coercions, LEAN_DEFAULT_PP_COERCIONS, "(pretty printer) display coercionss"); register_bool_option(*g_pp_universes, LEAN_DEFAULT_PP_UNIVERSES, "(pretty printer) display universes"); register_bool_option(*g_pp_full_names, LEAN_DEFAULT_PP_FULL_NAMES, "(pretty printer) display fully qualified names"); register_bool_option(*g_pp_private_names, LEAN_DEFAULT_PP_PRIVATE_NAMES, "(pretty printer) display internal names assigned to private declarations"); register_bool_option(*g_pp_purify_metavars, LEAN_DEFAULT_PP_PURIFY_METAVARS, "(pretty printer) rename internal metavariable names (with \"user-friendly\" ones) " "before pretty printing"); register_bool_option(*g_pp_purify_locals, LEAN_DEFAULT_PP_PURIFY_LOCALS, "(pretty printer) rename local names to avoid name capture, " "before pretty printing"); register_bool_option(*g_pp_locals_full_names, LEAN_DEFAULT_PP_LOCALS_FULL_NAMES, "(pretty printer) show full names of locals"); register_bool_option(*g_pp_beta, LEAN_DEFAULT_PP_BETA, "(pretty printer) apply beta-reduction when pretty printing"); register_bool_option(*g_pp_numerals, LEAN_DEFAULT_PP_NUMERALS, "(pretty printer) display nat/num numerals in decimal notation"); register_bool_option(*g_pp_strings, LEAN_DEFAULT_PP_STRINGS, "(pretty printer) pretty print string and character literals"); register_bool_option(*g_pp_preterm, LEAN_DEFAULT_PP_PRETERM, "(pretty printer) assume the term is a preterm (i.e., a term before elaboration)"); register_bool_option(*g_pp_goal_compact, LEAN_DEFAULT_PP_GOAL_COMPACT, "(pretty printer) try to display goal in a single line when possible"); register_unsigned_option(*g_pp_goal_max_hyps, LEAN_DEFAULT_PP_GOAL_MAX_HYPS, "(pretty printer) maximum number of hypotheses to be displayed"); register_bool_option(*g_pp_hide_comp_irrel, LEAN_DEFAULT_PP_HIDE_COMP_IRRELEVANT, "(pretty printer) hide terms marked as computationally irrelevant, these marks are introduced by the code generator"); register_bool_option(*g_pp_binder_types, LEAN_DEFAULT_PP_BINDER_TYPES, "(pretty printer) display types of lambda and Pi parameters"); register_bool_option(*g_pp_delayed_abstraction, LEAN_DEFAULT_PP_DELAYED_ABSTRACTION, "(pretty printer) display the location of delayed-abstractions (for debugging purposes)"); register_bool_option(*g_pp_structure_instances, LEAN_DEFAULT_PP_STRUCTURE_INSTANCES, "(pretty printer) display structure instances using the '{ field_name := field_value, ... }' notation " "or '⟨field_value, ... ⟩' if structure is tagged with [pp_using_anonymous_constructor] attribute"); register_bool_option(*g_pp_structure_instances_qualifier, LEAN_DEFAULT_PP_STRUCTURE_INSTANCES_QUALIFIER, "(pretty printer) include qualifier 'struct_name .' " "when displaying structure instances using the '{ struct_name . field_name := field_value, ... }' notation, " "this option is ignored when pp.structure_instances is false"); register_bool_option(*g_pp_structure_projections, LEAN_DEFAULT_PP_STRUCTURE_PROJECTIONS, "(pretty printer) display structure projections using field notation"); register_bool_option(*g_pp_all, LEAN_DEFAULT_PP_ALL, "(pretty printer) display coercions, implicit parameters, proof terms, fully qualified names, universes, " "and disable beta reduction and notation during pretty printing"); register_bool_option(*g_pp_instantiate_mvars, LEAN_DEFAULT_PP_INSTANTIATE_MVARS, "(pretty printer) instantiate assigned metavariables before pretty printing terms and goals"); register_bool_option(*g_pp_use_holes, LEAN_DEFAULT_PP_USE_HOLES, "(pretty printer) use holes '{! !}' when pretty printing metavariables and `sorry`"); register_bool_option(*g_pp_annotations, LEAN_DEFAULT_PP_ANNOTATIONS, "(pretty printer) display internal annotations (for debugging purposes only)"); options universes_true(*g_pp_universes, true); options full_names_true(*g_pp_full_names, true); options implicit_true(*g_pp_implicit, true); options proofs_true(*g_pp_proofs, true); options coercions_true(*g_pp_coercions, true); options notation_false(*g_pp_notation, false); options binder_types_true(*g_pp_binder_types, true); options implicit_coercions = join(coercions_true, implicit_true); options implicit_notation = join(notation_false, implicit_true); options all = universes_true + implicit_true + proofs_true + coercions_true + notation_false + full_names_true + binder_types_true; g_distinguishing_pp_options = new list<options>({implicit_true, full_names_true, coercions_true, implicit_coercions, implicit_notation, universes_true, all}); set_distinguishing_pp_options(*g_distinguishing_pp_options); }
void initialize_calc_proof_elaborator() { g_elaborator_calc_assistant = new name{"elaborator", "calc_assistant"}; register_bool_option(*g_elaborator_calc_assistant, LEAN_DEFAULT_CALC_ASSISTANT, "(elaborator) when needed lean automatically adds symmetry, " "inserts missing arguments, and applies substitutions"); }