def get_proof_term(self, t): pt = refl(t) is_l_atom = (dest_monomial(t.arg1) == t.arg1) is_r_atom = (dest_monomial(t.arg) == t.arg) if is_l_atom and is_r_atom: return pt.on_rhs(norm_mult_monomial(self.conds)) elif is_l_atom and not is_r_atom: if t.arg.is_number(): return pt.on_rhs(rewr_conv('real_mult_comm'), try_conv(rewr_conv('real_mul_rid')), try_conv(rewr_conv('real_mul_lzero'))) else: return pt.on_rhs(arg_conv(rewr_conv('real_mult_comm')), rewr_conv('real_mult_assoc'), rewr_conv('real_mult_comm'), arg_conv(norm_mult_monomial(self.conds))) elif not is_l_atom and is_r_atom: if t.arg1.is_number(): return pt.on_rhs(try_conv(rewr_conv('real_mul_rid')), try_conv(rewr_conv('real_mul_lzero'))) else: return pt.on_rhs(rewr_conv('real_mult_assoc', sym=True), arg_conv(norm_mult_monomial(self.conds))) else: return pt.on_rhs( binop_conv(to_coeff_form()), # (c_1 * m_1) * (c_2 * m_2) rewr_conv('real_mult_assoc'), # (c_1 * m_1 * c_2) * m_2 arg1_conv(swap_mult_r()), # (c_1 * c_2 * m_1) * m_2 arg1_conv(arg1_conv(real_eval_conv())), # (c_1c_2 * m_1) * m_2 rewr_conv('real_mult_assoc', sym=True), # c_1c_2 * (m_1 * m_2) arg_conv(norm_mult_monomial(self.conds)), from_coeff_form())
def get_proof_term(self, t): pt = refl(t) if t.is_plus(): if t.arg1.is_zero(): return pt.on_rhs(rewr_conv('int_add_0_left')) elif t.arg.is_zero(): return pt.on_rhs(rewr_conv('int_add_0_right')) elif t.arg.is_plus(): # t is of form a + (b + c) return pt.on_rhs( rewr_conv('int_add_assoc'), # (a + b) + c arg1_conv(self), # merge terms in b into a norm_add_monomial()) # merge c into a + b elif t.arg.is_minus(): # t is of form a + (b - c) return pt.on_rhs( arg_conv(norm_add_monomial()), # a + b + (-1) * c arg1_conv(self), norm_add_polynomial()) else: return pt.on_rhs(norm_add_monomial()) elif t.is_minus(): if t.arg.is_plus(): # t is of form a - (b + c) return pt.on_rhs( rewr_conv('int_sub_add_distr'), # a - b - c arg1_conv(self), # merge terms in b into a norm_add_monomial() # merge c into a - b ) elif t.arg.is_minus(): # t is of form a - (b - c) return pt.on_rhs( rewr_conv('int_sub_sub_distr'), # a - b + c arg1_conv(self), # merge terms in b into c norm_add_monomial() # merge c into a - b ) else: return pt.on_rhs(norm_add_monomial(), )
def get_proof_term(self, t): if not t.is_compares() or not t.arg1.get_type() == IntType: raise ConvException(str(t)) pt = refl(t) # first move all terms in rhs to lhs and normalize lhs if t.is_greater(): pt1 = pt.on_rhs(rewr_conv('int_gt_to_geq'), rewr_conv('int_geq'), arg1_conv(omega_simp_full_conv())) elif t.is_greater_eq(): pt1 = pt.on_rhs(rewr_conv('int_geq'), arg1_conv(omega_simp_full_conv())) elif t.is_less(): pt1 = pt.on_rhs(rewr_conv('int_less_to_leq'), rewr_conv('int_leq'), arg1_conv(omega_simp_full_conv())) elif t.is_less_eq(): pt1 = pt.on_rhs(rewr_conv('int_leq'), arg1_conv(omega_simp_full_conv())) else: raise NotImplementedError # move all constant term on lhs to rhs lhs = pt1.rhs.arg1 if lhs.is_number() or lhs.is_times() or lhs.arg.is_times(): return pt1 elif pt1.rhs.is_greater_eq() and lhs.arg.is_number(): return pt1.on_rhs(rewr_conv('int_geq_shift'), arg_conv(int_eval_conv())) elif pt1.rhs.is_less_eq() and lhs.arg.is_number(): return pt1.on_rhs(rewr_conv('int_leq_shift'), arg_conv(int_eval_conv())) else: raise NotImplementedError
def get_proof_term(self, t): pt = refl(t) if t.arg1.is_times(): # t is of form (a * b) * c cp = compare_atom(t.arg1.arg, t.arg) # compare b with c by their base if cp > 0: # if b > c, need to swap b with c return pt.on_rhs( swap_mult_r(), # (a * c) * b arg1_conv(self)) # possibly move c further inside a elif cp == 0: # if b and c have the same base, combine the exponents return pt.on_rhs( rewr_conv('int_mult_assoc', sym=True), # a * (b^e1 * b^e2) arg_conv(rewr_conv('int_power_add', sym=True)), # a * (b^(e1 + e2)) arg_conv(arg_conv(int_eval_conv()))) # evaluate e1 + e2 else: # if b < c, atoms already ordered since we assume b is ordered. return pt else: # t is of the form a * b cp = compare_atom(t.arg1, t.arg) # compare a with b by their base if cp > 0: # if a > b, need to swap a and b return pt.on_rhs(rewr_conv('int_mult_comm')) elif cp == 0: # if a and b have the same base, combine the exponents return pt.on_rhs(rewr_conv('int_power_add', sym=True), arg_conv(int_eval_conv())) else: return pt
def get_proof_term(self, t): pt = refl(t) if t.arg.is_times(): return pt.on_rhs(rewr_conv('real_mult_assoc'), arg1_conv(self), norm_mult_atom(self.conds)) else: return pt.on_rhs(norm_mult_atom(self.conds))
def get_proof_term(self, t): pt = refl(t) if t.arg1.is_one(): return pt.on_rhs(rewr_conv('real_mul_lid')) elif t.arg.is_one(): return pt.on_rhs(rewr_conv('real_mul_rid')) elif t.arg1.is_times(): # Left side has more than one atom. Compare last atom with b m1, m2 = dest_atom(t.arg1.arg), dest_atom(t.arg) if m1 == m2: pt = pt.on_rhs(rewr_conv('real_mult_assoc', sym=True), arg_conv(combine_atom(self.conds))) if pt.rhs.arg.is_one(): pt = pt.on_rhs(rewr_conv('real_mul_rid')) return pt elif atom_less(m1, m2): return pt else: pt = pt.on_rhs(swap_mult_r(), arg1_conv(self)) if pt.rhs.arg1.is_one(): pt = pt.on_rhs(rewr_conv('real_mul_lid')) return pt else: # Left side is an atom. Compare two sides m1, m2 = dest_atom(t.arg1), dest_atom(t.arg) if m1 == m2: return pt.on_rhs(combine_atom(self.conds)) elif atom_less(m1, m2): return pt else: return pt.on_rhs(rewr_conv('real_mult_comm'))
def get_proof_term(self, t): pt = refl(t).on_rhs(binop_conv(to_exponent_form())) if pt.rhs.arg1.is_comb('exp', 1) and pt.rhs.arg.is_comb('exp', 1): # Both sides are exponentials return pt.on_rhs(rewr_conv('real_exp_add', sym=True), arg_conv(auto.auto_conv(self.conds))) elif pt.rhs.arg1.is_nat_power() and pt.rhs.arg.is_nat_power(): # Both sides are natural number powers, simply add return pt.on_rhs(rewr_conv('real_pow_add', sym=True), arg_conv(nat.nat_conv())) else: # First check that x > 0 can be proved. If not, just return # without change. x = pt.rhs.arg1.arg1 try: x_gt_0 = auto.solve(x > 0, self.conds) except TacticException: return refl(t) # Convert both sides to real powers if pt.rhs.arg1.is_nat_power(): pt = pt.on_rhs(arg1_conv(rewr_conv('rpow_pow', sym=True))) if pt.rhs.arg.is_nat_power(): pt = pt.on_rhs(arg_conv(rewr_conv('rpow_pow', sym=True))) pt = pt.on_rhs(rewr_conv('rpow_add', sym=True, conds=[x_gt_0]), arg_conv(real_eval_conv())) # Simplify back to nat if possible if pt.rhs.arg.is_comb('of_nat', 1): pt = pt.on_rhs(rewr_conv('rpow_pow'), arg_conv(rewr_conv('nat_of_nat_def', sym=True))) return pt.on_rhs(from_exponent_form())
def get_proof_term(self, t): pt = refl(t) if t.arg.is_plus(): return pt.on_rhs(rewr_conv('real_add_assoc'), arg1_conv(self), norm_add_monomial()) else: return pt.on_rhs(norm_add_monomial())
def get_proof_term(self, t): pt = refl(t) if t.arg1.is_zero(): return pt.on_rhs(rewr_conv("real_add_lid")) elif t.arg.is_zero(): return pt.on_rhs(rewr_conv("real_add_rid")) elif t.arg1.is_plus(): # Left side has more than one term. Compare last term with a m1, m2 = dest_monomial(t.arg1.arg), dest_monomial(t.arg) if m1 == m2: pt = pt.on_rhs(rewr_conv('real_add_assoc', sym=True), arg_conv(combine_monomial())) if pt.rhs.arg.is_zero(): pt = pt.on_rhs(rewr_conv('real_add_rid')) return pt elif atom_less(m1, m2): return pt else: pt = pt.on_rhs(swap_add_r(), arg1_conv(self)) if pt.rhs.arg1.is_zero(): pt = pt.on_rhs(rewr_conv('real_add_lid')) return pt else: # Left side is an atom. Compare two sides m1, m2 = dest_monomial(t.arg1), dest_monomial(t.arg) if m1 == m2: return pt.on_rhs(combine_monomial()) elif atom_less(m1, m2): return pt else: return pt.on_rhs(rewr_conv('real_add_comm'))
def get_proof_term(self, t): pt = refl(t) if t.arg.is_times(): return pt.on_rhs(rewr_conv("mult_assoc", sym=True), arg1_conv(norm_mult_monomial()), norm_mult_atom()) else: return pt.on_rhs(norm_mult_atom())
def get_proof_term(self, t): pt = refl(t) if t.arg1.is_zero(): return pt.on_rhs(rewr_conv("nat_times_def_1")) elif t.arg.is_zero(): return pt.on_rhs(rewr_conv("mult_0_right")) elif t.arg1.is_one(): return pt.on_rhs(rewr_conv("mult_1_left")) elif t.arg.is_one(): return pt.on_rhs(rewr_conv("mult_1_right")) elif t.arg1.is_times(): cp = compare_atom(t.arg1.arg, t.arg) if cp > 0: return pt.on_rhs(swap_times_r(), arg1_conv(norm_mult_atom())) elif cp == 0: if t.arg.is_number() and has_binary_thms(): return pt.on_rhs(rewr_conv("mult_assoc"), arg_conv(nat_conv())) else: return pt else: return pt else: cp = compare_atom(t.arg1, t.arg) if cp > 0: return pt.on_rhs(rewr_conv("mult_comm")) elif cp == 0: if t.arg.is_number() and has_binary_thms(): return pt.on_rhs(nat_conv()) else: return pt else: return pt
def get_proof_term(self, t): pt = refl(t) if t.arg.is_plus(): return pt.on_rhs(rewr_conv("add_assoc", sym=True), arg1_conv(norm_add_1()), norm_add_atom_1()) else: return pt.on_rhs(norm_add_atom_1())
def get_proof_term(self, thy, t): if is_plus(t.arg): return every_conv(rewr_conv("add_assoc", sym=True), arg1_conv(norm_add_polynomial()), norm_add_monomial()).get_proof_term(thy, t) else: return norm_add_monomial().get_proof_term(thy, t)
def get_proof_term(self, thy, t): if is_times(t.arg): return every_conv(rewr_conv("mult_assoc", sym=True), arg1_conv(norm_mult_monomial()), norm_mult_atom()).get_proof_term(thy, t) else: return norm_mult_atom().get_proof_term(thy, t)
def interval_union_subset(t): """Given t of the form I1 Un I2, return a theorem of the form I1 Un I2 SUB I. """ assert t.is_comb('union', 2), "interval_union_subset" I1, I2 = t.args a, b = I1.args c, d = I2.args if is_closed_interval(I1) and is_closed_interval(I2): pt = apply_theorem('closed_interval_union', inst=Inst(a=a, b=b, c=c, d=d)) return pt.on_prop( arg_conv( then_conv(arg1_conv(const_min_conv()), arg_conv(const_max_conv())))) elif is_open_interval(I1) and is_ropen_interval(I2): if eval_hol_expr(c) <= eval_hol_expr(a): pt = apply_theorem('open_ropen_interval_union1', auto.auto_solve(real.less_eq(c, a)), inst=Inst(b=b, d=d)) else: pt = apply_theorem('open_ropen_interval_union2', auto.auto_solve(real.less(a, c)), inst=Inst(b=b, d=d)) return pt.on_prop(arg_conv(arg_conv(const_max_conv()))) else: raise NotImplementedError return pt
def get_proof_term(self, thy, t): if t.arg1 == zero: cv = rewr_conv("times_def_1") elif t.arg == zero: cv = rewr_conv("mult_0_right") elif t.arg1 == one: cv = rewr_conv("mult_1_left") elif t.arg == one: cv = rewr_conv("mult_1_right") elif is_times(t.arg1): cmp = compare_atom(t.arg1.arg, t.arg) if cmp == term_ord.GREATER: cv = then_conv(swap_times_r(), arg1_conv(norm_mult_atom())) elif cmp == term_ord.EQUAL: if is_binary(t.arg): cv = then_conv(rewr_conv("mult_assoc"), arg_conv(nat_conv())) else: cv = all_conv() else: cv = all_conv() else: cmp = compare_atom(t.arg1, t.arg) if cmp == term_ord.GREATER: cv = rewr_conv("mult_comm") elif cmp == term_ord.EQUAL: if is_binary(t.arg): cv = nat_conv() else: cv = all_conv() else: cv = all_conv() return cv.get_proof_term(thy, t)
def get_proof_term(self, t): if not t.is_compares(): raise ConvException('%s is not a comparison.' % str(t)) pt = refl(t) pt_norm_form = pt.on_rhs(norm_eq(), arg1_conv(omega_simp_full_conv())) summands = strip_plus(pt_norm_form.rhs.arg1) coeffs = [ int_eval(s.arg1) if not s.is_number() else int_eval(s) for s in summands ] g = functools.reduce(gcd, coeffs) if g <= 1: return pt vars = [s.arg for s in summands if not s.is_number()] elim_gcd_coeffs = [int(i / g) for i in coeffs] if len(vars) < len(coeffs): simp_t = sum([ coeff * v for coeff, v in zip(elim_gcd_coeffs[1:-1], vars[1:]) ], elim_gcd_coeffs[0] * vars[0]) + Int(elim_gcd_coeffs[-1]) else: simp_t = sum( [coeff * v for coeff, v in zip(elim_gcd_coeffs[1:], vars[1:])], elim_gcd_coeffs[0] * vars[0]) simp_t_times_gcd = Int(g) * simp_t pt_simp_t_times_gcd = refl(simp_t_times_gcd).on_rhs( omega_simp_full_conv()).symmetric() pt_c = ProofTerm('int_const_ineq', greater(IntType)(Int(g), Int(0))) if t.is_less(): gcd_pt = ProofTerm.theorem('int_simp_less') elif t.is_less_eq(): gcd_pt = ProofTerm.theorem('int_simp_leq') elif t.is_greater(): gcd_pt = ProofTerm.theorem('int_simp_gt') elif t.is_greater_eq(): gcd_pt = ProofTerm.theorem('int_simp_geq') inst1 = matcher.first_order_match(gcd_pt.prop.arg1, pt_c.prop) inst2 = matcher.first_order_match(gcd_pt.prop.arg.rhs.arg1, simp_t, inst=inst1) pt_simp = gcd_pt.substitution(inst2).implies_elim(pt_c).on_lhs( arg1_conv(omega_simp_full_conv())) return pt_norm_form.transitive(pt_simp).on_rhs(omega_form_conv())
def get_proof_term(self, t): pt = refl(t) if t.arg.is_conj(): return pt.on_rhs(rewr_conv('conj_assoc'), arg1_conv(rewr_conv('conj_comm')), rewr_conv('conj_assoc', sym=True)) else: return pt.on_rhs(rewr_conv('conj_comm'))
def get_proof_term(self, thy, t): if is_plus(t.arg): return every_conv(rewr_conv("distrib_l"), arg1_conv(norm_mult_polynomial()), arg_conv(norm_mult_poly_monomial()), norm_add_polynomial()).get_proof_term(thy, t) else: return norm_mult_poly_monomial().get_proof_term(thy, t)
def get_proof_term(self, t): pt = refl(t) if t.arg.is_times(): # t is of form a * (b * c) return pt.on_rhs( rewr_conv('int_mult_assoc'), # (a * b) * c arg1_conv(self), # merge terms in b into a norm_mult_atom()) # merge c into a * b else: return pt.on_rhs(norm_mult_atom())
def get_proof_term(self, t): if not t.is_equals(): raise ConvException("%s must be an equality." % str(t)) pt = refl(t) pt1 = pt.on_rhs(rewr_conv('int_sub_move_0_r', sym=True), arg1_conv(simp_full()), top_conv(rewr_conv('int_pow_1_r'))) summands = strip_plus(pt1.rhs.arg1) if summands[0].is_number(): first_coeff = summands[0] else: first_coeff = summands[0].arg1 if int_eval(first_coeff) < 0: return pt1.on_rhs(rewr_conv('int_pos_neg_eq_0'), arg1_conv(simp_full()), top_conv(rewr_conv('int_pow_1_r'))) else: return pt1
def get_proof_term(self, t): pt = refl(t) if t.arg.is_plus(): return pt.on_rhs(rewr_conv("distrib_l"), arg1_conv(norm_mult_polynomial()), arg_conv(norm_mult_poly_monomial()), norm_add_polynomial()) else: return pt.on_rhs(norm_mult_poly_monomial())
def get_proof_term(self, t): pt = refl(t) if t.arg1.is_number() and t.arg.is_number(): # c * d return pt.on_rhs(int_eval_conv()) elif t.arg1.is_number() and not t.arg.is_number(): # c * (d * body) return pt.on_rhs( rewr_conv('int_mult_assoc'), # (c * d) * body arg1_conv(int_eval_conv())) # evaluate c * d elif not t.arg1.is_number() and t.arg.is_number(): # (c * body) * d return pt.on_rhs(rewr_conv('int_mult_comm'), self) # d * (c * body) else: # (c * body1) * (d * body2) return pt.on_rhs( rewr_conv('int_mult_assoc'), # ((c * body1) * d) * body2 arg1_conv(swap_mult_r()), # ((c * d) * body1) * body2 arg1_conv(arg1_conv(int_eval_conv())), # evaluate c * d rewr_conv('int_mult_assoc', sym=True), # cd * (body1 * body2) arg_conv(norm_mult_monomial_wo_coeff()))
def get_proof_term(self, t): pt = refl(t) if t.is_minus(): # a - c return pt.on_rhs( rewr_conv('int_poly_neg2'), # a + (-k) * body arg_conv(norm_mult_monomial()), norm_add_monomial()) elif t.arg1.is_plus(): # (a + b) + c cp = compare_monomial(t.arg1.arg, t.arg) # compare b with c if cp > 0: # if b > c, need to swap b with c return pt.on_rhs( swap_add_r(), # (a + c) + b arg1_conv(self), # possibly move c further into a try_conv(rewr_conv('int_add_0_left'))) # 0 +b = 0 elif cp == 0: # if b and c have the same body, combine coefficients return pt.on_rhs( rewr_conv('int_add_assoc', sym=True), # a + (c1 * b + c2 * b) arg_conv(rewr_conv('int_mul_add_distr_r', sym=True)), # a + (c1 + c2) * b arg_conv(arg1_conv(int_eval_conv())), # evaluate c1 + c2 try_conv(arg_conv(rewr_conv('int_mul_0_l'))), try_conv(rewr_conv('int_add_0_right'))) else: # if b < c, monomials are already sorted return pt else: # a + b if t.arg.is_zero(): return pt.on_rhs(rewr_conv('int_add_0_right')) if t.arg1.is_zero(): return pt.on_rhs(rewr_conv('int_add_0_left')) cp = compare_monomial(t.arg1, t.arg) # compare a with b if cp > 0: # if a > b, need to swap a with b return pt.on_rhs(rewr_conv('int_add_comm')) elif cp == 0: # if b and c have the same body, combine coefficients if t.arg.is_number(): return pt.on_rhs(int_eval_conv()) else: return pt.on_rhs( rewr_conv('int_mul_add_distr_r', sym=True), arg1_conv(int_eval_conv()), try_conv(rewr_conv('int_mul_0_l'))) else: return pt
def get_proof_term(self, t): if not t.is_disj(): return refl(t) nnf_pt = nnf_conv().get_proof_term(Not(t)) norm_neg_disj_pt = sort_conj().get_proof_term(nnf_pt.rhs) nnf_pt_norm = nnf_pt.transitive(norm_neg_disj_pt) return nnf_pt_norm.on_prop(rewr_conv('neg_iff_both_sides'), arg1_conv(rewr_conv('double_neg')), arg_conv(nnf_conv()))
def get_proof_term(self, t): pt = refl(t) if t.arg1.is_plus(): # (a + b) * c return pt.on_rhs( rewr_conv('int_mul_add_distr_r'), # a * c + b * c arg1_conv(self), # process a * c arg_conv(norm_mult_monomial()), # process b * c norm_add_polynomial()) # add the results else: return pt.on_rhs(norm_mult_monomial())
def get_proof_term(self, goal, pts): assert len(pts) == 1 and hol_set.is_mem(pts[0].prop) and pts[0].prop.arg1.is_var(), \ "interval_inequality" var_name = pts[0].prop.arg1.name var_range = {var_name: pts[0]} if goal.is_not() and goal.arg.is_equals(): if expr.is_polynomial(expr.holpy_to_expr(goal.arg.arg1)): factored = expr.expr_to_holpy( expr.factor_polynomial(expr.holpy_to_expr(goal.arg.arg1))) if factored.is_times() and factored != goal.arg.arg1: eq_pt = auto.auto_solve(Eq(factored, goal.arg.arg1)) pt1 = get_bounds_proof(factored, var_range).on_prop( arg1_conv(rewr_conv(eq_pt))) else: pt1 = get_bounds_proof(goal.arg.arg1, var_range) else: pt1 = get_bounds_proof(goal.arg.arg1, var_range) pt2 = get_bounds_proof(goal.arg.arg, var_range) try: pt = combine_interval_bounds(pt1, pt2) if pt.prop.is_less_eq(): raise TacticException pt = apply_theorem('real_lt_neq', pt) except TacticException: pt = combine_interval_bounds(pt2, pt1) if pt.prop.is_less_eq(): raise TacticException pt = apply_theorem('real_gt_neq', reverse_inequality(pt)) return pt else: pt1 = get_bounds_proof(goal.arg1, var_range) pt2 = get_bounds_proof(goal.arg, var_range) if goal.is_less_eq(): pt = combine_interval_bounds(pt1, pt2) if pt.prop.is_less(): pt = apply_theorem('real_lt_imp_le', pt) return pt elif goal.is_less(): pt = combine_interval_bounds(pt1, pt2) if pt.prop.is_less_eq(): raise TacticException return pt elif goal.is_greater_eq(): pt = combine_interval_bounds(pt2, pt1) if pt.prop.is_less(): pt = apply_theorem('real_lt_imp_le', pt) return reverse_inequality(pt) elif goal.is_greater(): pt = combine_interval_bounds(pt2, pt1) if pt.prop.is_less_eq(): raise TacticException return reverse_inequality(pt) else: raise AssertionError('interval_inequality')
def get_proof_term(self, t): pt = refl(t) if t.arg1.is_zero(): return pt.on_rhs(rewr_conv('int_mul_0_l')) elif t.arg.is_zero(): return pt.on_rhs(rewr_conv('int_mul_0_r')) elif t.arg.is_plus(): # a * (b + c) return pt.on_rhs( rewr_conv('int_mul_add_distr_l'), # a * b + a * c arg1_conv(self), # process a * b arg_conv(norm_mult_poly_monomial()), # process a * c norm_add_polynomial()) elif t.arg.is_minus(): return pt.on_rhs(arg_conv(norm_add_polynomial()), norm_mult_polynomials()) elif t.arg1.is_minus(): return pt.on_rhs(arg1_conv(norm_add_polynomial()), norm_mult_polynomials()) else: return pt.on_rhs(norm_mult_poly_monomial())
def get_proof_term(self, t): pt = refl(t) if t.arg1 == true: return pt.on_rhs(rewr_conv('conj_true_left')) elif t.arg == true: return pt.on_rhs(rewr_conv('conj_true_right')) elif t.arg1 == false: return pt.on_rhs(rewr_conv('conj_false_right')) elif t.arg == false: return pt.on_rhs(rewr_conv('conj_false_left')) elif t.arg.is_conj(): if t.arg1 == Not(t.arg.arg1): # A /\ (A_1 /\ ... /\ A_n) return pt.on_rhs(rewr_conv('conj_assoc'), arg1_conv(rewr_conv('conj_neg_pos')), rewr_conv('conj_false_right')) elif Not(t.arg1) == t.arg.arg1: return pt.on_rhs(rewr_conv('conj_assoc'), arg1_conv(rewr_conv('conj_pos_neg')), rewr_conv('conj_false_right')) cp = term_ord.fast_compare(t.arg1, t.arg.arg1) if cp > 0: return pt.on_rhs(swap_conj_r(), arg_conv(self), try_conv(self)) elif cp == 0: return pt.on_rhs(rewr_conv('conj_assoc'), arg1_conv(rewr_conv('conj_same_atom'))) else: return pt else: if t.arg == Not(t.arg1): return pt.on_rhs(rewr_conv('conj_pos_neg')) elif t.arg1 == Not(t.arg): return pt.on_rhs(rewr_conv('conj_neg_pos')) cp = term_ord.fast_compare(t.arg1, t.arg) if cp > 0: return pt.on_rhs(swap_conj_r()) elif cp == 0: return pt.on_rhs(rewr_conv('conj_same_atom')) else: return pt
def get_proof_term(self, t): pt = refl(t) if t.is_not(): if t.arg == true: return pt.on_rhs(rewr_conv('not_true')) elif t.arg == false: return pt.on_rhs(rewr_conv('not_false')) elif t.arg.is_not(): return pt.on_rhs(rewr_conv('double_neg'), self) elif t.arg.is_conj(): return pt.on_rhs(rewr_conv('de_morgan_thm1'), arg1_conv(self), arg_conv(self)) elif t.arg.is_disj(): return pt.on_rhs(rewr_conv('de_morgan_thm2'), arg1_conv(self), arg_conv(self)) elif t.arg.is_equals() and t.arg.lhs.get_type() == BoolType: return pt.on_rhs(rewr_conv('neg_iff'), binop_conv(self)) else: return pt elif t.is_disj() or t.is_conj() or t.is_equals(): return pt.on_rhs(arg1_conv(self), arg_conv(self)) else: return pt