def action_negate(proof_step,
selected_objects: [MathObject],
target_selected: bool = True) -> CodeForLean:
"""
Translate into string of lean code corresponding to the action
If no hypothesis has been previously selected:
transform the target in an equivalent one with its negations 'pushed'.
If a hypothesis has been previously selected:
do the same to the hypothesis.
"""
test_selection(selected_objects, target_selected)
goal = proof_step.goal
if len(selected_objects) == 0:
if not goal.target.is_not():
raise WrongUserInput(error=_("Target is not a negation 'NOT P'"))
code = CodeForLean.from_string('push_neg')
code.add_success_msg(_("Negation pushed on target"))
elif len(selected_objects) == 1:
if not selected_objects[0].is_not():
error = _("Selected property is not a negation 'NOT P'")
raise WrongUserInput(error)
selected_hypo = selected_objects[0].info["name"]
code = CodeForLean.from_string(f'push_neg at {selected_hypo}')
code.add_success_msg(
_(f"Negation pushed on property "
f"{selected_hypo}"))
else:
raise WrongUserInput(error=_('Only one property at a time'))
return code
def action_or(proof_step,
selected_objects: [MathObject],
user_input=None,
target_selected: bool = True) -> CodeForLean:
"""
If the target is of the form P OR Q:
transform the target in P (or Q) according to the user's choice.
If a hypothesis of the form P OR Q has been previously selected:
transform the current goal into two subgoals,
one with P as a hypothesis,
and another with Q as a hypothesis.
"""
test_selection(selected_objects, target_selected)
goal = proof_step.goal
if len(selected_objects) == 0:
if not goal.target.is_or():
raise WrongUserInput(
error=_("Target is not a disjunction 'P OR Q'"))
else:
return construct_or(proof_step, user_input)
elif len(selected_objects) == 1:
if selected_objects[0].is_or():
return apply_or(proof_step, selected_objects, user_input)
else:
return construct_or_on_hyp(proof_step, selected_objects,
user_input)
elif len(selected_objects) == 2:
return construct_or_on_hyp(proof_step, selected_objects, user_input)
else: # More than 2 selected objects
raise WrongUserInput(error=_("Does not apply to more than two "
"properties"))
def action_and(proof_step,
selected_objects: [MathObject],
user_input: [str] = None,
target_selected: bool = True) -> CodeForLean:
"""
Translate into string of lean code corresponding to the action
If the target is of the form P AND Q:
transform the current goal into two subgoals, P, then Q.
If a hypothesis of the form P AND Q has been previously selected:
creates two new hypothesis P, and Q.
If two hypothesis P, then Q, have been previously selected:
add the new hypothesis P AND Q to the properties.
"""
test_selection(selected_objects, target_selected)
goal = proof_step.goal
if len(selected_objects) == 0:
return construct_and(proof_step, user_input)
if len(selected_objects) == 1:
if not selected_objects[0].is_and():
raise WrongUserInput(error=_("Selected property is not "
"a conjunction 'P AND Q'"))
else:
return apply_and(proof_step, selected_objects)
if len(selected_objects) == 2:
if not (selected_objects[0].math_type.is_prop
and selected_objects[1].math_type.is_prop):
raise WrongUserInput(error=_("Selected items are not properties"))
else:
return construct_and_hyp(proof_step, selected_objects)
raise WrongUserInput(error=_("Does not apply to more than two properties"))
def construct_or_on_hyp(proof_step,
selected_property: [MathObject],
user_input: [str] = None) -> CodeForLean:
"""
Construct a property 'P or Q' from property 'P' or property 'Q'.
Here we assume selected_object contains 1 or 2 items.
"""
if not user_input:
user_input = []
possible_codes = []
first_hypo_name = selected_property[0].info["name"]
hypo = selected_property[0].math_type.to_display()
if len(selected_property) == 2:
if not (selected_property[0].math_type.is_prop()
and selected_property[1].math_type.is_prop()):
error = _("Selected items are not properties")
raise WrongUserInput(error)
else:
second_selected_property = selected_property[1].info["name"]
elif len(selected_property) == 1:
if not selected_property[0].math_type.is_prop():
error = _("Selected item is not a property")
raise WrongUserInput(error)
if not user_input:
raise MissingParametersError(
InputType.Text,
title=_("Obtain 'P OR Q'"),
output=_("Enter the proposition you want to use:"))
else:
second_selected_property = user_input[0]
user_input = user_input[1:]
if not user_input:
raise MissingParametersError(
InputType.Choice,
[(_("Left"), f'({hypo}) OR ({second_selected_property})'),
(_('Right'), f'({second_selected_property}) OR ({hypo})')],
title=_("Choose side"),
output=_(f'On which side do you want') + f' {hypo} ?')
new_hypo_name = get_new_hyp(proof_step)
if user_input[0] == 0:
possible_codes.append(f'have {new_hypo_name} := '
f'@or.inl _ ({second_selected_property}) '
f'({first_hypo_name})')
elif user_input[0] == 1:
possible_codes.append(f'have {new_hypo_name} := '
f'@or.inr ({second_selected_property}) _ '
f'({first_hypo_name})')
else:
raise WrongUserInput("Unexpected error")
code = CodeForLean.or_else_from_list(possible_codes)
code.add_success_msg(
_('Property {} added to the context').format(new_hypo_name))
return code
def action_forall(proof_step,
selected_objects: [MathObject],
user_input: [str] = [],
target_selected: bool = True) -> CodeForLean:
"""
(1) If no selection and target is of the form ∀ x, P(x):
introduce x and transform the target into P(x)
(2) If a single universal property is selected, ask user for an object
to which the property will be applied
(3) If 2 or more items are selected, one of which is a universal
property, try to apply it to the other selected items
"""
test_selection(selected_objects, target_selected)
goal = proof_step.goal
if len(selected_objects) == 0:
if not goal.target.is_for_all():
error = _("target is not a universal property '∀x, P(x)'")
raise WrongUserInput(error)
else:
return construct_forall(proof_step)
elif len(selected_objects) == 1: # Ask user for item
if not selected_objects[0].is_for_all():
error = _("selected property is not a universal property '∀x, "
"P(x)'")
raise WrongUserInput(error)
elif not user_input:
raise MissingParametersError(InputType.Text,
title=_("Apply a universal property"),
output=_("Enter element on which you "
"want to apply:"))
else:
item = user_input[0]
item = add_type_indication(item) # e.g. (0:ℝ)
if item[0] != '(':
item = '(' + item + ')'
potential_var = MathObject(node="LOCAL_CONSTANT",
info={'name': item},
children=[],
math_type=None)
selected_objects.insert(0, potential_var)
# Now len(l) == 2
# From now on len(l) ≥ 2
# Search for a universal property among l, beginning with last item
selected_objects.reverse()
for item in selected_objects:
if item.is_for_all():
# Put item on last position
selected_objects.remove(item)
selected_objects.reverse()
selected_objects.append(item)
return apply_forall(proof_step, selected_objects)
raise WrongUserInput(error=_("no universal property among selected"))
def action_compute(proof_step, selected_objects, target_selected: bool = True):
"""
If the target is an equality, an inequality (or 'False'), then send
tactics trying to prove the goal by (mainly linearly) computing.
"""
goal = proof_step.goal
target = goal.target
if not (target.is_equality() or target.is_inequality()
or target.is_false()):
error = _("target is not an equality, an inequality, "
"nor a contradiction")
raise WrongUserInput(error)
# try_before = "try {apply div_pos}, " \
# + "try { all_goals {norm_num at *}}" \
# + ", "
# simplify_1 = "simp only " \
# + "[*, ne.symm, ne.def, not_false_iff, lt_of_le_of_ne]"
# possible_code = [try_before + "linarith",
# try_before + simplify_1]
# "finish" "norm_num *"
# if user_config.getboolean('use_library_search_for_computations'):
# possible_code.append('library_search')
code1 = CodeForLean.from_string("norm_num at *").solve1()
code2 = CodeForLean.from_string("compute_n 10")
code3 = CodeForLean.from_string("norm_num at *").try_().and_then(code2)
possible_code = code1.or_else(code3)
#possible_code = [solve1_wrap("norm_num at *"),
# solve1_wrap("try {norm_num at *}, compute_n 10")]
return possible_code
def action_exists(proof_step,
selected_objects: [MathObject],
user_input: [str] = None,
target_selected: bool = True) -> CodeForLean:
"""
Three cases:
(1) If target is of form ∃ x, P(x):
- if no selection, ask the user to enter a witness x and transform
the target into P(x).
- if some selection, use it as a witness for existence.
(2) If a hypothesis of form ∃ x, P(x) has been previously selected:
introduce a new x and add P(x) to the properties.
(3) If some 'x' and a property P(x) have been selected:
get property '∃ x, P(x)'
"""
test_selection(selected_objects, target_selected)
goal = proof_step.goal
if len(selected_objects) == 0:
if not goal.target.is_exists():
error = _("target is not existential property '∃x, P(x)'")
raise WrongUserInput(error)
else:
return construct_exists(proof_step, user_input)
elif len(selected_objects) == 1 and not user_input:
selected_hypo = selected_objects[0]
if selected_hypo.math_type.is_prop():
# Try to apply property "exists x, P(x)" to get a new MathObject x
if not selected_hypo.is_exists():
error = _("selection is not existential property '∃x, P(x)'")
raise WrongUserInput(error)
else:
return apply_exists(proof_step, selected_objects)
else: # h_selected is not a property : get an existence property
if not goal.target.is_exists():
error = _("target is not existential property '∃x, P(x)'")
raise WrongUserInput(error)
else:
object_name = selected_objects[0].info["name"]
return construct_exists(proof_step, [object_name])
elif len(selected_objects) == 2:
return construct_exists_on_hyp(proof_step, selected_objects)
raise WrongUserInput(error=_("does not apply to more than two properties"))
def action_iff(proof_step,
selected_objects: [MathObject],
user_input: [str] = [],
target_selected: bool = True) -> CodeForLean:
"""
Three cases:
(1) No selected property:
If the target is of the form P ⇔ Q:
introduce two subgoals, P⇒Q, and Q⇒P.
If target is of the form (P → Q) ∧ (Q → P):
replace by P ↔ Q
(2) 1 selected property, which is an iff P ⇔ Q:
split it into two implications P⇒Q, and Q⇒P.
(3) 2 properties:
try to obtain P ⇔ Q.
"""
test_selection(selected_objects, target_selected)
goal = proof_step.goal
if len(selected_objects) == 0:
if goal.target.math_type.node != "PROP_IFF":
code = destruct_iff(proof_step)
if code:
return code
else:
raise WrongUserInput(
error=_("target is not an iff property 'P ⇔ Q'"))
else:
return construct_iff(proof_step, user_input)
if len(selected_objects) == 1:
if selected_objects[0].math_type.node != "PROP_IFF":
error = _("selected property is not an iff property 'P ⇔ Q'")
raise WrongUserInput(error)
else:
return destruct_iff_on_hyp(proof_step, selected_objects)
if len(selected_objects) == 2:
if not (selected_objects[0].math_type.is_prop()
and selected_objects[1].math_type.is_prop()):
error = _("selected items should both be implications")
raise WrongUserInput(error)
else:
return construct_iff_on_hyp(proof_step, selected_objects)
raise WrongUserInput(error=_("does not apply to more than two properties"))
def method_absurdum(proof_step, selected_objects: [MathObject]) -> CodeForLean:
"""
If no selection, engage in a proof by contradiction.
"""
if len(selected_objects) == 0:
new_hypo = get_new_hyp(proof_step)
code = CodeForLean.from_string(f'by_contradiction {new_hypo}')
code.add_success_msg(_("Negation of target added to the context"))
return code
else:
error = _('Proof by contradiction only applies to target')
raise WrongUserInput(error)
def action_implicate(proof_step,
selected_objects: [MathObject],
target_selected: bool = True) -> CodeForLean:
"""
Three cases:
(1) No property selected:
If the target is of the form P ⇒ Q: introduce the hypothesis P in
the properties and transform the target into Q.
(2) A single selected property, of the form P ⇒ Q: If the target was Q,
it is replaced by P
(3) Exactly two selected property, on of which is an implication P ⇒ Q
and the other is P: Add Q to the context
"""
test_selection(selected_objects, target_selected)
goal = proof_step.goal
if len(selected_objects) == 0:
if not goal.target.is_implication():
raise WrongUserInput(
error=_("Target is not an implication 'P ⇒ Q'"))
else:
return construct_implicate(proof_step)
if len(selected_objects) == 1:
if not selected_objects[0].can_be_used_for_implication():
raise WrongUserInput(
error=_("Selected property is not an implication 'P ⇒ Q'"))
else:
return apply_implicate(proof_step, selected_objects)
elif len(selected_objects) == 2:
if not selected_objects[-1].can_be_used_for_implication():
if not selected_objects[0].can_be_used_for_implication():
raise WrongUserInput(error=_(
"Selected properties are not implications 'P ⇒ Q'"))
else: # l[0] is an implication but not l[1]: permute
selected_objects.reverse()
return apply_implicate_to_hyp(proof_step, selected_objects)
# TODO: treat the case of more properties, including the possibility of
# P, Q and 'P and Q ⇒ R'
raise WrongUserInput(error=_("Does not apply to more than two properties"))
def construct_implicate(proof_step) -> CodeForLean:
"""
Here the target is assumed to be an implication P ⇒ Q, P is added to the
context, and the target becomes Q.
"""
if not proof_step.goal.target.is_implication():
raise WrongUserInput(error=_("Target is not an implication 'P ⇒ Q'"))
else:
new_hypo_name = get_new_hyp(proof_step)
code = CodeForLean.from_string(f'intro {new_hypo_name}')
code.add_success_msg(
_("Property {} added to the context").format(new_hypo_name))
return code
def method_contrapose(proof_step,
selected_objects: [MathObject]) -> CodeForLean:
"""
If target is an implication, turn it to its contrapose.
"""
goal = proof_step.goal
if len(selected_objects) == 0:
if goal.target.math_type.node == "PROP_IMPLIES":
code = CodeForLean.from_string("contrapose")
code.add_success_msg(_("Target replaced by contrapositive"))
return code
else:
error = _('Proof by contraposition only applies when target is '
'an implication')
else:
error = _('Proof by contraposition only applies to target')
raise WrongUserInput(error)
def introduce_fun(proof_step, selected_objects: [MathObject]) -> CodeForLean:
"""
If a hypothesis of form ∀ a ∈ A, ∃ b ∈ B, P(a,b) has been previously
selected: use the axiom of choice to introduce a new function f : A → B
and add ∀ a ∈ A, P(a, f(a)) to the properties.
"""
goal = proof_step.goal
error = _('select a property "∀ x, ∃ y, P(x,y)" to get a function')
success = _("function {} and property {} added to the context")
if len(selected_objects) == 1:
h = selected_objects[0].info["name"]
# Finding expected math_type for the new function
universal_property = selected_objects[0]
if universal_property.is_for_all():
source_type = universal_property.math_type.children[0]
exist_property = universal_property.math_type.children[2]
if exist_property.is_exists(is_math_type=True):
target_type = exist_property.children[0]
math_type = MathObject(node="FUNCTION",
info={},
children=[source_type, target_type],
math_type=NO_MATH_TYPE)
hf = get_new_hyp(proof_step)
f = give_global_name(math_type=math_type,
proof_step=proof_step)
code = CodeForLean.from_string(f'cases '
f'classical.axiom_of_choice '
f'{h} with {f} {hf}, '
f'dsimp at {hf}, '
f'dsimp at {f}')
code.add_error_msg(error)
success = success.format(f, hf)
code.add_success_msg(success)
return code
raise WrongUserInput(error)
def method_cbr(proof_step,
selected_objects: [MathObject],
user_input: [str] = []) -> CodeForLean:
"""
Engage in a proof by cases.
- If selection is empty, then ask the user to choose a property
- If a disjunction is selected, use this disjunction for the proof by cases
_ If anything else is selected try to discuss on this property
(useful only in propositional calculus?)
In any case, ask the user which case she wants to prove first.
"""
if len(selected_objects) == 0:
# NB: user_input[1] contains the needed property
if len(user_input) == 1:
raise MissingParametersError(
InputType.Text,
title=_("cases"),
output=_("Enter the property you want to discriminate on:")
)
else:
h0 = user_input[1]
h1 = get_new_hyp(proof_step)
h2 = get_new_hyp(proof_step)
code = CodeForLean.from_string(f"cases (classical.em ({h0})) "
f"with {h1} {h2}")
code.add_success_msg(_("Proof by cases"))
code.add_disjunction(h0, h1, h2) # Strings, not MathObject
else:
prop = selected_objects[0]
if not prop.is_or():
error = _("Selected property is not a disjunction")
raise WrongUserInput(error)
else:
code = apply_or(proof_step, selected_objects, user_input)
return code
def construct_iff(proof_step, user_input: [str]) -> CodeForLean:
"""
Assuming target is an iff, split into two implications.
"""
target = proof_step.goal.target.math_type
code = CodeForLean.empty_code()
left = target.children[0]
right = target.children[1]
if not user_input:
choices = [("⇒", f'({left.to_display()}) ⇒ ({right.to_display()})'),
("⇐", f'({right.to_display()}) ⇒ ({left.to_display()})')]
raise MissingParametersError(
InputType.Choice,
choices,
title=_("Choose sub-goal"),
output=_("Which implication to prove first?"))
elif len(user_input) == 1:
if user_input[0] == 1:
code = CodeForLean.from_string("rw iff.comm")
left, right = right, left
code = code.and_then("split")
else:
raise WrongUserInput(error=_("Undocumented error"))
code.add_success_msg(_("Iff split in two implications"))
impl1 = MathObject(info={},
node="PROP_IMPLIES",
children=[left, right],
math_type="PROP")
impl2 = MathObject(info={},
node="PROP_IMPLIES",
children=[right, left],
math_type="PROP")
code.add_conjunction(target, impl1, impl2)
return code
def construct_and(proof_step, user_input: [str]) -> CodeForLean:
"""
Split the target 'P AND Q' into two sub-goals.
"""
target = proof_step.goal.target.math_type
if not target.is_and(is_math_type=True):
raise WrongUserInput(error=_("Target is not a conjunction 'P AND Q'"))
left = target.children[0]
right = target.children[1]
if not user_input:
# User choice
choices = [(_("Left"), left.to_display()),
(_("Right"), right.to_display())]
raise MissingParametersError(
InputType.Choice,
choices,
title=_("Choose sub-goal"),
output=_("Which property to prove first?"))
else:
if user_input[0] == 1:
# Prove second property first
if target.node == "PROP_∃":
# In this case, first rw target as a conjunction
code = CodeForLean.and_then_from_list(
["rw exists_prop", "rw and.comm"])
else:
code = CodeForLean.from_string("rw and.comm")
left, right = right, left
else:
code = CodeForLean.empty_code()
code = code.and_then("split")
code.add_success_msg(_('Target split'))
code.add_conjunction(target, left, right)
return code
def construct_exists_on_hyp(proof_step,
selected_objects: [MathObject]) -> CodeForLean:
"""
Try to construct an existence property from some object and some property
Here len(l) = 2
"""
x = selected_objects[0].info["name"]
hx = selected_objects[1].info["name"]
if (not selected_objects[0].math_type.is_prop()) \
and selected_objects[1].math_type.is_prop():
new_hypo = get_new_hyp(proof_step)
code_string = f'have {new_hypo} := exists.intro {x} {hx}'
elif (not selected_objects[1].math_type.is_prop()) \
and selected_objects[0].math_type.is_prop():
x, hx = hx, x
new_hypo = get_new_hyp(proof_step)
code_string = f'have {new_hypo} := exists.intro {x} {hx}'
else:
error = _("I cannot build an existential property with this")
raise WrongUserInput(error)
code = CodeForLean.from_string(code_string)
code.add_success_msg(_("get new existential property {}").format(new_hypo))
return code
def action_apply(proof_step,
selected_objects: [MathObject],
user_input: [str] = [],
target_selected: bool = True):
"""
Translate into string of lean code corresponding to the action
Function explain_how_to_apply should reflect the actions
Apply last selected item on the other selected
test for last selected item l[-1], and call functions accordingly:
- apply_function, if item is a function
- apply_susbtitute, if item can_be_used_for_substitution
ONLY if the option expanded_apply_button is set:
- apply_implicate, if item is an implication or a universal property
(or call action_forall if l[-1] is a universal property and none of
the other actions apply)
- apply_exists, if item is an existential property
- apply_and
- apply_or
...
"""
# fixme: rewrite to provide meaningful error msgs
if not selected_objects:
raise WrongUserInput(error=_("no property selected"))
# Now len(l) > 0
prop = selected_objects[-1] # property to be applied
# (1) If user wants to apply a function
# (note this is exclusive of other types of applications)
if prop.is_function():
if len(selected_objects) == 1:
# TODO: ask user for element on which to apply the function
# (plus new name, cf apply_forall)
error = _("select an element or an equality on which to "
"apply the function")
raise WrongUserInput(error=error)
else:
return apply_function(proof_step, selected_objects)
codes = CodeForLean.empty_code()
error = ""
# (2) If rewriting is possible
test, equality = prop.can_be_used_for_substitution()
if test:
codes = codes.or_else(apply_substitute(proof_step,
selected_objects,
user_input,
equality))
expanded_apply_button = cvars.get('expanded_apply_button', False)
if expanded_apply_button:
# What follows applies only if expanded_apply_button
# (4) Other easy applications
if len(selected_objects) == 1 and user_can_apply(selected_objects[0]):
if prop.is_exists():
codes = codes.or_else(apply_exists(proof_step,
selected_objects))
if prop.is_and():
codes = codes.or_else(apply_and(proof_step, selected_objects))
if prop.is_or():
codes = codes.or_else(apply_or(proof_step,
selected_objects,
user_input))
if not codes.is_empty():
return codes
else:
error = _("I cannot apply this") # fixme: be more precise
raise WrongUserInput(error)