absIneq = Forall((x, y),
Iff(LessThanEquals(Abs(x), y),
And(LessThanEquals(Neg(y), x), LessThanEquals(x, y))),
domain=Reals,
conditions=[GreaterThanEquals(y, zero)])
absIneq
triangleInequality = Forall([a, b],
LessThanEquals(Abs(Add(a, b)), Add(Abs(a),
Abs(b))),
domain=Complexes)
triangleInequality
absProd = Forall(xEtc,
Equals(Abs(Mult(xEtc)), Mult(Etcetera(Abs(xMulti)))),
domain=Complexes)
absProd
absFrac = Forall([a, b],
Equals(Abs(Fraction(a, b)), Fraction(Abs(a), Abs(b))),
domain=Complexes)
absFrac
modAbsScaled = Forall((a, b, c),
Equals(Mult(a, ModAbs(b, c)),
ModAbs(Mult(a, b), Mult(a, c))),
domain=Reals)
modAbsScaled
modAbsSubtractCancel = Forall(
LessThanEquals(
Neg(y), x), LessThanEquals(
x, y))), domain=Real, conditions=[
GreaterThanEquals(
y, zero)])
abs_ineq
# transferred by wdc 3/11/2020
triangle_inequality = Forall([a, b], LessThanEquals(
Abs(Add(a, b)), Add(Abs(a), Abs(b))), domain=Complex)
triangle_inequality
# transferred by wdc 3/11/2020
abs_prod = Forall(x_etc,
Equals(Abs(Mult(x_etc)),
Mult(Etcetera(Abs(x_multi)))),
domain=Complex)
abs_prod
# transferred by wdc 3/11/2020
abs_frac = Forall([a, b],
Equals(Abs(frac(a, b)), frac(Abs(a), Abs(b))),
domain=Complex)
abs_frac
# transferred by wdc 3/11/2020
mod_abs_scaled = Forall(
(a, b, c), Equals(
Mult(
a, ModAbs(
b, c)), ModAbs(
diff_square_comm
one_exp = Forall([x], Equals(Exp(x, one), x), domain=Complex)
one_exp
exp_one = Forall([x], Equals(Exp(one, x), one), domain=Complex)
exp_one
same_exp_distribute = Forall([x, y, z],
Equals(Mult(Exp(x, y), Exp(z, y)),
Exp(Mult(x, z), y)),
domain=Complex)
same_exp_distribute
sqrt_of_prod = Forall(x_etc,
Equals(sqrt(Mult(x_etc)), Mult(Etcetera(sqrt(x_multi)))),
domain=RealPos)
sqrt_of_prod
prod_of_sqrts = Forall(x_etc,
Equals(Mult(Etcetera(sqrt(x_multi))),
sqrt(Mult(x_etc))),
domain=RealPos)
prod_of_sqrts
sqrt_times_itself = Forall(x,
Equals(Mult(sqrt(x), sqrt(x)), x),
domain=Real,
conditions=[GreaterThanEquals(x, zero)])
sqrt_times_itself
fractionNotEqZero = Forall([a, b],
NotEquals(Fraction(a, b), zero),
domain=ComplexesSansZero)
fractionNotEqZero
fracZeroNumer = Forall(x, Equals(Fraction(zero, x), zero), domain=Complexes)
fracZeroNumer
fracOneDenom = Forall(x, Equals(Fraction(x, one), x), domain=Complexes)
fracOneDenom
distributeFractionThroughSum = Forall([xEtc, y],
Equals(
Fraction(Add(xEtc), y),
Add(Etcetera(Fraction(xMulti, y)))),
domain=Complexes,
conditions=[NotEquals(y, zero)])
distributeFractionThroughSum
distributeFractionThroughSumRev = Forall([xEtc, y],
Equals(
Add(Etcetera(Fraction(xMulti,
y))),
Fraction(Add(xEtc), y)),
domain=Complexes,
conditions=[NotEquals(y, zero)])
distributeFractionThroughSumRev
distributeFractionThroughSubtract = Forall([x, y, z],
Equals(
divide_not_eq_zero
fraction_not_eq_zero = Forall([a, b],
NotEquals(frac(a, b), zero),
domain=ComplexSansZero)
fraction_not_eq_zero
frac_zero_numer = Forall(x, Equals(frac(zero, x), zero), domain=Complex)
frac_zero_numer
frac_one_denom = Forall(x, Equals(frac(x, one), x), domain=Complex)
frac_one_denom
distributefrac_through_sum = Forall([x_etc, y],
Equals(frac(Add(x_etc), y),
Add(Etcetera(frac(x_multi, y)))),
domain=Complex,
conditions=[NotEquals(y, zero)])
distributefrac_through_sum
distributefrac_through_sum_rev = Forall([x_etc, y],
Equals(Add(Etcetera(frac(x_multi, y))),
frac(Add(x_etc), y)),
domain=Complex,
conditions=[NotEquals(y, zero)])
distributefrac_through_sum_rev
distributefrac_through_subtract = Forall([x, y, z],
Equals(frac(Sub(x, y), z),
Sub(frac(x, z), frac(y, z))),
domain=Complex,
multZero
multComm = Forall([vEtc, wEtc, xEtc, yEtc, zEtc],
Equals(Mult(vEtc, wEtc, xEtc, yEtc, zEtc),
Mult(vEtc, yEtc, xEtc, wEtc, zEtc)),
domain=Complexes)
multComm
multAssocRev = Forall([xEtc, yEtc, zEtc],
Equals(Mult(xEtc, Mult(yEtc), zEtc),
Mult(xEtc, yEtc, zEtc)))
multAssocRev
distributeThroughSum = Forall([xEtc, yEtc, zEtc],
Equals(Mult(xEtc, Add(yEtc), zEtc),
Add(Etcetera(Mult(xEtc, yMulti, zEtc)))),
domain=Complexes)
distributeThroughSum
distributeThroughSumRev = Forall([xEtc, yEtc, zEtc],
Equals(
Add(Etcetera(Mult(xEtc, yMulti, zEtc))),
Mult(xEtc, Add(yEtc), zEtc)),
domain=Complexes)
distributeThroughSumRev
distributeThroughSubtract = Forall([wEtc, x, y, zEtc],
Equals(
Mult(wEtc, Sub(x, y), zEtc),
Sub(Mult(wEtc, x, zEtc),
Mult(wEtc, y, zEtc))),
diffSquareComm
oneExp = Forall([x], Equals(Exp(x, one), x), domain=Complexes)
oneExp
expOne = Forall([x], Equals(Exp(one, x), one), domain=Complexes)
expOne
sameExpDistribute = Forall([x, y, z],
Equals(Mult(Exp(x, y), Exp(z, y)),
Exp(Mult(x, z), y)),
domain=Complexes)
sameExpDistribute
sqrtOfProd = Forall(xEtc,
Equals(sqrt(Mult(xEtc)), Mult(Etcetera(sqrt(xMulti)))),
domain=RealsPos)
sqrtOfProd
prodOfSqrts = Forall(xEtc,
Equals(Mult(Etcetera(sqrt(xMulti))), sqrt(Mult(xEtc))),
domain=RealsPos)
prodOfSqrts
sqrtTimesItself = Forall(x,
Equals(Mult(sqrt(x), sqrt(x)), x),
domain=Reals,
conditions=[GreaterThanEquals(x, zero)])
sqrtTimesItself
endTheorems(locals(), __package__)
mult_comm = Forall([v_etc, w_etc, x_etc, y_etc, z_etc],
Equals(Mult(v_etc, w_etc, x_etc, y_etc, z_etc),
Mult(v_etc, y_etc, x_etc, w_etc, z_etc)),
domain=Complex)
mult_comm
mult_assoc_rev = Forall([x_etc, y_etc, z_etc],
Equals(Mult(x_etc, Mult(y_etc), z_etc),
Mult(x_etc, y_etc, z_etc)))
mult_assoc_rev
distribute_through_sum = Forall([x_etc, y_etc, z_etc],
Equals(
Mult(x_etc, Add(y_etc), z_etc),
Add(Etcetera(Mult(x_etc, y_multi,
z_etc)))),
domain=Complex)
distribute_through_sum
distribute_through_sum_rev = Forall(
[x_etc, y_etc, z_etc],
Equals(Add(Etcetera(Mult(x_etc, y_multi, z_etc))),
Mult(x_etc, Add(y_etc), z_etc)),
domain=Complex)
distribute_through_sum_rev
distribute_through_subtract = Forall([w_etc, x, y, z_etc],
Equals(
Mult(w_etc, Sub(x, y), z_etc),
Sub(Mult(w_etc, x, z_etc),
Mult(w_etc, y, z_etc))),
expOne = Forall([x],
Equals(Exp(one,x),
one),
domain = Complexes)
expOne
# transferred 2/20/2020
sameExpDistribute = Forall([x,y,z],
Equals(Mult(Exp(x,y),Exp(z,y)),
Exp(Mult(x,z),y)),
domain = Complexes)
sameExpDistribute
# transferred 2/20/2020
sqrtOfProd = Forall(xEtc, Equals(sqrt(Mult(xEtc)),
Mult(Etcetera(sqrt(xMulti)))),
domain=RealsPos)
sqrtOfProd
# transferred 2/20/2020
prodOfSqrts = Forall(xEtc, Equals(Mult(Etcetera(sqrt(xMulti))),
sqrt(Mult(xEtc))),
domain=RealsPos)
prodOfSqrts
# transferred 2/20/2020
sqrtTimesItself = Forall(x, Equals(Mult(sqrt(x), sqrt(x)), x),
domain=Reals, conditions=[GreaterThanEquals(x, zero)])
sqrtTimesItself
endTheorems(locals(), __package__)
negatedNegativeIsPositive = Forall(a,
GreaterThan(Neg(a), zero),
domain=Reals,
conditions=[LessThan(a, zero)])
negatedNegativeIsPositive
negNotEqZero = Forall(a,
NotEquals(Neg(a), zero),
domain=Complexes,
conditions=[NotEquals(a, zero)])
negNotEqZero
distributeNegThroughSum = Forall([xEtc],
Equals(Neg(Add(xEtc)),
Add(Etcetera(Neg(xMulti)))),
domain=Complexes)
distributeNegThroughSum
distributeNegThroughSumRev = Forall([xEtc],
Equals(Add(Etcetera(Neg(xMulti))),
Neg(Add(xEtc))),
domain=Complexes)
distributeNegThroughSumRev
distributeNegThroughSubtract = Forall([x, y],
Equals(Neg(Sub(x, y)), Add(Neg(x), y)),
domain=Complexes)
distributeNegThroughSubtract
negTimesPos = Forall([x, y],
subtractCancelRightSumSingleLeft = Forall([x, y], Equals(Sub(y, Add(x, y)), Neg(x)), domain=Complexes)
subtractCancelRightSumSingleLeft
subtractCancelLeftSumSingleRight = Forall([x, y], Equals(Sub(Add(y, x), y), x), domain=Complexes)
subtractCancelLeftSumSingleRight
subtractCancelLeftSumSingleLeft = Forall([x, y], Equals(Sub(Add(x, y), y), x), domain=Complexes)
subtractCancelLeftSumSingleLeft
subtractCancelComplete = Forall(x, Equals(Sub(x, x), zero), domain=Complexes)
subtractCancelComplete
distributeSubtraction = Forall([x, yEtc],
Equals(Sub(x, Add(yEtc)),
Add(x, Etcetera(Neg(yMulti)))),
domain=Complexes)
distributeSubtraction
cancelAddition = Forall([a,b],
Equals(Add(a, Sub(b,b)), a),
domain=Complexes)
cancelAddition
cancelSubAndAdd = Forall([a,b],
Equals(Sub(Sub(a,Neg(b)), b), a),
domain=Complexes)
cancelSubAndAdd
cancelSubThenAdd = Forall([a,b],
Equals(Add(Sub(a,b), b), a),
subtract_cancel_left_sum_single_right = Forall([x, y],
Equals(Sub(Add(y, x), y), x),
domain=Complex)
subtract_cancel_left_sum_single_right
subtract_cancel_left_sum_single_left = Forall([x, y],
Equals(Sub(Add(x, y), y), x),
domain=Complex)
subtract_cancel_left_sum_single_left
subtract_cancel_complete = Forall(x, Equals(Sub(x, x), zero), domain=Complex)
subtract_cancel_complete
distribute_subtraction = Forall([x, y_etc],
Equals(Sub(x, Add(y_etc)),
Add(x, Etcetera(Neg(y_multi)))),
domain=Complex)
distribute_subtraction
cancel_addition = Forall([a, b], Equals(Add(a, Sub(b, b)), a), domain=Complex)
cancel_addition
cancel_sub_and_add = Forall([a, b],
Equals(Sub(Sub(a, Neg(b)), b), a),
domain=Complex)
cancel_sub_and_add
cancel_sub_then_add = Forall([a, b],
Equals(Add(Sub(a, b), b), a),
domain=Complex)
cancel_sub_then_add