add_nat_closure = Forall((a, b), InSet(Add(a, b), Natural), domain=Natural)
add_nat_closure
add_real_closure = Forall([x_etc], InSet(Add(x_etc), Real), domain=Real)
add_real_closure
add_complex_closure = Forall([x_etc],
InSet(Add(x_etc), Complex),
domain=Complex)
add_complex_closure
add_nat_pos_closure = Forall((a_etc, b, c_etc),
InSet(Add(a_etc, b, c_etc), NaturalPos),
domain=Natural,
conditions=[GreaterThan(b, zero)])
add_nat_pos_closure
add_zero = Forall(x, Equals(Add(zero, x), x), domain=Complex)
add_zero
add_comm = Forall([v_etc, w_etc, x_etc, y_etc, z_etc],
Equals(Add(v_etc, w_etc, x_etc, y_etc, z_etc),
Add(v_etc, y_etc, x_etc, w_etc, z_etc)),
domain=Complex)
add_comm
add_assoc = Forall(
[x_etc, y_etc, z_etc],
Equals(Add(x_etc, y_etc, z_etc), Add(x_etc, Add(y_etc), z_etc)),
)
int_within_real = Forall(a, InSet(a, Real), domain=Integer)
int_within_real
int_within_complex = Forall(a, InSet(a, Complex), domain=Integer)
int_within_complex
in_natural_if_non_neg = Forall(a,
InSet(a, Natural),
domain=Integer,
conditions=[GreaterThanEquals(a, zero)])
in_natural_if_non_neg
in_natural_pos_if_pos = Forall(a,
InSet(a, NaturalPos),
domain=Integer,
conditions=[GreaterThan(a, zero)])
in_natural_pos_if_pos
interval_is_int = Forall((a, b),
Forall(n, InSet(n, Integer), domain=Interval(a, b)),
domain=Integer)
interval_is_int
interval_is_nat = Forall((a, b),
Forall(n, InSet(n, Natural), domain=Interval(a, b)),
domain=Natural)
interval_is_nat
interval_in_nat_pos = Forall((a, b),
Forall(n,
InSet(n, NaturalPos),
from proveit import begin_theorems, end_theorems
begin_theorems(locals())
exp_nat_closure = Forall((a, b),
InSet(Exp(a, b), NaturalPos),
domain=Natural,
conditions=[NotEquals(a, zero)])
exp_nat_closure
exp_real_closure = Forall(
[a, b],
InSet(Exp(a, b), Real),
domain=Real,
conditions=[GreaterThanEquals(a, zero),
GreaterThan(b, zero)])
exp_real_closure
exp_real_pos_closure = Forall([a, b],
InSet(Exp(a, b), RealPos),
domain=Real,
conditions=[GreaterThan(a, zero)])
exp_real_pos_closure
exp_complex_closure = Forall([a, b],
InSet(Exp(a, b), Complex),
domain=Complex,
conditions=[NotEquals(a, zero)])
exp_complex_closure
sqrt_real_closure = Forall([a],
from proveit.logic import Forall, Or, Equals, Implies
from proveit.numbers import Real
from proveit.numbers import LessThan, LessThanEquals, GreaterThan, GreaterThanEquals
from proveit.common import x, y, z
from proveit import begin_axioms, end_axioms
begin_axioms(locals())
less_than_equals_def = Forall([x, y],
Or(LessThan(x, y), Equals(x, y)),
domain=Real,
conditions=LessThanEquals(x, y))
less_than_equals_def
greater_than_equals_def = Forall([x, y],
Or(GreaterThan(x, y), Equals(x, y)),
domain=Real,
conditions=GreaterThanEquals(x, y))
greater_than_equals_def
reverse_greater_than_equals = Forall((x, y),
Implies(GreaterThanEquals(x, y),
LessThanEquals(y, x)))
reverse_greater_than_equals
reverse_less_than_equals = Forall((x, y),
Implies(LessThanEquals(x, y),
GreaterThanEquals(y, x)))
reverse_less_than_equals
reverse_greater_than = Forall((x, y), Implies(GreaterThan(x, y),
begin_theorems(locals())
neg_int_closure = Forall(a, InSet(Neg(a), Integer), domain=Integer)
neg_int_closure
neg_real_closure = Forall(a, InSet(Neg(a), Real), domain=Real)
neg_real_closure
neg_complex_closure = Forall(a, InSet(Neg(a), Complex), domain=Complex)
neg_complex_closure
negated_positive_is_negative = Forall(a,
LessThan(Neg(a), zero),
domain=Real,
conditions=[GreaterThan(a, zero)])
negated_positive_is_negative
negated_negative_is_positive = Forall(a,
GreaterThan(Neg(a), zero),
domain=Real,
conditions=[LessThan(a, zero)])
negated_negative_is_positive
neg_not_eq_zero = Forall(a,
NotEquals(Neg(a), zero),
domain=Complex,
conditions=[NotEquals(a, zero)])
neg_not_eq_zero
distribute_neg_through_sum = Forall([x_etc],
subtract_int_closure = Forall([a, b],
InSet(Sub(a, b), Integer),
domain=Integer)
subtract_int_closure
subtract_closure_nats = Forall([a, b],
InSet(Sub(a, b), Natural),
domain=Integer,
conditions=[GreaterThanEquals(a, b)])
subtract_closure_nats
subtract_closure_nats_pos = Forall([a, b],
InSet(Sub(a, b), NaturalPos),
domain=Integer,
conditions=[GreaterThan(a, b)])
subtract_closure_nats_pos
subtract_complex_closure = Forall([a, b],
InSet(Sub(a, b), Complex),
domain=Complex)
subtract_complex_closure
subtract_real_closure = Forall([a, b], InSet(Sub(a, b), Real), domain=Real)
subtract_real_closure
subtract_one_in_nats = Forall(a,
InSet(Sub(a, one), Natural),
domain=NaturalPos)
subtract_one_in_nats
InSet(Min(a, b), RealPos),
domain=RealPos)
min_real_pos_closure
max_real_closure = Forall((a, b), InSet(Max(a, b), Real), domain=Real)
max_real_closure
max_real_pos_closure = Forall((a, b),
InSet(Max(a, b), RealPos),
domain=RealPos)
max_real_pos_closure
relax_greater_than = Forall([a, b],
GreaterThanEquals(a, b),
domain=Real,
conditions=GreaterThan(a, b))
relax_greater_than
relax_less_than = Forall([a, b],
LessThanEquals(a, b),
domain=Real,
conditions=LessThan(a, b))
relax_less_than
less_than_is_bool = Forall([a, b], InSet(LessThan(a, b), Boolean), domain=Real)
less_than_is_bool
less_than_equals_is_bool = Forall([a, b],
InSet(LessThanEquals(a, b), Boolean),
domain=Real)
less_than_equals_is_bool