You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
11117 lines
289 KiB
11117 lines
289 KiB
"""
|
|
This code is automatically generated. Never edit it manually.
|
|
For details of generating the code see `rubi_parsing_guide.md` in `parsetools`.
|
|
"""
|
|
|
|
from sympy.external import import_module
|
|
matchpy = import_module("matchpy")
|
|
|
|
if matchpy:
|
|
from matchpy import Pattern, ReplacementRule, CustomConstraint, is_match
|
|
from sympy.integrals.rubi.utility_function import (
|
|
Int, Sum, Set, With, Module, Scan, MapAnd, FalseQ,
|
|
ZeroQ, NegativeQ, NonzeroQ, FreeQ, NFreeQ, List, Log, PositiveQ,
|
|
PositiveIntegerQ, NegativeIntegerQ, IntegerQ, IntegersQ,
|
|
ComplexNumberQ, PureComplexNumberQ, RealNumericQ, PositiveOrZeroQ,
|
|
NegativeOrZeroQ, FractionOrNegativeQ, NegQ, Equal, Unequal, IntPart,
|
|
FracPart, RationalQ, ProductQ, SumQ, NonsumQ, Subst, First, Rest,
|
|
SqrtNumberQ, SqrtNumberSumQ, LinearQ, Sqrt, ArcCosh, Coefficient,
|
|
Denominator, Hypergeometric2F1, Not, Simplify, FractionalPart,
|
|
IntegerPart, AppellF1, EllipticPi, EllipticE, EllipticF, ArcTan,
|
|
ArcCot, ArcCoth, ArcTanh, ArcSin, ArcSinh, ArcCos, ArcCsc, ArcSec,
|
|
ArcCsch, ArcSech, Sinh, Tanh, Cosh, Sech, Csch, Coth, LessEqual, Less,
|
|
Greater, GreaterEqual, FractionQ, IntLinearcQ, Expand, IndependentQ,
|
|
PowerQ, IntegerPowerQ, PositiveIntegerPowerQ, FractionalPowerQ, AtomQ,
|
|
ExpQ, LogQ, Head, MemberQ, TrigQ, SinQ, CosQ, TanQ, CotQ, SecQ, CscQ,
|
|
Sin, Cos, Tan, Cot, Sec, Csc, HyperbolicQ, SinhQ, CoshQ, TanhQ, CothQ,
|
|
SechQ, CschQ, InverseTrigQ, SinCosQ, SinhCoshQ, LeafCount, Numerator,
|
|
NumberQ, NumericQ, Length, ListQ, Im, Re, InverseHyperbolicQ,
|
|
InverseFunctionQ, TrigHyperbolicFreeQ, InverseFunctionFreeQ, RealQ,
|
|
EqQ, FractionalPowerFreeQ, ComplexFreeQ, PolynomialQ, FactorSquareFree,
|
|
PowerOfLinearQ, Exponent, QuadraticQ, LinearPairQ, BinomialParts,
|
|
TrinomialParts, PolyQ, EvenQ, OddQ, PerfectSquareQ, NiceSqrtAuxQ,
|
|
NiceSqrtQ, Together, PosAux, PosQ, CoefficientList, ReplaceAll,
|
|
ExpandLinearProduct, GCD, ContentFactor, NumericFactor,
|
|
NonnumericFactors, MakeAssocList, GensymSubst, KernelSubst,
|
|
ExpandExpression, Apart, SmartApart, MatchQ,
|
|
PolynomialQuotientRemainder, FreeFactors, NonfreeFactors,
|
|
RemoveContentAux, RemoveContent, FreeTerms, NonfreeTerms,
|
|
ExpandAlgebraicFunction, CollectReciprocals, ExpandCleanup,
|
|
AlgebraicFunctionQ, Coeff, LeadTerm, RemainingTerms, LeadFactor,
|
|
RemainingFactors, LeadBase, LeadDegree, Numer, Denom, hypergeom, Expon,
|
|
MergeMonomials, PolynomialDivide, BinomialQ, TrinomialQ,
|
|
GeneralizedBinomialQ, GeneralizedTrinomialQ, FactorSquareFreeList,
|
|
PerfectPowerTest, SquareFreeFactorTest, RationalFunctionQ,
|
|
RationalFunctionFactors, NonrationalFunctionFactors, Reverse,
|
|
RationalFunctionExponents, RationalFunctionExpand, ExpandIntegrand,
|
|
SimplerQ, SimplerSqrtQ, SumSimplerQ, BinomialDegree, TrinomialDegree,
|
|
CancelCommonFactors, SimplerIntegrandQ, GeneralizedBinomialDegree,
|
|
GeneralizedBinomialParts, GeneralizedTrinomialDegree,
|
|
GeneralizedTrinomialParts, MonomialQ, MonomialSumQ,
|
|
MinimumMonomialExponent, MonomialExponent, LinearMatchQ,
|
|
PowerOfLinearMatchQ, QuadraticMatchQ, CubicMatchQ, BinomialMatchQ,
|
|
TrinomialMatchQ, GeneralizedBinomialMatchQ, GeneralizedTrinomialMatchQ,
|
|
QuotientOfLinearsMatchQ, PolynomialTermQ, PolynomialTerms,
|
|
NonpolynomialTerms, PseudoBinomialParts, NormalizePseudoBinomial,
|
|
PseudoBinomialPairQ, PseudoBinomialQ, PolynomialGCD, PolyGCD,
|
|
AlgebraicFunctionFactors, NonalgebraicFunctionFactors,
|
|
QuotientOfLinearsP, QuotientOfLinearsParts, QuotientOfLinearsQ,
|
|
Flatten, Sort, AbsurdNumberQ, AbsurdNumberFactors,
|
|
NonabsurdNumberFactors, SumSimplerAuxQ, Prepend, Drop,
|
|
CombineExponents, FactorInteger, FactorAbsurdNumber,
|
|
SubstForInverseFunction, SubstForFractionalPower,
|
|
SubstForFractionalPowerOfQuotientOfLinears,
|
|
FractionalPowerOfQuotientOfLinears, SubstForFractionalPowerQ,
|
|
SubstForFractionalPowerAuxQ, FractionalPowerOfSquareQ,
|
|
FractionalPowerSubexpressionQ, Apply, FactorNumericGcd,
|
|
MergeableFactorQ, MergeFactor, MergeFactors, TrigSimplifyQ,
|
|
TrigSimplify, TrigSimplifyRecur, Order, FactorOrder, Smallest,
|
|
OrderedQ, MinimumDegree, PositiveFactors, Sign, NonpositiveFactors,
|
|
PolynomialInAuxQ, PolynomialInQ, ExponentInAux, ExponentIn,
|
|
PolynomialInSubstAux, PolynomialInSubst, Distrib, DistributeDegree,
|
|
FunctionOfPower, DivideDegreesOfFactors, MonomialFactor, FullSimplify,
|
|
FunctionOfLinearSubst, FunctionOfLinear, NormalizeIntegrand,
|
|
NormalizeIntegrandAux, NormalizeIntegrandFactor,
|
|
NormalizeIntegrandFactorBase, NormalizeTogether,
|
|
NormalizeLeadTermSigns, AbsorbMinusSign, NormalizeSumFactors,
|
|
SignOfFactor, NormalizePowerOfLinear, SimplifyIntegrand, SimplifyTerm,
|
|
TogetherSimplify, SmartSimplify, SubstForExpn, ExpandToSum, UnifySum,
|
|
UnifyTerms, UnifyTerm, CalculusQ, FunctionOfInverseLinear,
|
|
PureFunctionOfSinhQ, PureFunctionOfTanhQ, PureFunctionOfCoshQ,
|
|
IntegerQuotientQ, OddQuotientQ, EvenQuotientQ, FindTrigFactor,
|
|
FunctionOfSinhQ, FunctionOfCoshQ, OddHyperbolicPowerQ, FunctionOfTanhQ,
|
|
FunctionOfTanhWeight, FunctionOfHyperbolicQ, SmartNumerator,
|
|
SmartDenominator, SubstForAux, ActivateTrig, ExpandTrig, TrigExpand,
|
|
SubstForTrig, SubstForHyperbolic, InertTrigFreeQ, LCM,
|
|
SubstForFractionalPowerOfLinear, FractionalPowerOfLinear,
|
|
InverseFunctionOfLinear, InertTrigQ, InertReciprocalQ, DeactivateTrig,
|
|
FixInertTrigFunction, DeactivateTrigAux, PowerOfInertTrigSumQ,
|
|
PiecewiseLinearQ, KnownTrigIntegrandQ, KnownSineIntegrandQ,
|
|
KnownTangentIntegrandQ, KnownCotangentIntegrandQ,
|
|
KnownSecantIntegrandQ, TryPureTanSubst, TryTanhSubst, TryPureTanhSubst,
|
|
AbsurdNumberGCD, AbsurdNumberGCDList, ExpandTrigExpand,
|
|
ExpandTrigReduce, ExpandTrigReduceAux, NormalizeTrig, TrigToExp,
|
|
ExpandTrigToExp, TrigReduce, FunctionOfTrig, AlgebraicTrigFunctionQ,
|
|
FunctionOfHyperbolic, FunctionOfQ, FunctionOfExpnQ, PureFunctionOfSinQ,
|
|
PureFunctionOfCosQ, PureFunctionOfTanQ, PureFunctionOfCotQ,
|
|
FunctionOfCosQ, FunctionOfSinQ, OddTrigPowerQ, FunctionOfTanQ,
|
|
FunctionOfTanWeight, FunctionOfTrigQ, FunctionOfDensePolynomialsQ,
|
|
FunctionOfLog, PowerVariableExpn, PowerVariableDegree,
|
|
PowerVariableSubst, EulerIntegrandQ, FunctionOfSquareRootOfQuadratic,
|
|
SquareRootOfQuadraticSubst, Divides, EasyDQ, ProductOfLinearPowersQ,
|
|
Rt, NthRoot, AtomBaseQ, SumBaseQ, NegSumBaseQ, AllNegTermQ,
|
|
SomeNegTermQ, TrigSquareQ, RtAux, TrigSquare, IntSum, IntTerm, Map2,
|
|
ConstantFactor, SameQ, ReplacePart, CommonFactors,
|
|
MostMainFactorPosition, FunctionOfExponentialQ, FunctionOfExponential,
|
|
FunctionOfExponentialFunction, FunctionOfExponentialFunctionAux,
|
|
FunctionOfExponentialTest, FunctionOfExponentialTestAux, stdev,
|
|
rubi_test, If, IntQuadraticQ, IntBinomialQ, RectifyTangent,
|
|
RectifyCotangent, Inequality, Condition, Simp, SimpHelp, SplitProduct,
|
|
SplitSum, SubstFor, SubstForAux, FresnelS, FresnelC, Erfc, Erfi, Gamma,
|
|
FunctionOfTrigOfLinearQ, ElementaryFunctionQ, Complex, UnsameQ,
|
|
_SimpFixFactor, SimpFixFactor, _FixSimplify, FixSimplify,
|
|
_SimplifyAntiderivativeSum, SimplifyAntiderivativeSum,
|
|
_SimplifyAntiderivative, SimplifyAntiderivative, _TrigSimplifyAux,
|
|
TrigSimplifyAux, Cancel, Part, PolyLog, D, Dist, Sum_doit, PolynomialQuotient, Floor,
|
|
PolynomialRemainder, Factor, PolyLog, CosIntegral, SinIntegral, LogIntegral, SinhIntegral,
|
|
CoshIntegral, Rule, Erf, PolyGamma, ExpIntegralEi, ExpIntegralE, LogGamma , UtilityOperator, Factorial,
|
|
Zeta, ProductLog, DerivativeDivides, HypergeometricPFQ, IntHide, OneQ, Null, rubi_exp as exp, rubi_log as log, Discriminant,
|
|
Negative, Quotient
|
|
)
|
|
from sympy.core.add import Add
|
|
from sympy.core.mod import Mod
|
|
from sympy.core.mul import Mul
|
|
from sympy.core import EulerGamma
|
|
from sympy.core.numbers import (Float, I, Integer)
|
|
from sympy.core.power import Pow
|
|
from sympy.core.singleton import S
|
|
from sympy.functions.elementary.complexes import (Abs, sign)
|
|
from sympy.functions.elementary.miscellaneous import sqrt
|
|
from sympy.integrals.integrals import Integral
|
|
from sympy.logic.boolalg import (And, Or)
|
|
from sympy.simplify.simplify import simplify
|
|
from sympy.integrals.rubi.symbol import WC
|
|
from sympy.core.symbol import symbols, Symbol
|
|
from sympy.functions import (sin, cos, tan, cot, csc, sec, sqrt, erf)
|
|
from sympy.functions.elementary.hyperbolic import (acosh, asinh, atanh, acoth, acsch, asech, cosh, sinh, tanh, coth, sech, csch)
|
|
from sympy.functions.elementary.trigonometric import (atan, acsc, asin, acot, acos, asec, atan2)
|
|
from sympy.core.numbers import pi as Pi
|
|
|
|
A_, B_, C_, F_, G_, H_, a_, b_, c_, d_, e_, f_, g_, h_, i_, j_, k_, l_, m_, n_, p_, q_, r_, t_, u_, v_, s_, w_, x_, y_, z_ = [WC(i) for i in 'ABCFGHabcdefghijklmnpqrtuvswxyz']
|
|
a1_, a2_, b1_, b2_, c1_, c2_, d1_, d2_, n1_, n2_, e1_, e2_, f1_, f2_, g1_, g2_, n1_, n2_, n3_, Pq_, Pm_, Px_, Qm_, Qr_, Qx_, jn_, mn_, non2_, RFx_, RGx_ = [WC(i) for i in ['a1', 'a2', 'b1', 'b2', 'c1', 'c2', 'd1', 'd2', 'n1', 'n2', 'e1', 'e2', 'f1', 'f2', 'g1', 'g2', 'n1', 'n2', 'n3', 'Pq', 'Pm', 'Px', 'Qm', 'Qr', 'Qx', 'jn', 'mn', 'non2', 'RFx', 'RGx']]
|
|
i, ii, Pqq, Q, R, r, C, k, u = symbols('i ii Pqq Q R r C k u')
|
|
_UseGamma = False
|
|
ShowSteps = False
|
|
StepCounter = None
|
|
|
|
|
|
|
|
def cons_f1(a):
|
|
return ZeroQ(a)
|
|
|
|
cons1 = CustomConstraint(cons_f1)
|
|
|
|
def cons_f2(a, x):
|
|
return FreeQ(a, x)
|
|
|
|
cons2 = CustomConstraint(cons_f2)
|
|
|
|
def cons_f3(b, x):
|
|
return FreeQ(b, x)
|
|
|
|
cons3 = CustomConstraint(cons_f3)
|
|
|
|
def cons_f4(n, x):
|
|
return FreeQ(n, x)
|
|
|
|
cons4 = CustomConstraint(cons_f4)
|
|
|
|
def cons_f5(p, x):
|
|
return FreeQ(p, x)
|
|
|
|
cons5 = CustomConstraint(cons_f5)
|
|
|
|
def cons_f6(b):
|
|
return ZeroQ(b)
|
|
|
|
cons6 = CustomConstraint(cons_f6)
|
|
|
|
def cons_f7(j, n):
|
|
return ZeroQ(j - S(2)*n)
|
|
|
|
cons7 = CustomConstraint(cons_f7)
|
|
|
|
def cons_f8(c, x):
|
|
return FreeQ(c, x)
|
|
|
|
cons8 = CustomConstraint(cons_f8)
|
|
|
|
def cons_f9(c):
|
|
return ZeroQ(c)
|
|
|
|
cons9 = CustomConstraint(cons_f9)
|
|
|
|
def cons_f10(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(FreeQ(v, x))
|
|
|
|
cons10 = CustomConstraint(cons_f10)
|
|
|
|
def cons_f11(Pm, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolyQ(Pm, x)
|
|
|
|
cons11 = CustomConstraint(cons_f11)
|
|
|
|
def cons_f12(p):
|
|
return Not(RationalQ(p))
|
|
|
|
cons12 = CustomConstraint(cons_f12)
|
|
|
|
def cons_f13(p):
|
|
return RationalQ(p)
|
|
|
|
cons13 = CustomConstraint(cons_f13)
|
|
|
|
def cons_f14(a, b, c, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c), x)
|
|
|
|
cons14 = CustomConstraint(cons_f14)
|
|
|
|
def cons_f15(a):
|
|
return EqQ(a**S(2), S(1))
|
|
|
|
cons15 = CustomConstraint(cons_f15)
|
|
|
|
def cons_f16(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_15(b, v):
|
|
return FreeQ(b, x)
|
|
_cons_15 = CustomConstraint(_cons_f_15)
|
|
pat = Pattern(UtilityOperator(b_*v_, x), _cons_15)
|
|
result_matchq = is_match(UtilityOperator(u, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons16 = CustomConstraint(cons_f16)
|
|
|
|
def cons_f17(u):
|
|
return SumQ(u)
|
|
|
|
cons17 = CustomConstraint(cons_f17)
|
|
|
|
def cons_f18(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_17(a, b, v):
|
|
return And(FreeQ(List(a, b), x), InverseFunctionQ(v))
|
|
_cons_17 = CustomConstraint(_cons_f_17)
|
|
pat = Pattern(UtilityOperator(a_ + v_*WC('b', S(1)), x), _cons_17)
|
|
result_matchq = is_match(UtilityOperator(u, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons18 = CustomConstraint(cons_f18)
|
|
|
|
def cons_f19(m, x):
|
|
return FreeQ(m, x)
|
|
|
|
cons19 = CustomConstraint(cons_f19)
|
|
|
|
def cons_f20(m):
|
|
return IntegerQ(m)
|
|
|
|
cons20 = CustomConstraint(cons_f20)
|
|
|
|
def cons_f21(m):
|
|
return Not(IntegerQ(m))
|
|
|
|
cons21 = CustomConstraint(cons_f21)
|
|
|
|
def cons_f22(n):
|
|
return PositiveIntegerQ(n + S(1)/2)
|
|
|
|
cons22 = CustomConstraint(cons_f22)
|
|
|
|
def cons_f23(m, n):
|
|
return IntegerQ(m + n)
|
|
|
|
cons23 = CustomConstraint(cons_f23)
|
|
|
|
def cons_f24(n):
|
|
return NegativeIntegerQ(n + S(-1)/2)
|
|
|
|
cons24 = CustomConstraint(cons_f24)
|
|
|
|
def cons_f25(n):
|
|
return Not(IntegerQ(n))
|
|
|
|
cons25 = CustomConstraint(cons_f25)
|
|
|
|
def cons_f26(m, n):
|
|
return Not(IntegerQ(m + n))
|
|
|
|
cons26 = CustomConstraint(cons_f26)
|
|
|
|
def cons_f27(a, b, c, d):
|
|
return ZeroQ(-a*d + b*c)
|
|
|
|
cons27 = CustomConstraint(cons_f27)
|
|
|
|
def cons_f28(a, b, c, d, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(Not(IntegerQ(n)), SimplerQ(c + d*x, a + b*x))
|
|
|
|
cons28 = CustomConstraint(cons_f28)
|
|
|
|
def cons_f29(d, x):
|
|
return FreeQ(d, x)
|
|
|
|
cons29 = CustomConstraint(cons_f29)
|
|
|
|
def cons_f30(b, d):
|
|
return PositiveQ(b/d)
|
|
|
|
cons30 = CustomConstraint(cons_f30)
|
|
|
|
def cons_f31(m, n):
|
|
return Not(Or(IntegerQ(m), IntegerQ(n)))
|
|
|
|
cons31 = CustomConstraint(cons_f31)
|
|
|
|
def cons_f32(b, d, m, n):
|
|
return Not(Or(IntegerQ(m), IntegerQ(n), PositiveQ(b/d)))
|
|
|
|
cons32 = CustomConstraint(cons_f32)
|
|
|
|
def cons_f33(m):
|
|
return RationalQ(m)
|
|
|
|
cons33 = CustomConstraint(cons_f33)
|
|
|
|
def cons_f34(m):
|
|
return LessEqual(m, S(-1))
|
|
|
|
cons34 = CustomConstraint(cons_f34)
|
|
|
|
def cons_f35(A, B, C, a, b):
|
|
return ZeroQ(A*b**S(2) - B*a*b + C*a**S(2))
|
|
|
|
cons35 = CustomConstraint(cons_f35)
|
|
|
|
def cons_f36(A, x):
|
|
return FreeQ(A, x)
|
|
|
|
cons36 = CustomConstraint(cons_f36)
|
|
|
|
def cons_f37(B, x):
|
|
return FreeQ(B, x)
|
|
|
|
cons37 = CustomConstraint(cons_f37)
|
|
|
|
def cons_f38(C, x):
|
|
return FreeQ(C, x)
|
|
|
|
cons38 = CustomConstraint(cons_f38)
|
|
|
|
def cons_f39(n, q):
|
|
return ZeroQ(n + q)
|
|
|
|
cons39 = CustomConstraint(cons_f39)
|
|
|
|
def cons_f40(p):
|
|
return IntegerQ(p)
|
|
|
|
cons40 = CustomConstraint(cons_f40)
|
|
|
|
def cons_f41(a, b, c, d):
|
|
return ZeroQ(a*c - b*d)
|
|
|
|
cons41 = CustomConstraint(cons_f41)
|
|
|
|
def cons_f42(m, n):
|
|
return Not(And(IntegerQ(m), NegQ(n)))
|
|
|
|
cons42 = CustomConstraint(cons_f42)
|
|
|
|
def cons_f43(m, p):
|
|
return ZeroQ(m + p)
|
|
|
|
cons43 = CustomConstraint(cons_f43)
|
|
|
|
def cons_f44(a, b, c, d):
|
|
return ZeroQ(a**S(2)*d + b**S(2)*c)
|
|
|
|
cons44 = CustomConstraint(cons_f44)
|
|
|
|
def cons_f45(a):
|
|
return PositiveQ(a)
|
|
|
|
cons45 = CustomConstraint(cons_f45)
|
|
|
|
def cons_f46(d):
|
|
return NegativeQ(d)
|
|
|
|
cons46 = CustomConstraint(cons_f46)
|
|
|
|
def cons_f47(a, b, c):
|
|
return ZeroQ(-S(4)*a*c + b**S(2))
|
|
|
|
cons47 = CustomConstraint(cons_f47)
|
|
|
|
def cons_f48(n, n2):
|
|
return ZeroQ(-S(2)*n + n2)
|
|
|
|
cons48 = CustomConstraint(cons_f48)
|
|
|
|
def cons_f49(b, c, d, e):
|
|
return ZeroQ(-b*e + S(2)*c*d)
|
|
|
|
cons49 = CustomConstraint(cons_f49)
|
|
|
|
def cons_f50(e, x):
|
|
return FreeQ(e, x)
|
|
|
|
cons50 = CustomConstraint(cons_f50)
|
|
|
|
def cons_f51(p, q):
|
|
return PosQ(-p + q)
|
|
|
|
cons51 = CustomConstraint(cons_f51)
|
|
|
|
def cons_f52(q, x):
|
|
return FreeQ(q, x)
|
|
|
|
cons52 = CustomConstraint(cons_f52)
|
|
|
|
def cons_f53(p, r):
|
|
return PosQ(-p + r)
|
|
|
|
cons53 = CustomConstraint(cons_f53)
|
|
|
|
def cons_f54(r, x):
|
|
return FreeQ(r, x)
|
|
|
|
cons54 = CustomConstraint(cons_f54)
|
|
|
|
def cons_f55(m, n):
|
|
return ZeroQ(m - n + S(1))
|
|
|
|
cons55 = CustomConstraint(cons_f55)
|
|
|
|
def cons_f56(p):
|
|
return NonzeroQ(p + S(1))
|
|
|
|
cons56 = CustomConstraint(cons_f56)
|
|
|
|
def cons_f57(a1, a2, b1, b2):
|
|
return ZeroQ(a1*b2 + a2*b1)
|
|
|
|
cons57 = CustomConstraint(cons_f57)
|
|
|
|
def cons_f58(m, n):
|
|
return ZeroQ(m - S(2)*n + S(1))
|
|
|
|
cons58 = CustomConstraint(cons_f58)
|
|
|
|
def cons_f59(a1, x):
|
|
return FreeQ(a1, x)
|
|
|
|
cons59 = CustomConstraint(cons_f59)
|
|
|
|
def cons_f60(b1, x):
|
|
return FreeQ(b1, x)
|
|
|
|
cons60 = CustomConstraint(cons_f60)
|
|
|
|
def cons_f61(a2, x):
|
|
return FreeQ(a2, x)
|
|
|
|
cons61 = CustomConstraint(cons_f61)
|
|
|
|
def cons_f62(b2, x):
|
|
return FreeQ(b2, x)
|
|
|
|
cons62 = CustomConstraint(cons_f62)
|
|
|
|
def cons_f63(Qm, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolyQ(Qm, x)
|
|
|
|
cons63 = CustomConstraint(cons_f63)
|
|
|
|
def cons_f64(m):
|
|
return PositiveIntegerQ(m)
|
|
|
|
cons64 = CustomConstraint(cons_f64)
|
|
|
|
def cons_f65(p):
|
|
return NegativeIntegerQ(p)
|
|
|
|
cons65 = CustomConstraint(cons_f65)
|
|
|
|
def cons_f66(Pq, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolyQ(Pq, x)
|
|
|
|
cons66 = CustomConstraint(cons_f66)
|
|
|
|
def cons_f67(Qr, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolyQ(Qr, x)
|
|
|
|
cons67 = CustomConstraint(cons_f67)
|
|
|
|
def cons_f68(m):
|
|
return NonzeroQ(m + S(1))
|
|
|
|
cons68 = CustomConstraint(cons_f68)
|
|
|
|
def cons_f69(a, b, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b), x)
|
|
|
|
cons69 = CustomConstraint(cons_f69)
|
|
|
|
def cons_f70(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return LinearQ(u, x)
|
|
|
|
cons70 = CustomConstraint(cons_f70)
|
|
|
|
def cons_f71(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return NonzeroQ(u - x)
|
|
|
|
cons71 = CustomConstraint(cons_f71)
|
|
|
|
def cons_f72(a, b, c, d):
|
|
return ZeroQ(a*d + b*c)
|
|
|
|
cons72 = CustomConstraint(cons_f72)
|
|
|
|
def cons_f73(a, b, c, d):
|
|
return NonzeroQ(-a*d + b*c)
|
|
|
|
cons73 = CustomConstraint(cons_f73)
|
|
|
|
def cons_f74(m, n):
|
|
return ZeroQ(m + n + S(2))
|
|
|
|
cons74 = CustomConstraint(cons_f74)
|
|
|
|
def cons_f75(m):
|
|
return PositiveIntegerQ(m + S(1)/2)
|
|
|
|
cons75 = CustomConstraint(cons_f75)
|
|
|
|
def cons_f76(m):
|
|
return NegativeIntegerQ(m + S(3)/2)
|
|
|
|
cons76 = CustomConstraint(cons_f76)
|
|
|
|
def cons_f77(a, c, m):
|
|
return Or(IntegerQ(m), And(PositiveQ(a), PositiveQ(c)))
|
|
|
|
cons77 = CustomConstraint(cons_f77)
|
|
|
|
def cons_f78(a, c):
|
|
return ZeroQ(a + c)
|
|
|
|
cons78 = CustomConstraint(cons_f78)
|
|
|
|
def cons_f79(m):
|
|
return Not(IntegerQ(S(2)*m))
|
|
|
|
cons79 = CustomConstraint(cons_f79)
|
|
|
|
def cons_f80(a, b, c, d):
|
|
return PosQ(b*d/(a*c))
|
|
|
|
cons80 = CustomConstraint(cons_f80)
|
|
|
|
def cons_f81(m):
|
|
return IntegerQ(m + S(1)/2)
|
|
|
|
cons81 = CustomConstraint(cons_f81)
|
|
|
|
def cons_f82(n):
|
|
return IntegerQ(n + S(1)/2)
|
|
|
|
cons82 = CustomConstraint(cons_f82)
|
|
|
|
def cons_f83(m, n):
|
|
return Less(S(0), m, n)
|
|
|
|
cons83 = CustomConstraint(cons_f83)
|
|
|
|
def cons_f84(m, n):
|
|
return Less(m, n, S(0))
|
|
|
|
cons84 = CustomConstraint(cons_f84)
|
|
|
|
def cons_f85(c, m, n):
|
|
return Or(Not(IntegerQ(n)), And(ZeroQ(c), LessEqual(S(7)*m + S(4)*n, S(0))), Less(S(9)*m + S(5)*n + S(5), S(0)), Greater(m + n + S(2), S(0)))
|
|
|
|
cons85 = CustomConstraint(cons_f85)
|
|
|
|
def cons_f86(m):
|
|
return NegativeIntegerQ(m)
|
|
|
|
cons86 = CustomConstraint(cons_f86)
|
|
|
|
def cons_f87(n):
|
|
return IntegerQ(n)
|
|
|
|
cons87 = CustomConstraint(cons_f87)
|
|
|
|
def cons_f88(m, n):
|
|
return Not(And(PositiveIntegerQ(n), Less(m + n + S(2), S(0))))
|
|
|
|
cons88 = CustomConstraint(cons_f88)
|
|
|
|
def cons_f89(n):
|
|
return RationalQ(n)
|
|
|
|
cons89 = CustomConstraint(cons_f89)
|
|
|
|
def cons_f90(n):
|
|
return Greater(n, S(0))
|
|
|
|
cons90 = CustomConstraint(cons_f90)
|
|
|
|
def cons_f91(n):
|
|
return Less(n, S(-1))
|
|
|
|
cons91 = CustomConstraint(cons_f91)
|
|
|
|
def cons_f92(a, b, c, d):
|
|
return PosQ((-a*d + b*c)/b)
|
|
|
|
cons92 = CustomConstraint(cons_f92)
|
|
|
|
def cons_f93(a, b, c, d):
|
|
return NegQ((-a*d + b*c)/b)
|
|
|
|
cons93 = CustomConstraint(cons_f93)
|
|
|
|
def cons_f94(n):
|
|
return Less(S(-1), n, S(0))
|
|
|
|
cons94 = CustomConstraint(cons_f94)
|
|
|
|
def cons_f95(m, n):
|
|
return RationalQ(m, n)
|
|
|
|
cons95 = CustomConstraint(cons_f95)
|
|
|
|
def cons_f96(m):
|
|
return Less(m, S(-1))
|
|
|
|
cons96 = CustomConstraint(cons_f96)
|
|
|
|
def cons_f97(m, n):
|
|
return Not(And(IntegerQ(n), Not(IntegerQ(m))))
|
|
|
|
cons97 = CustomConstraint(cons_f97)
|
|
|
|
def cons_f98(m, n):
|
|
return Not(And(IntegerQ(m + n), LessEqual(m + n + S(2), S(0)), Or(FractionQ(m), GreaterEqual(m + S(2)*n + S(1), S(0)))))
|
|
|
|
cons98 = CustomConstraint(cons_f98)
|
|
|
|
def cons_f99(a, b, c, d, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return IntLinearcQ(a, b, c, d, m, n, x)
|
|
|
|
cons99 = CustomConstraint(cons_f99)
|
|
|
|
def cons_f100(a, c, m, n):
|
|
return Not(And(Less(n, S(-1)), Or(ZeroQ(a), And(NonzeroQ(c), Less(m, n), IntegerQ(n)))))
|
|
|
|
cons100 = CustomConstraint(cons_f100)
|
|
|
|
def cons_f101(m, n):
|
|
return Unequal(m + n + S(1), S(0))
|
|
|
|
cons101 = CustomConstraint(cons_f101)
|
|
|
|
def cons_f102(m, n):
|
|
return Not(And(PositiveIntegerQ(m), Or(Not(IntegerQ(n)), Less(S(0), m, n))))
|
|
|
|
cons102 = CustomConstraint(cons_f102)
|
|
|
|
def cons_f103(m, n):
|
|
return Not(And(IntegerQ(m + n), Less(m + n + S(2), S(0))))
|
|
|
|
cons103 = CustomConstraint(cons_f103)
|
|
|
|
def cons_f104(b, d):
|
|
return ZeroQ(b + d)
|
|
|
|
cons104 = CustomConstraint(cons_f104)
|
|
|
|
def cons_f105(a, c):
|
|
return PositiveQ(a + c)
|
|
|
|
cons105 = CustomConstraint(cons_f105)
|
|
|
|
def cons_f106(a, b, c, d):
|
|
return PositiveQ(-a*d + b*c)
|
|
|
|
cons106 = CustomConstraint(cons_f106)
|
|
|
|
def cons_f107(b):
|
|
return PositiveQ(b)
|
|
|
|
cons107 = CustomConstraint(cons_f107)
|
|
|
|
def cons_f108(b, d):
|
|
return ZeroQ(b - d)
|
|
|
|
cons108 = CustomConstraint(cons_f108)
|
|
|
|
def cons_f109(m):
|
|
return Less(S(-1), m, S(0))
|
|
|
|
cons109 = CustomConstraint(cons_f109)
|
|
|
|
def cons_f110(m):
|
|
return LessEqual(S(3), Denominator(m), S(4))
|
|
|
|
cons110 = CustomConstraint(cons_f110)
|
|
|
|
def cons_f111(b, d):
|
|
return PosQ(d/b)
|
|
|
|
cons111 = CustomConstraint(cons_f111)
|
|
|
|
def cons_f112(b, d):
|
|
return NegQ(d/b)
|
|
|
|
cons112 = CustomConstraint(cons_f112)
|
|
|
|
def cons_f113(m, n):
|
|
return Equal(m + n + S(1), S(0))
|
|
|
|
cons113 = CustomConstraint(cons_f113)
|
|
|
|
def cons_f114(m, n):
|
|
return LessEqual(Denominator(n), Denominator(m))
|
|
|
|
cons114 = CustomConstraint(cons_f114)
|
|
|
|
def cons_f115(m, n):
|
|
return NegativeIntegerQ(m + n + S(2))
|
|
|
|
cons115 = CustomConstraint(cons_f115)
|
|
|
|
def cons_f116(m, n):
|
|
return Or(SumSimplerQ(m, S(1)), Not(SumSimplerQ(n, S(1))))
|
|
|
|
cons116 = CustomConstraint(cons_f116)
|
|
|
|
def cons_f117(b, c, d, n):
|
|
return Or(IntegerQ(n), And(PositiveQ(c), Not(And(ZeroQ(n + S(1)/2), ZeroQ(c**S(2) - d**S(2)), PositiveQ(-d/(b*c))))))
|
|
|
|
cons117 = CustomConstraint(cons_f117)
|
|
|
|
def cons_f118(b, c, d, m):
|
|
return Or(IntegerQ(m), PositiveQ(-d/(b*c)))
|
|
|
|
cons118 = CustomConstraint(cons_f118)
|
|
|
|
def cons_f119(c):
|
|
return Not(PositiveQ(c))
|
|
|
|
cons119 = CustomConstraint(cons_f119)
|
|
|
|
def cons_f120(b, c, d):
|
|
return Not(PositiveQ(-d/(b*c)))
|
|
|
|
cons120 = CustomConstraint(cons_f120)
|
|
|
|
def cons_f121(c, d, m, n):
|
|
return Or(And(RationalQ(m), Not(And(ZeroQ(n + S(1)/2), ZeroQ(c**S(2) - d**S(2))))), Not(RationalQ(n)))
|
|
|
|
cons121 = CustomConstraint(cons_f121)
|
|
|
|
def cons_f122(a, b, c, d):
|
|
return PositiveQ(b/(-a*d + b*c))
|
|
|
|
cons122 = CustomConstraint(cons_f122)
|
|
|
|
def cons_f123(a, b, c, d, m, n):
|
|
return Or(RationalQ(m), Not(And(RationalQ(n), PositiveQ(-d/(-a*d + b*c)))))
|
|
|
|
cons123 = CustomConstraint(cons_f123)
|
|
|
|
def cons_f124(m, n):
|
|
return Or(RationalQ(m), Not(SimplerQ(n + S(1), m + S(1))))
|
|
|
|
cons124 = CustomConstraint(cons_f124)
|
|
|
|
def cons_f125(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return NonzeroQ(Coefficient(u, x, S(0)))
|
|
|
|
cons125 = CustomConstraint(cons_f125)
|
|
|
|
def cons_f126(m, n):
|
|
return ZeroQ(m - n)
|
|
|
|
cons126 = CustomConstraint(cons_f126)
|
|
|
|
def cons_f127(f, x):
|
|
return FreeQ(f, x)
|
|
|
|
cons127 = CustomConstraint(cons_f127)
|
|
|
|
def cons_f128(n, p):
|
|
return NonzeroQ(n + p + S(2))
|
|
|
|
cons128 = CustomConstraint(cons_f128)
|
|
|
|
def cons_f129(a, b, c, d, e, f, n, p):
|
|
return ZeroQ(a*d*f*(n + p + S(2)) - b*(c*f*(p + S(1)) + d*e*(n + S(1))))
|
|
|
|
cons129 = CustomConstraint(cons_f129)
|
|
|
|
def cons_f130(p):
|
|
return PositiveIntegerQ(p)
|
|
|
|
cons130 = CustomConstraint(cons_f130)
|
|
|
|
def cons_f131(a, b, e, f):
|
|
return ZeroQ(a*f + b*e)
|
|
|
|
cons131 = CustomConstraint(cons_f131)
|
|
|
|
def cons_f132(n, p):
|
|
return Not(And(NegativeIntegerQ(n + p + S(2)), Greater(n + S(2)*p, S(0))))
|
|
|
|
cons132 = CustomConstraint(cons_f132)
|
|
|
|
def cons_f133(n, p):
|
|
return Or(NonzeroQ(n + S(1)), Equal(p, S(1)))
|
|
|
|
cons133 = CustomConstraint(cons_f133)
|
|
|
|
def cons_f134(a, b, e, f):
|
|
return NonzeroQ(a*f + b*e)
|
|
|
|
cons134 = CustomConstraint(cons_f134)
|
|
|
|
def cons_f135(a, b, d, e, f, n, p):
|
|
return Or(Not(IntegerQ(n)), Less(S(5)*n + S(9)*p, S(0)), GreaterEqual(n + p + S(1), S(0)), And(GreaterEqual(n + p + S(2), S(0)), RationalQ(a, b, d, e, f)))
|
|
|
|
cons135 = CustomConstraint(cons_f135)
|
|
|
|
def cons_f136(a, b, c, d, e, f, n, p):
|
|
return Or(NegativeIntegerQ(n, p), ZeroQ(p + S(-1)), And(PositiveIntegerQ(p), Or(Not(IntegerQ(n)), LessEqual(S(5)*n + S(9)*p + S(10), S(0)), GreaterEqual(n + p + S(1), S(0)), And(GreaterEqual(n + p + S(2), S(0)), RationalQ(a, b, c, d, e, f)))))
|
|
|
|
cons136 = CustomConstraint(cons_f136)
|
|
|
|
def cons_f137(n, p):
|
|
return ZeroQ(n + p + S(2))
|
|
|
|
cons137 = CustomConstraint(cons_f137)
|
|
|
|
def cons_f138(n, p):
|
|
return Not(And(SumSimplerQ(n, S(1)), Not(SumSimplerQ(p, S(1)))))
|
|
|
|
cons138 = CustomConstraint(cons_f138)
|
|
|
|
def cons_f139(p):
|
|
return Less(p, S(-1))
|
|
|
|
cons139 = CustomConstraint(cons_f139)
|
|
|
|
def cons_f140(c, e, n, p):
|
|
return Or(Not(And(RationalQ(n), Less(n, S(-1)))), IntegerQ(p), Not(Or(IntegerQ(n), Not(Or(ZeroQ(e), Not(Or(ZeroQ(c), Less(p, n))))))))
|
|
|
|
cons140 = CustomConstraint(cons_f140)
|
|
|
|
def cons_f141(p):
|
|
return SumSimplerQ(p, S(1))
|
|
|
|
cons141 = CustomConstraint(cons_f141)
|
|
|
|
def cons_f142(n, p):
|
|
return NonzeroQ(n + p + S(3))
|
|
|
|
cons142 = CustomConstraint(cons_f142)
|
|
|
|
def cons_f143(a, b, c, d, e, f, n, p):
|
|
return ZeroQ(-b*(c*f*(p + S(1)) + d*e*(n + S(1)))*(a*d*f*(n + p + S(4)) - b*(c*f*(p + S(2)) + d*e*(n + S(2)))) + d*f*(a**S(2)*d*f*(n + p + S(3)) - b*(a*(c*f*(p + S(1)) + d*e*(n + S(1))) + b*c*e))*(n + p + S(2)))
|
|
|
|
cons143 = CustomConstraint(cons_f143)
|
|
|
|
def cons_f144(m, n):
|
|
return ZeroQ(m - n + S(-1))
|
|
|
|
cons144 = CustomConstraint(cons_f144)
|
|
|
|
def cons_f145(m):
|
|
return Not(PositiveIntegerQ(m))
|
|
|
|
cons145 = CustomConstraint(cons_f145)
|
|
|
|
def cons_f146(m, n, p):
|
|
return NonzeroQ(m + n + p + S(2))
|
|
|
|
cons146 = CustomConstraint(cons_f146)
|
|
|
|
def cons_f147(p):
|
|
return Less(S(0), p, S(1))
|
|
|
|
cons147 = CustomConstraint(cons_f147)
|
|
|
|
def cons_f148(p):
|
|
return Greater(p, S(1))
|
|
|
|
cons148 = CustomConstraint(cons_f148)
|
|
|
|
def cons_f149(p):
|
|
return Not(IntegerQ(p))
|
|
|
|
cons149 = CustomConstraint(cons_f149)
|
|
|
|
def cons_f150(n):
|
|
return PositiveIntegerQ(n)
|
|
|
|
cons150 = CustomConstraint(cons_f150)
|
|
|
|
def cons_f151(p):
|
|
return FractionQ(p)
|
|
|
|
cons151 = CustomConstraint(cons_f151)
|
|
|
|
def cons_f152(m, n):
|
|
return IntegersQ(m, n)
|
|
|
|
cons152 = CustomConstraint(cons_f152)
|
|
|
|
def cons_f153(m, n, p):
|
|
return Or(IntegerQ(p), And(Greater(m, S(0)), GreaterEqual(n, S(-1))))
|
|
|
|
cons153 = CustomConstraint(cons_f153)
|
|
|
|
def cons_f154(n, p):
|
|
return Or(And(RationalQ(n), Less(n, S(-1))), And(ZeroQ(n + p + S(3)), NonzeroQ(n + S(1)), Or(SumSimplerQ(n, S(1)), Not(SumSimplerQ(p, S(1))))))
|
|
|
|
cons154 = CustomConstraint(cons_f154)
|
|
|
|
def cons_f155(a, b, c, d, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f), x)
|
|
|
|
cons155 = CustomConstraint(cons_f155)
|
|
|
|
def cons_f156(a, b, c, d, e, f):
|
|
return ZeroQ(S(2)*b*d*e - f*(a*d + b*c))
|
|
|
|
cons156 = CustomConstraint(cons_f156)
|
|
|
|
def cons_f157(m, n):
|
|
return ZeroQ(m + n + S(1))
|
|
|
|
cons157 = CustomConstraint(cons_f157)
|
|
|
|
def cons_f158(a, b, c, d, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return SimplerQ(a + b*x, c + d*x)
|
|
|
|
cons158 = CustomConstraint(cons_f158)
|
|
|
|
def cons_f159(m, n, p):
|
|
return ZeroQ(m + n + p + S(2))
|
|
|
|
cons159 = CustomConstraint(cons_f159)
|
|
|
|
def cons_f160(m, p):
|
|
return Not(And(SumSimplerQ(p, S(1)), Not(SumSimplerQ(m, S(1)))))
|
|
|
|
cons160 = CustomConstraint(cons_f160)
|
|
|
|
def cons_f161(m, n, p):
|
|
return ZeroQ(m + n + p + S(3))
|
|
|
|
cons161 = CustomConstraint(cons_f161)
|
|
|
|
def cons_f162(a, b, c, d, e, f, m, n, p):
|
|
return ZeroQ(a*d*f*(m + S(1)) + b*c*f*(n + S(1)) + b*d*e*(p + S(1)))
|
|
|
|
cons162 = CustomConstraint(cons_f162)
|
|
|
|
def cons_f163(m):
|
|
return Or(And(RationalQ(m), Less(m, S(-1))), SumSimplerQ(m, S(1)))
|
|
|
|
cons163 = CustomConstraint(cons_f163)
|
|
|
|
def cons_f164(m, n, p):
|
|
return RationalQ(m, n, p)
|
|
|
|
cons164 = CustomConstraint(cons_f164)
|
|
|
|
def cons_f165(p):
|
|
return Greater(p, S(0))
|
|
|
|
cons165 = CustomConstraint(cons_f165)
|
|
|
|
def cons_f166(m, n, p):
|
|
return Or(IntegersQ(S(2)*m, S(2)*n, S(2)*p), IntegersQ(m, n + p), IntegersQ(p, m + n))
|
|
|
|
cons166 = CustomConstraint(cons_f166)
|
|
|
|
def cons_f167(n):
|
|
return Greater(n, S(1))
|
|
|
|
cons167 = CustomConstraint(cons_f167)
|
|
|
|
def cons_f168(m):
|
|
return Greater(m, S(1))
|
|
|
|
cons168 = CustomConstraint(cons_f168)
|
|
|
|
def cons_f169(m, n, p):
|
|
return NonzeroQ(m + n + p + S(1))
|
|
|
|
cons169 = CustomConstraint(cons_f169)
|
|
|
|
def cons_f170(m):
|
|
return Greater(m, S(0))
|
|
|
|
cons170 = CustomConstraint(cons_f170)
|
|
|
|
def cons_f171(m, n, p):
|
|
return Or(IntegersQ(S(2)*m, S(2)*n, S(2)*p), Or(IntegersQ(m, n + p), IntegersQ(p, m + n)))
|
|
|
|
cons171 = CustomConstraint(cons_f171)
|
|
|
|
def cons_f172(m, n, p):
|
|
return IntegersQ(S(2)*m, S(2)*n, S(2)*p)
|
|
|
|
cons172 = CustomConstraint(cons_f172)
|
|
|
|
def cons_f173(n, p):
|
|
return Or(IntegerQ(n), IntegersQ(S(2)*n, S(2)*p))
|
|
|
|
cons173 = CustomConstraint(cons_f173)
|
|
|
|
def cons_f174(m, n):
|
|
return PositiveIntegerQ(m + n + S(1))
|
|
|
|
cons174 = CustomConstraint(cons_f174)
|
|
|
|
def cons_f175(m, n):
|
|
return Or(And(RationalQ(m), Greater(m, S(0))), And(Not(RationalQ(m)), Or(SumSimplerQ(m, S(-1)), Not(SumSimplerQ(n, S(-1))))))
|
|
|
|
cons175 = CustomConstraint(cons_f175)
|
|
|
|
def cons_f176(c, d, e, f):
|
|
return PositiveQ(-f/(-c*f + d*e))
|
|
|
|
cons176 = CustomConstraint(cons_f176)
|
|
|
|
def cons_f177(c, d, e, f):
|
|
return Not(PositiveQ(-f/(-c*f + d*e)))
|
|
|
|
cons177 = CustomConstraint(cons_f177)
|
|
|
|
def cons_f178(c, d, e, f):
|
|
return NonzeroQ(-c*f + d*e)
|
|
|
|
cons178 = CustomConstraint(cons_f178)
|
|
|
|
def cons_f179(c):
|
|
return PositiveQ(c)
|
|
|
|
cons179 = CustomConstraint(cons_f179)
|
|
|
|
def cons_f180(e):
|
|
return PositiveQ(e)
|
|
|
|
cons180 = CustomConstraint(cons_f180)
|
|
|
|
def cons_f181(b, d):
|
|
return Not(NegativeQ(-b/d))
|
|
|
|
cons181 = CustomConstraint(cons_f181)
|
|
|
|
def cons_f182(b, d):
|
|
return NegativeQ(-b/d)
|
|
|
|
cons182 = CustomConstraint(cons_f182)
|
|
|
|
def cons_f183(c, e):
|
|
return Not(And(PositiveQ(c), PositiveQ(e)))
|
|
|
|
cons183 = CustomConstraint(cons_f183)
|
|
|
|
def cons_f184(a, b, e, f):
|
|
return PositiveQ(b/(-a*f + b*e))
|
|
|
|
cons184 = CustomConstraint(cons_f184)
|
|
|
|
def cons_f185(a, b, c, d):
|
|
return Not(NegativeQ(-(-a*d + b*c)/d))
|
|
|
|
cons185 = CustomConstraint(cons_f185)
|
|
|
|
def cons_f186(a, b, c, d, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(SimplerQ(c + d*x, a + b*x), PositiveQ(-d/(-a*d + b*c)), PositiveQ(d/(-c*f + d*e)), Not(NegativeQ((-a*d + b*c)/b))))
|
|
|
|
cons186 = CustomConstraint(cons_f186)
|
|
|
|
def cons_f187(a, b, c, d, e, f):
|
|
return Not(And(PositiveQ(b/(-a*d + b*c)), PositiveQ(b/(-a*f + b*e))))
|
|
|
|
cons187 = CustomConstraint(cons_f187)
|
|
|
|
def cons_f188(b, d, f):
|
|
return Or(PositiveQ(-b/d), NegativeQ(-b/f))
|
|
|
|
cons188 = CustomConstraint(cons_f188)
|
|
|
|
def cons_f189(b, d, f):
|
|
return Or(PosQ(-b/d), NegQ(-b/f))
|
|
|
|
cons189 = CustomConstraint(cons_f189)
|
|
|
|
def cons_f190(a, b, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return SimplerQ(a + b*x, e + f*x)
|
|
|
|
cons190 = CustomConstraint(cons_f190)
|
|
|
|
def cons_f191(a, b, c, d, e, f):
|
|
return Or(PositiveQ(-(-a*d + b*c)/d), NegativeQ(-(-a*f + b*e)/f))
|
|
|
|
cons191 = CustomConstraint(cons_f191)
|
|
|
|
def cons_f192(a, b, c, d, e, f):
|
|
return Or(PosQ(-(-a*d + b*c)/d), NegQ(-(-a*f + b*e)/f))
|
|
|
|
cons192 = CustomConstraint(cons_f192)
|
|
|
|
def cons_f193(a, b, c, d, e, f):
|
|
return ZeroQ(-a*d*f - b*c*f + S(2)*b*d*e)
|
|
|
|
cons193 = CustomConstraint(cons_f193)
|
|
|
|
def cons_f194(m, n):
|
|
return PositiveIntegerQ(m - n)
|
|
|
|
cons194 = CustomConstraint(cons_f194)
|
|
|
|
def cons_f195(m, n):
|
|
return Or(PositiveIntegerQ(m), NegativeIntegerQ(m, n))
|
|
|
|
cons195 = CustomConstraint(cons_f195)
|
|
|
|
def cons_f196(m, n, p):
|
|
return NegativeIntegerQ(m + n + p + S(2))
|
|
|
|
cons196 = CustomConstraint(cons_f196)
|
|
|
|
def cons_f197(m, n, p):
|
|
return Or(SumSimplerQ(m, S(1)), And(Not(And(NonzeroQ(n + S(1)), SumSimplerQ(n, S(1)))), Not(And(NonzeroQ(p + S(1)), SumSimplerQ(p, S(1))))))
|
|
|
|
cons197 = CustomConstraint(cons_f197)
|
|
|
|
def cons_f198(n):
|
|
return NegativeIntegerQ(n)
|
|
|
|
cons198 = CustomConstraint(cons_f198)
|
|
|
|
def cons_f199(e, p):
|
|
return Or(IntegerQ(p), PositiveQ(e))
|
|
|
|
cons199 = CustomConstraint(cons_f199)
|
|
|
|
def cons_f200(b, c, d):
|
|
return PositiveQ(-d/(b*c))
|
|
|
|
cons200 = CustomConstraint(cons_f200)
|
|
|
|
def cons_f201(c, d, e, f, p):
|
|
return Or(IntegerQ(p), PositiveQ(d/(-c*f + d*e)))
|
|
|
|
cons201 = CustomConstraint(cons_f201)
|
|
|
|
def cons_f202(a, b, c, d, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(PositiveQ(d/(a*d - b*c)), SimplerQ(c + d*x, a + b*x)))
|
|
|
|
cons202 = CustomConstraint(cons_f202)
|
|
|
|
def cons_f203(a, b, c, d):
|
|
return Not(PositiveQ(b/(-a*d + b*c)))
|
|
|
|
cons203 = CustomConstraint(cons_f203)
|
|
|
|
def cons_f204(a, b, c, d, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(SimplerQ(c + d*x, a + b*x))
|
|
|
|
cons204 = CustomConstraint(cons_f204)
|
|
|
|
def cons_f205(a, b, c, d, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(PositiveQ(d/(a*d - b*c)), PositiveQ(d/(-c*f + d*e)), SimplerQ(c + d*x, a + b*x)))
|
|
|
|
cons205 = CustomConstraint(cons_f205)
|
|
|
|
def cons_f206(a, b, c, d, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(PositiveQ(f/(a*f - b*e)), PositiveQ(f/(c*f - d*e)), SimplerQ(e + f*x, a + b*x)))
|
|
|
|
cons206 = CustomConstraint(cons_f206)
|
|
|
|
def cons_f207(a, b, e, f):
|
|
return Not(PositiveQ(b/(-a*f + b*e)))
|
|
|
|
cons207 = CustomConstraint(cons_f207)
|
|
|
|
def cons_f208(a, b, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(SimplerQ(e + f*x, a + b*x))
|
|
|
|
cons208 = CustomConstraint(cons_f208)
|
|
|
|
def cons_f209(m, n):
|
|
return Or(PositiveIntegerQ(m), IntegersQ(m, n))
|
|
|
|
cons209 = CustomConstraint(cons_f209)
|
|
|
|
def cons_f210(g, x):
|
|
return FreeQ(g, x)
|
|
|
|
cons210 = CustomConstraint(cons_f210)
|
|
|
|
def cons_f211(h, x):
|
|
return FreeQ(h, x)
|
|
|
|
cons211 = CustomConstraint(cons_f211)
|
|
|
|
def cons_f212(m, n):
|
|
return Not(And(SumSimplerQ(n, S(1)), Not(SumSimplerQ(m, S(1)))))
|
|
|
|
cons212 = CustomConstraint(cons_f212)
|
|
|
|
def cons_f213(m, n):
|
|
return Or(And(RationalQ(m), Less(m, S(-2))), And(ZeroQ(m + n + S(3)), Not(And(RationalQ(n), Less(n, S(-2))))))
|
|
|
|
cons213 = CustomConstraint(cons_f213)
|
|
|
|
def cons_f214(m):
|
|
return Or(And(RationalQ(m), Inequality(S(-2), LessEqual, m, Less, S(-1))), SumSimplerQ(m, S(1)))
|
|
|
|
cons214 = CustomConstraint(cons_f214)
|
|
|
|
def cons_f215(m, n):
|
|
return NonzeroQ(m + n + S(3))
|
|
|
|
cons215 = CustomConstraint(cons_f215)
|
|
|
|
def cons_f216(m, n):
|
|
return NonzeroQ(m + n + S(2))
|
|
|
|
cons216 = CustomConstraint(cons_f216)
|
|
|
|
def cons_f217(m, n, p):
|
|
return Or(IntegersQ(m, n, p), PositiveIntegerQ(n, p))
|
|
|
|
cons217 = CustomConstraint(cons_f217)
|
|
|
|
def cons_f218(a, b, c, d, e, f, g, h, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, h), x)
|
|
|
|
cons218 = CustomConstraint(cons_f218)
|
|
|
|
def cons_f219(a, b, c, d, e, f, g, h, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, h, n, p), x)
|
|
|
|
cons219 = CustomConstraint(cons_f219)
|
|
|
|
def cons_f220(c, d, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return SimplerQ(c + d*x, e + f*x)
|
|
|
|
cons220 = CustomConstraint(cons_f220)
|
|
|
|
def cons_f221(m, n, p):
|
|
return Or(SumSimplerQ(m, S(1)), And(Not(SumSimplerQ(n, S(1))), Not(SumSimplerQ(p, S(1)))))
|
|
|
|
cons221 = CustomConstraint(cons_f221)
|
|
|
|
def cons_f222(p, q):
|
|
return IntegersQ(p, q)
|
|
|
|
cons222 = CustomConstraint(cons_f222)
|
|
|
|
def cons_f223(q):
|
|
return PositiveIntegerQ(q)
|
|
|
|
cons223 = CustomConstraint(cons_f223)
|
|
|
|
def cons_f224(a, b, c, d, e, f, g, h, m, n, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, h, m, n, p, q), x)
|
|
|
|
cons224 = CustomConstraint(cons_f224)
|
|
|
|
def cons_f225(a, b, c, d, e, f, g, h, i, m, n, p, q, r, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, h, i, m, n, p, q, r), x)
|
|
|
|
cons225 = CustomConstraint(cons_f225)
|
|
|
|
def cons_f226(i, x):
|
|
return FreeQ(i, x)
|
|
|
|
cons226 = CustomConstraint(cons_f226)
|
|
|
|
def cons_f227(p):
|
|
return NonzeroQ(S(2)*p + S(1))
|
|
|
|
cons227 = CustomConstraint(cons_f227)
|
|
|
|
def cons_f228(a, b, c):
|
|
return NonzeroQ(-S(4)*a*c + b**S(2))
|
|
|
|
cons228 = CustomConstraint(cons_f228)
|
|
|
|
def cons_f229(a, b, c):
|
|
return PerfectSquareQ(-S(4)*a*c + b**S(2))
|
|
|
|
cons229 = CustomConstraint(cons_f229)
|
|
|
|
def cons_f230(a, b, c):
|
|
return Not(PerfectSquareQ(-S(4)*a*c + b**S(2)))
|
|
|
|
cons230 = CustomConstraint(cons_f230)
|
|
|
|
def cons_f231(p):
|
|
return IntegerQ(S(4)*p)
|
|
|
|
cons231 = CustomConstraint(cons_f231)
|
|
|
|
def cons_f232(p):
|
|
return Unequal(p, S(-3)/2)
|
|
|
|
cons232 = CustomConstraint(cons_f232)
|
|
|
|
def cons_f233(a, b, c):
|
|
return PosQ(-S(4)*a*c + b**S(2))
|
|
|
|
cons233 = CustomConstraint(cons_f233)
|
|
|
|
def cons_f234(a, b, c):
|
|
return PositiveQ(S(4)*a - b**S(2)/c)
|
|
|
|
cons234 = CustomConstraint(cons_f234)
|
|
|
|
def cons_f235(b, c, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(b, c), x)
|
|
|
|
cons235 = CustomConstraint(cons_f235)
|
|
|
|
def cons_f236(p):
|
|
return LessEqual(S(3), Denominator(p), S(4))
|
|
|
|
cons236 = CustomConstraint(cons_f236)
|
|
|
|
def cons_f237(p):
|
|
return Not(IntegerQ(S(4)*p))
|
|
|
|
cons237 = CustomConstraint(cons_f237)
|
|
|
|
def cons_f238(m):
|
|
return IntegerQ(m/S(2) + S(1)/2)
|
|
|
|
cons238 = CustomConstraint(cons_f238)
|
|
|
|
def cons_f239(m, p):
|
|
return ZeroQ(m + S(2)*p + S(1))
|
|
|
|
cons239 = CustomConstraint(cons_f239)
|
|
|
|
def cons_f240(m, p):
|
|
return NonzeroQ(m + S(2)*p + S(1))
|
|
|
|
cons240 = CustomConstraint(cons_f240)
|
|
|
|
def cons_f241(b, c, d, e):
|
|
return NonzeroQ(-b*e + S(2)*c*d)
|
|
|
|
cons241 = CustomConstraint(cons_f241)
|
|
|
|
def cons_f242(m, p):
|
|
return ZeroQ(m + S(2)*p + S(2))
|
|
|
|
cons242 = CustomConstraint(cons_f242)
|
|
|
|
def cons_f243(m):
|
|
return NonzeroQ(m + S(2))
|
|
|
|
cons243 = CustomConstraint(cons_f243)
|
|
|
|
def cons_f244(m, p):
|
|
return ZeroQ(m + S(2)*p + S(3))
|
|
|
|
cons244 = CustomConstraint(cons_f244)
|
|
|
|
def cons_f245(p):
|
|
return NonzeroQ(p + S(3)/2)
|
|
|
|
cons245 = CustomConstraint(cons_f245)
|
|
|
|
def cons_f246(m, p):
|
|
return RationalQ(m, p)
|
|
|
|
cons246 = CustomConstraint(cons_f246)
|
|
|
|
def cons_f247(m):
|
|
return Inequality(S(-2), LessEqual, m, Less, S(-1))
|
|
|
|
cons247 = CustomConstraint(cons_f247)
|
|
|
|
def cons_f248(p):
|
|
return IntegerQ(S(2)*p)
|
|
|
|
cons248 = CustomConstraint(cons_f248)
|
|
|
|
def cons_f249(m):
|
|
return Less(m, S(-2))
|
|
|
|
cons249 = CustomConstraint(cons_f249)
|
|
|
|
def cons_f250(m, p):
|
|
return Not(And(NegativeIntegerQ(m + S(2)*p + S(3)), Greater(m + S(3)*p + S(3), S(0))))
|
|
|
|
cons250 = CustomConstraint(cons_f250)
|
|
|
|
def cons_f251(m, p):
|
|
return NonzeroQ(m + S(2)*p)
|
|
|
|
cons251 = CustomConstraint(cons_f251)
|
|
|
|
def cons_f252(m):
|
|
return Not(And(RationalQ(m), Less(m, S(-2))))
|
|
|
|
cons252 = CustomConstraint(cons_f252)
|
|
|
|
def cons_f253(m, p):
|
|
return Not(And(IntegerQ(m), Less(S(0), m, S(2)*p)))
|
|
|
|
cons253 = CustomConstraint(cons_f253)
|
|
|
|
def cons_f254(m):
|
|
return Inequality(S(0), Less, m, LessEqual, S(1))
|
|
|
|
cons254 = CustomConstraint(cons_f254)
|
|
|
|
def cons_f255(m, p):
|
|
return NonzeroQ(m + p + S(1))
|
|
|
|
cons255 = CustomConstraint(cons_f255)
|
|
|
|
def cons_f256(m, p):
|
|
return Or(Not(RationalQ(p)), Inequality(S(-1), LessEqual, p, Less, S(0)), And(IntegerQ(m), Less(S(0), m, S(2)*p)), And(Equal(m, S(1)/2), Less(p, S(0))))
|
|
|
|
cons256 = CustomConstraint(cons_f256)
|
|
|
|
def cons_f257(m, p):
|
|
return Or(IntegerQ(m), IntegerQ(S(2)*p))
|
|
|
|
cons257 = CustomConstraint(cons_f257)
|
|
|
|
def cons_f258(a, b, c, d, e):
|
|
return ZeroQ(a*e**S(2) - b*d*e + c*d**S(2))
|
|
|
|
cons258 = CustomConstraint(cons_f258)
|
|
|
|
def cons_f259(a, c, d, e):
|
|
return ZeroQ(a*e**S(2) + c*d**S(2))
|
|
|
|
cons259 = CustomConstraint(cons_f259)
|
|
|
|
def cons_f260(a, d, m, p):
|
|
return Or(IntegerQ(p), And(PositiveQ(a), PositiveQ(d), IntegerQ(m + p)))
|
|
|
|
cons260 = CustomConstraint(cons_f260)
|
|
|
|
def cons_f261(m, p):
|
|
return Or(Less(S(0), -m, p), Less(p, -m, S(0)))
|
|
|
|
cons261 = CustomConstraint(cons_f261)
|
|
|
|
def cons_f262(m):
|
|
return Unequal(m, S(2))
|
|
|
|
cons262 = CustomConstraint(cons_f262)
|
|
|
|
def cons_f263(m):
|
|
return Unequal(m, S(-1))
|
|
|
|
cons263 = CustomConstraint(cons_f263)
|
|
|
|
def cons_f264(m, p):
|
|
return PositiveIntegerQ(m + p)
|
|
|
|
cons264 = CustomConstraint(cons_f264)
|
|
|
|
def cons_f265(m, p):
|
|
return NegativeIntegerQ(m + S(2)*p + S(2))
|
|
|
|
cons265 = CustomConstraint(cons_f265)
|
|
|
|
def cons_f266(m, p):
|
|
return Or(Less(m, S(-2)), ZeroQ(m + S(2)*p + S(1)))
|
|
|
|
cons266 = CustomConstraint(cons_f266)
|
|
|
|
def cons_f267(m, p):
|
|
return Or(Inequality(S(-2), LessEqual, m, Less, S(0)), Equal(m + p + S(1), S(0)))
|
|
|
|
cons267 = CustomConstraint(cons_f267)
|
|
|
|
def cons_f268(m):
|
|
return GreaterEqual(m, S(1))
|
|
|
|
cons268 = CustomConstraint(cons_f268)
|
|
|
|
def cons_f269(m):
|
|
return Less(m, S(0))
|
|
|
|
cons269 = CustomConstraint(cons_f269)
|
|
|
|
def cons_f270(d):
|
|
return PositiveQ(d)
|
|
|
|
cons270 = CustomConstraint(cons_f270)
|
|
|
|
def cons_f271(m, p):
|
|
return Not(And(ZeroQ(m + S(-3)), Unequal(p, S(1))))
|
|
|
|
cons271 = CustomConstraint(cons_f271)
|
|
|
|
def cons_f272(m, p):
|
|
return NonzeroQ(m + S(2)*p + S(3))
|
|
|
|
cons272 = CustomConstraint(cons_f272)
|
|
|
|
def cons_f273(m, p):
|
|
return Not(And(EvenQ(m), Less(m + S(2)*p + S(3), S(0))))
|
|
|
|
cons273 = CustomConstraint(cons_f273)
|
|
|
|
def cons_f274(m):
|
|
return Not(And(RationalQ(m), Less(m, S(-1))))
|
|
|
|
cons274 = CustomConstraint(cons_f274)
|
|
|
|
def cons_f275(m, p):
|
|
return Not(And(PositiveIntegerQ(m/S(2) + S(-1)/2), Or(Not(IntegerQ(p)), Less(m, S(2)*p))))
|
|
|
|
cons275 = CustomConstraint(cons_f275)
|
|
|
|
def cons_f276(m):
|
|
return Not(And(RationalQ(m), Greater(m, S(1))))
|
|
|
|
cons276 = CustomConstraint(cons_f276)
|
|
|
|
def cons_f277(a, b, c):
|
|
return NegativeQ(c/(-S(4)*a*c + b**S(2)))
|
|
|
|
cons277 = CustomConstraint(cons_f277)
|
|
|
|
def cons_f278(m):
|
|
return EqQ(m**S(2), S(1)/4)
|
|
|
|
cons278 = CustomConstraint(cons_f278)
|
|
|
|
def cons_f279(m, p):
|
|
return Or(IntegerQ(S(2)*p), And(IntegerQ(m), RationalQ(p)), OddQ(m))
|
|
|
|
cons279 = CustomConstraint(cons_f279)
|
|
|
|
def cons_f280(m, p):
|
|
return Or(IntegerQ(S(2)*p), And(IntegerQ(m), RationalQ(p)), IntegerQ(m/S(2) + p + S(3)/2))
|
|
|
|
cons280 = CustomConstraint(cons_f280)
|
|
|
|
def cons_f281(a, b, c, d, e):
|
|
return NonzeroQ(a*e**S(2) - b*d*e + c*d**S(2))
|
|
|
|
cons281 = CustomConstraint(cons_f281)
|
|
|
|
def cons_f282(a, c, d, e):
|
|
return NonzeroQ(a*e**S(2) + c*d**S(2))
|
|
|
|
cons282 = CustomConstraint(cons_f282)
|
|
|
|
def cons_f283(m, p):
|
|
return Not(And(ZeroQ(m + S(-1)), Greater(p, S(1))))
|
|
|
|
cons283 = CustomConstraint(cons_f283)
|
|
|
|
def cons_f284(a, b, c):
|
|
return NiceSqrtQ(-S(4)*a*c + b**S(2))
|
|
|
|
cons284 = CustomConstraint(cons_f284)
|
|
|
|
def cons_f285(a, c):
|
|
return NiceSqrtQ(-a*c)
|
|
|
|
cons285 = CustomConstraint(cons_f285)
|
|
|
|
def cons_f286(a, b, c):
|
|
return Not(NiceSqrtQ(-S(4)*a*c + b**S(2)))
|
|
|
|
cons286 = CustomConstraint(cons_f286)
|
|
|
|
def cons_f287(a, c):
|
|
return Not(NiceSqrtQ(-a*c))
|
|
|
|
cons287 = CustomConstraint(cons_f287)
|
|
|
|
def cons_f288(d, m):
|
|
return Or(NonzeroQ(d), Greater(m, S(2)))
|
|
|
|
cons288 = CustomConstraint(cons_f288)
|
|
|
|
def cons_f289(p):
|
|
return Not(And(RationalQ(p), LessEqual(p, S(-1))))
|
|
|
|
cons289 = CustomConstraint(cons_f289)
|
|
|
|
def cons_f290(a, b, d, e):
|
|
return ZeroQ(a*e + b*d)
|
|
|
|
cons290 = CustomConstraint(cons_f290)
|
|
|
|
def cons_f291(b, c, d, e):
|
|
return ZeroQ(b*e + c*d)
|
|
|
|
cons291 = CustomConstraint(cons_f291)
|
|
|
|
def cons_f292(m, p):
|
|
return PositiveIntegerQ(m - p + S(1))
|
|
|
|
cons292 = CustomConstraint(cons_f292)
|
|
|
|
def cons_f293(b, c, d, e):
|
|
return NonzeroQ(-b*e + c*d)
|
|
|
|
cons293 = CustomConstraint(cons_f293)
|
|
|
|
def cons_f294(m):
|
|
return Equal(m**S(2), S(1)/4)
|
|
|
|
cons294 = CustomConstraint(cons_f294)
|
|
|
|
def cons_f295(c):
|
|
return NegativeQ(c)
|
|
|
|
cons295 = CustomConstraint(cons_f295)
|
|
|
|
def cons_f296(b):
|
|
return RationalQ(b)
|
|
|
|
cons296 = CustomConstraint(cons_f296)
|
|
|
|
def cons_f297(m):
|
|
return ZeroQ(m**S(2) + S(-1)/4)
|
|
|
|
cons297 = CustomConstraint(cons_f297)
|
|
|
|
def cons_f298(m, p):
|
|
return Equal(m + S(2)*p + S(2), S(0))
|
|
|
|
cons298 = CustomConstraint(cons_f298)
|
|
|
|
def cons_f299(a, c, d, e, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, d, e), x)
|
|
|
|
cons299 = CustomConstraint(cons_f299)
|
|
|
|
def cons_f300(m, p):
|
|
return Or(IntegerQ(p), And(RationalQ(m), Less(m, S(-1))))
|
|
|
|
cons300 = CustomConstraint(cons_f300)
|
|
|
|
def cons_f301(m, p):
|
|
return Not(NegativeIntegerQ(m + S(2)*p + S(1)))
|
|
|
|
cons301 = CustomConstraint(cons_f301)
|
|
|
|
def cons_f302(a, b, c, d, e, m, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return IntQuadraticQ(a, b, c, d, e, m, p, x)
|
|
|
|
cons302 = CustomConstraint(cons_f302)
|
|
|
|
def cons_f303(a, c, d, e, m, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return IntQuadraticQ(a, S(0), c, d, e, m, p, x)
|
|
|
|
cons303 = CustomConstraint(cons_f303)
|
|
|
|
def cons_f304(m):
|
|
return Or(Not(RationalQ(m)), Less(m, S(1)))
|
|
|
|
cons304 = CustomConstraint(cons_f304)
|
|
|
|
def cons_f305(m, p):
|
|
return Not(NegativeIntegerQ(m + S(2)*p))
|
|
|
|
cons305 = CustomConstraint(cons_f305)
|
|
|
|
def cons_f306(m, p):
|
|
return Or(Less(m, S(1)), And(NegativeIntegerQ(m + S(2)*p + S(3)), Unequal(m, S(2))))
|
|
|
|
cons306 = CustomConstraint(cons_f306)
|
|
|
|
def cons_f307(m):
|
|
return If(RationalQ(m), Greater(m, S(1)), SumSimplerQ(m, S(-2)))
|
|
|
|
cons307 = CustomConstraint(cons_f307)
|
|
|
|
def cons_f308(a, b, c, d, e, m, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(And(RationalQ(m), Less(m, S(-1)), IntQuadraticQ(a, b, c, d, e, m, p, x)), And(SumSimplerQ(m, S(1)), IntegerQ(p), NonzeroQ(m + S(1))), And(NegativeIntegerQ(m + S(2)*p + S(3)), NonzeroQ(m + S(1))))
|
|
|
|
cons308 = CustomConstraint(cons_f308)
|
|
|
|
def cons_f309(a, c, d, e, m, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(And(RationalQ(m), Less(m, S(-1)), IntQuadraticQ(a, S(0), c, d, e, m, p, x)), And(SumSimplerQ(m, S(1)), IntegerQ(p), NonzeroQ(m + S(1))), And(NegativeIntegerQ(m + S(2)*p + S(3)), NonzeroQ(m + S(1))))
|
|
|
|
cons309 = CustomConstraint(cons_f309)
|
|
|
|
def cons_f310(a, b, c, d, e):
|
|
return ZeroQ(-S(3)*a*c*e**S(2) + b**S(2)*e**S(2) - b*c*d*e + c**S(2)*d**S(2))
|
|
|
|
cons310 = CustomConstraint(cons_f310)
|
|
|
|
def cons_f311(b, c, d, e):
|
|
return PosQ(c*e**S(2)*(-b*e + S(2)*c*d))
|
|
|
|
cons311 = CustomConstraint(cons_f311)
|
|
|
|
def cons_f312(a, c, d, e):
|
|
return ZeroQ(-S(3)*a*e**S(2) + c*d**S(2))
|
|
|
|
cons312 = CustomConstraint(cons_f312)
|
|
|
|
def cons_f313(b, c, d, e):
|
|
return NegQ(c*e**S(2)*(-b*e + S(2)*c*d))
|
|
|
|
cons313 = CustomConstraint(cons_f313)
|
|
|
|
def cons_f314(a, b, c, d, e):
|
|
return ZeroQ(S(9)*a*c*e**S(2) - S(2)*b**S(2)*e**S(2) - b*c*d*e + c**S(2)*d**S(2))
|
|
|
|
cons314 = CustomConstraint(cons_f314)
|
|
|
|
def cons_f315(a, b, c):
|
|
return Not(PositiveQ(S(4)*a - b**S(2)/c))
|
|
|
|
cons315 = CustomConstraint(cons_f315)
|
|
|
|
def cons_f316(p):
|
|
return Not(IntegerQ(S(2)*p))
|
|
|
|
cons316 = CustomConstraint(cons_f316)
|
|
|
|
def cons_f317(d, e, f, g):
|
|
return NonzeroQ(-d*g + e*f)
|
|
|
|
cons317 = CustomConstraint(cons_f317)
|
|
|
|
def cons_f318(b, c, f, g):
|
|
return ZeroQ(-b*g + S(2)*c*f)
|
|
|
|
cons318 = CustomConstraint(cons_f318)
|
|
|
|
def cons_f319(m):
|
|
return Not(And(RationalQ(m), Greater(m, S(0))))
|
|
|
|
cons319 = CustomConstraint(cons_f319)
|
|
|
|
def cons_f320(m, p):
|
|
return Or(Not(RationalQ(p)), And(Greater(p, S(0)), Or(Not(IntegerQ(m)), GreaterEqual(m, -S(2)*p + S(-2)), Less(m, -S(4)*p + S(-4)))))
|
|
|
|
cons320 = CustomConstraint(cons_f320)
|
|
|
|
def cons_f321(m, p):
|
|
return NonzeroQ(m + S(2)*p + S(2))
|
|
|
|
cons321 = CustomConstraint(cons_f321)
|
|
|
|
def cons_f322(m, p):
|
|
return Or(Not(RationalQ(p)), Less(m, S(2)*p + S(2)))
|
|
|
|
cons322 = CustomConstraint(cons_f322)
|
|
|
|
def cons_f323(b, c, f, g):
|
|
return NonzeroQ(-b*g + S(2)*c*f)
|
|
|
|
cons323 = CustomConstraint(cons_f323)
|
|
|
|
def cons_f324(p):
|
|
return Less(p, S(0))
|
|
|
|
cons324 = CustomConstraint(cons_f324)
|
|
|
|
def cons_f325(b, c, d, e, m, p):
|
|
return Or(And(ZeroQ(m + S(2)*p + S(2)), NonzeroQ(m + S(1))), And(ZeroQ(-b*e + S(2)*c*d), NonzeroQ(m + S(-1))))
|
|
|
|
cons325 = CustomConstraint(cons_f325)
|
|
|
|
def cons_f326(d, e, f, g, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(ZeroQ(m + S(-1)), SimplerQ(f + g*x, d + e*x)))
|
|
|
|
cons326 = CustomConstraint(cons_f326)
|
|
|
|
def cons_f327(a, d, m, p):
|
|
return Or(IntegerQ(p), And(PositiveQ(a), PositiveQ(d), ZeroQ(m + p)))
|
|
|
|
cons327 = CustomConstraint(cons_f327)
|
|
|
|
def cons_f328(b, c, d, e, f, g, m, p):
|
|
return ZeroQ(e*(p + S(1))*(-b*g + S(2)*c*f) + m*(c*e*f + g*(-b*e + c*d)))
|
|
|
|
cons328 = CustomConstraint(cons_f328)
|
|
|
|
def cons_f329(d, e, f, g, m, p):
|
|
return ZeroQ(S(2)*e*f*(p + S(1)) + m*(d*g + e*f))
|
|
|
|
cons329 = CustomConstraint(cons_f329)
|
|
|
|
def cons_f330(m):
|
|
return SumSimplerQ(m, S(-1))
|
|
|
|
cons330 = CustomConstraint(cons_f330)
|
|
|
|
def cons_f331(m, p):
|
|
return Or(And(RationalQ(m), Less(m, S(-1)), Not(PositiveIntegerQ(m + p + S(1)))), And(RationalQ(m, p), Less(m, S(0)), Less(p, S(-1))), ZeroQ(m + S(2)*p + S(2)))
|
|
|
|
cons331 = CustomConstraint(cons_f331)
|
|
|
|
def cons_f332(a, c, f, g):
|
|
return ZeroQ(a*g**S(2) + c*f**S(2))
|
|
|
|
cons332 = CustomConstraint(cons_f332)
|
|
|
|
def cons_f333(p):
|
|
return Less(p, S(-2))
|
|
|
|
cons333 = CustomConstraint(cons_f333)
|
|
|
|
def cons_f334(m, p):
|
|
return Or(Less(S(0), -m, p + S(1)), Less(p, -m, S(0)))
|
|
|
|
cons334 = CustomConstraint(cons_f334)
|
|
|
|
def cons_f335(n, p):
|
|
return NegativeIntegerQ(n + S(2)*p)
|
|
|
|
cons335 = CustomConstraint(cons_f335)
|
|
|
|
def cons_f336(b, c, d, e, f, g):
|
|
return ZeroQ(-b*e*g + c*d*g + c*e*f)
|
|
|
|
cons336 = CustomConstraint(cons_f336)
|
|
|
|
def cons_f337(m, n):
|
|
return NonzeroQ(m - n + S(-1))
|
|
|
|
cons337 = CustomConstraint(cons_f337)
|
|
|
|
def cons_f338(d, e, f, g):
|
|
return ZeroQ(d*g + e*f)
|
|
|
|
cons338 = CustomConstraint(cons_f338)
|
|
|
|
def cons_f339(m, n):
|
|
return ZeroQ(m - n + S(-2))
|
|
|
|
cons339 = CustomConstraint(cons_f339)
|
|
|
|
def cons_f340(n, p):
|
|
return RationalQ(n, p)
|
|
|
|
cons340 = CustomConstraint(cons_f340)
|
|
|
|
def cons_f341(n, p):
|
|
return Not(And(IntegerQ(n + p), LessEqual(n + p + S(2), S(0))))
|
|
|
|
cons341 = CustomConstraint(cons_f341)
|
|
|
|
def cons_f342(n):
|
|
return Not(PositiveIntegerQ(n))
|
|
|
|
cons342 = CustomConstraint(cons_f342)
|
|
|
|
def cons_f343(n, p):
|
|
return Not(And(IntegerQ(n + p), Less(n + p + S(2), S(0))))
|
|
|
|
cons343 = CustomConstraint(cons_f343)
|
|
|
|
def cons_f344(n, p):
|
|
return Or(IntegerQ(S(2)*p), IntegerQ(n))
|
|
|
|
cons344 = CustomConstraint(cons_f344)
|
|
|
|
def cons_f345(m, p):
|
|
return ZeroQ(m + p + S(-1))
|
|
|
|
cons345 = CustomConstraint(cons_f345)
|
|
|
|
def cons_f346(b, c, d, e, f, g, n, p):
|
|
return ZeroQ(b*e*g*(n + S(1)) - c*d*g*(S(2)*n + p + S(3)) + c*e*f*(p + S(1)))
|
|
|
|
cons346 = CustomConstraint(cons_f346)
|
|
|
|
def cons_f347(d, e, f, g, n, p):
|
|
return ZeroQ(-d*g*(S(2)*n + p + S(3)) + e*f*(p + S(1)))
|
|
|
|
cons347 = CustomConstraint(cons_f347)
|
|
|
|
def cons_f348(n):
|
|
return Not(And(RationalQ(n), Less(n, S(-1))))
|
|
|
|
cons348 = CustomConstraint(cons_f348)
|
|
|
|
def cons_f349(p):
|
|
return IntegerQ(p + S(-1)/2)
|
|
|
|
cons349 = CustomConstraint(cons_f349)
|
|
|
|
def cons_f350(m, p):
|
|
return Not(And(Less(m, S(0)), Less(p, S(0))))
|
|
|
|
cons350 = CustomConstraint(cons_f350)
|
|
|
|
def cons_f351(p):
|
|
return Unequal(p, S(1)/2)
|
|
|
|
cons351 = CustomConstraint(cons_f351)
|
|
|
|
def cons_f352(a, b, c, d, e, f, g):
|
|
return ZeroQ(-S(2)*a*e*g + b*(d*g + e*f) - S(2)*c*d*f)
|
|
|
|
cons352 = CustomConstraint(cons_f352)
|
|
|
|
def cons_f353(a, c, d, e, f, g):
|
|
return ZeroQ(a*e*g + c*d*f)
|
|
|
|
cons353 = CustomConstraint(cons_f353)
|
|
|
|
def cons_f354(b, c, d, e, m):
|
|
return Not(And(Equal(m, S(1)), Or(ZeroQ(d), ZeroQ(-b*e + S(2)*c*d))))
|
|
|
|
cons354 = CustomConstraint(cons_f354)
|
|
|
|
def cons_f355(d, m):
|
|
return Not(And(Equal(m, S(1)), ZeroQ(d)))
|
|
|
|
cons355 = CustomConstraint(cons_f355)
|
|
|
|
def cons_f356(a, b, c, d, e, f, g, p):
|
|
return ZeroQ(-S(2)*a*c*e*g + b**S(2)*e*g*(p + S(2)) + c*(S(2)*p + S(3))*(-b*(d*g + e*f) + S(2)*c*d*f))
|
|
|
|
cons356 = CustomConstraint(cons_f356)
|
|
|
|
def cons_f357(a, c, d, e, f, g, p):
|
|
return ZeroQ(a*e*g - c*d*f*(S(2)*p + S(3)))
|
|
|
|
cons357 = CustomConstraint(cons_f357)
|
|
|
|
def cons_f358(m):
|
|
return Not(RationalQ(m))
|
|
|
|
cons358 = CustomConstraint(cons_f358)
|
|
|
|
def cons_f359(p):
|
|
return Not(PositiveIntegerQ(p))
|
|
|
|
cons359 = CustomConstraint(cons_f359)
|
|
|
|
def cons_f360(m, p):
|
|
return ZeroQ(m - p)
|
|
|
|
cons360 = CustomConstraint(cons_f360)
|
|
|
|
def cons_f361(m, p):
|
|
return Less(m + S(2)*p, S(0))
|
|
|
|
cons361 = CustomConstraint(cons_f361)
|
|
|
|
def cons_f362(m, p):
|
|
return Not(NegativeIntegerQ(m + S(2)*p + S(3)))
|
|
|
|
cons362 = CustomConstraint(cons_f362)
|
|
|
|
def cons_f363(m, p):
|
|
return Or(And(RationalQ(m), Less(m, S(-1))), Equal(p, S(1)), And(IntegerQ(p), Not(RationalQ(m))))
|
|
|
|
cons363 = CustomConstraint(cons_f363)
|
|
|
|
def cons_f364(m, p):
|
|
return Or(IntegerQ(m), IntegerQ(p), IntegersQ(S(2)*m, S(2)*p))
|
|
|
|
cons364 = CustomConstraint(cons_f364)
|
|
|
|
def cons_f365(m, p):
|
|
return Or(IntegerQ(p), Not(RationalQ(m)), Inequality(S(-1), LessEqual, m, Less, S(0)))
|
|
|
|
cons365 = CustomConstraint(cons_f365)
|
|
|
|
def cons_f366(a, b, c, d, e, f, g, m, p):
|
|
return Or(And(Equal(m, S(2)), Equal(p, S(-3)), RationalQ(a, b, c, d, e, f, g)), Not(NegativeIntegerQ(m + S(2)*p + S(3))))
|
|
|
|
cons366 = CustomConstraint(cons_f366)
|
|
|
|
def cons_f367(a, c, d, e, f, g, m, p):
|
|
return Or(And(Equal(m, S(2)), Equal(p, S(-3)), RationalQ(a, c, d, e, f, g)), Not(NegativeIntegerQ(m + S(2)*p + S(3))))
|
|
|
|
cons367 = CustomConstraint(cons_f367)
|
|
|
|
def cons_f368(d, e, f, g, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(Equal(m, S(1)), SimplerQ(d + e*x, f + g*x)))
|
|
|
|
cons368 = CustomConstraint(cons_f368)
|
|
|
|
def cons_f369(m):
|
|
return FractionQ(m)
|
|
|
|
cons369 = CustomConstraint(cons_f369)
|
|
|
|
def cons_f370(d, e, f, g, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(Equal(m, S(1)), SimplerQ(f + g*x, d + e*x)))
|
|
|
|
cons370 = CustomConstraint(cons_f370)
|
|
|
|
def cons_f371(m, p):
|
|
return NegativeIntegerQ(m + S(2)*p + S(3))
|
|
|
|
cons371 = CustomConstraint(cons_f371)
|
|
|
|
def cons_f372(a, b, c, d, e):
|
|
return ZeroQ(S(4)*c*(a - d) - (b - e)**S(2))
|
|
|
|
cons372 = CustomConstraint(cons_f372)
|
|
|
|
def cons_f373(a, b, d, e, f, g):
|
|
return ZeroQ(e*f*(b - e) - S(2)*g*(-a*e + b*d))
|
|
|
|
cons373 = CustomConstraint(cons_f373)
|
|
|
|
def cons_f374(a, b, d, e):
|
|
return NonzeroQ(-a*e + b*d)
|
|
|
|
cons374 = CustomConstraint(cons_f374)
|
|
|
|
def cons_f375(a, c, f, g, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, f, g), x)
|
|
|
|
cons375 = CustomConstraint(cons_f375)
|
|
|
|
def cons_f376(a, c, e, f, g, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, e, f, g), x)
|
|
|
|
cons376 = CustomConstraint(cons_f376)
|
|
|
|
def cons_f377(m, n, p):
|
|
return IntegersQ(m, n, p)
|
|
|
|
cons377 = CustomConstraint(cons_f377)
|
|
|
|
def cons_f378(n, p):
|
|
return IntegersQ(n, p)
|
|
|
|
cons378 = CustomConstraint(cons_f378)
|
|
|
|
def cons_f379(d, f, m):
|
|
return Or(IntegerQ(m), And(PositiveQ(d), PositiveQ(f)))
|
|
|
|
cons379 = CustomConstraint(cons_f379)
|
|
|
|
def cons_f380(m, n, p):
|
|
return Or(IntegerQ(p), IntegersQ(m, n))
|
|
|
|
cons380 = CustomConstraint(cons_f380)
|
|
|
|
def cons_f381(a, c, e, f, g, m, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, e, f, g, m, p), x)
|
|
|
|
cons381 = CustomConstraint(cons_f381)
|
|
|
|
def cons_f382(a, b, c, d, e, f, g, m, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, m, n, p), x)
|
|
|
|
cons382 = CustomConstraint(cons_f382)
|
|
|
|
def cons_f383(a, c, d, e, f, g, m, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, d, e, f, g, m, n, p), x)
|
|
|
|
cons383 = CustomConstraint(cons_f383)
|
|
|
|
def cons_f384(a, c, d, f):
|
|
return ZeroQ(-a*f + c*d)
|
|
|
|
cons384 = CustomConstraint(cons_f384)
|
|
|
|
def cons_f385(a, b, d, e):
|
|
return ZeroQ(-a*e + b*d)
|
|
|
|
cons385 = CustomConstraint(cons_f385)
|
|
|
|
def cons_f386(c, f, p):
|
|
return Or(IntegerQ(p), PositiveQ(c/f))
|
|
|
|
cons386 = CustomConstraint(cons_f386)
|
|
|
|
def cons_f387(a, b, c, d, e, f, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(Not(IntegerQ(q)), LessEqual(LeafCount(d + e*x + f*x**S(2)), LeafCount(a + b*x + c*x**S(2))))
|
|
|
|
cons387 = CustomConstraint(cons_f387)
|
|
|
|
def cons_f388(q):
|
|
return Not(IntegerQ(q))
|
|
|
|
cons388 = CustomConstraint(cons_f388)
|
|
|
|
def cons_f389(c, f):
|
|
return Not(PositiveQ(c/f))
|
|
|
|
cons389 = CustomConstraint(cons_f389)
|
|
|
|
def cons_f390(a, b, c, d, e, f, q):
|
|
return ZeroQ(c*(-S(2)*d*f + e**S(2)*(q + S(2))) + f*(S(2)*q + S(3))*(S(2)*a*f - b*e))
|
|
|
|
cons390 = CustomConstraint(cons_f390)
|
|
|
|
def cons_f391(q):
|
|
return NonzeroQ(q + S(1))
|
|
|
|
cons391 = CustomConstraint(cons_f391)
|
|
|
|
def cons_f392(q):
|
|
return NonzeroQ(S(2)*q + S(3))
|
|
|
|
cons392 = CustomConstraint(cons_f392)
|
|
|
|
def cons_f393(a, c, d, e, f, q):
|
|
return ZeroQ(S(2)*a*f**S(2)*(S(2)*q + S(3)) + c*(-S(2)*d*f + e**S(2)*(q + S(2))))
|
|
|
|
cons393 = CustomConstraint(cons_f393)
|
|
|
|
def cons_f394(a, c, d, f, q):
|
|
return ZeroQ(S(2)*a*f*q + S(3)*a*f - c*d)
|
|
|
|
cons394 = CustomConstraint(cons_f394)
|
|
|
|
def cons_f395(q):
|
|
return PositiveIntegerQ(q + S(2))
|
|
|
|
cons395 = CustomConstraint(cons_f395)
|
|
|
|
def cons_f396(d, e, f):
|
|
return NonzeroQ(-S(4)*d*f + e**S(2))
|
|
|
|
cons396 = CustomConstraint(cons_f396)
|
|
|
|
def cons_f397(q):
|
|
return RationalQ(q)
|
|
|
|
cons397 = CustomConstraint(cons_f397)
|
|
|
|
def cons_f398(q):
|
|
return Less(q, S(-1))
|
|
|
|
cons398 = CustomConstraint(cons_f398)
|
|
|
|
def cons_f399(a, b, c, d, e, f, q):
|
|
return NonzeroQ(c*(-S(2)*d*f + e**S(2)*(q + S(2))) + f*(S(2)*q + S(3))*(S(2)*a*f - b*e))
|
|
|
|
cons399 = CustomConstraint(cons_f399)
|
|
|
|
def cons_f400(a, c, d, e, f, q):
|
|
return NonzeroQ(S(2)*a*f**S(2)*(S(2)*q + S(3)) + c*(-S(2)*d*f + e**S(2)*(q + S(2))))
|
|
|
|
cons400 = CustomConstraint(cons_f400)
|
|
|
|
def cons_f401(a, c, d, f, q):
|
|
return NonzeroQ(S(2)*a*f*q + S(3)*a*f - c*d)
|
|
|
|
cons401 = CustomConstraint(cons_f401)
|
|
|
|
def cons_f402(q):
|
|
return Not(PositiveIntegerQ(q))
|
|
|
|
cons402 = CustomConstraint(cons_f402)
|
|
|
|
def cons_f403(q):
|
|
return Not(And(RationalQ(q), LessEqual(q, S(-1))))
|
|
|
|
cons403 = CustomConstraint(cons_f403)
|
|
|
|
def cons_f404(p, q):
|
|
return RationalQ(p, q)
|
|
|
|
cons404 = CustomConstraint(cons_f404)
|
|
|
|
def cons_f405(q):
|
|
return Greater(q, S(0))
|
|
|
|
cons405 = CustomConstraint(cons_f405)
|
|
|
|
def cons_f406(a, b, c, d, e, f):
|
|
return NonzeroQ(-(-a*e + b*d)*(-b*f + c*e) + (-a*f + c*d)**S(2))
|
|
|
|
cons406 = CustomConstraint(cons_f406)
|
|
|
|
def cons_f407(p, q):
|
|
return Not(And(Not(IntegerQ(p)), IntegerQ(q), Less(q, S(-1))))
|
|
|
|
cons407 = CustomConstraint(cons_f407)
|
|
|
|
def cons_f408(a, b, c, d, f):
|
|
return NonzeroQ(b**S(2)*d*f + (-a*f + c*d)**S(2))
|
|
|
|
cons408 = CustomConstraint(cons_f408)
|
|
|
|
def cons_f409(a, c, d, e, f):
|
|
return NonzeroQ(a*c*e**S(2) + (-a*f + c*d)**S(2))
|
|
|
|
cons409 = CustomConstraint(cons_f409)
|
|
|
|
def cons_f410(p, q):
|
|
return NonzeroQ(p + q)
|
|
|
|
cons410 = CustomConstraint(cons_f410)
|
|
|
|
def cons_f411(p, q):
|
|
return NonzeroQ(S(2)*p + S(2)*q + S(1))
|
|
|
|
cons411 = CustomConstraint(cons_f411)
|
|
|
|
def cons_f412(b, c, e, f):
|
|
return ZeroQ(-b*f + c*e)
|
|
|
|
cons412 = CustomConstraint(cons_f412)
|
|
|
|
def cons_f413(b, c, e, f):
|
|
return NonzeroQ(-b*f + c*e)
|
|
|
|
cons413 = CustomConstraint(cons_f413)
|
|
|
|
def cons_f414(a, c):
|
|
return PosQ(-a*c)
|
|
|
|
cons414 = CustomConstraint(cons_f414)
|
|
|
|
def cons_f415(a, b, c):
|
|
return NegQ(-S(4)*a*c + b**S(2))
|
|
|
|
cons415 = CustomConstraint(cons_f415)
|
|
|
|
def cons_f416(a, c):
|
|
return NegQ(-a*c)
|
|
|
|
cons416 = CustomConstraint(cons_f416)
|
|
|
|
def cons_f417(a, b, c, d, e, f, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, p, q), x)
|
|
|
|
cons417 = CustomConstraint(cons_f417)
|
|
|
|
def cons_f418(a, c, d, e, f, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, d, e, f, p, q), x)
|
|
|
|
cons418 = CustomConstraint(cons_f418)
|
|
|
|
def cons_f419(a, b, c, g, h):
|
|
return ZeroQ(a*h**S(2) - b*g*h + c*g**S(2))
|
|
|
|
cons419 = CustomConstraint(cons_f419)
|
|
|
|
def cons_f420(a, c, d, e, f, g, h):
|
|
return ZeroQ(a**S(2)*f*h**S(2) - a*c*e*g*h + c**S(2)*d*g**S(2))
|
|
|
|
cons420 = CustomConstraint(cons_f420)
|
|
|
|
def cons_f421(a, c, g, h):
|
|
return ZeroQ(a*h**S(2) + c*g**S(2))
|
|
|
|
cons421 = CustomConstraint(cons_f421)
|
|
|
|
def cons_f422(a, c, d, f, g, h):
|
|
return ZeroQ(a**S(2)*f*h**S(2) + c**S(2)*d*g**S(2))
|
|
|
|
cons422 = CustomConstraint(cons_f422)
|
|
|
|
def cons_f423(a, b, c, e, f):
|
|
return ZeroQ(a*f**S(2) - b*e*f + c*e**S(2))
|
|
|
|
cons423 = CustomConstraint(cons_f423)
|
|
|
|
def cons_f424(a, c, e, f):
|
|
return ZeroQ(a*f**S(2) + c*e**S(2))
|
|
|
|
cons424 = CustomConstraint(cons_f424)
|
|
|
|
def cons_f425(b, c, e, f, g, h, m, p):
|
|
return ZeroQ(b*f*h*(m + p + S(2)) + c*(-e*h*(m + S(2)*p + S(3)) + S(2)*f*g*(p + S(1))))
|
|
|
|
cons425 = CustomConstraint(cons_f425)
|
|
|
|
def cons_f426(a, b, c, d, f, g, h, m, p):
|
|
return ZeroQ(b*f*g*(p + S(1)) + h*(a*f*(m + S(1)) - c*d*(m + S(2)*p + S(3))))
|
|
|
|
cons426 = CustomConstraint(cons_f426)
|
|
|
|
def cons_f427(c, e, f, g, h, m, p):
|
|
return ZeroQ(c*(-e*h*(m + S(2)*p + S(3)) + S(2)*f*g*(p + S(1))))
|
|
|
|
cons427 = CustomConstraint(cons_f427)
|
|
|
|
def cons_f428(a, c, d, f, h, m, p):
|
|
return ZeroQ(h*(a*f*(m + S(1)) - c*d*(m + S(2)*p + S(3))))
|
|
|
|
cons428 = CustomConstraint(cons_f428)
|
|
|
|
def cons_f429(b, c, f, g, h, m, p):
|
|
return ZeroQ(b*f*h*(m + p + S(2)) + S(2)*c*f*g*(p + S(1)))
|
|
|
|
cons429 = CustomConstraint(cons_f429)
|
|
|
|
def cons_f430(m, p):
|
|
return Or(IntegersQ(m, p), PositiveIntegerQ(p))
|
|
|
|
cons430 = CustomConstraint(cons_f430)
|
|
|
|
def cons_f431(a, b, c, g, h):
|
|
return NonzeroQ(a*h**S(2) - b*g*h + c*g**S(2))
|
|
|
|
cons431 = CustomConstraint(cons_f431)
|
|
|
|
def cons_f432(a, c, g, h):
|
|
return NonzeroQ(a*h**S(2) + c*g**S(2))
|
|
|
|
cons432 = CustomConstraint(cons_f432)
|
|
|
|
def cons_f433(a, b, c, g, h):
|
|
return NonzeroQ(c*g**S(2) - h*(-a*h + b*g))
|
|
|
|
cons433 = CustomConstraint(cons_f433)
|
|
|
|
def cons_f434(p, q):
|
|
return Or(Greater(p, S(0)), Greater(q, S(0)))
|
|
|
|
cons434 = CustomConstraint(cons_f434)
|
|
|
|
def cons_f435(p, q):
|
|
return NonzeroQ(p + q + S(1))
|
|
|
|
cons435 = CustomConstraint(cons_f435)
|
|
|
|
def cons_f436(a, c):
|
|
return PositiveQ(a*c)
|
|
|
|
cons436 = CustomConstraint(cons_f436)
|
|
|
|
def cons_f437(a, c):
|
|
return Not(PositiveQ(a*c))
|
|
|
|
cons437 = CustomConstraint(cons_f437)
|
|
|
|
def cons_f438(e, f, g, h):
|
|
return ZeroQ(e*h - S(2)*f*g)
|
|
|
|
cons438 = CustomConstraint(cons_f438)
|
|
|
|
def cons_f439(e, f, g, h):
|
|
return NonzeroQ(e*h - S(2)*f*g)
|
|
|
|
cons439 = CustomConstraint(cons_f439)
|
|
|
|
def cons_f440(d, e, g, h):
|
|
return ZeroQ(S(2)*d*h - e*g)
|
|
|
|
cons440 = CustomConstraint(cons_f440)
|
|
|
|
def cons_f441(d, e, g, h):
|
|
return NonzeroQ(S(2)*d*h - e*g)
|
|
|
|
cons441 = CustomConstraint(cons_f441)
|
|
|
|
def cons_f442(a, b, c, d, e, f, g, h):
|
|
return ZeroQ(g**S(2)*(-b*f + c*e) - S(2)*g*h*(-a*f + c*d) + h**S(2)*(-a*e + b*d))
|
|
|
|
cons442 = CustomConstraint(cons_f442)
|
|
|
|
def cons_f443(a, c, d, e, f, g, h):
|
|
return ZeroQ(a*e*h**S(2) - c*e*g**S(2) + S(2)*g*h*(-a*f + c*d))
|
|
|
|
cons443 = CustomConstraint(cons_f443)
|
|
|
|
def cons_f444(a, b, c, d, f, g, h):
|
|
return ZeroQ(b*d*h**S(2) - b*f*g**S(2) - S(2)*g*h*(-a*f + c*d))
|
|
|
|
cons444 = CustomConstraint(cons_f444)
|
|
|
|
def cons_f445(a, b, c, d, f):
|
|
return ZeroQ(c**S(2)*d - f*(-S(3)*a*c + b**S(2)))
|
|
|
|
cons445 = CustomConstraint(cons_f445)
|
|
|
|
def cons_f446(a, b, c, g, h):
|
|
return ZeroQ(S(9)*a*c*h**S(2) - S(2)*b**S(2)*h**S(2) - b*c*g*h + c**S(2)*g**S(2))
|
|
|
|
cons446 = CustomConstraint(cons_f446)
|
|
|
|
def cons_f447(b, c, g, h):
|
|
return PositiveQ(-S(9)*c*h**S(2)/(-b*h + S(2)*c*g)**S(2))
|
|
|
|
cons447 = CustomConstraint(cons_f447)
|
|
|
|
def cons_f448(a, c, d, f):
|
|
return ZeroQ(S(3)*a*f + c*d)
|
|
|
|
cons448 = CustomConstraint(cons_f448)
|
|
|
|
def cons_f449(a, c, g, h):
|
|
return ZeroQ(S(9)*a*h**S(2) + c*g**S(2))
|
|
|
|
cons449 = CustomConstraint(cons_f449)
|
|
|
|
def cons_f450(a):
|
|
return Not(PositiveQ(a))
|
|
|
|
cons450 = CustomConstraint(cons_f450)
|
|
|
|
def cons_f451(a, b, c, d, e, f, g, h, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, h, p, q), x)
|
|
|
|
cons451 = CustomConstraint(cons_f451)
|
|
|
|
def cons_f452(a, c, d, e, f, g, h, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, d, e, f, g, h, p, q), x)
|
|
|
|
cons452 = CustomConstraint(cons_f452)
|
|
|
|
def cons_f453(x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return LinearQ(z, x)
|
|
|
|
cons453 = CustomConstraint(cons_f453)
|
|
|
|
def cons_f454(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return QuadraticQ(List(u, v), x)
|
|
|
|
cons454 = CustomConstraint(cons_f454)
|
|
|
|
def cons_f455(u, v, x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(LinearMatchQ(z, x), QuadraticMatchQ(List(u, v), x)))
|
|
|
|
cons455 = CustomConstraint(cons_f455)
|
|
|
|
def cons_f456(p, q):
|
|
return NonzeroQ(S(2)*p + S(2)*q + S(3))
|
|
|
|
cons456 = CustomConstraint(cons_f456)
|
|
|
|
def cons_f457(A, B, C, a, b, c, d, e, f, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, A, B, C, p, q), x)
|
|
|
|
cons457 = CustomConstraint(cons_f457)
|
|
|
|
def cons_f458(A, C, a, b, c, d, e, f, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, A, C, p, q), x)
|
|
|
|
cons458 = CustomConstraint(cons_f458)
|
|
|
|
def cons_f459(A, B, C, a, c, d, e, f, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, d, e, f, A, B, C, p, q), x)
|
|
|
|
cons459 = CustomConstraint(cons_f459)
|
|
|
|
def cons_f460(A, C, a, c, d, e, f, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, d, e, f, A, C, p, q), x)
|
|
|
|
cons460 = CustomConstraint(cons_f460)
|
|
|
|
def cons_f461(b, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(b, n, p), x)
|
|
|
|
cons461 = CustomConstraint(cons_f461)
|
|
|
|
def cons_f462(n, p):
|
|
return ZeroQ(p + S(1) + S(1)/n)
|
|
|
|
cons462 = CustomConstraint(cons_f462)
|
|
|
|
def cons_f463(n, p):
|
|
return NegativeIntegerQ(p + S(1) + S(1)/n)
|
|
|
|
cons463 = CustomConstraint(cons_f463)
|
|
|
|
def cons_f464(n):
|
|
return NonzeroQ(S(3)*n + S(1))
|
|
|
|
cons464 = CustomConstraint(cons_f464)
|
|
|
|
def cons_f465(n):
|
|
return Less(n, S(0))
|
|
|
|
cons465 = CustomConstraint(cons_f465)
|
|
|
|
def cons_f466(n, p):
|
|
return PositiveIntegerQ(n, p)
|
|
|
|
cons466 = CustomConstraint(cons_f466)
|
|
|
|
def cons_f467(n, p):
|
|
return Or(IntegerQ(S(2)*p), And(Equal(n, S(2)), IntegerQ(S(4)*p)), And(Equal(n, S(2)), IntegerQ(S(3)*p)), Less(Denominator(p + S(1)/n), Denominator(p)))
|
|
|
|
cons467 = CustomConstraint(cons_f467)
|
|
|
|
def cons_f468(a, b):
|
|
return PosQ(b/a)
|
|
|
|
cons468 = CustomConstraint(cons_f468)
|
|
|
|
def cons_f469(n):
|
|
return PositiveIntegerQ(n/S(2) + S(-3)/2)
|
|
|
|
cons469 = CustomConstraint(cons_f469)
|
|
|
|
def cons_f470(a, b):
|
|
return PosQ(a/b)
|
|
|
|
cons470 = CustomConstraint(cons_f470)
|
|
|
|
def cons_f471(a, b):
|
|
return NegQ(a/b)
|
|
|
|
cons471 = CustomConstraint(cons_f471)
|
|
|
|
def cons_f472(a, b):
|
|
return Or(PositiveQ(a), PositiveQ(b))
|
|
|
|
cons472 = CustomConstraint(cons_f472)
|
|
|
|
def cons_f473(a, b):
|
|
return Or(NegativeQ(a), NegativeQ(b))
|
|
|
|
cons473 = CustomConstraint(cons_f473)
|
|
|
|
def cons_f474(a, b):
|
|
return Or(PositiveQ(a), NegativeQ(b))
|
|
|
|
cons474 = CustomConstraint(cons_f474)
|
|
|
|
def cons_f475(a, b):
|
|
return Or(NegativeQ(a), PositiveQ(b))
|
|
|
|
cons475 = CustomConstraint(cons_f475)
|
|
|
|
def cons_f476(n):
|
|
return PositiveIntegerQ(n/S(4) + S(-1)/2)
|
|
|
|
cons476 = CustomConstraint(cons_f476)
|
|
|
|
def cons_f477(a, b):
|
|
try:
|
|
return Or(PositiveQ(a/b), And(PosQ(a/b), AtomQ(SplitProduct(SumBaseQ, a)), AtomQ(SplitProduct(SumBaseQ, b))))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons477 = CustomConstraint(cons_f477)
|
|
|
|
def cons_f478(a, b):
|
|
return Not(PositiveQ(a/b))
|
|
|
|
cons478 = CustomConstraint(cons_f478)
|
|
|
|
def cons_f479(n):
|
|
return PositiveIntegerQ(n/S(4) + S(-1))
|
|
|
|
cons479 = CustomConstraint(cons_f479)
|
|
|
|
def cons_f480(a, b):
|
|
return PositiveQ(a/b)
|
|
|
|
cons480 = CustomConstraint(cons_f480)
|
|
|
|
def cons_f481(b):
|
|
return PosQ(b)
|
|
|
|
cons481 = CustomConstraint(cons_f481)
|
|
|
|
def cons_f482(b):
|
|
return NegQ(b)
|
|
|
|
cons482 = CustomConstraint(cons_f482)
|
|
|
|
def cons_f483(a):
|
|
return PosQ(a)
|
|
|
|
cons483 = CustomConstraint(cons_f483)
|
|
|
|
def cons_f484(a):
|
|
return NegQ(a)
|
|
|
|
cons484 = CustomConstraint(cons_f484)
|
|
|
|
def cons_f485(a, b):
|
|
return NegQ(b/a)
|
|
|
|
cons485 = CustomConstraint(cons_f485)
|
|
|
|
def cons_f486(a):
|
|
return NegativeQ(a)
|
|
|
|
cons486 = CustomConstraint(cons_f486)
|
|
|
|
def cons_f487(p):
|
|
return Less(S(-1), p, S(0))
|
|
|
|
cons487 = CustomConstraint(cons_f487)
|
|
|
|
def cons_f488(p):
|
|
return Unequal(p, S(-1)/2)
|
|
|
|
cons488 = CustomConstraint(cons_f488)
|
|
|
|
def cons_f489(n, p):
|
|
return IntegerQ(p + S(1)/n)
|
|
|
|
cons489 = CustomConstraint(cons_f489)
|
|
|
|
def cons_f490(n, p):
|
|
return Less(Denominator(p + S(1)/n), Denominator(p))
|
|
|
|
cons490 = CustomConstraint(cons_f490)
|
|
|
|
def cons_f491(n):
|
|
return FractionQ(n)
|
|
|
|
cons491 = CustomConstraint(cons_f491)
|
|
|
|
def cons_f492(n):
|
|
return Not(IntegerQ(S(1)/n))
|
|
|
|
cons492 = CustomConstraint(cons_f492)
|
|
|
|
def cons_f493(n, p):
|
|
return Not(NegativeIntegerQ(p + S(1)/n))
|
|
|
|
cons493 = CustomConstraint(cons_f493)
|
|
|
|
def cons_f494(a, p):
|
|
return Or(IntegerQ(p), PositiveQ(a))
|
|
|
|
cons494 = CustomConstraint(cons_f494)
|
|
|
|
def cons_f495(a, p):
|
|
return Not(Or(IntegerQ(p), PositiveQ(a)))
|
|
|
|
cons495 = CustomConstraint(cons_f495)
|
|
|
|
def cons_f496(a1, a2, p):
|
|
return Or(IntegerQ(p), And(PositiveQ(a1), PositiveQ(a2)))
|
|
|
|
cons496 = CustomConstraint(cons_f496)
|
|
|
|
def cons_f497(n):
|
|
return PositiveIntegerQ(S(2)*n)
|
|
|
|
cons497 = CustomConstraint(cons_f497)
|
|
|
|
def cons_f498(n, p):
|
|
return Or(IntegerQ(S(2)*p), Less(Denominator(p + S(1)/n), Denominator(p)))
|
|
|
|
cons498 = CustomConstraint(cons_f498)
|
|
|
|
def cons_f499(n):
|
|
return NegativeIntegerQ(S(2)*n)
|
|
|
|
cons499 = CustomConstraint(cons_f499)
|
|
|
|
def cons_f500(n):
|
|
return FractionQ(S(2)*n)
|
|
|
|
cons500 = CustomConstraint(cons_f500)
|
|
|
|
def cons_f501(c, m):
|
|
return Or(IntegerQ(m), PositiveQ(c))
|
|
|
|
cons501 = CustomConstraint(cons_f501)
|
|
|
|
def cons_f502(m, n):
|
|
return IntegerQ((m + S(1))/n)
|
|
|
|
cons502 = CustomConstraint(cons_f502)
|
|
|
|
def cons_f503(m, n):
|
|
return Not(IntegerQ((m + S(1))/n))
|
|
|
|
cons503 = CustomConstraint(cons_f503)
|
|
|
|
def cons_f504(n):
|
|
return NegQ(n)
|
|
|
|
cons504 = CustomConstraint(cons_f504)
|
|
|
|
def cons_f505(m, n, p):
|
|
return ZeroQ(p + S(1) + (m + S(1))/n)
|
|
|
|
cons505 = CustomConstraint(cons_f505)
|
|
|
|
def cons_f506(m, n, p):
|
|
return ZeroQ(p + S(1) + (m + S(1))/(S(2)*n))
|
|
|
|
cons506 = CustomConstraint(cons_f506)
|
|
|
|
def cons_f507(m, n):
|
|
return IntegerQ((m + S(1))/(S(2)*n))
|
|
|
|
cons507 = CustomConstraint(cons_f507)
|
|
|
|
def cons_f508(m, n, p):
|
|
return NegativeIntegerQ((m + n*(p + S(1)) + S(1))/n)
|
|
|
|
cons508 = CustomConstraint(cons_f508)
|
|
|
|
def cons_f509(m, n, p):
|
|
return NegativeIntegerQ((m + S(2)*n*(p + S(1)) + S(1))/(S(2)*n))
|
|
|
|
cons509 = CustomConstraint(cons_f509)
|
|
|
|
def cons_f510(m, n, p):
|
|
return Not(NegativeIntegerQ((m + n*p + n + S(1))/n))
|
|
|
|
cons510 = CustomConstraint(cons_f510)
|
|
|
|
def cons_f511(a, b, c, m, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return IntBinomialQ(a, b, c, n, m, p, x)
|
|
|
|
cons511 = CustomConstraint(cons_f511)
|
|
|
|
def cons_f512(m, n, p):
|
|
return NonzeroQ(m + S(2)*n*p + S(1))
|
|
|
|
cons512 = CustomConstraint(cons_f512)
|
|
|
|
def cons_f513(a1, a2, b1, b2, c, m, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return IntBinomialQ(a1*a2, b1*b2, c, n, m, p, x)
|
|
|
|
cons513 = CustomConstraint(cons_f513)
|
|
|
|
def cons_f514(m, n, p):
|
|
return NonzeroQ(m + n*p + S(1))
|
|
|
|
cons514 = CustomConstraint(cons_f514)
|
|
|
|
def cons_f515(m):
|
|
return PositiveIntegerQ(m/S(4) + S(-1)/2)
|
|
|
|
cons515 = CustomConstraint(cons_f515)
|
|
|
|
def cons_f516(m):
|
|
return NegativeIntegerQ(m/S(4) + S(-1)/2)
|
|
|
|
cons516 = CustomConstraint(cons_f516)
|
|
|
|
def cons_f517(m):
|
|
return IntegerQ(S(2)*m)
|
|
|
|
cons517 = CustomConstraint(cons_f517)
|
|
|
|
def cons_f518(m):
|
|
return Greater(m, S(3)/2)
|
|
|
|
cons518 = CustomConstraint(cons_f518)
|
|
|
|
def cons_f519(m, n):
|
|
return Greater(m + S(1), n)
|
|
|
|
cons519 = CustomConstraint(cons_f519)
|
|
|
|
def cons_f520(m, n, p):
|
|
return Not(NegativeIntegerQ((m + n*(p + S(1)) + S(1))/n))
|
|
|
|
cons520 = CustomConstraint(cons_f520)
|
|
|
|
def cons_f521(m, n):
|
|
return Greater(m + S(1), S(2)*n)
|
|
|
|
cons521 = CustomConstraint(cons_f521)
|
|
|
|
def cons_f522(m, n, p):
|
|
return Not(NegativeIntegerQ((m + S(2)*n*(p + S(1)) + S(1))/(S(2)*n)))
|
|
|
|
cons522 = CustomConstraint(cons_f522)
|
|
|
|
def cons_f523(n):
|
|
return PositiveIntegerQ(n/S(2) + S(-1)/2)
|
|
|
|
cons523 = CustomConstraint(cons_f523)
|
|
|
|
def cons_f524(m, n):
|
|
return Less(m, n + S(-1))
|
|
|
|
cons524 = CustomConstraint(cons_f524)
|
|
|
|
def cons_f525(m, n):
|
|
return PositiveIntegerQ(m, n/S(2) + S(-1)/2)
|
|
|
|
cons525 = CustomConstraint(cons_f525)
|
|
|
|
def cons_f526(m, n):
|
|
return PositiveIntegerQ(m, n/S(4) + S(-1)/2)
|
|
|
|
cons526 = CustomConstraint(cons_f526)
|
|
|
|
def cons_f527(m, n):
|
|
return PositiveIntegerQ(m, n/S(4))
|
|
|
|
cons527 = CustomConstraint(cons_f527)
|
|
|
|
def cons_f528(m, n):
|
|
return Less(m, n/S(2))
|
|
|
|
cons528 = CustomConstraint(cons_f528)
|
|
|
|
def cons_f529(m, n):
|
|
return Inequality(n/S(2), LessEqual, m, Less, n)
|
|
|
|
cons529 = CustomConstraint(cons_f529)
|
|
|
|
def cons_f530(m, n):
|
|
return PositiveIntegerQ(m, n)
|
|
|
|
cons530 = CustomConstraint(cons_f530)
|
|
|
|
def cons_f531(m, n):
|
|
return Greater(m, S(2)*n + S(-1))
|
|
|
|
cons531 = CustomConstraint(cons_f531)
|
|
|
|
def cons_f532(m, n):
|
|
return Greater(m, n + S(-1))
|
|
|
|
cons532 = CustomConstraint(cons_f532)
|
|
|
|
def cons_f533(m, n):
|
|
return SumSimplerQ(m, -n)
|
|
|
|
cons533 = CustomConstraint(cons_f533)
|
|
|
|
def cons_f534(m, n, p):
|
|
return NegativeIntegerQ((m + n*p + S(1))/n)
|
|
|
|
cons534 = CustomConstraint(cons_f534)
|
|
|
|
def cons_f535(m, n):
|
|
return SumSimplerQ(m, -S(2)*n)
|
|
|
|
cons535 = CustomConstraint(cons_f535)
|
|
|
|
def cons_f536(m, n, p):
|
|
return NegativeIntegerQ((m + S(2)*n*p + S(1))/(S(2)*n))
|
|
|
|
cons536 = CustomConstraint(cons_f536)
|
|
|
|
def cons_f537(m, n):
|
|
return SumSimplerQ(m, n)
|
|
|
|
cons537 = CustomConstraint(cons_f537)
|
|
|
|
def cons_f538(m, n):
|
|
return SumSimplerQ(m, S(2)*n)
|
|
|
|
cons538 = CustomConstraint(cons_f538)
|
|
|
|
def cons_f539(m, n, p):
|
|
return IntegersQ(m, p + (m + S(1))/n)
|
|
|
|
cons539 = CustomConstraint(cons_f539)
|
|
|
|
def cons_f540(m, n, p):
|
|
return IntegersQ(m, p + (m + S(1))/(S(2)*n))
|
|
|
|
cons540 = CustomConstraint(cons_f540)
|
|
|
|
def cons_f541(m, n, p):
|
|
return Less(Denominator(p + (m + S(1))/n), Denominator(p))
|
|
|
|
cons541 = CustomConstraint(cons_f541)
|
|
|
|
def cons_f542(m, n, p):
|
|
return Less(Denominator(p + (m + S(1))/(S(2)*n)), Denominator(p))
|
|
|
|
cons542 = CustomConstraint(cons_f542)
|
|
|
|
def cons_f543(m, n):
|
|
return IntegerQ(n/(m + S(1)))
|
|
|
|
cons543 = CustomConstraint(cons_f543)
|
|
|
|
def cons_f544(m, n):
|
|
return IntegerQ(S(2)*n/(m + S(1)))
|
|
|
|
cons544 = CustomConstraint(cons_f544)
|
|
|
|
def cons_f545(n):
|
|
return Not(IntegerQ(S(2)*n))
|
|
|
|
cons545 = CustomConstraint(cons_f545)
|
|
|
|
def cons_f546(m, n, p):
|
|
return ZeroQ(p + (m + S(1))/n)
|
|
|
|
cons546 = CustomConstraint(cons_f546)
|
|
|
|
def cons_f547(m, n, p):
|
|
return ZeroQ(p + (m + S(1))/(S(2)*n))
|
|
|
|
cons547 = CustomConstraint(cons_f547)
|
|
|
|
def cons_f548(m, n, p):
|
|
return IntegerQ(p + (m + S(1))/n)
|
|
|
|
cons548 = CustomConstraint(cons_f548)
|
|
|
|
def cons_f549(m, n, p):
|
|
return IntegerQ(p + (m + S(1))/(S(2)*n))
|
|
|
|
cons549 = CustomConstraint(cons_f549)
|
|
|
|
def cons_f550(m, n):
|
|
return FractionQ((m + S(1))/n)
|
|
|
|
cons550 = CustomConstraint(cons_f550)
|
|
|
|
def cons_f551(m, n):
|
|
return Or(SumSimplerQ(m, n), SumSimplerQ(m, -n))
|
|
|
|
cons551 = CustomConstraint(cons_f551)
|
|
|
|
def cons_f552(a, p):
|
|
return Or(NegativeIntegerQ(p), PositiveQ(a))
|
|
|
|
cons552 = CustomConstraint(cons_f552)
|
|
|
|
def cons_f553(a, p):
|
|
return Not(Or(NegativeIntegerQ(p), PositiveQ(a)))
|
|
|
|
cons553 = CustomConstraint(cons_f553)
|
|
|
|
def cons_f554(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return LinearQ(v, x)
|
|
|
|
cons554 = CustomConstraint(cons_f554)
|
|
|
|
def cons_f555(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return NonzeroQ(v - x)
|
|
|
|
cons555 = CustomConstraint(cons_f555)
|
|
|
|
def cons_f556(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return LinearPairQ(u, v, x)
|
|
|
|
cons556 = CustomConstraint(cons_f556)
|
|
|
|
def cons_f557(p, q):
|
|
return PositiveIntegerQ(p, q)
|
|
|
|
cons557 = CustomConstraint(cons_f557)
|
|
|
|
def cons_f558(n, p):
|
|
return ZeroQ(n*p + S(1))
|
|
|
|
cons558 = CustomConstraint(cons_f558)
|
|
|
|
def cons_f559(n, p, q):
|
|
return ZeroQ(n*(p + q + S(1)) + S(1))
|
|
|
|
cons559 = CustomConstraint(cons_f559)
|
|
|
|
def cons_f560(n, p, q):
|
|
return ZeroQ(n*(p + q + S(2)) + S(1))
|
|
|
|
cons560 = CustomConstraint(cons_f560)
|
|
|
|
def cons_f561(a, b, c, d, p, q):
|
|
return ZeroQ(a*d*(p + S(1)) + b*c*(q + S(1)))
|
|
|
|
cons561 = CustomConstraint(cons_f561)
|
|
|
|
def cons_f562(p, q):
|
|
return Or(And(RationalQ(p), Less(p, S(-1))), Not(And(RationalQ(q), Less(q, S(-1)))))
|
|
|
|
cons562 = CustomConstraint(cons_f562)
|
|
|
|
def cons_f563(a, b, c, d, n, p):
|
|
return ZeroQ(a*d - b*c*(n*(p + S(1)) + S(1)))
|
|
|
|
cons563 = CustomConstraint(cons_f563)
|
|
|
|
def cons_f564(n, p):
|
|
return Or(And(RationalQ(p), Less(p, S(-1))), NegativeIntegerQ(p + S(1)/n))
|
|
|
|
cons564 = CustomConstraint(cons_f564)
|
|
|
|
def cons_f565(n, p):
|
|
return NonzeroQ(n*(p + S(1)) + S(1))
|
|
|
|
cons565 = CustomConstraint(cons_f565)
|
|
|
|
def cons_f566(q):
|
|
return NegativeIntegerQ(q)
|
|
|
|
cons566 = CustomConstraint(cons_f566)
|
|
|
|
def cons_f567(p, q):
|
|
return GreaterEqual(p, -q)
|
|
|
|
cons567 = CustomConstraint(cons_f567)
|
|
|
|
def cons_f568(a, b, c, d):
|
|
return ZeroQ(S(3)*a*d + b*c)
|
|
|
|
cons568 = CustomConstraint(cons_f568)
|
|
|
|
def cons_f569(p):
|
|
return Or(Equal(p, S(1)/2), Equal(Denominator(p), S(4)))
|
|
|
|
cons569 = CustomConstraint(cons_f569)
|
|
|
|
def cons_f570(p):
|
|
return Equal(Denominator(p), S(4))
|
|
|
|
cons570 = CustomConstraint(cons_f570)
|
|
|
|
def cons_f571(p):
|
|
return Or(Equal(p, S(-5)/4), Equal(p, S(-7)/4))
|
|
|
|
cons571 = CustomConstraint(cons_f571)
|
|
|
|
def cons_f572(a, b):
|
|
return PosQ(a*b)
|
|
|
|
cons572 = CustomConstraint(cons_f572)
|
|
|
|
def cons_f573(a, b):
|
|
return NegQ(a*b)
|
|
|
|
cons573 = CustomConstraint(cons_f573)
|
|
|
|
def cons_f574(p):
|
|
return Or(Equal(p, S(3)/4), Equal(p, S(5)/4))
|
|
|
|
cons574 = CustomConstraint(cons_f574)
|
|
|
|
def cons_f575(c, d):
|
|
return PosQ(d/c)
|
|
|
|
cons575 = CustomConstraint(cons_f575)
|
|
|
|
def cons_f576(q):
|
|
return Less(S(0), q, S(1))
|
|
|
|
cons576 = CustomConstraint(cons_f576)
|
|
|
|
def cons_f577(a, b, c, d, n, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return IntBinomialQ(a, b, c, d, n, p, q, x)
|
|
|
|
cons577 = CustomConstraint(cons_f577)
|
|
|
|
def cons_f578(q):
|
|
return Greater(q, S(1))
|
|
|
|
cons578 = CustomConstraint(cons_f578)
|
|
|
|
def cons_f579(p, q):
|
|
return Greater(p + q, S(0))
|
|
|
|
cons579 = CustomConstraint(cons_f579)
|
|
|
|
def cons_f580(n, p, q):
|
|
return NonzeroQ(n*(p + q) + S(1))
|
|
|
|
cons580 = CustomConstraint(cons_f580)
|
|
|
|
def cons_f581(p):
|
|
return Not(And(IntegerQ(p), Greater(p, S(1))))
|
|
|
|
cons581 = CustomConstraint(cons_f581)
|
|
|
|
def cons_f582(a, b, c, d):
|
|
return Not(SimplerSqrtQ(b/a, d/c))
|
|
|
|
cons582 = CustomConstraint(cons_f582)
|
|
|
|
def cons_f583(c, d):
|
|
return NegQ(d/c)
|
|
|
|
cons583 = CustomConstraint(cons_f583)
|
|
|
|
def cons_f584(a, b, c, d):
|
|
return Not(And(NegQ(b/a), SimplerSqrtQ(-b/a, -d/c)))
|
|
|
|
cons584 = CustomConstraint(cons_f584)
|
|
|
|
def cons_f585(a, b, c, d):
|
|
return PositiveQ(a - b*c/d)
|
|
|
|
cons585 = CustomConstraint(cons_f585)
|
|
|
|
def cons_f586(n):
|
|
return NonzeroQ(n + S(1))
|
|
|
|
cons586 = CustomConstraint(cons_f586)
|
|
|
|
def cons_f587(mn, n):
|
|
return EqQ(mn, -n)
|
|
|
|
cons587 = CustomConstraint(cons_f587)
|
|
|
|
def cons_f588(q):
|
|
return IntegerQ(q)
|
|
|
|
cons588 = CustomConstraint(cons_f588)
|
|
|
|
def cons_f589(n, p):
|
|
return Or(PosQ(n), Not(IntegerQ(p)))
|
|
|
|
cons589 = CustomConstraint(cons_f589)
|
|
|
|
def cons_f590(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PseudoBinomialPairQ(u, v, x)
|
|
|
|
cons590 = CustomConstraint(cons_f590)
|
|
|
|
def cons_f591(m, p):
|
|
return IntegersQ(p, m/p)
|
|
|
|
cons591 = CustomConstraint(cons_f591)
|
|
|
|
def cons_f592(m, p, u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PseudoBinomialPairQ(u*x**(m/p), v, x)
|
|
|
|
cons592 = CustomConstraint(cons_f592)
|
|
|
|
def cons_f593(e, m):
|
|
return Or(IntegerQ(m), PositiveQ(e))
|
|
|
|
cons593 = CustomConstraint(cons_f593)
|
|
|
|
def cons_f594(a, b, c, d, m, n, p):
|
|
return ZeroQ(a*d*(m + S(1)) - b*c*(m + n*(p + S(1)) + S(1)))
|
|
|
|
cons594 = CustomConstraint(cons_f594)
|
|
|
|
def cons_f595(n, non2):
|
|
return ZeroQ(-n/S(2) + non2)
|
|
|
|
cons595 = CustomConstraint(cons_f595)
|
|
|
|
def cons_f596(a1, a2, b1, b2, c, d, m, n, p):
|
|
return ZeroQ(a1*a2*d*(m + S(1)) - b1*b2*c*(m + n*(p + S(1)) + S(1)))
|
|
|
|
cons596 = CustomConstraint(cons_f596)
|
|
|
|
def cons_f597(m, n, p):
|
|
return ZeroQ(m + n*(p + S(1)) + S(1))
|
|
|
|
cons597 = CustomConstraint(cons_f597)
|
|
|
|
def cons_f598(e, n):
|
|
return Or(IntegerQ(n), PositiveQ(e))
|
|
|
|
cons598 = CustomConstraint(cons_f598)
|
|
|
|
def cons_f599(m, n):
|
|
return Or(And(Greater(n, S(0)), Less(m, S(-1))), And(Less(n, S(0)), Greater(m + n, S(-1))))
|
|
|
|
cons599 = CustomConstraint(cons_f599)
|
|
|
|
def cons_f600(p):
|
|
return Not(And(IntegerQ(p), Less(p, S(-1))))
|
|
|
|
cons600 = CustomConstraint(cons_f600)
|
|
|
|
def cons_f601(m):
|
|
return PositiveIntegerQ(m/S(2))
|
|
|
|
cons601 = CustomConstraint(cons_f601)
|
|
|
|
def cons_f602(m, p):
|
|
return Or(IntegerQ(p), Equal(m + S(2)*p + S(1), S(0)))
|
|
|
|
cons602 = CustomConstraint(cons_f602)
|
|
|
|
def cons_f603(m):
|
|
return NegativeIntegerQ(m/S(2))
|
|
|
|
cons603 = CustomConstraint(cons_f603)
|
|
|
|
def cons_f604(m, n, p):
|
|
return Or(IntegerQ(p), Not(RationalQ(m)), And(PositiveIntegerQ(n), NegativeIntegerQ(p + S(1)/2), LessEqual(S(-1), m, -n*(p + S(1)))))
|
|
|
|
cons604 = CustomConstraint(cons_f604)
|
|
|
|
def cons_f605(m, n, p):
|
|
return NonzeroQ(m + n*(p + S(1)) + S(1))
|
|
|
|
cons605 = CustomConstraint(cons_f605)
|
|
|
|
def cons_f606(m):
|
|
return Or(IntegerQ(m), PositiveIntegerQ(S(2)*m + S(2)), Not(RationalQ(m)))
|
|
|
|
cons606 = CustomConstraint(cons_f606)
|
|
|
|
def cons_f607(m, n, p):
|
|
return NonzeroQ(m + n*(p + S(2)) + S(1))
|
|
|
|
cons607 = CustomConstraint(cons_f607)
|
|
|
|
def cons_f608(m, p, q):
|
|
return RationalQ(m, p, q)
|
|
|
|
cons608 = CustomConstraint(cons_f608)
|
|
|
|
def cons_f609(m, n):
|
|
return Greater(m - n + S(1), S(0))
|
|
|
|
cons609 = CustomConstraint(cons_f609)
|
|
|
|
def cons_f610(a, b, c, d, e, m, n, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return IntBinomialQ(a, b, c, d, e, m, n, p, q, x)
|
|
|
|
cons610 = CustomConstraint(cons_f610)
|
|
|
|
def cons_f611(m, n):
|
|
return Greater(m - n + S(1), n)
|
|
|
|
cons611 = CustomConstraint(cons_f611)
|
|
|
|
def cons_f612(m, n):
|
|
return Inequality(n, GreaterEqual, m - n + S(1), Greater, S(0))
|
|
|
|
cons612 = CustomConstraint(cons_f612)
|
|
|
|
def cons_f613(m, q):
|
|
return RationalQ(m, q)
|
|
|
|
cons613 = CustomConstraint(cons_f613)
|
|
|
|
def cons_f614(m, n):
|
|
return LessEqual(n, m, S(2)*n + S(-1))
|
|
|
|
cons614 = CustomConstraint(cons_f614)
|
|
|
|
def cons_f615(m, n):
|
|
return IntegersQ(m/S(2), n/S(2))
|
|
|
|
cons615 = CustomConstraint(cons_f615)
|
|
|
|
def cons_f616(m, n):
|
|
return Less(S(0), m - n + S(1), n)
|
|
|
|
cons616 = CustomConstraint(cons_f616)
|
|
|
|
def cons_f617(n):
|
|
return LessEqual(n, S(4))
|
|
|
|
cons617 = CustomConstraint(cons_f617)
|
|
|
|
def cons_f618(a, b, c, d):
|
|
return ZeroQ(-a*d + S(4)*b*c)
|
|
|
|
cons618 = CustomConstraint(cons_f618)
|
|
|
|
def cons_f619(m):
|
|
return PositiveIntegerQ(m/S(3) + S(-1)/3)
|
|
|
|
cons619 = CustomConstraint(cons_f619)
|
|
|
|
def cons_f620(m):
|
|
return NegativeIntegerQ(m/S(3) + S(-1)/3)
|
|
|
|
cons620 = CustomConstraint(cons_f620)
|
|
|
|
def cons_f621(m):
|
|
return IntegerQ(m/S(3) + S(-1)/3)
|
|
|
|
cons621 = CustomConstraint(cons_f621)
|
|
|
|
def cons_f622(n):
|
|
return Or(EqQ(n, S(2)), EqQ(n, S(4)))
|
|
|
|
cons622 = CustomConstraint(cons_f622)
|
|
|
|
def cons_f623(a, b, c, d, n):
|
|
return Not(And(EqQ(n, S(2)), SimplerSqrtQ(-b/a, -d/c)))
|
|
|
|
cons623 = CustomConstraint(cons_f623)
|
|
|
|
def cons_f624(m, n, p, q):
|
|
return IntegersQ(p + (m + S(1))/n, q)
|
|
|
|
cons624 = CustomConstraint(cons_f624)
|
|
|
|
def cons_f625(m, n):
|
|
return Or(ZeroQ(m - n), ZeroQ(m - S(2)*n + S(1)))
|
|
|
|
cons625 = CustomConstraint(cons_f625)
|
|
|
|
def cons_f626(m, p, q):
|
|
return IntegersQ(m, p, q)
|
|
|
|
cons626 = CustomConstraint(cons_f626)
|
|
|
|
def cons_f627(p):
|
|
return GreaterEqual(p, S(-2))
|
|
|
|
cons627 = CustomConstraint(cons_f627)
|
|
|
|
def cons_f628(m, q):
|
|
return Or(GreaterEqual(q, S(-2)), And(Equal(q, S(-3)), IntegerQ(m/S(2) + S(-1)/2)))
|
|
|
|
cons628 = CustomConstraint(cons_f628)
|
|
|
|
def cons_f629(m, n):
|
|
return NonzeroQ(m - n + S(1))
|
|
|
|
cons629 = CustomConstraint(cons_f629)
|
|
|
|
def cons_f630(p, q, r):
|
|
return PositiveIntegerQ(p, q, r)
|
|
|
|
cons630 = CustomConstraint(cons_f630)
|
|
|
|
def cons_f631(a, b, c, d, e, f, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, n), x)
|
|
|
|
cons631 = CustomConstraint(cons_f631)
|
|
|
|
def cons_f632(a, b, c, d, n):
|
|
return Not(And(ZeroQ(n + S(-2)), Or(And(PosQ(b/a), PosQ(d/c)), And(NegQ(b/a), Or(PosQ(d/c), And(PositiveQ(a), Or(Not(PositiveQ(c)), SimplerSqrtQ(-b/a, -d/c))))))))
|
|
|
|
cons632 = CustomConstraint(cons_f632)
|
|
|
|
def cons_f633(n, p, q):
|
|
return NonzeroQ(n*(p + q + S(1)) + S(1))
|
|
|
|
cons633 = CustomConstraint(cons_f633)
|
|
|
|
def cons_f634(a, b, c, d, e, f, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, p, n), x)
|
|
|
|
cons634 = CustomConstraint(cons_f634)
|
|
|
|
def cons_f635(a, b, c, d, e, f, n, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, n, p, q), x)
|
|
|
|
cons635 = CustomConstraint(cons_f635)
|
|
|
|
def cons_f636(c, d):
|
|
return PositiveQ(d/c)
|
|
|
|
cons636 = CustomConstraint(cons_f636)
|
|
|
|
def cons_f637(e, f):
|
|
return PositiveQ(f/e)
|
|
|
|
cons637 = CustomConstraint(cons_f637)
|
|
|
|
def cons_f638(c, d, e, f):
|
|
return Not(SimplerSqrtQ(d/c, f/e))
|
|
|
|
cons638 = CustomConstraint(cons_f638)
|
|
|
|
def cons_f639(c, d, e, f):
|
|
return Not(SimplerSqrtQ(-f/e, -d/c))
|
|
|
|
cons639 = CustomConstraint(cons_f639)
|
|
|
|
def cons_f640(e, f):
|
|
return PosQ(f/e)
|
|
|
|
cons640 = CustomConstraint(cons_f640)
|
|
|
|
def cons_f641(c, d, e, f):
|
|
return Not(And(NegQ(f/e), SimplerSqrtQ(-f/e, -d/c)))
|
|
|
|
cons641 = CustomConstraint(cons_f641)
|
|
|
|
def cons_f642(q, r):
|
|
return RationalQ(q, r)
|
|
|
|
cons642 = CustomConstraint(cons_f642)
|
|
|
|
def cons_f643(r):
|
|
return Greater(r, S(1))
|
|
|
|
cons643 = CustomConstraint(cons_f643)
|
|
|
|
def cons_f644(q):
|
|
return LessEqual(q, S(-1))
|
|
|
|
cons644 = CustomConstraint(cons_f644)
|
|
|
|
def cons_f645(c, d, e, f):
|
|
return PosQ((-c*f + d*e)/c)
|
|
|
|
cons645 = CustomConstraint(cons_f645)
|
|
|
|
def cons_f646(c, d, e, f):
|
|
return NegQ((-c*f + d*e)/c)
|
|
|
|
cons646 = CustomConstraint(cons_f646)
|
|
|
|
def cons_f647(a, b, c, d, e, f, n, p, q, r, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, n, p, q, r), x)
|
|
|
|
cons647 = CustomConstraint(cons_f647)
|
|
|
|
def cons_f648(u, v):
|
|
return ZeroQ(u - v)
|
|
|
|
cons648 = CustomConstraint(cons_f648)
|
|
|
|
def cons_f649(u, w):
|
|
return ZeroQ(u - w)
|
|
|
|
cons649 = CustomConstraint(cons_f649)
|
|
|
|
def cons_f650(r):
|
|
return IntegerQ(r)
|
|
|
|
cons650 = CustomConstraint(cons_f650)
|
|
|
|
def cons_f651(n, n2):
|
|
return ZeroQ(-n/S(2) + n2)
|
|
|
|
cons651 = CustomConstraint(cons_f651)
|
|
|
|
def cons_f652(e1, e2, f1, f2):
|
|
return ZeroQ(e1*f2 + e2*f1)
|
|
|
|
cons652 = CustomConstraint(cons_f652)
|
|
|
|
def cons_f653(e1, e2, r):
|
|
return Or(IntegerQ(r), And(PositiveQ(e1), PositiveQ(e2)))
|
|
|
|
cons653 = CustomConstraint(cons_f653)
|
|
|
|
def cons_f654(e1, x):
|
|
return FreeQ(e1, x)
|
|
|
|
cons654 = CustomConstraint(cons_f654)
|
|
|
|
def cons_f655(f1, x):
|
|
return FreeQ(f1, x)
|
|
|
|
cons655 = CustomConstraint(cons_f655)
|
|
|
|
def cons_f656(e2, x):
|
|
return FreeQ(e2, x)
|
|
|
|
cons656 = CustomConstraint(cons_f656)
|
|
|
|
def cons_f657(f2, x):
|
|
return FreeQ(f2, x)
|
|
|
|
cons657 = CustomConstraint(cons_f657)
|
|
|
|
def cons_f658(g, m):
|
|
return Or(IntegerQ(m), PositiveQ(g))
|
|
|
|
cons658 = CustomConstraint(cons_f658)
|
|
|
|
def cons_f659(p, q, r):
|
|
return PositiveIntegerQ(p + S(2), q, r)
|
|
|
|
cons659 = CustomConstraint(cons_f659)
|
|
|
|
def cons_f660(p, q, r):
|
|
return IntegersQ(p, q, r)
|
|
|
|
cons660 = CustomConstraint(cons_f660)
|
|
|
|
def cons_f661(a, b, c, d, e, f, q):
|
|
return Not(And(Equal(q, S(1)), SimplerQ(-a*d + b*c, -a*f + b*e)))
|
|
|
|
cons661 = CustomConstraint(cons_f661)
|
|
|
|
def cons_f662(c, d, e, f, n, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(Equal(q, S(1)), SimplerQ(e + f*x**n, c + d*x**n)))
|
|
|
|
cons662 = CustomConstraint(cons_f662)
|
|
|
|
def cons_f663(r):
|
|
return PositiveIntegerQ(r)
|
|
|
|
cons663 = CustomConstraint(cons_f663)
|
|
|
|
def cons_f664(a, b, c, d, e, f, g, m, n, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, m, n, p, q), x)
|
|
|
|
cons664 = CustomConstraint(cons_f664)
|
|
|
|
def cons_f665(a, b, c, d, e, f, g, m, n, p, q, r, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, m, n, p, q, r), x)
|
|
|
|
cons665 = CustomConstraint(cons_f665)
|
|
|
|
def cons_f666(n, p):
|
|
return ZeroQ(n*(S(2)*p + S(1)) + S(1))
|
|
|
|
cons666 = CustomConstraint(cons_f666)
|
|
|
|
def cons_f667(n, p):
|
|
return ZeroQ(S(2)*n*(p + S(1)) + S(1))
|
|
|
|
cons667 = CustomConstraint(cons_f667)
|
|
|
|
def cons_f668(n, p):
|
|
return Or(ZeroQ(S(2)*n*p + S(1)), ZeroQ(n*(S(2)*p + S(-1)) + S(1)))
|
|
|
|
cons668 = CustomConstraint(cons_f668)
|
|
|
|
def cons_f669(p):
|
|
return IntegerQ(p + S(1)/2)
|
|
|
|
cons669 = CustomConstraint(cons_f669)
|
|
|
|
def cons_f670(n):
|
|
return NonzeroQ(S(2)*n + S(1))
|
|
|
|
cons670 = CustomConstraint(cons_f670)
|
|
|
|
def cons_f671(n, p):
|
|
return NonzeroQ(S(2)*n*p + S(1))
|
|
|
|
cons671 = CustomConstraint(cons_f671)
|
|
|
|
def cons_f672(n, p):
|
|
return NonzeroQ(n*(S(2)*p + S(-1)) + S(1))
|
|
|
|
cons672 = CustomConstraint(cons_f672)
|
|
|
|
def cons_f673(n, p):
|
|
return NonzeroQ(n*(S(2)*p + S(1)) + S(1))
|
|
|
|
cons673 = CustomConstraint(cons_f673)
|
|
|
|
def cons_f674(n, p):
|
|
return NonzeroQ(S(2)*n*(p + S(1)) + S(1))
|
|
|
|
cons674 = CustomConstraint(cons_f674)
|
|
|
|
def cons_f675(n, p):
|
|
return Or(IntegerQ(p), ZeroQ(n + S(-2)))
|
|
|
|
cons675 = CustomConstraint(cons_f675)
|
|
|
|
def cons_f676(n):
|
|
return PositiveIntegerQ(n/S(2))
|
|
|
|
cons676 = CustomConstraint(cons_f676)
|
|
|
|
def cons_f677(a, b, c):
|
|
return PositiveQ(-S(4)*a*c + b**S(2))
|
|
|
|
cons677 = CustomConstraint(cons_f677)
|
|
|
|
def cons_f678(a, c):
|
|
return PositiveQ(c/a)
|
|
|
|
cons678 = CustomConstraint(cons_f678)
|
|
|
|
def cons_f679(a, b):
|
|
return NegativeQ(b/a)
|
|
|
|
cons679 = CustomConstraint(cons_f679)
|
|
|
|
def cons_f680(a, c):
|
|
return PosQ(c/a)
|
|
|
|
cons680 = CustomConstraint(cons_f680)
|
|
|
|
def cons_f681(a, c):
|
|
return NegQ(c/a)
|
|
|
|
cons681 = CustomConstraint(cons_f681)
|
|
|
|
def cons_f682(n, n2):
|
|
return EqQ(n2, S(2)*n)
|
|
|
|
cons682 = CustomConstraint(cons_f682)
|
|
|
|
def cons_f683(n):
|
|
return PosQ(n)
|
|
|
|
cons683 = CustomConstraint(cons_f683)
|
|
|
|
def cons_f684(m, n, p):
|
|
return ZeroQ(m + n*(S(2)*p + S(1)) + S(1))
|
|
|
|
cons684 = CustomConstraint(cons_f684)
|
|
|
|
def cons_f685(m, n):
|
|
return NonzeroQ(m + n + S(1))
|
|
|
|
cons685 = CustomConstraint(cons_f685)
|
|
|
|
def cons_f686(m, n, p):
|
|
return ZeroQ(m + S(2)*n*(p + S(1)) + S(1))
|
|
|
|
cons686 = CustomConstraint(cons_f686)
|
|
|
|
def cons_f687(m, n):
|
|
return Inequality(S(-1), LessEqual, m + n, Less, S(0))
|
|
|
|
cons687 = CustomConstraint(cons_f687)
|
|
|
|
def cons_f688(m, n):
|
|
return Less(m + n, S(-1))
|
|
|
|
cons688 = CustomConstraint(cons_f688)
|
|
|
|
def cons_f689(m, n, p):
|
|
return Not(And(NegativeIntegerQ((m + S(2)*n*(p + S(1)) + S(1))/n), Greater(p + (m + S(2)*n*(p + S(1)) + S(1))/n, S(0))))
|
|
|
|
cons689 = CustomConstraint(cons_f689)
|
|
|
|
def cons_f690(m, n, p):
|
|
return NonzeroQ(m + n*(S(2)*p + S(-1)) + S(1))
|
|
|
|
cons690 = CustomConstraint(cons_f690)
|
|
|
|
def cons_f691(m, n, p):
|
|
return Not(And(PositiveIntegerQ(m), IntegerQ((m + S(1))/n), Less(S(-1) + (m + S(1))/n, S(2)*p)))
|
|
|
|
cons691 = CustomConstraint(cons_f691)
|
|
|
|
def cons_f692(m, n):
|
|
return Inequality(n + S(-1), Less, m, LessEqual, S(2)*n + S(-1))
|
|
|
|
cons692 = CustomConstraint(cons_f692)
|
|
|
|
def cons_f693(m, n, p):
|
|
return Or(IntegerQ(S(2)*p), PositiveIntegerQ((m + S(1))/n))
|
|
|
|
cons693 = CustomConstraint(cons_f693)
|
|
|
|
def cons_f694(m, n, p):
|
|
return Unequal(m + S(2)*n*p + S(1), S(0))
|
|
|
|
cons694 = CustomConstraint(cons_f694)
|
|
|
|
def cons_f695(m, n, p):
|
|
return Unequal(m + n*(S(2)*p + S(-1)) + S(1), S(0))
|
|
|
|
cons695 = CustomConstraint(cons_f695)
|
|
|
|
def cons_f696(m, n, p):
|
|
return Or(IntegerQ(p), And(IntegerQ(S(2)*p), IntegerQ(m), Equal(n, S(2))))
|
|
|
|
cons696 = CustomConstraint(cons_f696)
|
|
|
|
def cons_f697(m, n):
|
|
return Greater(m, S(3)*n + S(-1))
|
|
|
|
cons697 = CustomConstraint(cons_f697)
|
|
|
|
def cons_f698(a, b, c):
|
|
return NegativeQ(-S(4)*a*c + b**S(2))
|
|
|
|
cons698 = CustomConstraint(cons_f698)
|
|
|
|
def cons_f699(a, c):
|
|
return PosQ(a*c)
|
|
|
|
cons699 = CustomConstraint(cons_f699)
|
|
|
|
def cons_f700(m, n):
|
|
return PositiveIntegerQ(n/S(2), m)
|
|
|
|
cons700 = CustomConstraint(cons_f700)
|
|
|
|
def cons_f701(m, n):
|
|
return Inequality(S(3)*n/S(2), LessEqual, m, Less, S(2)*n)
|
|
|
|
cons701 = CustomConstraint(cons_f701)
|
|
|
|
def cons_f702(m, n):
|
|
return Inequality(n/S(2), LessEqual, m, Less, S(3)*n/S(2))
|
|
|
|
cons702 = CustomConstraint(cons_f702)
|
|
|
|
def cons_f703(m, n):
|
|
return GreaterEqual(m, n)
|
|
|
|
cons703 = CustomConstraint(cons_f703)
|
|
|
|
def cons_f704(p):
|
|
return NegativeIntegerQ(p + S(1))
|
|
|
|
cons704 = CustomConstraint(cons_f704)
|
|
|
|
def cons_f705(b, c, d, e, n, p):
|
|
return ZeroQ(b*e*(n*p + S(1)) - c*d*(n*(S(2)*p + S(1)) + S(1)))
|
|
|
|
cons705 = CustomConstraint(cons_f705)
|
|
|
|
def cons_f706(b, c, d, e, n, p):
|
|
return NonzeroQ(b*e*(n*p + S(1)) - c*d*(n*(S(2)*p + S(1)) + S(1)))
|
|
|
|
cons706 = CustomConstraint(cons_f706)
|
|
|
|
def cons_f707(a, c, d, e):
|
|
return ZeroQ(-a*e**S(2) + c*d**S(2))
|
|
|
|
cons707 = CustomConstraint(cons_f707)
|
|
|
|
def cons_f708(d, e):
|
|
return PosQ(d*e)
|
|
|
|
cons708 = CustomConstraint(cons_f708)
|
|
|
|
def cons_f709(d, e):
|
|
return NegQ(d*e)
|
|
|
|
cons709 = CustomConstraint(cons_f709)
|
|
|
|
def cons_f710(a, c, d, e):
|
|
return NonzeroQ(-a*e**S(2) + c*d**S(2))
|
|
|
|
cons710 = CustomConstraint(cons_f710)
|
|
|
|
def cons_f711(a, c):
|
|
return NegQ(a*c)
|
|
|
|
cons711 = CustomConstraint(cons_f711)
|
|
|
|
def cons_f712(a, c, n):
|
|
return Or(PosQ(a*c), Not(IntegerQ(n)))
|
|
|
|
cons712 = CustomConstraint(cons_f712)
|
|
|
|
def cons_f713(a, b, c, d, e):
|
|
return Or(PositiveQ(-b/c + S(2)*d/e), And(Not(NegativeQ(-b/c + S(2)*d/e)), ZeroQ(d - e*Rt(a/c, S(2)))))
|
|
|
|
cons713 = CustomConstraint(cons_f713)
|
|
|
|
def cons_f714(a, b, c):
|
|
return Not(PositiveQ(-S(4)*a*c + b**S(2)))
|
|
|
|
cons714 = CustomConstraint(cons_f714)
|
|
|
|
def cons_f715(a, b, c, n):
|
|
return Or(PosQ(-S(4)*a*c + b**S(2)), Not(PositiveIntegerQ(n/S(2))))
|
|
|
|
cons715 = CustomConstraint(cons_f715)
|
|
|
|
def cons_f716(n, p):
|
|
return NonzeroQ(S(2)*n*p + n + S(1))
|
|
|
|
cons716 = CustomConstraint(cons_f716)
|
|
|
|
def cons_f717(a, c):
|
|
return PositiveQ(-a*c)
|
|
|
|
cons717 = CustomConstraint(cons_f717)
|
|
|
|
def cons_f718(n, p, q):
|
|
return NonzeroQ(S(2)*n*p + n*q + S(1))
|
|
|
|
cons718 = CustomConstraint(cons_f718)
|
|
|
|
def cons_f719(p):
|
|
return PositiveIntegerQ(p + S(-1)/2)
|
|
|
|
cons719 = CustomConstraint(cons_f719)
|
|
|
|
def cons_f720(c):
|
|
return Not(NegativeQ(c))
|
|
|
|
cons720 = CustomConstraint(cons_f720)
|
|
|
|
def cons_f721(p):
|
|
return NegativeIntegerQ(p + S(1)/2)
|
|
|
|
cons721 = CustomConstraint(cons_f721)
|
|
|
|
def cons_f722(b, c, d, e):
|
|
return ZeroQ(-b*e + c*d)
|
|
|
|
cons722 = CustomConstraint(cons_f722)
|
|
|
|
def cons_f723(a, d):
|
|
return Not(And(PositiveQ(a), PositiveQ(d)))
|
|
|
|
cons723 = CustomConstraint(cons_f723)
|
|
|
|
def cons_f724(n, p, q):
|
|
return Or(And(IntegersQ(p, q), Not(IntegerQ(n))), PositiveIntegerQ(p), And(PositiveIntegerQ(q), Not(IntegerQ(n))))
|
|
|
|
cons724 = CustomConstraint(cons_f724)
|
|
|
|
def cons_f725(n, p):
|
|
return Not(IntegersQ(n, S(2)*p))
|
|
|
|
cons725 = CustomConstraint(cons_f725)
|
|
|
|
def cons_f726(n, q):
|
|
return Not(IntegersQ(n, q))
|
|
|
|
cons726 = CustomConstraint(cons_f726)
|
|
|
|
def cons_f727(mn, n2):
|
|
return EqQ(n2, -S(2)*mn)
|
|
|
|
cons727 = CustomConstraint(cons_f727)
|
|
|
|
def cons_f728(mn, x):
|
|
return FreeQ(mn, x)
|
|
|
|
cons728 = CustomConstraint(cons_f728)
|
|
|
|
def cons_f729(n2):
|
|
return PosQ(n2)
|
|
|
|
cons729 = CustomConstraint(cons_f729)
|
|
|
|
def cons_f730(n2):
|
|
return NegQ(n2)
|
|
|
|
cons730 = CustomConstraint(cons_f730)
|
|
|
|
def cons_f731(d1, d2, e1, e2):
|
|
return ZeroQ(d1*e2 + d2*e1)
|
|
|
|
cons731 = CustomConstraint(cons_f731)
|
|
|
|
def cons_f732(d1, d2, q):
|
|
return Or(IntegerQ(q), And(PositiveQ(d1), PositiveQ(d2)))
|
|
|
|
cons732 = CustomConstraint(cons_f732)
|
|
|
|
def cons_f733(d1, x):
|
|
return FreeQ(d1, x)
|
|
|
|
cons733 = CustomConstraint(cons_f733)
|
|
|
|
def cons_f734(d2, x):
|
|
return FreeQ(d2, x)
|
|
|
|
cons734 = CustomConstraint(cons_f734)
|
|
|
|
def cons_f735(f, m):
|
|
return Or(IntegerQ(m), PositiveQ(f))
|
|
|
|
cons735 = CustomConstraint(cons_f735)
|
|
|
|
def cons_f736(m, n):
|
|
return PositiveIntegerQ(m, n, (m + S(1))/n)
|
|
|
|
cons736 = CustomConstraint(cons_f736)
|
|
|
|
def cons_f737(m, q):
|
|
return IntegersQ(m, q)
|
|
|
|
cons737 = CustomConstraint(cons_f737)
|
|
|
|
def cons_f738(n, p):
|
|
return Greater(S(2)*n*p, n + S(-1))
|
|
|
|
cons738 = CustomConstraint(cons_f738)
|
|
|
|
def cons_f739(m, n, p, q):
|
|
return NonzeroQ(m + S(2)*n*p + n*q + S(1))
|
|
|
|
cons739 = CustomConstraint(cons_f739)
|
|
|
|
def cons_f740(m, n, p):
|
|
return Unequal(m + n*(S(2)*p + S(1)) + S(1), S(0))
|
|
|
|
cons740 = CustomConstraint(cons_f740)
|
|
|
|
def cons_f741(m, n, p):
|
|
return NonzeroQ(m + n*(S(2)*p + S(1)) + S(1))
|
|
|
|
cons741 = CustomConstraint(cons_f741)
|
|
|
|
def cons_f742(m, n):
|
|
return IntegersQ(m, n/S(2))
|
|
|
|
cons742 = CustomConstraint(cons_f742)
|
|
|
|
def cons_f743(d, e):
|
|
return PositiveQ(d/e)
|
|
|
|
cons743 = CustomConstraint(cons_f743)
|
|
|
|
def cons_f744(b, c, d, e):
|
|
return PosQ(c*(-b*e + S(2)*c*d)/e)
|
|
|
|
cons744 = CustomConstraint(cons_f744)
|
|
|
|
def cons_f745(n):
|
|
return IntegerQ(n/S(2))
|
|
|
|
cons745 = CustomConstraint(cons_f745)
|
|
|
|
def cons_f746(n):
|
|
return Greater(n, S(2))
|
|
|
|
cons746 = CustomConstraint(cons_f746)
|
|
|
|
def cons_f747(m, n):
|
|
return Less(m, -n)
|
|
|
|
cons747 = CustomConstraint(cons_f747)
|
|
|
|
def cons_f748(m, n):
|
|
return Greater(m, n)
|
|
|
|
cons748 = CustomConstraint(cons_f748)
|
|
|
|
def cons_f749(m, q):
|
|
return Or(PositiveIntegerQ(q), IntegersQ(m, q))
|
|
|
|
cons749 = CustomConstraint(cons_f749)
|
|
|
|
def cons_f750(p, q):
|
|
return Or(PositiveIntegerQ(p), PositiveIntegerQ(q))
|
|
|
|
cons750 = CustomConstraint(cons_f750)
|
|
|
|
def cons_f751(f, m):
|
|
return Not(Or(IntegerQ(m), PositiveQ(f)))
|
|
|
|
cons751 = CustomConstraint(cons_f751)
|
|
|
|
def cons_f752(n, q):
|
|
return ZeroQ(n - q)
|
|
|
|
cons752 = CustomConstraint(cons_f752)
|
|
|
|
def cons_f753(n, r):
|
|
return ZeroQ(-n + r)
|
|
|
|
cons753 = CustomConstraint(cons_f753)
|
|
|
|
def cons_f754(n, q, r):
|
|
return ZeroQ(-S(2)*n + q + r)
|
|
|
|
cons754 = CustomConstraint(cons_f754)
|
|
|
|
def cons_f755(n, q):
|
|
return PosQ(n - q)
|
|
|
|
cons755 = CustomConstraint(cons_f755)
|
|
|
|
def cons_f756(n, p, q):
|
|
return NonzeroQ(p*(S(2)*n - q) + S(1))
|
|
|
|
cons756 = CustomConstraint(cons_f756)
|
|
|
|
def cons_f757(n, q):
|
|
return ZeroQ(-n + q)
|
|
|
|
cons757 = CustomConstraint(cons_f757)
|
|
|
|
def cons_f758(m, n, q):
|
|
return Or(And(ZeroQ(m + S(-1)), ZeroQ(n + S(-3)), ZeroQ(q + S(-2))), And(Or(ZeroQ(m + S(1)/2), ZeroQ(m + S(-3)/2), ZeroQ(m + S(-1)/2), ZeroQ(m + S(-5)/2)), ZeroQ(n + S(-3)), ZeroQ(q + S(-1))))
|
|
|
|
cons758 = CustomConstraint(cons_f758)
|
|
|
|
def cons_f759(m, n):
|
|
return ZeroQ(m - S(3)*n/S(2) + S(3)/2)
|
|
|
|
cons759 = CustomConstraint(cons_f759)
|
|
|
|
def cons_f760(n, q):
|
|
return ZeroQ(-n + q + S(1))
|
|
|
|
cons760 = CustomConstraint(cons_f760)
|
|
|
|
def cons_f761(n, r):
|
|
return ZeroQ(-n + r + S(-1))
|
|
|
|
cons761 = CustomConstraint(cons_f761)
|
|
|
|
def cons_f762(m, n):
|
|
return ZeroQ(m - S(3)*n/S(2) + S(1)/2)
|
|
|
|
cons762 = CustomConstraint(cons_f762)
|
|
|
|
def cons_f763(m, n, p):
|
|
return Equal(m + p*(n + S(-1)) + S(-1), S(0))
|
|
|
|
cons763 = CustomConstraint(cons_f763)
|
|
|
|
def cons_f764(m, n, p, q):
|
|
return Equal(m + p*q + S(1), n - q)
|
|
|
|
cons764 = CustomConstraint(cons_f764)
|
|
|
|
def cons_f765(m, n, p, q):
|
|
return Greater(m + p*q + S(1), n - q)
|
|
|
|
cons765 = CustomConstraint(cons_f765)
|
|
|
|
def cons_f766(m, n, p, q):
|
|
return Unequal(m + p*(S(2)*n - q) + S(1), S(0))
|
|
|
|
cons766 = CustomConstraint(cons_f766)
|
|
|
|
def cons_f767(m, n, p, q):
|
|
return Unequal(m + p*q + (n - q)*(S(2)*p + S(-1)) + S(1), S(0))
|
|
|
|
cons767 = CustomConstraint(cons_f767)
|
|
|
|
def cons_f768(m, n, p, q):
|
|
return LessEqual(m + p*q + S(1), -n + q + S(1))
|
|
|
|
cons768 = CustomConstraint(cons_f768)
|
|
|
|
def cons_f769(m, p, q):
|
|
return NonzeroQ(m + p*q + S(1))
|
|
|
|
cons769 = CustomConstraint(cons_f769)
|
|
|
|
def cons_f770(m, n, p, q):
|
|
return Greater(m + p*q + S(1), -n + q)
|
|
|
|
cons770 = CustomConstraint(cons_f770)
|
|
|
|
def cons_f771(m, n, p, q):
|
|
return Equal(m + p*q + S(1), -(n - q)*(S(2)*p + S(3)))
|
|
|
|
cons771 = CustomConstraint(cons_f771)
|
|
|
|
def cons_f772(m, n, p, q):
|
|
return Greater(m + p*q + S(1), S(2)*n - S(2)*q)
|
|
|
|
cons772 = CustomConstraint(cons_f772)
|
|
|
|
def cons_f773(m, n, p, q):
|
|
return Less(m + p*q + S(1), n - q)
|
|
|
|
cons773 = CustomConstraint(cons_f773)
|
|
|
|
def cons_f774(m, n, p, q):
|
|
return Less(n - q, m + p*q + S(1), S(2)*n - S(2)*q)
|
|
|
|
cons774 = CustomConstraint(cons_f774)
|
|
|
|
def cons_f775(p):
|
|
return Inequality(S(-1), LessEqual, p, Less, S(0))
|
|
|
|
cons775 = CustomConstraint(cons_f775)
|
|
|
|
def cons_f776(m, n, p, q):
|
|
return Equal(m + p*q + S(1), S(2)*n - S(2)*q)
|
|
|
|
cons776 = CustomConstraint(cons_f776)
|
|
|
|
def cons_f777(m, n, p, q):
|
|
return Equal(m + p*q + S(1), -S(2)*(n - q)*(p + S(1)))
|
|
|
|
cons777 = CustomConstraint(cons_f777)
|
|
|
|
def cons_f778(m, p, q):
|
|
return Less(m + p*q + S(1), S(0))
|
|
|
|
cons778 = CustomConstraint(cons_f778)
|
|
|
|
def cons_f779(n, q, r):
|
|
return ZeroQ(-n + q + r)
|
|
|
|
cons779 = CustomConstraint(cons_f779)
|
|
|
|
def cons_f780(j, n, q):
|
|
return ZeroQ(j - S(2)*n + q)
|
|
|
|
cons780 = CustomConstraint(cons_f780)
|
|
|
|
def cons_f781(j, n, q):
|
|
return ZeroQ(j - n + q)
|
|
|
|
cons781 = CustomConstraint(cons_f781)
|
|
|
|
def cons_f782(n):
|
|
return ZeroQ(n + S(-3))
|
|
|
|
cons782 = CustomConstraint(cons_f782)
|
|
|
|
def cons_f783(q):
|
|
return ZeroQ(q + S(-2))
|
|
|
|
cons783 = CustomConstraint(cons_f783)
|
|
|
|
def cons_f784(n, p, q):
|
|
return NonzeroQ(p*q + (n - q)*(S(2)*p + S(1)) + S(1))
|
|
|
|
cons784 = CustomConstraint(cons_f784)
|
|
|
|
def cons_f785(m, n, p, q):
|
|
return LessEqual(m + p*q, -n + q)
|
|
|
|
cons785 = CustomConstraint(cons_f785)
|
|
|
|
def cons_f786(m, p, q):
|
|
return Unequal(m + p*q + S(1), S(0))
|
|
|
|
cons786 = CustomConstraint(cons_f786)
|
|
|
|
def cons_f787(m, n, p, q):
|
|
return Unequal(m + p*q + (n - q)*(S(2)*p + S(1)) + S(1), S(0))
|
|
|
|
cons787 = CustomConstraint(cons_f787)
|
|
|
|
def cons_f788(m, n, p, q):
|
|
return Greater(m + p*q, n - q + S(-1))
|
|
|
|
cons788 = CustomConstraint(cons_f788)
|
|
|
|
def cons_f789(m, n, p, q):
|
|
return Greater(m + p*q, -n + q + S(-1))
|
|
|
|
cons789 = CustomConstraint(cons_f789)
|
|
|
|
def cons_f790(m, n, p, q):
|
|
return Less(m + p*q, n - q + S(-1))
|
|
|
|
cons790 = CustomConstraint(cons_f790)
|
|
|
|
def cons_f791(m, n, p, q):
|
|
return GreaterEqual(m + p*q, n - q + S(-1))
|
|
|
|
cons791 = CustomConstraint(cons_f791)
|
|
|
|
def cons_f792(m, n, p, q):
|
|
return Or(Inequality(S(-1), LessEqual, p, Less, S(0)), Equal(m + p*q + (n - q)*(S(2)*p + S(1)) + S(1), S(0)))
|
|
|
|
cons792 = CustomConstraint(cons_f792)
|
|
|
|
def cons_f793(m):
|
|
return Or(ZeroQ(m + S(-1)/2), ZeroQ(m + S(1)/2))
|
|
|
|
cons793 = CustomConstraint(cons_f793)
|
|
|
|
def cons_f794(q):
|
|
return ZeroQ(q + S(-1))
|
|
|
|
cons794 = CustomConstraint(cons_f794)
|
|
|
|
def cons_f795(j, k, q):
|
|
return ZeroQ(j - k + q)
|
|
|
|
cons795 = CustomConstraint(cons_f795)
|
|
|
|
def cons_f796(j, k, n):
|
|
return ZeroQ(j - S(2)*k + n)
|
|
|
|
cons796 = CustomConstraint(cons_f796)
|
|
|
|
def cons_f797(j, k):
|
|
return PosQ(-j + k)
|
|
|
|
cons797 = CustomConstraint(cons_f797)
|
|
|
|
def cons_f798(j, x):
|
|
return FreeQ(j, x)
|
|
|
|
cons798 = CustomConstraint(cons_f798)
|
|
|
|
def cons_f799(k, x):
|
|
return FreeQ(k, x)
|
|
|
|
cons799 = CustomConstraint(cons_f799)
|
|
|
|
def cons_f800(n, q):
|
|
return IntegerQ(n*q)
|
|
|
|
cons800 = CustomConstraint(cons_f800)
|
|
|
|
def cons_f801(a, b, c, d, e, f, m, n, p, q, r, s, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, m, n, p, q, r, s), x)
|
|
|
|
cons801 = CustomConstraint(cons_f801)
|
|
|
|
def cons_f802(s, x):
|
|
return FreeQ(s, x)
|
|
|
|
cons802 = CustomConstraint(cons_f802)
|
|
|
|
def cons_f803(b, d, e):
|
|
return PositiveQ(b*d*e)
|
|
|
|
cons803 = CustomConstraint(cons_f803)
|
|
|
|
def cons_f804(a, b, c, d):
|
|
return PositiveQ(-a*d/b + c)
|
|
|
|
cons804 = CustomConstraint(cons_f804)
|
|
|
|
def cons_f805(n):
|
|
return IntegerQ(S(1)/n)
|
|
|
|
cons805 = CustomConstraint(cons_f805)
|
|
|
|
def cons_f806(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolynomialQ(u, x)
|
|
|
|
cons806 = CustomConstraint(cons_f806)
|
|
|
|
def cons_f807(m, r):
|
|
return IntegersQ(m, r)
|
|
|
|
cons807 = CustomConstraint(cons_f807)
|
|
|
|
def cons_f808(a, b, c, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, n, p), x)
|
|
|
|
cons808 = CustomConstraint(cons_f808)
|
|
|
|
def cons_f809(n, n2):
|
|
return ZeroQ(S(2)*n + n2)
|
|
|
|
cons809 = CustomConstraint(cons_f809)
|
|
|
|
def cons_f810(n):
|
|
return IntegerQ(S(2)*n)
|
|
|
|
cons810 = CustomConstraint(cons_f810)
|
|
|
|
def cons_f811(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(LinearMatchQ(u, x))
|
|
|
|
cons811 = CustomConstraint(cons_f811)
|
|
|
|
def cons_f812(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return LinearQ(List(u, v), x)
|
|
|
|
cons812 = CustomConstraint(cons_f812)
|
|
|
|
def cons_f813(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(LinearMatchQ(List(u, v), x))
|
|
|
|
cons813 = CustomConstraint(cons_f813)
|
|
|
|
def cons_f814(u, v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return LinearQ(List(u, v, w), x)
|
|
|
|
cons814 = CustomConstraint(cons_f814)
|
|
|
|
def cons_f815(u, v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(LinearMatchQ(List(u, v, w), x))
|
|
|
|
cons815 = CustomConstraint(cons_f815)
|
|
|
|
def cons_f816(u, v, w, x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return LinearQ(List(u, v, w, z), x)
|
|
|
|
cons816 = CustomConstraint(cons_f816)
|
|
|
|
def cons_f817(u, v, w, x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(LinearMatchQ(List(u, v, w, z), x))
|
|
|
|
cons817 = CustomConstraint(cons_f817)
|
|
|
|
def cons_f818(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return QuadraticQ(u, x)
|
|
|
|
cons818 = CustomConstraint(cons_f818)
|
|
|
|
def cons_f819(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(QuadraticMatchQ(u, x))
|
|
|
|
cons819 = CustomConstraint(cons_f819)
|
|
|
|
def cons_f820(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return QuadraticQ(v, x)
|
|
|
|
cons820 = CustomConstraint(cons_f820)
|
|
|
|
def cons_f821(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(LinearMatchQ(u, x), QuadraticMatchQ(v, x)))
|
|
|
|
cons821 = CustomConstraint(cons_f821)
|
|
|
|
def cons_f822(w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return QuadraticQ(w, x)
|
|
|
|
cons822 = CustomConstraint(cons_f822)
|
|
|
|
def cons_f823(u, v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(LinearMatchQ(List(u, v), x), QuadraticMatchQ(w, x)))
|
|
|
|
cons823 = CustomConstraint(cons_f823)
|
|
|
|
def cons_f824(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(QuadraticMatchQ(List(u, v), x))
|
|
|
|
cons824 = CustomConstraint(cons_f824)
|
|
|
|
def cons_f825(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return BinomialQ(u, x)
|
|
|
|
cons825 = CustomConstraint(cons_f825)
|
|
|
|
def cons_f826(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(BinomialMatchQ(u, x))
|
|
|
|
cons826 = CustomConstraint(cons_f826)
|
|
|
|
def cons_f827(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return BinomialQ(List(u, v), x)
|
|
|
|
cons827 = CustomConstraint(cons_f827)
|
|
|
|
def cons_f828(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return ZeroQ(BinomialDegree(u, x) - BinomialDegree(v, x))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons828 = CustomConstraint(cons_f828)
|
|
|
|
def cons_f829(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(BinomialMatchQ(List(u, v), x))
|
|
|
|
cons829 = CustomConstraint(cons_f829)
|
|
|
|
def cons_f830(u, v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return BinomialQ(List(u, v, w), x)
|
|
|
|
cons830 = CustomConstraint(cons_f830)
|
|
|
|
def cons_f831(u, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return ZeroQ(BinomialDegree(u, x) - BinomialDegree(w, x))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons831 = CustomConstraint(cons_f831)
|
|
|
|
def cons_f832(u, v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(BinomialMatchQ(List(u, v, w), x))
|
|
|
|
cons832 = CustomConstraint(cons_f832)
|
|
|
|
def cons_f833(u, v, x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return BinomialQ(List(u, v, z), x)
|
|
|
|
cons833 = CustomConstraint(cons_f833)
|
|
|
|
def cons_f834(u, x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return ZeroQ(BinomialDegree(u, x) - BinomialDegree(z, x))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons834 = CustomConstraint(cons_f834)
|
|
|
|
def cons_f835(u, v, x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(BinomialMatchQ(List(u, v, z), x))
|
|
|
|
cons835 = CustomConstraint(cons_f835)
|
|
|
|
def cons_f836(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return GeneralizedBinomialQ(u, x)
|
|
|
|
cons836 = CustomConstraint(cons_f836)
|
|
|
|
def cons_f837(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(GeneralizedBinomialMatchQ(u, x))
|
|
|
|
cons837 = CustomConstraint(cons_f837)
|
|
|
|
def cons_f838(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return TrinomialQ(u, x)
|
|
|
|
cons838 = CustomConstraint(cons_f838)
|
|
|
|
def cons_f839(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(TrinomialMatchQ(u, x))
|
|
|
|
cons839 = CustomConstraint(cons_f839)
|
|
|
|
def cons_f840(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return TrinomialQ(v, x)
|
|
|
|
cons840 = CustomConstraint(cons_f840)
|
|
|
|
def cons_f841(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(BinomialMatchQ(u, x), TrinomialMatchQ(v, x)))
|
|
|
|
cons841 = CustomConstraint(cons_f841)
|
|
|
|
def cons_f842(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return BinomialQ(v, x)
|
|
|
|
cons842 = CustomConstraint(cons_f842)
|
|
|
|
def cons_f843(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(BinomialMatchQ(u, x), BinomialMatchQ(v, x)))
|
|
|
|
cons843 = CustomConstraint(cons_f843)
|
|
|
|
def cons_f844(x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return BinomialQ(z, x)
|
|
|
|
cons844 = CustomConstraint(cons_f844)
|
|
|
|
def cons_f845(u, x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(BinomialMatchQ(z, x), TrinomialMatchQ(u, x)))
|
|
|
|
cons845 = CustomConstraint(cons_f845)
|
|
|
|
def cons_f846(u, x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(BinomialMatchQ(z, x), BinomialMatchQ(u, x)))
|
|
|
|
cons846 = CustomConstraint(cons_f846)
|
|
|
|
def cons_f847(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return GeneralizedTrinomialQ(u, x)
|
|
|
|
cons847 = CustomConstraint(cons_f847)
|
|
|
|
def cons_f848(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(GeneralizedTrinomialMatchQ(u, x))
|
|
|
|
cons848 = CustomConstraint(cons_f848)
|
|
|
|
def cons_f849(u, x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return ZeroQ(BinomialDegree(z, x) - GeneralizedTrinomialDegree(u, x))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons849 = CustomConstraint(cons_f849)
|
|
|
|
def cons_f850(u, x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(BinomialMatchQ(z, x), GeneralizedTrinomialMatchQ(u, x)))
|
|
|
|
cons850 = CustomConstraint(cons_f850)
|
|
|
|
def cons_f851(n, q):
|
|
return ZeroQ(-n/S(4) + q)
|
|
|
|
cons851 = CustomConstraint(cons_f851)
|
|
|
|
def cons_f852(n, r):
|
|
return ZeroQ(-S(3)*n/S(4) + r)
|
|
|
|
cons852 = CustomConstraint(cons_f852)
|
|
|
|
def cons_f853(m, n):
|
|
return ZeroQ(S(4)*m - n + S(4))
|
|
|
|
cons853 = CustomConstraint(cons_f853)
|
|
|
|
def cons_f854(a, c, e, h):
|
|
return ZeroQ(a*h + c*e)
|
|
|
|
cons854 = CustomConstraint(cons_f854)
|
|
|
|
def cons_f855(m):
|
|
return NegativeIntegerQ(m + S(1))
|
|
|
|
cons855 = CustomConstraint(cons_f855)
|
|
|
|
def cons_f856(m, n):
|
|
return PositiveIntegerQ(n/(m + S(1)))
|
|
|
|
cons856 = CustomConstraint(cons_f856)
|
|
|
|
def cons_f857(Pq, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolyQ(Pq, x**(m + S(1)))
|
|
|
|
cons857 = CustomConstraint(cons_f857)
|
|
|
|
def cons_f858(Pq, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return NonzeroQ(Coeff(Pq, x, n + S(-1)))
|
|
|
|
cons858 = CustomConstraint(cons_f858)
|
|
|
|
def cons_f859(n, p):
|
|
return Or(PositiveIntegerQ(p), ZeroQ(n + S(-1)))
|
|
|
|
cons859 = CustomConstraint(cons_f859)
|
|
|
|
def cons_f860(Pq, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolyQ(Pq, x**n)
|
|
|
|
cons860 = CustomConstraint(cons_f860)
|
|
|
|
def cons_f861(Pq, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(Coeff(Pq, x, S(0)))
|
|
|
|
cons861 = CustomConstraint(cons_f861)
|
|
|
|
def cons_f862(Pq):
|
|
return SumQ(Pq)
|
|
|
|
cons862 = CustomConstraint(cons_f862)
|
|
|
|
def cons_f863(Pq, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Less(m + Expon(Pq, x) + S(1), S(0))
|
|
|
|
cons863 = CustomConstraint(cons_f863)
|
|
|
|
def cons_f864(Pq, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Less(Expon(Pq, x), n + S(-1))
|
|
|
|
cons864 = CustomConstraint(cons_f864)
|
|
|
|
def cons_f865(a, b, d, g):
|
|
return ZeroQ(a*g + b*d)
|
|
|
|
cons865 = CustomConstraint(cons_f865)
|
|
|
|
def cons_f866(a, b, e, h):
|
|
return ZeroQ(-S(3)*a*h + b*e)
|
|
|
|
cons866 = CustomConstraint(cons_f866)
|
|
|
|
def cons_f867(A, B, a, b):
|
|
return ZeroQ(-A**S(3)*b + B**S(3)*a)
|
|
|
|
cons867 = CustomConstraint(cons_f867)
|
|
|
|
def cons_f868(A, B, a, b):
|
|
return NonzeroQ(-A**S(3)*b + B**S(3)*a)
|
|
|
|
cons868 = CustomConstraint(cons_f868)
|
|
|
|
def cons_f869(A, B, C):
|
|
return ZeroQ(-A*C + B**S(2))
|
|
|
|
cons869 = CustomConstraint(cons_f869)
|
|
|
|
def cons_f870(B, C, a, b):
|
|
return ZeroQ(B**S(3)*b + C**S(3)*a)
|
|
|
|
cons870 = CustomConstraint(cons_f870)
|
|
|
|
def cons_f871(A, B, C, a, b):
|
|
return ZeroQ(A*b**(S(2)/3) - B*a**(S(1)/3)*b**(S(1)/3) - S(2)*C*a**(S(2)/3))
|
|
|
|
cons871 = CustomConstraint(cons_f871)
|
|
|
|
def cons_f872(B, C, a, b):
|
|
return ZeroQ(B*a**(S(1)/3)*b**(S(1)/3) + S(2)*C*a**(S(2)/3))
|
|
|
|
cons872 = CustomConstraint(cons_f872)
|
|
|
|
def cons_f873(A, C, a, b):
|
|
return ZeroQ(A*b**(S(2)/3) - S(2)*C*a**(S(2)/3))
|
|
|
|
cons873 = CustomConstraint(cons_f873)
|
|
|
|
def cons_f874(A, B, C, a, b):
|
|
return ZeroQ(A*(-b)**(S(2)/3) - B*(-a)**(S(1)/3)*(-b)**(S(1)/3) - S(2)*C*(-a)**(S(2)/3))
|
|
|
|
cons874 = CustomConstraint(cons_f874)
|
|
|
|
def cons_f875(B, C, a, b):
|
|
return ZeroQ(B*(-a)**(S(1)/3)*(-b)**(S(1)/3) + S(2)*C*(-a)**(S(2)/3))
|
|
|
|
cons875 = CustomConstraint(cons_f875)
|
|
|
|
def cons_f876(A, C, a, b):
|
|
return ZeroQ(A*(-b)**(S(2)/3) - S(2)*C*(-a)**(S(2)/3))
|
|
|
|
cons876 = CustomConstraint(cons_f876)
|
|
|
|
def cons_f877(A, B, C, a, b):
|
|
return ZeroQ(A*b**(S(2)/3) + B*b**(S(1)/3)*(-a)**(S(1)/3) - S(2)*C*(-a)**(S(2)/3))
|
|
|
|
cons877 = CustomConstraint(cons_f877)
|
|
|
|
def cons_f878(B, C, a, b):
|
|
return ZeroQ(B*b**(S(1)/3)*(-a)**(S(1)/3) - S(2)*C*(-a)**(S(2)/3))
|
|
|
|
cons878 = CustomConstraint(cons_f878)
|
|
|
|
def cons_f879(A, C, a, b):
|
|
return ZeroQ(A*b**(S(2)/3) - S(2)*C*(-a)**(S(2)/3))
|
|
|
|
cons879 = CustomConstraint(cons_f879)
|
|
|
|
def cons_f880(A, B, C, a, b):
|
|
return ZeroQ(A*(-b)**(S(2)/3) + B*a**(S(1)/3)*(-b)**(S(1)/3) - S(2)*C*a**(S(2)/3))
|
|
|
|
cons880 = CustomConstraint(cons_f880)
|
|
|
|
def cons_f881(B, C, a, b):
|
|
return ZeroQ(B*a**(S(1)/3)*(-b)**(S(1)/3) - S(2)*C*a**(S(2)/3))
|
|
|
|
cons881 = CustomConstraint(cons_f881)
|
|
|
|
def cons_f882(A, C, a, b):
|
|
return ZeroQ(A*(-b)**(S(2)/3) - S(2)*C*a**(S(2)/3))
|
|
|
|
cons882 = CustomConstraint(cons_f882)
|
|
|
|
def cons_f883(A, B, C, a, b):
|
|
return ZeroQ(A - B*(a/b)**(S(1)/3) - S(2)*C*(a/b)**(S(2)/3))
|
|
|
|
cons883 = CustomConstraint(cons_f883)
|
|
|
|
def cons_f884(B, C, a, b):
|
|
return ZeroQ(B*(a/b)**(S(1)/3) + S(2)*C*(a/b)**(S(2)/3))
|
|
|
|
cons884 = CustomConstraint(cons_f884)
|
|
|
|
def cons_f885(A, C, a, b):
|
|
return ZeroQ(A - S(2)*C*(a/b)**(S(2)/3))
|
|
|
|
cons885 = CustomConstraint(cons_f885)
|
|
|
|
def cons_f886(A, B, C, a, b):
|
|
return ZeroQ(A - B*Rt(a/b, S(3)) - S(2)*C*Rt(a/b, S(3))**S(2))
|
|
|
|
cons886 = CustomConstraint(cons_f886)
|
|
|
|
def cons_f887(B, C, a, b):
|
|
return ZeroQ(B*Rt(a/b, S(3)) + S(2)*C*Rt(a/b, S(3))**S(2))
|
|
|
|
cons887 = CustomConstraint(cons_f887)
|
|
|
|
def cons_f888(A, C, a, b):
|
|
return ZeroQ(A - S(2)*C*Rt(a/b, S(3))**S(2))
|
|
|
|
cons888 = CustomConstraint(cons_f888)
|
|
|
|
def cons_f889(A, B, C, a, b):
|
|
return ZeroQ(A + B*(-a/b)**(S(1)/3) - S(2)*C*(-a/b)**(S(2)/3))
|
|
|
|
cons889 = CustomConstraint(cons_f889)
|
|
|
|
def cons_f890(B, C, a, b):
|
|
return ZeroQ(B*(-a/b)**(S(1)/3) - S(2)*C*(-a/b)**(S(2)/3))
|
|
|
|
cons890 = CustomConstraint(cons_f890)
|
|
|
|
def cons_f891(A, C, a, b):
|
|
return ZeroQ(A - S(2)*C*(-a/b)**(S(2)/3))
|
|
|
|
cons891 = CustomConstraint(cons_f891)
|
|
|
|
def cons_f892(A, B, C, a, b):
|
|
return ZeroQ(A + B*Rt(-a/b, S(3)) - S(2)*C*Rt(-a/b, S(3))**S(2))
|
|
|
|
cons892 = CustomConstraint(cons_f892)
|
|
|
|
def cons_f893(B, C, a, b):
|
|
return ZeroQ(B*Rt(-a/b, S(3)) - S(2)*C*Rt(-a/b, S(3))**S(2))
|
|
|
|
cons893 = CustomConstraint(cons_f893)
|
|
|
|
def cons_f894(A, C, a, b):
|
|
return ZeroQ(A - S(2)*C*Rt(-a/b, S(3))**S(2))
|
|
|
|
cons894 = CustomConstraint(cons_f894)
|
|
|
|
def cons_f895(A, B, a, b):
|
|
return Or(ZeroQ(-A**S(3)*b + B**S(3)*a), Not(RationalQ(a/b)))
|
|
|
|
cons895 = CustomConstraint(cons_f895)
|
|
|
|
def cons_f896(a, b):
|
|
return Not(RationalQ(a/b))
|
|
|
|
cons896 = CustomConstraint(cons_f896)
|
|
|
|
def cons_f897(A, C, a, b):
|
|
return Not(RationalQ(a, b, A, C))
|
|
|
|
cons897 = CustomConstraint(cons_f897)
|
|
|
|
def cons_f898(A, B, C, a, b):
|
|
return ZeroQ(A - B*(a/b)**(S(1)/3) + C*(a/b)**(S(2)/3))
|
|
|
|
cons898 = CustomConstraint(cons_f898)
|
|
|
|
def cons_f899(B, C, a, b):
|
|
return ZeroQ(B*(a/b)**(S(1)/3) - C*(a/b)**(S(2)/3))
|
|
|
|
cons899 = CustomConstraint(cons_f899)
|
|
|
|
def cons_f900(A, C, a, b):
|
|
return ZeroQ(A + C*(a/b)**(S(2)/3))
|
|
|
|
cons900 = CustomConstraint(cons_f900)
|
|
|
|
def cons_f901(A, B, C, a, b):
|
|
return ZeroQ(A + B*(-a/b)**(S(1)/3) + C*(-a/b)**(S(2)/3))
|
|
|
|
cons901 = CustomConstraint(cons_f901)
|
|
|
|
def cons_f902(B, C, a, b):
|
|
return ZeroQ(B*(-a/b)**(S(1)/3) + C*(-a/b)**(S(2)/3))
|
|
|
|
cons902 = CustomConstraint(cons_f902)
|
|
|
|
def cons_f903(A, C, a, b):
|
|
return ZeroQ(A + C*(-a/b)**(S(2)/3))
|
|
|
|
cons903 = CustomConstraint(cons_f903)
|
|
|
|
def cons_f904(a, b):
|
|
return RationalQ(a/b)
|
|
|
|
cons904 = CustomConstraint(cons_f904)
|
|
|
|
def cons_f905(a, b):
|
|
return Greater(a/b, S(0))
|
|
|
|
cons905 = CustomConstraint(cons_f905)
|
|
|
|
def cons_f906(a, b):
|
|
return Less(a/b, S(0))
|
|
|
|
cons906 = CustomConstraint(cons_f906)
|
|
|
|
def cons_f907(Pq, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Less(Expon(Pq, x), n)
|
|
|
|
cons907 = CustomConstraint(cons_f907)
|
|
|
|
def cons_f908(a, b, c, d):
|
|
return ZeroQ(c*Rt(b/a, S(3)) - d*(S(1) - sqrt(S(3))))
|
|
|
|
cons908 = CustomConstraint(cons_f908)
|
|
|
|
def cons_f909(a, b, c, d):
|
|
return NonzeroQ(c*Rt(b/a, S(3)) - d*(S(1) - sqrt(S(3))))
|
|
|
|
cons909 = CustomConstraint(cons_f909)
|
|
|
|
def cons_f910(a, b, c, d):
|
|
return ZeroQ(c*Rt(b/a, S(3)) - d*(S(1) + sqrt(S(3))))
|
|
|
|
cons910 = CustomConstraint(cons_f910)
|
|
|
|
def cons_f911(a, b, c, d):
|
|
return NonzeroQ(c*Rt(b/a, S(3)) - d*(S(1) + sqrt(S(3))))
|
|
|
|
cons911 = CustomConstraint(cons_f911)
|
|
|
|
def cons_f912(a, b, c, d):
|
|
return ZeroQ(S(2)*c*Rt(b/a, S(3))**S(2) - d*(S(1) - sqrt(S(3))))
|
|
|
|
cons912 = CustomConstraint(cons_f912)
|
|
|
|
def cons_f913(a, b, c, d):
|
|
return NonzeroQ(S(2)*c*Rt(b/a, S(3))**S(2) - d*(S(1) - sqrt(S(3))))
|
|
|
|
cons913 = CustomConstraint(cons_f913)
|
|
|
|
def cons_f914(a, b, c, d):
|
|
return ZeroQ(-a*d**S(4) + b*c**S(4))
|
|
|
|
cons914 = CustomConstraint(cons_f914)
|
|
|
|
def cons_f915(a, b, c, d):
|
|
return NonzeroQ(-a*d**S(4) + b*c**S(4))
|
|
|
|
cons915 = CustomConstraint(cons_f915)
|
|
|
|
def cons_f916(Pq, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return NonzeroQ(Coeff(Pq, x, S(0)))
|
|
|
|
cons916 = CustomConstraint(cons_f916)
|
|
|
|
def cons_f917(Pq, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(PolyQ(Pq, x**(n/S(2))))
|
|
|
|
cons917 = CustomConstraint(cons_f917)
|
|
|
|
def cons_f918(Pq, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Equal(Expon(Pq, x), n + S(-1))
|
|
|
|
cons918 = CustomConstraint(cons_f918)
|
|
|
|
def cons_f919(Pq, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return LessEqual(n + S(-1), Expon(Pq, x))
|
|
|
|
cons919 = CustomConstraint(cons_f919)
|
|
|
|
def cons_f920(Pq, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(PolyQ(Pq, x), PolyQ(Pq, x**n))
|
|
|
|
cons920 = CustomConstraint(cons_f920)
|
|
|
|
def cons_f921(Pq, n, v):
|
|
return PolyQ(Pq, v**n)
|
|
|
|
cons921 = CustomConstraint(cons_f921)
|
|
|
|
def cons_f922(a, b, c, d, e, f, n, p):
|
|
return ZeroQ(a*c*f - e*(a*d + b*c)*(n*(p + S(1)) + S(1)))
|
|
|
|
cons922 = CustomConstraint(cons_f922)
|
|
|
|
def cons_f923(a, b, c, d, e, g, n, p):
|
|
return ZeroQ(a*c*g - b*d*e*(S(2)*n*(p + S(1)) + S(1)))
|
|
|
|
cons923 = CustomConstraint(cons_f923)
|
|
|
|
def cons_f924(n, p):
|
|
return ZeroQ(n*(p + S(1)) + S(1))
|
|
|
|
cons924 = CustomConstraint(cons_f924)
|
|
|
|
def cons_f925(a, b, c, d, e, f, m, n, p):
|
|
return ZeroQ(a*c*f*(m + S(1)) - e*(a*d + b*c)*(m + n*(p + S(1)) + S(1)))
|
|
|
|
cons925 = CustomConstraint(cons_f925)
|
|
|
|
def cons_f926(a, b, c, d, e, g, m, n, p):
|
|
return ZeroQ(a*c*g*(m + S(1)) - b*d*e*(m + S(2)*n*(p + S(1)) + S(1)))
|
|
|
|
cons926 = CustomConstraint(cons_f926)
|
|
|
|
def cons_f927(Px, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolynomialQ(Px, x)
|
|
|
|
cons927 = CustomConstraint(cons_f927)
|
|
|
|
def cons_f928(a, b, d, e, n, p):
|
|
return ZeroQ(a*e - b*d*(n*(p + S(1)) + S(1)))
|
|
|
|
cons928 = CustomConstraint(cons_f928)
|
|
|
|
def cons_f929(a, c, d, f, n, p):
|
|
return ZeroQ(a*f - c*d*(S(2)*n*(p + S(1)) + S(1)))
|
|
|
|
cons929 = CustomConstraint(cons_f929)
|
|
|
|
def cons_f930(a, c, d, f):
|
|
return ZeroQ(a*f + c*d)
|
|
|
|
cons930 = CustomConstraint(cons_f930)
|
|
|
|
def cons_f931(a, b, d, e, m, n, p):
|
|
return ZeroQ(a*e*(m + S(1)) - b*d*(m + n*(p + S(1)) + S(1)))
|
|
|
|
cons931 = CustomConstraint(cons_f931)
|
|
|
|
def cons_f932(a, c, d, f, m, n, p):
|
|
return ZeroQ(a*f*(m + S(1)) - c*d*(m + S(2)*n*(p + S(1)) + S(1)))
|
|
|
|
cons932 = CustomConstraint(cons_f932)
|
|
|
|
def cons_f933(n, n3):
|
|
return ZeroQ(-S(3)*n + n3)
|
|
|
|
cons933 = CustomConstraint(cons_f933)
|
|
|
|
def cons_f934(a, b, c, d, e, g, n, p):
|
|
return ZeroQ(a**S(2)*g*(n + S(1)) - c*(a*e - b*d*(n*(p + S(1)) + S(1)))*(n*(S(2)*p + S(3)) + S(1)))
|
|
|
|
cons934 = CustomConstraint(cons_f934)
|
|
|
|
def cons_f935(a, b, c, d, e, f, n, p):
|
|
return ZeroQ(a**S(2)*f*(n + S(1)) - a*c*d*(n + S(1))*(S(2)*n*(p + S(1)) + S(1)) - b*(a*e - b*d*(n*(p + S(1)) + S(1)))*(n*(p + S(2)) + S(1)))
|
|
|
|
cons935 = CustomConstraint(cons_f935)
|
|
|
|
def cons_f936(a, b, c, d, g, n, p):
|
|
return ZeroQ(a**S(2)*g*(n + S(1)) + b*c*d*(n*(p + S(1)) + S(1))*(n*(S(2)*p + S(3)) + S(1)))
|
|
|
|
cons936 = CustomConstraint(cons_f936)
|
|
|
|
def cons_f937(a, b, c, d, f, n, p):
|
|
return ZeroQ(a**S(2)*f*(n + S(1)) - a*c*d*(n + S(1))*(S(2)*n*(p + S(1)) + S(1)) + b**S(2)*d*(n*(p + S(1)) + S(1))*(n*(p + S(2)) + S(1)))
|
|
|
|
cons937 = CustomConstraint(cons_f937)
|
|
|
|
def cons_f938(a, b, c, d, e, n, p):
|
|
return ZeroQ(a*c*d*(n + S(1))*(S(2)*n*(p + S(1)) + S(1)) + b*(a*e - b*d*(n*(p + S(1)) + S(1)))*(n*(p + S(2)) + S(1)))
|
|
|
|
cons938 = CustomConstraint(cons_f938)
|
|
|
|
def cons_f939(a, b, c, d, n, p):
|
|
return ZeroQ(a*c*d*(n + S(1))*(S(2)*n*(p + S(1)) + S(1)) - b**S(2)*d*(n*(p + S(1)) + S(1))*(n*(p + S(2)) + S(1)))
|
|
|
|
cons939 = CustomConstraint(cons_f939)
|
|
|
|
def cons_f940(n, q):
|
|
return ZeroQ(-n/S(2) + q)
|
|
|
|
cons940 = CustomConstraint(cons_f940)
|
|
|
|
def cons_f941(n, r):
|
|
return ZeroQ(-S(3)*n/S(2) + r)
|
|
|
|
cons941 = CustomConstraint(cons_f941)
|
|
|
|
def cons_f942(n, s):
|
|
return ZeroQ(-S(2)*n + s)
|
|
|
|
cons942 = CustomConstraint(cons_f942)
|
|
|
|
def cons_f943(m, n):
|
|
return ZeroQ(S(2)*m - n + S(2))
|
|
|
|
cons943 = CustomConstraint(cons_f943)
|
|
|
|
def cons_f944(a, c, d, g):
|
|
return ZeroQ(a*g + c*d)
|
|
|
|
cons944 = CustomConstraint(cons_f944)
|
|
|
|
def cons_f945(a, c, e, h):
|
|
return ZeroQ(-S(3)*a*h + c*e)
|
|
|
|
cons945 = CustomConstraint(cons_f945)
|
|
|
|
def cons_f946(b, c, g, h):
|
|
return ZeroQ(-S(2)*b*h + c*g)
|
|
|
|
cons946 = CustomConstraint(cons_f946)
|
|
|
|
def cons_f947(a, b, c, d, e, g):
|
|
return ZeroQ(S(3)*a*g - S(2)*b*e + S(3)*c*d)
|
|
|
|
cons947 = CustomConstraint(cons_f947)
|
|
|
|
def cons_f948(b, c, d, e):
|
|
return ZeroQ(-S(2)*b*e + S(3)*c*d)
|
|
|
|
cons948 = CustomConstraint(cons_f948)
|
|
|
|
def cons_f949(Pq, a, b, c, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(NiceSqrtQ(-S(4)*a*c + b**S(2)), Less(Expon(Pq, x), n))
|
|
|
|
cons949 = CustomConstraint(cons_f949)
|
|
|
|
def cons_f950(c):
|
|
return PosQ(c)
|
|
|
|
cons950 = CustomConstraint(cons_f950)
|
|
|
|
def cons_f951(c):
|
|
return NegQ(c)
|
|
|
|
cons951 = CustomConstraint(cons_f951)
|
|
|
|
def cons_f952(Pq, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(PolyQ(Pq, x**n))
|
|
|
|
cons952 = CustomConstraint(cons_f952)
|
|
|
|
def cons_f953(m):
|
|
return NegativeIntegerQ(m + S(-1)/2)
|
|
|
|
cons953 = CustomConstraint(cons_f953)
|
|
|
|
def cons_f954(j, n):
|
|
return NonzeroQ(-j + n)
|
|
|
|
cons954 = CustomConstraint(cons_f954)
|
|
|
|
def cons_f955(j, n, p):
|
|
return ZeroQ(j*p + j - n + S(1))
|
|
|
|
cons955 = CustomConstraint(cons_f955)
|
|
|
|
def cons_f956(j, n, p):
|
|
return NegativeIntegerQ((j - n*p - n + S(-1))/(j - n))
|
|
|
|
cons956 = CustomConstraint(cons_f956)
|
|
|
|
def cons_f957(j, p):
|
|
return NonzeroQ(j*p + S(1))
|
|
|
|
cons957 = CustomConstraint(cons_f957)
|
|
|
|
def cons_f958(j, n, p):
|
|
return RationalQ(j, n, p)
|
|
|
|
cons958 = CustomConstraint(cons_f958)
|
|
|
|
def cons_f959(j, n):
|
|
return Less(S(0), j, n)
|
|
|
|
cons959 = CustomConstraint(cons_f959)
|
|
|
|
def cons_f960(j, p):
|
|
return Less(j*p + S(1), S(0))
|
|
|
|
cons960 = CustomConstraint(cons_f960)
|
|
|
|
def cons_f961(n, p):
|
|
return NonzeroQ(n*p + S(1))
|
|
|
|
cons961 = CustomConstraint(cons_f961)
|
|
|
|
def cons_f962(j, n, p):
|
|
return Greater(j*p + S(1), -j + n)
|
|
|
|
cons962 = CustomConstraint(cons_f962)
|
|
|
|
def cons_f963(p):
|
|
return PositiveIntegerQ(p + S(1)/2)
|
|
|
|
cons963 = CustomConstraint(cons_f963)
|
|
|
|
def cons_f964(j, p):
|
|
return ZeroQ(j*p + S(1))
|
|
|
|
cons964 = CustomConstraint(cons_f964)
|
|
|
|
def cons_f965(n):
|
|
return NonzeroQ(n + S(-2))
|
|
|
|
cons965 = CustomConstraint(cons_f965)
|
|
|
|
def cons_f966(j, n):
|
|
return RationalQ(j, n)
|
|
|
|
cons966 = CustomConstraint(cons_f966)
|
|
|
|
def cons_f967(j, n):
|
|
return Less(S(2)*n + S(-2), j, n)
|
|
|
|
cons967 = CustomConstraint(cons_f967)
|
|
|
|
def cons_f968(j, n):
|
|
return PosQ(-j + n)
|
|
|
|
cons968 = CustomConstraint(cons_f968)
|
|
|
|
def cons_f969(j, n):
|
|
return IntegerQ(j/n)
|
|
|
|
cons969 = CustomConstraint(cons_f969)
|
|
|
|
def cons_f970(j, m, n, p):
|
|
return ZeroQ(-j + m + n*p + n + S(1))
|
|
|
|
cons970 = CustomConstraint(cons_f970)
|
|
|
|
def cons_f971(c, j):
|
|
return Or(IntegerQ(j), PositiveQ(c))
|
|
|
|
cons971 = CustomConstraint(cons_f971)
|
|
|
|
def cons_f972(j, m, n, p):
|
|
return NegativeIntegerQ((j - m - n*p - n + S(-1))/(j - n))
|
|
|
|
cons972 = CustomConstraint(cons_f972)
|
|
|
|
def cons_f973(j, m, p):
|
|
return NonzeroQ(j*p + m + S(1))
|
|
|
|
cons973 = CustomConstraint(cons_f973)
|
|
|
|
def cons_f974(c, j, n):
|
|
return Or(IntegersQ(j, n), PositiveQ(c))
|
|
|
|
cons974 = CustomConstraint(cons_f974)
|
|
|
|
def cons_f975(n):
|
|
return NonzeroQ(n**S(2) + S(-1))
|
|
|
|
cons975 = CustomConstraint(cons_f975)
|
|
|
|
def cons_f976(j, m, n, p):
|
|
return RationalQ(j, m, n, p)
|
|
|
|
cons976 = CustomConstraint(cons_f976)
|
|
|
|
def cons_f977(j, m, p):
|
|
return Less(j*p + m + S(1), S(0))
|
|
|
|
cons977 = CustomConstraint(cons_f977)
|
|
|
|
def cons_f978(j, m, n, p):
|
|
return Greater(j*p + m + S(1), -j + n)
|
|
|
|
cons978 = CustomConstraint(cons_f978)
|
|
|
|
def cons_f979(j, m, n, p):
|
|
return PositiveQ(j*p + j + m - n + S(1))
|
|
|
|
cons979 = CustomConstraint(cons_f979)
|
|
|
|
def cons_f980(j, m, p):
|
|
return NegativeQ(j*p + m + S(1))
|
|
|
|
cons980 = CustomConstraint(cons_f980)
|
|
|
|
def cons_f981(j, m, p):
|
|
return ZeroQ(j*p + m + S(1))
|
|
|
|
cons981 = CustomConstraint(cons_f981)
|
|
|
|
def cons_f982(j, m):
|
|
return ZeroQ(-j/S(2) + m + S(1))
|
|
|
|
cons982 = CustomConstraint(cons_f982)
|
|
|
|
def cons_f983(j, k):
|
|
return NonzeroQ(-j + k)
|
|
|
|
cons983 = CustomConstraint(cons_f983)
|
|
|
|
def cons_f984(k, n):
|
|
return IntegerQ(k/n)
|
|
|
|
cons984 = CustomConstraint(cons_f984)
|
|
|
|
def cons_f985(jn, j, n):
|
|
return ZeroQ(jn - j - n)
|
|
|
|
cons985 = CustomConstraint(cons_f985)
|
|
|
|
def cons_f986(a, b, c, d, j, m, n, p):
|
|
return ZeroQ(a*d*(j*p + m + S(1)) - b*c*(m + n + p*(j + n) + S(1)))
|
|
|
|
cons986 = CustomConstraint(cons_f986)
|
|
|
|
def cons_f987(e, j):
|
|
return Or(PositiveQ(e), IntegersQ(j))
|
|
|
|
cons987 = CustomConstraint(cons_f987)
|
|
|
|
def cons_f988(j, m, p):
|
|
return RationalQ(j, m, p)
|
|
|
|
cons988 = CustomConstraint(cons_f988)
|
|
|
|
def cons_f989(j, m):
|
|
return Inequality(S(0), Less, j, LessEqual, m)
|
|
|
|
cons989 = CustomConstraint(cons_f989)
|
|
|
|
def cons_f990(e, j):
|
|
return Or(PositiveQ(e), IntegerQ(j))
|
|
|
|
cons990 = CustomConstraint(cons_f990)
|
|
|
|
def cons_f991(j, m, n, p):
|
|
return Or(Less(j*p + m, S(-1)), And(IntegersQ(m + S(-1)/2, p + S(-1)/2), Less(p, S(0)), Less(m, -n*p + S(-1))))
|
|
|
|
cons991 = CustomConstraint(cons_f991)
|
|
|
|
def cons_f992(e, j, n):
|
|
return Or(PositiveQ(e), IntegersQ(j, n))
|
|
|
|
cons992 = CustomConstraint(cons_f992)
|
|
|
|
def cons_f993(j, m, n, p):
|
|
return NonzeroQ(j*p + m - n + S(1))
|
|
|
|
cons993 = CustomConstraint(cons_f993)
|
|
|
|
def cons_f994(j, m, n, p):
|
|
return NonzeroQ(m + n + p*(j + n) + S(1))
|
|
|
|
cons994 = CustomConstraint(cons_f994)
|
|
|
|
def cons_f995(j, n):
|
|
return Not(And(ZeroQ(n + S(-1)), ZeroQ(j + S(-1))))
|
|
|
|
cons995 = CustomConstraint(cons_f995)
|
|
|
|
def cons_f996(n):
|
|
return Less(S(-1), n, S(1))
|
|
|
|
cons996 = CustomConstraint(cons_f996)
|
|
|
|
def cons_f997(m):
|
|
return Greater(m**S(2), S(1))
|
|
|
|
cons997 = CustomConstraint(cons_f997)
|
|
|
|
def cons_f998(j, n):
|
|
return PositiveIntegerQ(j, n, j/n)
|
|
|
|
cons998 = CustomConstraint(cons_f998)
|
|
|
|
def cons_f999(j, n):
|
|
return PositiveIntegerQ(j, n)
|
|
|
|
cons999 = CustomConstraint(cons_f999)
|
|
|
|
def cons_f1000(j, n):
|
|
return Less(j, n)
|
|
|
|
cons1000 = CustomConstraint(cons_f1000)
|
|
|
|
def cons_f1001(a, b, d):
|
|
return ZeroQ(S(27)*a**S(2)*d + S(4)*b**S(3))
|
|
|
|
cons1001 = CustomConstraint(cons_f1001)
|
|
|
|
def cons_f1002(a, b, d):
|
|
return NonzeroQ(S(27)*a**S(2)*d + S(4)*b**S(3))
|
|
|
|
cons1002 = CustomConstraint(cons_f1002)
|
|
|
|
def cons_f1003(a, c, d):
|
|
return ZeroQ(S(27)*a*d**S(2) + S(4)*c**S(3))
|
|
|
|
cons1003 = CustomConstraint(cons_f1003)
|
|
|
|
def cons_f1004(a, c, d):
|
|
return NonzeroQ(S(27)*a*d**S(2) + S(4)*c**S(3))
|
|
|
|
cons1004 = CustomConstraint(cons_f1004)
|
|
|
|
def cons_f1005(b, c, d):
|
|
return ZeroQ(-S(3)*b*d + c**S(2))
|
|
|
|
cons1005 = CustomConstraint(cons_f1005)
|
|
|
|
def cons_f1006(a, b, c):
|
|
return ZeroQ(-S(3)*a*c + b**S(2))
|
|
|
|
cons1006 = CustomConstraint(cons_f1006)
|
|
|
|
def cons_f1007(a, b, c):
|
|
return NonzeroQ(-S(3)*a*c + b**S(2))
|
|
|
|
cons1007 = CustomConstraint(cons_f1007)
|
|
|
|
def cons_f1008(b, c, d):
|
|
return NonzeroQ(-S(3)*b*d + c**S(2))
|
|
|
|
cons1008 = CustomConstraint(cons_f1008)
|
|
|
|
def cons_f1009(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolyQ(u, x, S(3))
|
|
|
|
cons1009 = CustomConstraint(cons_f1009)
|
|
|
|
def cons_f1010(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(CubicMatchQ(u, x))
|
|
|
|
cons1010 = CustomConstraint(cons_f1010)
|
|
|
|
def cons_f1011(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolyQ(v, x, S(3))
|
|
|
|
cons1011 = CustomConstraint(cons_f1011)
|
|
|
|
def cons_f1012(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(LinearMatchQ(u, x), CubicMatchQ(v, x)))
|
|
|
|
cons1012 = CustomConstraint(cons_f1012)
|
|
|
|
def cons_f1013(f, g):
|
|
return ZeroQ(f + g)
|
|
|
|
cons1013 = CustomConstraint(cons_f1013)
|
|
|
|
def cons_f1014(a, c):
|
|
return PosQ(a**S(2)*(S(2)*a - c))
|
|
|
|
cons1014 = CustomConstraint(cons_f1014)
|
|
|
|
def cons_f1015(a, c):
|
|
return NegQ(a**S(2)*(S(2)*a - c))
|
|
|
|
cons1015 = CustomConstraint(cons_f1015)
|
|
|
|
def cons_f1016(b, c, d, e):
|
|
return ZeroQ(S(8)*b*e**S(2) - S(4)*c*d*e + d**S(3))
|
|
|
|
cons1016 = CustomConstraint(cons_f1016)
|
|
|
|
def cons_f1017(p):
|
|
return UnsameQ(p, S(2))
|
|
|
|
cons1017 = CustomConstraint(cons_f1017)
|
|
|
|
def cons_f1018(p):
|
|
return UnsameQ(p, S(3))
|
|
|
|
cons1018 = CustomConstraint(cons_f1018)
|
|
|
|
def cons_f1019(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolynomialQ(v, x)
|
|
|
|
cons1019 = CustomConstraint(cons_f1019)
|
|
|
|
def cons_f1020(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Equal(Exponent(v, x), S(4))
|
|
|
|
cons1020 = CustomConstraint(cons_f1020)
|
|
|
|
def cons_f1021(a, b, c, d):
|
|
return ZeroQ(S(8)*a**S(2)*d - S(4)*a*b*c + b**S(3))
|
|
|
|
cons1021 = CustomConstraint(cons_f1021)
|
|
|
|
def cons_f1022(b, d):
|
|
return ZeroQ(-b + d)
|
|
|
|
cons1022 = CustomConstraint(cons_f1022)
|
|
|
|
def cons_f1023(a, e):
|
|
return ZeroQ(-a + e)
|
|
|
|
cons1023 = CustomConstraint(cons_f1023)
|
|
|
|
def cons_f1024(a, b, c, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return SumQ(Factor(a*x**S(4) + a + b*x**S(3) + b*x + c*x**S(2)))
|
|
|
|
cons1024 = CustomConstraint(cons_f1024)
|
|
|
|
def cons_f1025(D, x):
|
|
return FreeQ(D, x)
|
|
|
|
cons1025 = CustomConstraint(cons_f1025)
|
|
|
|
def cons_f1026(A, B, C, b, c, d, e):
|
|
return ZeroQ(B**S(2)*d - S(2)*B*(S(2)*A*e + C*c) + S(2)*C*(A*d + C*b))
|
|
|
|
cons1026 = CustomConstraint(cons_f1026)
|
|
|
|
def cons_f1027(A, B, C, a, c, d, e):
|
|
return ZeroQ(-S(4)*A*B*C*d + S(4)*A*e*(S(2)*A*C + B**S(2)) - B**S(3)*d + S(2)*B**S(2)*C*c - S(8)*C**S(3)*a)
|
|
|
|
cons1027 = CustomConstraint(cons_f1027)
|
|
|
|
def cons_f1028(A, B, C, c, d, e):
|
|
return PosQ(C*(C*(-S(4)*c*e + d**S(2)) + S(2)*e*(-S(4)*A*e + B*d)))
|
|
|
|
cons1028 = CustomConstraint(cons_f1028)
|
|
|
|
def cons_f1029(A, C, b, d):
|
|
return ZeroQ(A*d + C*b)
|
|
|
|
cons1029 = CustomConstraint(cons_f1029)
|
|
|
|
def cons_f1030(A, C, a, e):
|
|
return ZeroQ(-A**S(2)*e + C**S(2)*a)
|
|
|
|
cons1030 = CustomConstraint(cons_f1030)
|
|
|
|
def cons_f1031(A, C, c, d, e):
|
|
return PosQ(C*(-S(8)*A*e**S(2) + C*(-S(4)*c*e + d**S(2))))
|
|
|
|
cons1031 = CustomConstraint(cons_f1031)
|
|
|
|
def cons_f1032(A, B, C, c, d, e):
|
|
return NegQ(C*(C*(-S(4)*c*e + d**S(2)) + S(2)*e*(-S(4)*A*e + B*d)))
|
|
|
|
cons1032 = CustomConstraint(cons_f1032)
|
|
|
|
def cons_f1033(A, C, c, d, e):
|
|
return NegQ(C*(-S(8)*A*e**S(2) + C*(-S(4)*c*e + d**S(2))))
|
|
|
|
cons1033 = CustomConstraint(cons_f1033)
|
|
|
|
def cons_f1034(A, B, C, D, b, c, d, e):
|
|
return ZeroQ(S(4)*d*(-S(2)*B*e + D*c)**S(2) - S(4)*(-S(2)*B*e + D*c)*(-S(8)*A*e**S(2) - S(4)*C*c*e + S(2)*D*b*e + S(3)*D*c*d) + S(8)*(-S(4)*C*e + S(3)*D*d)*(-A*d*e - C*b*e + D*b*d))
|
|
|
|
cons1034 = CustomConstraint(cons_f1034)
|
|
|
|
def cons_f1035(A, B, C, D, a, b, c, d, e):
|
|
return ZeroQ(S(8)*a*(-S(4)*C*e + S(3)*D*d)**S(3) - S(8)*c*(-S(2)*B*e + D*c)**S(2)*(-S(4)*C*e + S(3)*D*d) + S(8)*d*(-S(4)*A*e + D*b)*(-S(2)*B*e + D*c)*(-S(4)*C*e + S(3)*D*d) + S(8)*d*(-S(2)*B*e + D*c)**S(3) - S(4)*e*(-S(4)*A*e + D*b)*(S(2)*(-S(4)*A*e + D*b)*(-S(4)*C*e + S(3)*D*d) + S(4)*(-S(2)*B*e + D*c)**S(2)))
|
|
|
|
cons1035 = CustomConstraint(cons_f1035)
|
|
|
|
def cons_f1036(A, D, b, c, d, e):
|
|
return ZeroQ(D**S(2)*c**S(2)*d - D*c*(-S(8)*A*e**S(2) - S(4)*C*c*e + S(2)*D*b*e + S(3)*D*c*d) + S(2)*(-S(4)*C*e + S(3)*D*d)*(-A*d*e - C*b*e + D*b*d))
|
|
|
|
cons1036 = CustomConstraint(cons_f1036)
|
|
|
|
def cons_f1037(A, B, D, a, b, c, d, e):
|
|
return ZeroQ(S(54)*D**S(3)*a*d**S(3) - S(6)*D*c*d*(-S(2)*B*e + D*c)**S(2) + S(6)*D*d**S(2)*(-S(4)*A*e + D*b)*(-S(2)*B*e + D*c) + S(2)*d*(-S(2)*B*e + D*c)**S(3) - e*(-S(4)*A*e + D*b)*(S(6)*D*d*(-S(4)*A*e + D*b) + S(4)*(-S(2)*B*e + D*c)**S(2)))
|
|
|
|
cons1037 = CustomConstraint(cons_f1037)
|
|
|
|
def cons_f1038(a, c, e, f):
|
|
return ZeroQ(a*e**S(2) - c*f**S(2))
|
|
|
|
cons1038 = CustomConstraint(cons_f1038)
|
|
|
|
def cons_f1039(b, d, e, f):
|
|
return ZeroQ(b*e**S(2) - d*f**S(2))
|
|
|
|
cons1039 = CustomConstraint(cons_f1039)
|
|
|
|
def cons_f1040(a, c, e, f):
|
|
return NonzeroQ(a*e**S(2) - c*f**S(2))
|
|
|
|
cons1040 = CustomConstraint(cons_f1040)
|
|
|
|
def cons_f1041(b, d, e, f):
|
|
return NonzeroQ(b*e**S(2) - d*f**S(2))
|
|
|
|
cons1041 = CustomConstraint(cons_f1041)
|
|
|
|
def cons_f1042(n, p):
|
|
return ZeroQ(-S(2)*n + p)
|
|
|
|
cons1042 = CustomConstraint(cons_f1042)
|
|
|
|
def cons_f1043(b, c, d):
|
|
return ZeroQ(b*c**S(2) - d**S(2))
|
|
|
|
cons1043 = CustomConstraint(cons_f1043)
|
|
|
|
def cons_f1044(b, c, d):
|
|
return NonzeroQ(b*c**S(2) - d**S(2))
|
|
|
|
cons1044 = CustomConstraint(cons_f1044)
|
|
|
|
def cons_f1045(a, b, c, d, e, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e), x)
|
|
|
|
cons1045 = CustomConstraint(cons_f1045)
|
|
|
|
def cons_f1046(a, b, c, d, e):
|
|
return NonzeroQ(a*e**S(4) + b*d**S(2)*e**S(2) + c*d**S(4))
|
|
|
|
cons1046 = CustomConstraint(cons_f1046)
|
|
|
|
def cons_f1047(b, c, d, e):
|
|
return ZeroQ(b*d*e**S(2) + S(2)*c*d**S(3))
|
|
|
|
cons1047 = CustomConstraint(cons_f1047)
|
|
|
|
def cons_f1048(b, c, d, e):
|
|
return NonzeroQ(b*d*e**S(2) + S(2)*c*d**S(3))
|
|
|
|
cons1048 = CustomConstraint(cons_f1048)
|
|
|
|
def cons_f1049(a, c, d, e):
|
|
return NonzeroQ(a*e**S(4) + c*d**S(4))
|
|
|
|
cons1049 = CustomConstraint(cons_f1049)
|
|
|
|
def cons_f1050(A, B, d, e):
|
|
return ZeroQ(A*e + B*d)
|
|
|
|
cons1050 = CustomConstraint(cons_f1050)
|
|
|
|
def cons_f1051(A, B, a, c):
|
|
return ZeroQ(A*c + B*a)
|
|
|
|
cons1051 = CustomConstraint(cons_f1051)
|
|
|
|
def cons_f1052(a, c, d, e):
|
|
return ZeroQ(a*e + c*d)
|
|
|
|
cons1052 = CustomConstraint(cons_f1052)
|
|
|
|
def cons_f1053(a, b, c, d, e, f, g, h):
|
|
return ZeroQ(-f**S(2)*(a*h**S(2) - b*g*h + c*g**S(2)) + (-d*h + e*g)**S(2))
|
|
|
|
cons1053 = CustomConstraint(cons_f1053)
|
|
|
|
def cons_f1054(b, c, d, e, f, g, h):
|
|
return ZeroQ(-S(2)*d*e*h + S(2)*e**S(2)*g - f**S(2)*(-b*h + S(2)*c*g))
|
|
|
|
cons1054 = CustomConstraint(cons_f1054)
|
|
|
|
def cons_f1055(f, j, u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(LinearMatchQ(u, x), QuadraticMatchQ(v, x), Or(ZeroQ(j), ZeroQ(f + S(-1)))))
|
|
|
|
cons1055 = CustomConstraint(cons_f1055)
|
|
|
|
def cons_f1056(f, g, h, j, k, u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(-f**S(2)*k**S(2)*(g**S(2)*Coefficient(v, x, S(2)) - g*h*Coefficient(v, x, S(1)) + h**S(2)*Coefficient(v, x, S(0))) + (g*Coefficient(u, x, S(1)) - h*(f*j + Coefficient(u, x, S(0))))**S(2))
|
|
|
|
cons1056 = CustomConstraint(cons_f1056)
|
|
|
|
def cons_f1057(c, e, f):
|
|
return ZeroQ(-c*f**S(2) + e**S(2))
|
|
|
|
cons1057 = CustomConstraint(cons_f1057)
|
|
|
|
def cons_f1058(f, u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(-f**S(2)*Coefficient(v, x, S(2)) + Coefficient(u, x, S(1))**S(2))
|
|
|
|
cons1058 = CustomConstraint(cons_f1058)
|
|
|
|
def cons_f1059(a, c, g, i):
|
|
return ZeroQ(-a*i + c*g)
|
|
|
|
cons1059 = CustomConstraint(cons_f1059)
|
|
|
|
def cons_f1060(m, p):
|
|
return IntegersQ(p, S(2)*m)
|
|
|
|
cons1060 = CustomConstraint(cons_f1060)
|
|
|
|
def cons_f1061(c, i, m):
|
|
return Or(IntegerQ(m), PositiveQ(i/c))
|
|
|
|
cons1061 = CustomConstraint(cons_f1061)
|
|
|
|
def cons_f1062(b, c, h, i):
|
|
return ZeroQ(-b*i + c*h)
|
|
|
|
cons1062 = CustomConstraint(cons_f1062)
|
|
|
|
def cons_f1063(c, i):
|
|
return Not(PositiveQ(i/c))
|
|
|
|
cons1063 = CustomConstraint(cons_f1063)
|
|
|
|
def cons_f1064(v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return QuadraticQ(List(v, w), x)
|
|
|
|
cons1064 = CustomConstraint(cons_f1064)
|
|
|
|
def cons_f1065(f, j, u, v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(LinearMatchQ(u, x), QuadraticMatchQ(List(v, w), x), Or(ZeroQ(j), ZeroQ(f + S(-1)))))
|
|
|
|
cons1065 = CustomConstraint(cons_f1065)
|
|
|
|
def cons_f1066(f, k, u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(-f**S(2)*k**S(2)*Coefficient(v, x, S(2)) + Coefficient(u, x, S(1))**S(2))
|
|
|
|
cons1066 = CustomConstraint(cons_f1066)
|
|
|
|
def cons_f1067(n, p):
|
|
return ZeroQ(p - S(2)/n)
|
|
|
|
cons1067 = CustomConstraint(cons_f1067)
|
|
|
|
def cons_f1068(a, b, c):
|
|
return ZeroQ(a**S(2) - b**S(2)*c)
|
|
|
|
cons1068 = CustomConstraint(cons_f1068)
|
|
|
|
def cons_f1069(a, b, d):
|
|
return ZeroQ(a**S(2) - b**S(2)*d)
|
|
|
|
cons1069 = CustomConstraint(cons_f1069)
|
|
|
|
def cons_f1070(a, b, c):
|
|
return ZeroQ(a + b**S(2)*c)
|
|
|
|
cons1070 = CustomConstraint(cons_f1070)
|
|
|
|
def cons_f1071(a, b, c, e):
|
|
return ZeroQ(a + b**S(2)*c*e)
|
|
|
|
cons1071 = CustomConstraint(cons_f1071)
|
|
|
|
def cons_f1072(b, c, d):
|
|
return ZeroQ(-b*d**S(2) + c**S(2))
|
|
|
|
cons1072 = CustomConstraint(cons_f1072)
|
|
|
|
def cons_f1073(b, e):
|
|
return ZeroQ(-b**S(2) + e)
|
|
|
|
cons1073 = CustomConstraint(cons_f1073)
|
|
|
|
def cons_f1074(a, b, c, d):
|
|
return ZeroQ(-a*d + b*c, S(0))
|
|
|
|
cons1074 = CustomConstraint(cons_f1074)
|
|
|
|
def cons_f1075(A, B, a, d, n):
|
|
return ZeroQ(-A**S(2)*d*(n + S(-1))**S(2) + B**S(2)*a)
|
|
|
|
cons1075 = CustomConstraint(cons_f1075)
|
|
|
|
def cons_f1076(A, B, c, d, n):
|
|
return ZeroQ(S(2)*A*d*(n + S(-1)) + B*c)
|
|
|
|
cons1076 = CustomConstraint(cons_f1076)
|
|
|
|
def cons_f1077(k, m):
|
|
return ZeroQ(k - S(2)*m + S(-2))
|
|
|
|
cons1077 = CustomConstraint(cons_f1077)
|
|
|
|
def cons_f1078(A, B, a, d, m, n):
|
|
return ZeroQ(-A**S(2)*d*(m - n + S(1))**S(2) + B**S(2)*a*(m + S(1))**S(2))
|
|
|
|
cons1078 = CustomConstraint(cons_f1078)
|
|
|
|
def cons_f1079(A, B, c, d, m, n):
|
|
return ZeroQ(-S(2)*A*d*(m - n + S(1)) + B*c*(m + S(1)))
|
|
|
|
cons1079 = CustomConstraint(cons_f1079)
|
|
|
|
def cons_f1080(a, b, c, d, f, g):
|
|
return ZeroQ(-S(12)*a**S(3)*g**S(2) + a**S(2)*c*f**S(2) + S(2)*a*b*g*(a*f + S(3)*c*d) + S(9)*c**S(3)*d**S(2) - c*d*f*(S(6)*a*c + b**S(2)))
|
|
|
|
cons1080 = CustomConstraint(cons_f1080)
|
|
|
|
def cons_f1081(a, b, c, d, e, f, g):
|
|
return ZeroQ(a**S(3)*c*f**S(2)*g + S(2)*a**S(3)*g**S(2)*(-S(6)*a*g + b*f) - S(3)*a**S(2)*c**S(2)*d*f*g + S(3)*c**S(4)*d**S(2)*e - c**S(3)*d*(-S(12)*a*d*g + a*e*f + S(2)*b*d*f))
|
|
|
|
cons1081 = CustomConstraint(cons_f1081)
|
|
|
|
def cons_f1082(a, c, d, f):
|
|
return NonzeroQ(-a*f + S(3)*c*d)
|
|
|
|
cons1082 = CustomConstraint(cons_f1082)
|
|
|
|
def cons_f1083(a, b, c, d, g):
|
|
return NonzeroQ(-S(2)*a**S(2)*g + b*c*d)
|
|
|
|
cons1083 = CustomConstraint(cons_f1083)
|
|
|
|
def cons_f1084(a, b, c, d, f, g):
|
|
return NonzeroQ(S(4)*a**S(2)*g - a*b*f + b*c*d)
|
|
|
|
cons1084 = CustomConstraint(cons_f1084)
|
|
|
|
def cons_f1085(a, b, c, d, f, g):
|
|
return PosQ((S(12)*a**S(2)*g**S(2) - a*c*f**S(2) + f*(-S(2)*a*b*g + S(3)*c**S(2)*d))/(c*g*(-a*f + S(3)*c*d)))
|
|
|
|
cons1085 = CustomConstraint(cons_f1085)
|
|
|
|
def cons_f1086(a, c, d, f, g):
|
|
return ZeroQ(-S(12)*a**S(3)*g**S(2) + a**S(2)*c*f**S(2) - S(6)*a*c**S(2)*d*f + S(9)*c**S(3)*d**S(2))
|
|
|
|
cons1086 = CustomConstraint(cons_f1086)
|
|
|
|
def cons_f1087(a, c, d, e, f, g):
|
|
return ZeroQ(-S(12)*a**S(4)*g**S(3) + a**S(3)*c*f**S(2)*g - S(3)*a**S(2)*c**S(2)*d*f*g - a*c**S(3)*d*(-S(12)*d*g + e*f) + S(3)*c**S(4)*d**S(2)*e)
|
|
|
|
cons1087 = CustomConstraint(cons_f1087)
|
|
|
|
def cons_f1088(a, c, d, f, g):
|
|
return PosQ((S(12)*a**S(2)*g**S(2) - a*c*f**S(2) + S(3)*c**S(2)*d*f)/(c*g*(-a*f + S(3)*c*d)))
|
|
|
|
cons1088 = CustomConstraint(cons_f1088)
|
|
|
|
def cons_f1089(v):
|
|
return SumQ(v)
|
|
|
|
cons1089 = CustomConstraint(cons_f1089)
|
|
|
|
def cons_f1090(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(MonomialQ(u, x), BinomialQ(v, x)))
|
|
|
|
cons1090 = CustomConstraint(cons_f1090)
|
|
|
|
def cons_f1091(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(ZeroQ(Coefficient(u, x, S(0))), ZeroQ(Coefficient(v, x, S(0)))))
|
|
|
|
cons1091 = CustomConstraint(cons_f1091)
|
|
|
|
def cons_f1092(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PiecewiseLinearQ(u, x)
|
|
|
|
cons1092 = CustomConstraint(cons_f1092)
|
|
|
|
def cons_f1093(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PiecewiseLinearQ(u, v, x)
|
|
|
|
cons1093 = CustomConstraint(cons_f1093)
|
|
|
|
def cons_f1094(n):
|
|
return Unequal(n, S(1))
|
|
|
|
cons1094 = CustomConstraint(cons_f1094)
|
|
|
|
def cons_f1095(m, n):
|
|
return Or(And(RationalQ(m, n), Less(m, S(-1)), Greater(n, S(0)), Not(And(IntegerQ(m + n), Less(m + n + S(2), S(0)), Or(FractionQ(m), GreaterEqual(m + S(2)*n + S(1), S(0)))))), And(PositiveIntegerQ(n, m), LessEqual(n, m)), And(PositiveIntegerQ(n), Not(IntegerQ(m))), And(NegativeIntegerQ(m), Not(IntegerQ(n))))
|
|
|
|
cons1095 = CustomConstraint(cons_f1095)
|
|
|
|
def cons_f1096(n):
|
|
return Not(RationalQ(n))
|
|
|
|
cons1096 = CustomConstraint(cons_f1096)
|
|
|
|
def cons_f1097(n):
|
|
return SumSimplerQ(n, S(-1))
|
|
|
|
cons1097 = CustomConstraint(cons_f1097)
|
|
|
|
def cons_f1098(m):
|
|
return SumSimplerQ(m, S(1))
|
|
|
|
cons1098 = CustomConstraint(cons_f1098)
|
|
|
|
def cons_f1099(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(LinearQ(u, x))
|
|
|
|
cons1099 = CustomConstraint(cons_f1099)
|
|
|
|
def cons_f1100():
|
|
return Not(SameQ(_UseGamma, True))
|
|
|
|
cons1100 = CustomConstraint(cons_f1100)
|
|
|
|
def cons_f1101(F, x):
|
|
return FreeQ(F, x)
|
|
|
|
cons1101 = CustomConstraint(cons_f1101)
|
|
|
|
def cons_f1102(F, b, c, d, e, f, g, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, b, c, d, e, f, g, m, n), x)
|
|
|
|
cons1102 = CustomConstraint(cons_f1102)
|
|
|
|
def cons_f1103(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PowerOfLinearQ(u, x)
|
|
|
|
cons1103 = CustomConstraint(cons_f1103)
|
|
|
|
def cons_f1104(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(LinearMatchQ(v, x), PowerOfLinearMatchQ(u, x)))
|
|
|
|
cons1104 = CustomConstraint(cons_f1104)
|
|
|
|
def cons_f1105(F, a, b, c, d, e, f, g, m, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, a, b, c, d, e, f, g, m, n, p), x)
|
|
|
|
cons1105 = CustomConstraint(cons_f1105)
|
|
|
|
def cons_f1106(F, G, f, g, i, j, n, q):
|
|
return ZeroQ(f*g*n*log(F) - i*j*q*log(G))
|
|
|
|
cons1106 = CustomConstraint(cons_f1106)
|
|
|
|
def cons_f1107(F, G, e, f, g, h, i, j, k, n, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return NonzeroQ((G**(j*(h + i*x))*k)**q - (F**(g*(e + f*x)))**n)
|
|
|
|
cons1107 = CustomConstraint(cons_f1107)
|
|
|
|
def cons_f1108(F, a, b, c, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, a, b, c, n), x)
|
|
|
|
cons1108 = CustomConstraint(cons_f1108)
|
|
|
|
def cons_f1109():
|
|
return SameQ(_UseGamma, True)
|
|
|
|
cons1109 = CustomConstraint(cons_f1109)
|
|
|
|
def cons_f1110(F, c, m, u, v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(-c*(-Coefficient(u, x, S(0))*Coefficient(w, x, S(1)) + Coefficient(u, x, S(1))*Coefficient(w, x, S(0)))*Coefficient(v, x, S(1))*log(F) + (m + S(1))*Coefficient(u, x, S(1))*Coefficient(w, x, S(1)))
|
|
|
|
cons1110 = CustomConstraint(cons_f1110)
|
|
|
|
def cons_f1111(w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolynomialQ(w, x)
|
|
|
|
cons1111 = CustomConstraint(cons_f1111)
|
|
|
|
def cons_f1112(e, f, h, n):
|
|
return ZeroQ(e - f*h*(n + S(1)))
|
|
|
|
cons1112 = CustomConstraint(cons_f1112)
|
|
|
|
def cons_f1113(F, b, c, e, g, h, n):
|
|
return ZeroQ(-b*c*e*log(F) + g*h*(n + S(1)))
|
|
|
|
cons1113 = CustomConstraint(cons_f1113)
|
|
|
|
def cons_f1114(e, f, h, m, n):
|
|
return ZeroQ(e*(m + S(1)) - f*h*(n + S(1)))
|
|
|
|
cons1114 = CustomConstraint(cons_f1114)
|
|
|
|
def cons_f1115(F, a, b, c, d, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, a, b, c, d), x)
|
|
|
|
cons1115 = CustomConstraint(cons_f1115)
|
|
|
|
def cons_f1116(n):
|
|
return IntegerQ(S(2)/n)
|
|
|
|
cons1116 = CustomConstraint(cons_f1116)
|
|
|
|
def cons_f1117(n):
|
|
return Not(IntegerQ(S(2)/n))
|
|
|
|
cons1117 = CustomConstraint(cons_f1117)
|
|
|
|
def cons_f1118(c, d, e, f):
|
|
return ZeroQ(-c*f + d*e)
|
|
|
|
cons1118 = CustomConstraint(cons_f1118)
|
|
|
|
def cons_f1119(m, n):
|
|
return ZeroQ(-S(2)*m + n + S(-2))
|
|
|
|
cons1119 = CustomConstraint(cons_f1119)
|
|
|
|
def cons_f1120(m, n):
|
|
return IntegerQ(S(2)*(m + S(1))/n)
|
|
|
|
cons1120 = CustomConstraint(cons_f1120)
|
|
|
|
def cons_f1121(m, n):
|
|
return Less(S(0), (m + S(1))/n, S(5))
|
|
|
|
cons1121 = CustomConstraint(cons_f1121)
|
|
|
|
def cons_f1122(m, n):
|
|
return Or(Less(S(0), n, m + S(1)), Less(m, n, S(0)))
|
|
|
|
cons1122 = CustomConstraint(cons_f1122)
|
|
|
|
def cons_f1123(m, n):
|
|
return Less(S(-4), (m + S(1))/n, S(5))
|
|
|
|
cons1123 = CustomConstraint(cons_f1123)
|
|
|
|
def cons_f1124(m, n):
|
|
return Or(And(Greater(n, S(0)), Less(m, S(-1))), Inequality(S(0), Less, -n, LessEqual, m + S(1)))
|
|
|
|
cons1124 = CustomConstraint(cons_f1124)
|
|
|
|
def cons_f1125(d, f):
|
|
return NonzeroQ(-d + f)
|
|
|
|
cons1125 = CustomConstraint(cons_f1125)
|
|
|
|
def cons_f1126(c, e):
|
|
return NonzeroQ(c*e)
|
|
|
|
cons1126 = CustomConstraint(cons_f1126)
|
|
|
|
def cons_f1127(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(LinearMatchQ(u, x), BinomialMatchQ(v, x)))
|
|
|
|
cons1127 = CustomConstraint(cons_f1127)
|
|
|
|
def cons_f1128(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PowerOfLinearQ(v, x)
|
|
|
|
cons1128 = CustomConstraint(cons_f1128)
|
|
|
|
def cons_f1129(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(PowerOfLinearMatchQ(v, x))
|
|
|
|
cons1129 = CustomConstraint(cons_f1129)
|
|
|
|
def cons_f1130(c, d, g, h):
|
|
return ZeroQ(-c*h + d*g)
|
|
|
|
cons1130 = CustomConstraint(cons_f1130)
|
|
|
|
def cons_f1131(c, d, g, h):
|
|
return NonzeroQ(-c*h + d*g)
|
|
|
|
cons1131 = CustomConstraint(cons_f1131)
|
|
|
|
def cons_f1132(F, a, b, c, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, a, b, c), x)
|
|
|
|
cons1132 = CustomConstraint(cons_f1132)
|
|
|
|
def cons_f1133(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(QuadraticMatchQ(v, x))
|
|
|
|
cons1133 = CustomConstraint(cons_f1133)
|
|
|
|
def cons_f1134(b, c, d, e):
|
|
return ZeroQ(b*e - S(2)*c*d)
|
|
|
|
cons1134 = CustomConstraint(cons_f1134)
|
|
|
|
def cons_f1135(b, c, d, e):
|
|
return NonzeroQ(b*e - S(2)*c*d)
|
|
|
|
cons1135 = CustomConstraint(cons_f1135)
|
|
|
|
def cons_f1136(F, a, b, c, d, e, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, a, b, c, d, e, m), x)
|
|
|
|
cons1136 = CustomConstraint(cons_f1136)
|
|
|
|
def cons_f1137(c, d, e, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(S(2)*e*(c + d*x) - v)
|
|
|
|
cons1137 = CustomConstraint(cons_f1137)
|
|
|
|
def cons_f1138(F, G, a, b, c, d, e, f, g, h, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, G, a, b, c, d, e, f, g, h, n), x)
|
|
|
|
cons1138 = CustomConstraint(cons_f1138)
|
|
|
|
def cons_f1139(G, x):
|
|
return FreeQ(G, x)
|
|
|
|
cons1139 = CustomConstraint(cons_f1139)
|
|
|
|
def cons_f1140(F, G, d, e, g, h):
|
|
return Not(RationalQ(FullSimplify(g*h*log(G)/(d*e*log(F)))))
|
|
|
|
cons1140 = CustomConstraint(cons_f1140)
|
|
|
|
def cons_f1141(F, G, H, a, b, c, d, e, f, g, h, n, r, s, t, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, G, H, a, b, c, d, e, f, g, h, r, s, t, n), x)
|
|
|
|
cons1141 = CustomConstraint(cons_f1141)
|
|
|
|
def cons_f1142(H, x):
|
|
return FreeQ(H, x)
|
|
|
|
cons1142 = CustomConstraint(cons_f1142)
|
|
|
|
def cons_f1143(t, x):
|
|
return FreeQ(t, x)
|
|
|
|
cons1143 = CustomConstraint(cons_f1143)
|
|
|
|
def cons_f1144(F, G, d, e, g, h, n):
|
|
return ZeroQ(d*e*n*log(F) + g*h*log(G))
|
|
|
|
cons1144 = CustomConstraint(cons_f1144)
|
|
|
|
def cons_f1145(F, G, H, d, e, g, h, s, t):
|
|
return Not(RationalQ(FullSimplify((g*h*log(G) + s*t*log(H))/(d*e*log(F)))))
|
|
|
|
cons1145 = CustomConstraint(cons_f1145)
|
|
|
|
def cons_f1146(u, v):
|
|
return ZeroQ(-S(2)*u + v)
|
|
|
|
cons1146 = CustomConstraint(cons_f1146)
|
|
|
|
def cons_f1147(c, d, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(c + d*x + v)
|
|
|
|
cons1147 = CustomConstraint(cons_f1147)
|
|
|
|
def cons_f1148(w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return LinearQ(w, x)
|
|
|
|
cons1148 = CustomConstraint(cons_f1148)
|
|
|
|
def cons_f1149(v, w):
|
|
return ZeroQ(v + w)
|
|
|
|
cons1149 = CustomConstraint(cons_f1149)
|
|
|
|
def cons_f1150(v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return If(RationalQ(Coefficient(v, x, S(1))), Greater(Coefficient(v, x, S(1)), S(0)), Less(LeafCount(v), LeafCount(w)))
|
|
|
|
cons1150 = CustomConstraint(cons_f1150)
|
|
|
|
def cons_f1151(F, a, b, c, d, e, g, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, a, b, c, d, e, g, n), x)
|
|
|
|
cons1151 = CustomConstraint(cons_f1151)
|
|
|
|
def cons_f1152(F, a, c, d, e, g, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, a, c, d, e, g, n), x)
|
|
|
|
cons1152 = CustomConstraint(cons_f1152)
|
|
|
|
def cons_f1153(F, a, b, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, a, b), x)
|
|
|
|
cons1153 = CustomConstraint(cons_f1153)
|
|
|
|
def cons_f1154(n):
|
|
return Unequal(n, S(-1))
|
|
|
|
cons1154 = CustomConstraint(cons_f1154)
|
|
|
|
def cons_f1155(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FunctionOfExponentialQ(u, x)
|
|
|
|
cons1155 = CustomConstraint(cons_f1155)
|
|
|
|
def cons_f1156(v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return LinearQ(List(v, w), x)
|
|
|
|
cons1156 = CustomConstraint(cons_f1156)
|
|
|
|
def cons_f1157(v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(BinomialQ(v + w, x), And(PolynomialQ(v + w, x), LessEqual(Exponent(v + w, x), S(2))))
|
|
|
|
cons1157 = CustomConstraint(cons_f1157)
|
|
|
|
def cons_f1158(c, d, e, f, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(c, d, e, f, p, q), x)
|
|
|
|
cons1158 = CustomConstraint(cons_f1158)
|
|
|
|
def cons_f1159(d, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(d, e, f), x)
|
|
|
|
cons1159 = CustomConstraint(cons_f1159)
|
|
|
|
def cons_f1160(b, p, q):
|
|
return PosQ(b*p*q)
|
|
|
|
cons1160 = CustomConstraint(cons_f1160)
|
|
|
|
def cons_f1161(b, p, q):
|
|
return NegQ(b*p*q)
|
|
|
|
cons1161 = CustomConstraint(cons_f1161)
|
|
|
|
def cons_f1162(e, f, g, h):
|
|
return ZeroQ(-e*h + f*g)
|
|
|
|
cons1162 = CustomConstraint(cons_f1162)
|
|
|
|
def cons_f1163(m, p):
|
|
return ZeroQ(m - p + S(1))
|
|
|
|
cons1163 = CustomConstraint(cons_f1163)
|
|
|
|
def cons_f1164(f, h, p):
|
|
return Or(IntegerQ(p), PositiveQ(h/f))
|
|
|
|
cons1164 = CustomConstraint(cons_f1164)
|
|
|
|
def cons_f1165(f, h, p):
|
|
return Not(Or(IntegerQ(p), PositiveQ(h/f)))
|
|
|
|
cons1165 = CustomConstraint(cons_f1165)
|
|
|
|
def cons_f1166(b, m, p, q):
|
|
return PosQ((m + S(1))/(b*p*q))
|
|
|
|
cons1166 = CustomConstraint(cons_f1166)
|
|
|
|
def cons_f1167(b, m, p, q):
|
|
return NegQ((m + S(1))/(b*p*q))
|
|
|
|
cons1167 = CustomConstraint(cons_f1167)
|
|
|
|
def cons_f1168(c, e, f, g, h):
|
|
return ZeroQ(c*(-e*h + f*g) + h)
|
|
|
|
cons1168 = CustomConstraint(cons_f1168)
|
|
|
|
def cons_f1169(c, e, f, g, h):
|
|
return NonzeroQ(c*(-e*h + f*g) + h)
|
|
|
|
cons1169 = CustomConstraint(cons_f1169)
|
|
|
|
def cons_f1170(c, e, f, g, h):
|
|
return PositiveQ(c*(e - f*g/h))
|
|
|
|
cons1170 = CustomConstraint(cons_f1170)
|
|
|
|
def cons_f1171(e, f, g, h):
|
|
return NonzeroQ(-e*h + f*g)
|
|
|
|
cons1171 = CustomConstraint(cons_f1171)
|
|
|
|
def cons_f1172(m, n):
|
|
return IntegersQ(S(2)*m, S(2)*n)
|
|
|
|
cons1172 = CustomConstraint(cons_f1172)
|
|
|
|
def cons_f1173(m, n):
|
|
return Or(Equal(n, S(1)), Not(PositiveIntegerQ(m)), And(Equal(n, S(2)), NonzeroQ(m + S(-1))))
|
|
|
|
cons1173 = CustomConstraint(cons_f1173)
|
|
|
|
def cons_f1174(c, e, f, i, j):
|
|
return ZeroQ(f*i + j*(c - e))
|
|
|
|
cons1174 = CustomConstraint(cons_f1174)
|
|
|
|
def cons_f1175(m, n):
|
|
return Or(IntegerQ(n), Greater(m, S(0)))
|
|
|
|
cons1175 = CustomConstraint(cons_f1175)
|
|
|
|
def cons_f1176(a, b, c, d, e, f, g, h, i, j, m, n, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, h, i, j, m, n, p, q), x)
|
|
|
|
cons1176 = CustomConstraint(cons_f1176)
|
|
|
|
def cons_f1177(e, f, g, h):
|
|
return ZeroQ(e**S(2)*h + f**S(2)*g)
|
|
|
|
cons1177 = CustomConstraint(cons_f1177)
|
|
|
|
def cons_f1178(c, e):
|
|
return ZeroQ(c - S(2)*e)
|
|
|
|
cons1178 = CustomConstraint(cons_f1178)
|
|
|
|
def cons_f1179(c, e):
|
|
return PositiveQ(c/(S(2)*e))
|
|
|
|
cons1179 = CustomConstraint(cons_f1179)
|
|
|
|
def cons_f1180(a, c, e):
|
|
return Or(NonzeroQ(c - S(2)*e), NonzeroQ(a))
|
|
|
|
cons1180 = CustomConstraint(cons_f1180)
|
|
|
|
def cons_f1181(e, f, g, h, i):
|
|
return ZeroQ(e**S(2)*i - e*f*h + f**S(2)*g)
|
|
|
|
cons1181 = CustomConstraint(cons_f1181)
|
|
|
|
def cons_f1182(e, f, g, i):
|
|
return ZeroQ(e**S(2)*i + f**S(2)*g)
|
|
|
|
cons1182 = CustomConstraint(cons_f1182)
|
|
|
|
def cons_f1183(g):
|
|
return PositiveQ(g)
|
|
|
|
cons1183 = CustomConstraint(cons_f1183)
|
|
|
|
def cons_f1184(g1, g2, h1, h2):
|
|
return ZeroQ(g1*h2 + g2*h1)
|
|
|
|
cons1184 = CustomConstraint(cons_f1184)
|
|
|
|
def cons_f1185(g1):
|
|
return PositiveQ(g1)
|
|
|
|
cons1185 = CustomConstraint(cons_f1185)
|
|
|
|
def cons_f1186(g2):
|
|
return PositiveQ(g2)
|
|
|
|
cons1186 = CustomConstraint(cons_f1186)
|
|
|
|
def cons_f1187(g1, x):
|
|
return FreeQ(g1, x)
|
|
|
|
cons1187 = CustomConstraint(cons_f1187)
|
|
|
|
def cons_f1188(h1, x):
|
|
return FreeQ(h1, x)
|
|
|
|
cons1188 = CustomConstraint(cons_f1188)
|
|
|
|
def cons_f1189(g2, x):
|
|
return FreeQ(g2, x)
|
|
|
|
cons1189 = CustomConstraint(cons_f1189)
|
|
|
|
def cons_f1190(h2, x):
|
|
return FreeQ(h2, x)
|
|
|
|
cons1190 = CustomConstraint(cons_f1190)
|
|
|
|
def cons_f1191(g):
|
|
return Not(PositiveQ(g))
|
|
|
|
cons1191 = CustomConstraint(cons_f1191)
|
|
|
|
def cons_f1192(g, h, i, j, k):
|
|
return ZeroQ(h - i*(-g*k + h*j))
|
|
|
|
cons1192 = CustomConstraint(cons_f1192)
|
|
|
|
def cons_f1193(g, h, j, k):
|
|
return ZeroQ(-g*k + h*j)
|
|
|
|
cons1193 = CustomConstraint(cons_f1193)
|
|
|
|
def cons_f1194(F):
|
|
return MemberQ(List(Log, ArcSin, ArcCos, ArcTan, ArcCot, ArcSinh, ArcCosh, ArcTanh, ArcCoth), F)
|
|
|
|
cons1194 = CustomConstraint(cons_f1194)
|
|
|
|
def cons_f1195(m, r):
|
|
return ZeroQ(m + r)
|
|
|
|
cons1195 = CustomConstraint(cons_f1195)
|
|
|
|
def cons_f1196(r, r1):
|
|
return ZeroQ(-r + r1 + S(1))
|
|
|
|
cons1196 = CustomConstraint(cons_f1196)
|
|
|
|
def cons_f1197(a, b, c, d, e, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, n), x)
|
|
|
|
cons1197 = CustomConstraint(cons_f1197)
|
|
|
|
def cons_f1198(mn, n):
|
|
return ZeroQ(mn + n)
|
|
|
|
cons1198 = CustomConstraint(cons_f1198)
|
|
|
|
def cons_f1199(a, b, c, d, e):
|
|
return ZeroQ(-a*c*d + b*c*e + d)
|
|
|
|
cons1199 = CustomConstraint(cons_f1199)
|
|
|
|
def cons_f1200(RFx, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return RationalFunctionQ(RFx, x)
|
|
|
|
cons1200 = CustomConstraint(cons_f1200)
|
|
|
|
def cons_f1201(e, f, g):
|
|
return ZeroQ(-S(4)*e*g + f**S(2))
|
|
|
|
cons1201 = CustomConstraint(cons_f1201)
|
|
|
|
def cons_f1202(c, d, p, q, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1201(cc, dd, e, f, pp, qq):
|
|
return FreeQ(List(cc, dd, e, f, pp, qq), x)
|
|
_cons_1201 = CustomConstraint(_cons_f_1201)
|
|
pat = Pattern(UtilityOperator(((x*WC('f', S(1)) + WC('e', S(0)))**WC('pp', S(1))*WC('dd', S(1)))**WC('qq', S(1))*WC('cc', S(1)), x), _cons_1201)
|
|
result_matchq = is_match(UtilityOperator(c*(d*v**p)**q, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1202 = CustomConstraint(cons_f1202)
|
|
|
|
def cons_f1203(a, b, c, n, p, q, r, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, n, p, q, r), x)
|
|
|
|
cons1203 = CustomConstraint(cons_f1203)
|
|
|
|
def cons_f1204(a, b, c, n, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(SameQ(x**(n*p*q), a*(b*(c*x**n)**p)**q))
|
|
|
|
cons1204 = CustomConstraint(cons_f1204)
|
|
|
|
def cons_f1205(n1, n2):
|
|
return ZeroQ(n1 + n2)
|
|
|
|
cons1205 = CustomConstraint(cons_f1205)
|
|
|
|
def cons_f1206(n1, x):
|
|
return FreeQ(n1, x)
|
|
|
|
cons1206 = CustomConstraint(cons_f1206)
|
|
|
|
def cons_f1207(c, d, f, g):
|
|
return ZeroQ(-c*g + d*f)
|
|
|
|
cons1207 = CustomConstraint(cons_f1207)
|
|
|
|
def cons_f1208(b, d, e):
|
|
return ZeroQ(-b*e + d)
|
|
|
|
cons1208 = CustomConstraint(cons_f1208)
|
|
|
|
def cons_f1209(a, b, f, g):
|
|
return ZeroQ(-a*g + b*f)
|
|
|
|
cons1209 = CustomConstraint(cons_f1209)
|
|
|
|
def cons_f1210(c, d, f, g):
|
|
return NonzeroQ(-c*g + d*f)
|
|
|
|
cons1210 = CustomConstraint(cons_f1210)
|
|
|
|
def cons_f1211(a, b, f, g):
|
|
return NonzeroQ(-a*g + b*f)
|
|
|
|
cons1211 = CustomConstraint(cons_f1211)
|
|
|
|
def cons_f1212(m, m2):
|
|
return ZeroQ(m + m2 + S(2))
|
|
|
|
cons1212 = CustomConstraint(cons_f1212)
|
|
|
|
def cons_f1213(a, b, c, d, u, x):
|
|
return FreeQ(simplify(Mul(u, Add(c, Mul(d, x)), Pow(Add(a, Mul(b, x)), S(-1)))), x)
|
|
|
|
cons1213 = CustomConstraint(cons_f1213)
|
|
|
|
def cons_f1214(a, b, c, d, e, f, g):
|
|
return ZeroQ(-c*g + d*f - e*(-a*g + b*f))
|
|
|
|
cons1214 = CustomConstraint(cons_f1214)
|
|
|
|
def cons_f1215(c, d, f, g):
|
|
return ZeroQ(c**S(2)*g + d**S(2)*f)
|
|
|
|
cons1215 = CustomConstraint(cons_f1215)
|
|
|
|
def cons_f1216(a, b, c, d, e):
|
|
return ZeroQ(-a*d*e - b*c*e + S(2)*c*d)
|
|
|
|
cons1216 = CustomConstraint(cons_f1216)
|
|
|
|
def cons_f1217(c, d, f, g, h):
|
|
return ZeroQ(c**S(2)*h - c*d*g + d**S(2)*f)
|
|
|
|
cons1217 = CustomConstraint(cons_f1217)
|
|
|
|
def cons_f1218(c, d, f, h):
|
|
return ZeroQ(c**S(2)*h + d**S(2)*f)
|
|
|
|
cons1218 = CustomConstraint(cons_f1218)
|
|
|
|
def cons_f1219(u, v):
|
|
return FreeQ(simplify(Mul(u, Pow(Add(S(1), Mul(S(-1), v)), S(-1)))), x)
|
|
|
|
cons1219 = CustomConstraint(cons_f1219)
|
|
|
|
def cons_f1220(u, v):
|
|
return FreeQ(simplify(Mul(u, Add(S(1), Mul(S(-1), v)))), x)
|
|
|
|
cons1220 = CustomConstraint(cons_f1220)
|
|
|
|
def cons_f1221(u, v):
|
|
return FreeQ(simplify(Mul(u, Pow(v, S(-1)))), x)
|
|
|
|
cons1221 = CustomConstraint(cons_f1221)
|
|
|
|
def cons_f1222(u, v):
|
|
return FreeQ(simplify(Mul(u, v)), x)
|
|
|
|
cons1222 = CustomConstraint(cons_f1222)
|
|
|
|
def cons_f1223(a, b, c, d, f, h):
|
|
return ZeroQ(-a*c*h + b*d*f)
|
|
|
|
cons1223 = CustomConstraint(cons_f1223)
|
|
|
|
def cons_f1224(a, b, c, d, g, h):
|
|
return ZeroQ(-a*d*h - b*c*h + b*d*g)
|
|
|
|
cons1224 = CustomConstraint(cons_f1224)
|
|
|
|
def cons_f1225(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return QuotientOfLinearsQ(v, x)
|
|
|
|
cons1225 = CustomConstraint(cons_f1225)
|
|
|
|
def cons_f1226(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(QuotientOfLinearsMatchQ(v, x))
|
|
|
|
cons1226 = CustomConstraint(cons_f1226)
|
|
|
|
def cons_f1227(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(BinomialMatchQ(v, x))
|
|
|
|
cons1227 = CustomConstraint(cons_f1227)
|
|
|
|
def cons_f1228(a, b, c, d, e, f, g, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, n, p), x)
|
|
|
|
cons1228 = CustomConstraint(cons_f1228)
|
|
|
|
def cons_f1229(a, b, c, d, e, f, g, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g, p), x)
|
|
|
|
cons1229 = CustomConstraint(cons_f1229)
|
|
|
|
def cons_f1230(m):
|
|
return IntegerQ(m/S(2) + S(-1)/2)
|
|
|
|
cons1230 = CustomConstraint(cons_f1230)
|
|
|
|
def cons_f1231(m):
|
|
return Not(IntegerQ(m/S(2) + S(-1)/2))
|
|
|
|
cons1231 = CustomConstraint(cons_f1231)
|
|
|
|
def cons_f1232(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return InverseFunctionFreeQ(u, x)
|
|
|
|
cons1232 = CustomConstraint(cons_f1232)
|
|
|
|
def cons_f1233(n):
|
|
return Not(And(RationalQ(n), Less(n, S(0))))
|
|
|
|
cons1233 = CustomConstraint(cons_f1233)
|
|
|
|
def cons_f1234(m, n):
|
|
return Or(Equal(n, S(1)), IntegerQ(m))
|
|
|
|
cons1234 = CustomConstraint(cons_f1234)
|
|
|
|
def cons_f1235(RFx, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(PolynomialQ(RFx, x))
|
|
|
|
cons1235 = CustomConstraint(cons_f1235)
|
|
|
|
def cons_f1236(Px, Qx, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return QuadraticQ(List(Qx, Px), x)
|
|
|
|
cons1236 = CustomConstraint(cons_f1236)
|
|
|
|
def cons_f1237(Px, Qx, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(D(Px/Qx, x))
|
|
|
|
cons1237 = CustomConstraint(cons_f1237)
|
|
|
|
def cons_f1238(RGx, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return RationalFunctionQ(RGx, x)
|
|
|
|
cons1238 = CustomConstraint(cons_f1238)
|
|
|
|
def cons_f1239(d):
|
|
return NonzeroQ(d + S(-1))
|
|
|
|
cons1239 = CustomConstraint(cons_f1239)
|
|
|
|
def cons_f1240(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1239(g, m):
|
|
return FreeQ(List(g, m), x)
|
|
_cons_1239 = CustomConstraint(_cons_f_1239)
|
|
pat = Pattern(UtilityOperator((x*WC('g', S(1)))**WC('m', S(1)), x), _cons_1239)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Or(ZeroQ(v + S(-1)), result_matchq)
|
|
|
|
cons1240 = CustomConstraint(cons_f1240)
|
|
|
|
def cons_f1241(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return RationalFunctionQ(D(u, x)/u, x)
|
|
|
|
cons1241 = CustomConstraint(cons_f1241)
|
|
|
|
def cons_f1242(a, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return Or(NonzeroQ(a), Not(And(BinomialQ(u, x), ZeroQ(BinomialDegree(u, x)**S(2) + S(-1)))))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons1242 = CustomConstraint(cons_f1242)
|
|
|
|
def cons_f1243(Qx, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return QuadraticQ(Qx, x)
|
|
|
|
cons1243 = CustomConstraint(cons_f1243)
|
|
|
|
def cons_f1244(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return InverseFunctionFreeQ(v, x)
|
|
|
|
cons1244 = CustomConstraint(cons_f1244)
|
|
|
|
def cons_f1245(w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return InverseFunctionFreeQ(w, x)
|
|
|
|
cons1245 = CustomConstraint(cons_f1245)
|
|
|
|
def cons_f1246(a, b, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, n, p), x)
|
|
|
|
cons1246 = CustomConstraint(cons_f1246)
|
|
|
|
def cons_f1247(A, B, a, b):
|
|
return NonzeroQ(A*b - B*a)
|
|
|
|
cons1247 = CustomConstraint(cons_f1247)
|
|
|
|
def cons_f1248(a, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, f), x)
|
|
|
|
cons1248 = CustomConstraint(cons_f1248)
|
|
|
|
def cons_f1249(u):
|
|
return NonsumQ(u)
|
|
|
|
cons1249 = CustomConstraint(cons_f1249)
|
|
|
|
def cons_f1250(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return AlgebraicFunctionQ(u, x)
|
|
|
|
cons1250 = CustomConstraint(cons_f1250)
|
|
|
|
def cons_f1251(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FunctionOfTrigOfLinearQ(u, x)
|
|
|
|
cons1251 = CustomConstraint(cons_f1251)
|
|
|
|
def cons_f1252(n):
|
|
return IntegerQ(n/S(2) + S(-1)/2)
|
|
|
|
cons1252 = CustomConstraint(cons_f1252)
|
|
|
|
def cons_f1253(m, n):
|
|
return Not(And(IntegerQ(m/S(2) + S(-1)/2), Less(S(0), m, n)))
|
|
|
|
cons1253 = CustomConstraint(cons_f1253)
|
|
|
|
def cons_f1254(m, n):
|
|
return Not(And(IntegerQ(m/S(2) + S(-1)/2), Inequality(S(0), Less, m, LessEqual, n)))
|
|
|
|
cons1254 = CustomConstraint(cons_f1254)
|
|
|
|
def cons_f1255(m, n):
|
|
return Or(IntegersQ(S(2)*m, S(2)*n), ZeroQ(m + n))
|
|
|
|
cons1255 = CustomConstraint(cons_f1255)
|
|
|
|
def cons_f1256(a, b, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, e, f), x)
|
|
|
|
cons1256 = CustomConstraint(cons_f1256)
|
|
|
|
def cons_f1257(m, n):
|
|
return ZeroQ(m + n)
|
|
|
|
cons1257 = CustomConstraint(cons_f1257)
|
|
|
|
def cons_f1258(m):
|
|
return Less(S(0), m, S(1))
|
|
|
|
cons1258 = CustomConstraint(cons_f1258)
|
|
|
|
def cons_f1259(a, b, m, n):
|
|
return Or(RationalQ(n), And(Not(RationalQ(m)), Or(ZeroQ(b + S(-1)), NonzeroQ(a + S(-1)))))
|
|
|
|
cons1259 = CustomConstraint(cons_f1259)
|
|
|
|
def cons_f1260(a, b, e, f, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, e, f, m, n), x)
|
|
|
|
cons1260 = CustomConstraint(cons_f1260)
|
|
|
|
def cons_f1261(m, n):
|
|
return ZeroQ(m - n + S(2))
|
|
|
|
cons1261 = CustomConstraint(cons_f1261)
|
|
|
|
def cons_f1262(m, n):
|
|
return NonzeroQ(m - n)
|
|
|
|
cons1262 = CustomConstraint(cons_f1262)
|
|
|
|
def cons_f1263(c, d, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(c, d), x)
|
|
|
|
cons1263 = CustomConstraint(cons_f1263)
|
|
|
|
def cons_f1264(c, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(c, c), x)
|
|
|
|
cons1264 = CustomConstraint(cons_f1264)
|
|
|
|
def cons_f1265(b, c, d, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(b, c, d), x)
|
|
|
|
cons1265 = CustomConstraint(cons_f1265)
|
|
|
|
def cons_f1266(a, b, c, d, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d), x)
|
|
|
|
cons1266 = CustomConstraint(cons_f1266)
|
|
|
|
def cons_f1267(a, b):
|
|
return ZeroQ(a**S(2) - b**S(2))
|
|
|
|
cons1267 = CustomConstraint(cons_f1267)
|
|
|
|
def cons_f1268(n):
|
|
return PositiveIntegerQ(n + S(-1)/2)
|
|
|
|
cons1268 = CustomConstraint(cons_f1268)
|
|
|
|
def cons_f1269(a, b):
|
|
return NonzeroQ(a**S(2) - b**S(2))
|
|
|
|
cons1269 = CustomConstraint(cons_f1269)
|
|
|
|
def cons_f1270(a, b):
|
|
return PositiveQ(a + b)
|
|
|
|
cons1270 = CustomConstraint(cons_f1270)
|
|
|
|
def cons_f1271(a, b):
|
|
return PositiveQ(a - b)
|
|
|
|
cons1271 = CustomConstraint(cons_f1271)
|
|
|
|
def cons_f1272(a, b):
|
|
return Not(PositiveQ(a + b))
|
|
|
|
cons1272 = CustomConstraint(cons_f1272)
|
|
|
|
def cons_f1273(a, b):
|
|
return PositiveQ(a**S(2) - b**S(2))
|
|
|
|
cons1273 = CustomConstraint(cons_f1273)
|
|
|
|
def cons_f1274(c):
|
|
return SimplerQ(-Pi/S(2) + c, c)
|
|
|
|
cons1274 = CustomConstraint(cons_f1274)
|
|
|
|
def cons_f1275(a, b, c, d, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, n), x)
|
|
|
|
cons1275 = CustomConstraint(cons_f1275)
|
|
|
|
def cons_f1276(p):
|
|
return IntegerQ(p/S(2) + S(-1)/2)
|
|
|
|
cons1276 = CustomConstraint(cons_f1276)
|
|
|
|
def cons_f1277(a, b, m, p):
|
|
return Or(GreaterEqual(p, S(-1)), Not(And(IntegerQ(m + S(1)/2), ZeroQ(a**S(2) - b**S(2)))))
|
|
|
|
cons1277 = CustomConstraint(cons_f1277)
|
|
|
|
def cons_f1278(a, b, p):
|
|
return Or(IntegerQ(S(2)*p), NonzeroQ(a**S(2) - b**S(2)))
|
|
|
|
cons1278 = CustomConstraint(cons_f1278)
|
|
|
|
def cons_f1279(m, p):
|
|
return GreaterEqual(S(2)*m + p, S(0))
|
|
|
|
cons1279 = CustomConstraint(cons_f1279)
|
|
|
|
def cons_f1280(m, p):
|
|
return ZeroQ(m + p + S(1))
|
|
|
|
cons1280 = CustomConstraint(cons_f1280)
|
|
|
|
def cons_f1281(p):
|
|
return Not(NegativeIntegerQ(p))
|
|
|
|
cons1281 = CustomConstraint(cons_f1281)
|
|
|
|
def cons_f1282(m, p):
|
|
return NegativeIntegerQ(m + p + S(1))
|
|
|
|
cons1282 = CustomConstraint(cons_f1282)
|
|
|
|
def cons_f1283(m, p):
|
|
return NonzeroQ(S(2)*m + p + S(1))
|
|
|
|
cons1283 = CustomConstraint(cons_f1283)
|
|
|
|
def cons_f1284(m, p):
|
|
return ZeroQ(S(2)*m + p + S(-1))
|
|
|
|
cons1284 = CustomConstraint(cons_f1284)
|
|
|
|
def cons_f1285(m):
|
|
return NonzeroQ(m + S(-1))
|
|
|
|
cons1285 = CustomConstraint(cons_f1285)
|
|
|
|
def cons_f1286(m, p):
|
|
return PositiveIntegerQ(m + p/S(2) + S(-1)/2)
|
|
|
|
cons1286 = CustomConstraint(cons_f1286)
|
|
|
|
def cons_f1287(m, p):
|
|
return NonzeroQ(m + p)
|
|
|
|
cons1287 = CustomConstraint(cons_f1287)
|
|
|
|
def cons_f1288(m, p):
|
|
return LessEqual(p, -S(2)*m)
|
|
|
|
cons1288 = CustomConstraint(cons_f1288)
|
|
|
|
def cons_f1289(m, p):
|
|
return IntegersQ(m + S(1)/2, S(2)*p)
|
|
|
|
cons1289 = CustomConstraint(cons_f1289)
|
|
|
|
def cons_f1290(m, p):
|
|
return IntegersQ(S(2)*m, S(2)*p)
|
|
|
|
cons1290 = CustomConstraint(cons_f1290)
|
|
|
|
def cons_f1291(m, p):
|
|
return Or(Greater(m, S(-2)), ZeroQ(S(2)*m + p + S(1)), And(Equal(m, S(-2)), IntegerQ(p)))
|
|
|
|
cons1291 = CustomConstraint(cons_f1291)
|
|
|
|
def cons_f1292(m):
|
|
return LessEqual(m, S(-2))
|
|
|
|
cons1292 = CustomConstraint(cons_f1292)
|
|
|
|
def cons_f1293(m, p):
|
|
return Not(NegativeIntegerQ(m + p + S(1)))
|
|
|
|
cons1293 = CustomConstraint(cons_f1293)
|
|
|
|
def cons_f1294(p):
|
|
return Not(And(RationalQ(p), GreaterEqual(p, S(1))))
|
|
|
|
cons1294 = CustomConstraint(cons_f1294)
|
|
|
|
def cons_f1295(p):
|
|
return Greater(p, S(2))
|
|
|
|
cons1295 = CustomConstraint(cons_f1295)
|
|
|
|
def cons_f1296(m, p):
|
|
return Or(IntegersQ(S(2)*m, S(2)*p), IntegerQ(m))
|
|
|
|
cons1296 = CustomConstraint(cons_f1296)
|
|
|
|
def cons_f1297(m, p):
|
|
return ZeroQ(m + p + S(2))
|
|
|
|
cons1297 = CustomConstraint(cons_f1297)
|
|
|
|
def cons_f1298(m, p):
|
|
return NegativeIntegerQ(m + p + S(2))
|
|
|
|
cons1298 = CustomConstraint(cons_f1298)
|
|
|
|
def cons_f1299(m, p):
|
|
return Not(PositiveIntegerQ(m + p + S(1)))
|
|
|
|
cons1299 = CustomConstraint(cons_f1299)
|
|
|
|
def cons_f1300(p):
|
|
return IntegerQ(p/S(2) + S(1)/2)
|
|
|
|
cons1300 = CustomConstraint(cons_f1300)
|
|
|
|
def cons_f1301(m, p):
|
|
return IntegersQ(m, p)
|
|
|
|
cons1301 = CustomConstraint(cons_f1301)
|
|
|
|
def cons_f1302(m, p):
|
|
return Equal(p, S(2)*m)
|
|
|
|
cons1302 = CustomConstraint(cons_f1302)
|
|
|
|
def cons_f1303(m, p):
|
|
return IntegersQ(m, p/S(2))
|
|
|
|
cons1303 = CustomConstraint(cons_f1303)
|
|
|
|
def cons_f1304(m, p):
|
|
return Or(Less(p, S(0)), Greater(m - p/S(2), S(0)))
|
|
|
|
cons1304 = CustomConstraint(cons_f1304)
|
|
|
|
def cons_f1305(m):
|
|
return Not(And(RationalQ(m), Less(m, S(0))))
|
|
|
|
cons1305 = CustomConstraint(cons_f1305)
|
|
|
|
def cons_f1306(m):
|
|
return IntegerQ(m + S(-1)/2)
|
|
|
|
cons1306 = CustomConstraint(cons_f1306)
|
|
|
|
def cons_f1307(m):
|
|
return Not(Less(m, S(-1)))
|
|
|
|
cons1307 = CustomConstraint(cons_f1307)
|
|
|
|
def cons_f1308(p):
|
|
return IntegerQ(p/S(2))
|
|
|
|
cons1308 = CustomConstraint(cons_f1308)
|
|
|
|
def cons_f1309(p):
|
|
return IntegersQ(S(2)*p)
|
|
|
|
cons1309 = CustomConstraint(cons_f1309)
|
|
|
|
def cons_f1310(a, b, e, f, g, m, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, e, f, g, m, p), x)
|
|
|
|
cons1310 = CustomConstraint(cons_f1310)
|
|
|
|
def cons_f1311(m, n):
|
|
return Not(And(IntegerQ(n), Or(And(Less(m, S(0)), Greater(n, S(0))), Less(S(0), n, m), Less(m, n, S(0)))))
|
|
|
|
cons1311 = CustomConstraint(cons_f1311)
|
|
|
|
def cons_f1312(n):
|
|
return NonzeroQ(n + S(1)/2)
|
|
|
|
cons1312 = CustomConstraint(cons_f1312)
|
|
|
|
def cons_f1313(m):
|
|
return PositiveIntegerQ(m + S(-1)/2)
|
|
|
|
cons1313 = CustomConstraint(cons_f1313)
|
|
|
|
def cons_f1314(m, n):
|
|
return Not(And(NegativeIntegerQ(m + n), Greater(S(2)*m + n + S(1), S(0))))
|
|
|
|
cons1314 = CustomConstraint(cons_f1314)
|
|
|
|
def cons_f1315(m, n):
|
|
return Not(And(PositiveIntegerQ(n + S(-1)/2), Less(n, m)))
|
|
|
|
cons1315 = CustomConstraint(cons_f1315)
|
|
|
|
def cons_f1316(m):
|
|
return NonzeroQ(m + S(1)/2)
|
|
|
|
cons1316 = CustomConstraint(cons_f1316)
|
|
|
|
def cons_f1317(m, n):
|
|
return NegativeIntegerQ(m + n + S(1))
|
|
|
|
cons1317 = CustomConstraint(cons_f1317)
|
|
|
|
def cons_f1318(m, n):
|
|
return Not(And(RationalQ(n), Less(m, n, S(-1))))
|
|
|
|
cons1318 = CustomConstraint(cons_f1318)
|
|
|
|
def cons_f1319(m, n):
|
|
return Or(FractionQ(m), Not(FractionQ(n)))
|
|
|
|
cons1319 = CustomConstraint(cons_f1319)
|
|
|
|
def cons_f1320(b, c, d, e, f, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(b, c, d, e, f, m), x)
|
|
|
|
cons1320 = CustomConstraint(cons_f1320)
|
|
|
|
def cons_f1321(a, b, c, d, m):
|
|
return ZeroQ(a*d*m + b*c*(m + S(1)))
|
|
|
|
cons1321 = CustomConstraint(cons_f1321)
|
|
|
|
def cons_f1322(m):
|
|
return Less(m, S(-1)/2)
|
|
|
|
cons1322 = CustomConstraint(cons_f1322)
|
|
|
|
def cons_f1323(m):
|
|
return Not(And(RationalQ(m), Less(m, S(-1)/2)))
|
|
|
|
cons1323 = CustomConstraint(cons_f1323)
|
|
|
|
def cons_f1324(c, d):
|
|
return ZeroQ(c**S(2) - d**S(2))
|
|
|
|
cons1324 = CustomConstraint(cons_f1324)
|
|
|
|
def cons_f1325(c, d):
|
|
return NonzeroQ(c**S(2) - d**S(2))
|
|
|
|
cons1325 = CustomConstraint(cons_f1325)
|
|
|
|
def cons_f1326(c, m, n):
|
|
return Or(IntegersQ(S(2)*m, S(2)*n), IntegerQ(m + S(1)/2), And(IntegerQ(m), ZeroQ(c)))
|
|
|
|
cons1326 = CustomConstraint(cons_f1326)
|
|
|
|
def cons_f1327(n):
|
|
return Less(S(0), n, S(1))
|
|
|
|
cons1327 = CustomConstraint(cons_f1327)
|
|
|
|
def cons_f1328(c, m, n):
|
|
return Or(IntegersQ(S(2)*m, S(2)*n), And(IntegerQ(m), ZeroQ(c)))
|
|
|
|
cons1328 = CustomConstraint(cons_f1328)
|
|
|
|
def cons_f1329(n):
|
|
return Not(And(RationalQ(n), Greater(n, S(0))))
|
|
|
|
cons1329 = CustomConstraint(cons_f1329)
|
|
|
|
def cons_f1330(c, n):
|
|
return Or(IntegerQ(S(2)*n), ZeroQ(c))
|
|
|
|
cons1330 = CustomConstraint(cons_f1330)
|
|
|
|
def cons_f1331(n):
|
|
return NonzeroQ(S(2)*n + S(3))
|
|
|
|
cons1331 = CustomConstraint(cons_f1331)
|
|
|
|
def cons_f1332(a, b, d):
|
|
return ZeroQ(-a/b + d)
|
|
|
|
cons1332 = CustomConstraint(cons_f1332)
|
|
|
|
def cons_f1333(b, d):
|
|
return PositiveQ(d/b)
|
|
|
|
cons1333 = CustomConstraint(cons_f1333)
|
|
|
|
def cons_f1334(b, d):
|
|
return Not(PositiveQ(d/b))
|
|
|
|
cons1334 = CustomConstraint(cons_f1334)
|
|
|
|
def cons_f1335(m):
|
|
return Greater(m, S(2))
|
|
|
|
cons1335 = CustomConstraint(cons_f1335)
|
|
|
|
def cons_f1336(m, n):
|
|
return Or(IntegerQ(m), IntegersQ(S(2)*m, S(2)*n))
|
|
|
|
cons1336 = CustomConstraint(cons_f1336)
|
|
|
|
def cons_f1337(a, c, m, n):
|
|
return Not(And(IntegerQ(n), Greater(n, S(2)), Or(Not(IntegerQ(m)), And(ZeroQ(a), NonzeroQ(c)))))
|
|
|
|
cons1337 = CustomConstraint(cons_f1337)
|
|
|
|
def cons_f1338(n):
|
|
return Less(S(1), n, S(2))
|
|
|
|
cons1338 = CustomConstraint(cons_f1338)
|
|
|
|
def cons_f1339(a, m, n):
|
|
return Or(And(ZeroQ(a), IntegerQ(m), Not(IntegerQ(n))), Not(And(IntegerQ(S(2)*n), Less(n, S(-1)), Or(And(IntegerQ(n), Not(IntegerQ(m))), ZeroQ(a)))))
|
|
|
|
cons1339 = CustomConstraint(cons_f1339)
|
|
|
|
def cons_f1340(c, d):
|
|
return PositiveQ(c + d)
|
|
|
|
cons1340 = CustomConstraint(cons_f1340)
|
|
|
|
def cons_f1341(c, d):
|
|
return PositiveQ(c - d)
|
|
|
|
cons1341 = CustomConstraint(cons_f1341)
|
|
|
|
def cons_f1342(c, d):
|
|
return Not(PositiveQ(c + d))
|
|
|
|
cons1342 = CustomConstraint(cons_f1342)
|
|
|
|
def cons_f1343(c, d):
|
|
return PositiveQ(c**S(2) - d**S(2))
|
|
|
|
cons1343 = CustomConstraint(cons_f1343)
|
|
|
|
def cons_f1344(b, c, d):
|
|
return PosQ((c + d)/b)
|
|
|
|
cons1344 = CustomConstraint(cons_f1344)
|
|
|
|
def cons_f1345(c):
|
|
return PositiveQ(c**S(2))
|
|
|
|
cons1345 = CustomConstraint(cons_f1345)
|
|
|
|
def cons_f1346(b, c, d):
|
|
return NegQ((c + d)/b)
|
|
|
|
cons1346 = CustomConstraint(cons_f1346)
|
|
|
|
def cons_f1347(a, b, c, d):
|
|
return PosQ((a + b)/(c + d))
|
|
|
|
cons1347 = CustomConstraint(cons_f1347)
|
|
|
|
def cons_f1348(a, b, c, d):
|
|
return NegQ((a + b)/(c + d))
|
|
|
|
cons1348 = CustomConstraint(cons_f1348)
|
|
|
|
def cons_f1349(a, b):
|
|
return NegativeQ(a**S(2) - b**S(2))
|
|
|
|
cons1349 = CustomConstraint(cons_f1349)
|
|
|
|
def cons_f1350(d):
|
|
return ZeroQ(d**S(2) + S(-1))
|
|
|
|
cons1350 = CustomConstraint(cons_f1350)
|
|
|
|
def cons_f1351(b, d):
|
|
return PositiveQ(b*d)
|
|
|
|
cons1351 = CustomConstraint(cons_f1351)
|
|
|
|
def cons_f1352(b):
|
|
return PositiveQ(b**S(2))
|
|
|
|
cons1352 = CustomConstraint(cons_f1352)
|
|
|
|
def cons_f1353(b, d):
|
|
return Not(And(ZeroQ(d**S(2) + S(-1)), PositiveQ(b*d)))
|
|
|
|
cons1353 = CustomConstraint(cons_f1353)
|
|
|
|
def cons_f1354(a, b, d):
|
|
return PosQ((a + b)/d)
|
|
|
|
cons1354 = CustomConstraint(cons_f1354)
|
|
|
|
def cons_f1355(a):
|
|
return PositiveQ(a**S(2))
|
|
|
|
cons1355 = CustomConstraint(cons_f1355)
|
|
|
|
def cons_f1356(a, b, d):
|
|
return NegQ((a + b)/d)
|
|
|
|
cons1356 = CustomConstraint(cons_f1356)
|
|
|
|
def cons_f1357(a, b, c, d):
|
|
return PosQ((c + d)/(a + b))
|
|
|
|
cons1357 = CustomConstraint(cons_f1357)
|
|
|
|
def cons_f1358(a, b, c, d):
|
|
return NegQ((c + d)/(a + b))
|
|
|
|
cons1358 = CustomConstraint(cons_f1358)
|
|
|
|
def cons_f1359(m):
|
|
return Less(S(0), m, S(2))
|
|
|
|
cons1359 = CustomConstraint(cons_f1359)
|
|
|
|
def cons_f1360(n):
|
|
return Less(S(-1), n, S(2))
|
|
|
|
cons1360 = CustomConstraint(cons_f1360)
|
|
|
|
def cons_f1361(m, n):
|
|
return NonzeroQ(m + n)
|
|
|
|
cons1361 = CustomConstraint(cons_f1361)
|
|
|
|
def cons_f1362(a, b, c, d, e, f, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, m, n), x)
|
|
|
|
cons1362 = CustomConstraint(cons_f1362)
|
|
|
|
def cons_f1363(a, b, n, p):
|
|
return Or(And(Less(p, S(0)), NonzeroQ(a**S(2) - b**S(2))), Less(S(0), n, p + S(-1)), Less(p + S(1), -n, S(2)*p + S(1)))
|
|
|
|
cons1363 = CustomConstraint(cons_f1363)
|
|
|
|
def cons_f1364(n, p):
|
|
return Or(Less(S(0), n, p/S(2) + S(1)/2), Inequality(p, LessEqual, -n, Less, S(2)*p + S(-3)), Inequality(S(0), Less, n, LessEqual, -p))
|
|
|
|
cons1364 = CustomConstraint(cons_f1364)
|
|
|
|
def cons_f1365(a, b, d, e, f, g, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, d, e, f, g, n, p), x)
|
|
|
|
cons1365 = CustomConstraint(cons_f1365)
|
|
|
|
def cons_f1366(m, n):
|
|
return Not(And(IntegerQ(n), Less(n**S(2), m**S(2))))
|
|
|
|
cons1366 = CustomConstraint(cons_f1366)
|
|
|
|
def cons_f1367(n, p):
|
|
return NonzeroQ(S(2)*n + p + S(1))
|
|
|
|
cons1367 = CustomConstraint(cons_f1367)
|
|
|
|
def cons_f1368(m, n, p):
|
|
return Not(And(NegativeIntegerQ(m + n + p), Greater(S(2)*m + n + S(3)*p/S(2) + S(1), S(0))))
|
|
|
|
cons1368 = CustomConstraint(cons_f1368)
|
|
|
|
def cons_f1369(m, n, p):
|
|
return Not(And(PositiveIntegerQ(n + p/S(2) + S(-1)/2), Greater(m - n, S(0))))
|
|
|
|
cons1369 = CustomConstraint(cons_f1369)
|
|
|
|
def cons_f1370(m, p):
|
|
return ZeroQ(S(2)*m + p + S(1))
|
|
|
|
cons1370 = CustomConstraint(cons_f1370)
|
|
|
|
def cons_f1371(m, n, p):
|
|
return ZeroQ(m + n + p + S(1))
|
|
|
|
cons1371 = CustomConstraint(cons_f1371)
|
|
|
|
def cons_f1372(m, n, p):
|
|
return NegativeIntegerQ(m + n + p + S(1))
|
|
|
|
cons1372 = CustomConstraint(cons_f1372)
|
|
|
|
def cons_f1373(m, n, p):
|
|
return NonzeroQ(m + n + p)
|
|
|
|
cons1373 = CustomConstraint(cons_f1373)
|
|
|
|
def cons_f1374(m, n):
|
|
return Not(And(RationalQ(n), Less(S(0), n, m)))
|
|
|
|
cons1374 = CustomConstraint(cons_f1374)
|
|
|
|
def cons_f1375(a, b, c, d, m, p):
|
|
return ZeroQ(a*d*m + b*c*(m + p + S(1)))
|
|
|
|
cons1375 = CustomConstraint(cons_f1375)
|
|
|
|
def cons_f1376(m):
|
|
return Greater(m, S(-1))
|
|
|
|
cons1376 = CustomConstraint(cons_f1376)
|
|
|
|
def cons_f1377(m, p):
|
|
return PositiveIntegerQ(m + p/S(2) + S(1)/2)
|
|
|
|
cons1377 = CustomConstraint(cons_f1377)
|
|
|
|
def cons_f1378(m):
|
|
return Less(m, S(-3)/2)
|
|
|
|
cons1378 = CustomConstraint(cons_f1378)
|
|
|
|
def cons_f1379(m):
|
|
return Inequality(S(-3)/2, LessEqual, m, Less, S(0))
|
|
|
|
cons1379 = CustomConstraint(cons_f1379)
|
|
|
|
def cons_f1380(m, p):
|
|
return Or(And(RationalQ(m), Less(m, S(-1))), NegativeIntegerQ(m + p))
|
|
|
|
cons1380 = CustomConstraint(cons_f1380)
|
|
|
|
def cons_f1381(p):
|
|
return Not(And(RationalQ(p), Less(p, S(-1))))
|
|
|
|
cons1381 = CustomConstraint(cons_f1381)
|
|
|
|
def cons_f1382(m, p):
|
|
return Equal(S(2)*m + p, S(0))
|
|
|
|
cons1382 = CustomConstraint(cons_f1382)
|
|
|
|
def cons_f1383(m, n, p):
|
|
return IntegersQ(m, n, p/S(2))
|
|
|
|
cons1383 = CustomConstraint(cons_f1383)
|
|
|
|
def cons_f1384(m, n, p):
|
|
return Or(And(Greater(m, S(0)), Greater(p, S(0)), Less(-m - p, n, S(-1))), And(Greater(m, S(2)), Less(p, S(0)), Greater(m + p/S(2), S(0))))
|
|
|
|
cons1384 = CustomConstraint(cons_f1384)
|
|
|
|
def cons_f1385(m, n):
|
|
return Or(NegativeIntegerQ(m), Not(PositiveIntegerQ(n)))
|
|
|
|
cons1385 = CustomConstraint(cons_f1385)
|
|
|
|
def cons_f1386(m, p):
|
|
return Or(Equal(S(2)*m + p, S(0)), And(Greater(S(2)*m + p, S(0)), Less(p, S(-1))))
|
|
|
|
cons1386 = CustomConstraint(cons_f1386)
|
|
|
|
def cons_f1387(m):
|
|
return LessEqual(m, S(-1)/2)
|
|
|
|
cons1387 = CustomConstraint(cons_f1387)
|
|
|
|
def cons_f1388(m, p):
|
|
return NonzeroQ(m + p + S(2))
|
|
|
|
cons1388 = CustomConstraint(cons_f1388)
|
|
|
|
def cons_f1389(n, p):
|
|
return Or(IntegerQ(p), PositiveIntegerQ(n))
|
|
|
|
cons1389 = CustomConstraint(cons_f1389)
|
|
|
|
def cons_f1390(m, p):
|
|
return ZeroQ(m + p + S(1)/2)
|
|
|
|
cons1390 = CustomConstraint(cons_f1390)
|
|
|
|
def cons_f1391(m, p):
|
|
return ZeroQ(m + p + S(3)/2)
|
|
|
|
cons1391 = CustomConstraint(cons_f1391)
|
|
|
|
def cons_f1392(m, n):
|
|
return Or(PositiveIntegerQ(m), IntegersQ(S(2)*m, S(2)*n))
|
|
|
|
cons1392 = CustomConstraint(cons_f1392)
|
|
|
|
def cons_f1393(n):
|
|
return Not(Less(n, S(-1)))
|
|
|
|
cons1393 = CustomConstraint(cons_f1393)
|
|
|
|
def cons_f1394(m, n):
|
|
return Or(Less(m, S(-2)), ZeroQ(m + n + S(4)))
|
|
|
|
cons1394 = CustomConstraint(cons_f1394)
|
|
|
|
def cons_f1395(m, n):
|
|
return NonzeroQ(m + n + S(4))
|
|
|
|
cons1395 = CustomConstraint(cons_f1395)
|
|
|
|
def cons_f1396(m, n):
|
|
return Or(Less(n, S(-2)), ZeroQ(m + n + S(4)))
|
|
|
|
cons1396 = CustomConstraint(cons_f1396)
|
|
|
|
def cons_f1397(n):
|
|
return NonzeroQ(n + S(2))
|
|
|
|
cons1397 = CustomConstraint(cons_f1397)
|
|
|
|
def cons_f1398(m, n):
|
|
return NonzeroQ(m + n + S(5))
|
|
|
|
cons1398 = CustomConstraint(cons_f1398)
|
|
|
|
def cons_f1399(m, n):
|
|
return NonzeroQ(m + n + S(6))
|
|
|
|
cons1399 = CustomConstraint(cons_f1399)
|
|
|
|
def cons_f1400(m, n, p):
|
|
return IntegersQ(m, S(2)*n, p/S(2))
|
|
|
|
cons1400 = CustomConstraint(cons_f1400)
|
|
|
|
def cons_f1401(m, p):
|
|
return Or(Less(m, S(-1)), And(Equal(m, S(-1)), Greater(p, S(0))))
|
|
|
|
cons1401 = CustomConstraint(cons_f1401)
|
|
|
|
def cons_f1402(n, p):
|
|
return Or(Less(n, S(0)), PositiveIntegerQ(p + S(1)/2))
|
|
|
|
cons1402 = CustomConstraint(cons_f1402)
|
|
|
|
def cons_f1403(n, p):
|
|
return IntegersQ(S(2)*n, S(2)*p)
|
|
|
|
cons1403 = CustomConstraint(cons_f1403)
|
|
|
|
def cons_f1404(n, p):
|
|
return Or(LessEqual(n, S(-2)), And(Equal(n, S(-3)/2), Equal(p, S(3)/2)))
|
|
|
|
cons1404 = CustomConstraint(cons_f1404)
|
|
|
|
def cons_f1405(n, p):
|
|
return Or(Less(n, S(-1)), And(Equal(p, S(3)/2), Equal(n, S(-1)/2)))
|
|
|
|
cons1405 = CustomConstraint(cons_f1405)
|
|
|
|
def cons_f1406(p):
|
|
return Less(S(-1), p, S(1))
|
|
|
|
cons1406 = CustomConstraint(cons_f1406)
|
|
|
|
def cons_f1407(m, n):
|
|
return Or(Greater(m, S(0)), IntegerQ(n))
|
|
|
|
cons1407 = CustomConstraint(cons_f1407)
|
|
|
|
def cons_f1408(m, n, p):
|
|
return IntegersQ(m, S(2)*n, S(2)*p)
|
|
|
|
cons1408 = CustomConstraint(cons_f1408)
|
|
|
|
def cons_f1409(m, n, p):
|
|
return Or(LessEqual(n, S(-2)), And(Equal(m, S(-1)), Equal(n, S(-3)/2), Equal(p, S(3)/2)))
|
|
|
|
cons1409 = CustomConstraint(cons_f1409)
|
|
|
|
def cons_f1410(p):
|
|
return PositiveIntegerQ(p/S(2))
|
|
|
|
cons1410 = CustomConstraint(cons_f1410)
|
|
|
|
def cons_f1411(a, b, c, d):
|
|
return Or(ZeroQ(a**S(2) - b**S(2)), ZeroQ(c**S(2) - d**S(2)))
|
|
|
|
cons1411 = CustomConstraint(cons_f1411)
|
|
|
|
def cons_f1412(c, d):
|
|
return ZeroQ(-c + d)
|
|
|
|
cons1412 = CustomConstraint(cons_f1412)
|
|
|
|
def cons_f1413(a, b):
|
|
return PositiveQ(-a**S(2) + b**S(2))
|
|
|
|
cons1413 = CustomConstraint(cons_f1413)
|
|
|
|
def cons_f1414(a, b, c, d):
|
|
return NonzeroQ(a*d + b*c)
|
|
|
|
cons1414 = CustomConstraint(cons_f1414)
|
|
|
|
def cons_f1415(a, b, c, d):
|
|
return Or(NonzeroQ(a**S(2) - b**S(2)), NonzeroQ(c**S(2) - d**S(2)))
|
|
|
|
cons1415 = CustomConstraint(cons_f1415)
|
|
|
|
def cons_f1416(n, p):
|
|
return ZeroQ(S(2)*n + p)
|
|
|
|
cons1416 = CustomConstraint(cons_f1416)
|
|
|
|
def cons_f1417(m, n, p):
|
|
return Or(IntegersQ(m, n), IntegersQ(m, p), IntegersQ(n, p))
|
|
|
|
cons1417 = CustomConstraint(cons_f1417)
|
|
|
|
def cons_f1418(p):
|
|
return NonzeroQ(p + S(-2))
|
|
|
|
cons1418 = CustomConstraint(cons_f1418)
|
|
|
|
def cons_f1419(m, n):
|
|
return Not(And(IntegerQ(m), IntegerQ(n)))
|
|
|
|
cons1419 = CustomConstraint(cons_f1419)
|
|
|
|
def cons_f1420(A, B, a, b):
|
|
return ZeroQ(A*b + B*a)
|
|
|
|
cons1420 = CustomConstraint(cons_f1420)
|
|
|
|
def cons_f1421(A, B, a, b, m, n):
|
|
return ZeroQ(A*b*(m + n + S(1)) + B*a*(m - n))
|
|
|
|
cons1421 = CustomConstraint(cons_f1421)
|
|
|
|
def cons_f1422(m, n):
|
|
return Or(And(RationalQ(m), Less(m, S(-1)/2)), And(NegativeIntegerQ(m + n), Not(SumSimplerQ(n, S(1)))))
|
|
|
|
cons1422 = CustomConstraint(cons_f1422)
|
|
|
|
def cons_f1423(m):
|
|
return NonzeroQ(S(2)*m + S(1))
|
|
|
|
cons1423 = CustomConstraint(cons_f1423)
|
|
|
|
def cons_f1424(A, B, a, b, c, d, m, n):
|
|
return ZeroQ(A*(a*d*m + b*c*(n + S(1))) - B*(a*c*m + b*d*(n + S(1))))
|
|
|
|
cons1424 = CustomConstraint(cons_f1424)
|
|
|
|
def cons_f1425(m):
|
|
return Greater(m, S(1)/2)
|
|
|
|
cons1425 = CustomConstraint(cons_f1425)
|
|
|
|
def cons_f1426(A, B, a, b, c, d, n):
|
|
return ZeroQ(A*b*d*(S(2)*n + S(3)) - B*(-S(2)*a*d*(n + S(1)) + b*c))
|
|
|
|
cons1426 = CustomConstraint(cons_f1426)
|
|
|
|
def cons_f1427(m, n):
|
|
return Or(IntegerQ(n), ZeroQ(m + S(1)/2))
|
|
|
|
cons1427 = CustomConstraint(cons_f1427)
|
|
|
|
def cons_f1428(A, B, a, b):
|
|
return NonzeroQ(A*b + B*a)
|
|
|
|
cons1428 = CustomConstraint(cons_f1428)
|
|
|
|
def cons_f1429(a, c, m, n):
|
|
return Not(And(IntegerQ(n), Greater(n, S(1)), Or(Not(IntegerQ(m)), And(ZeroQ(a), NonzeroQ(c)))))
|
|
|
|
cons1429 = CustomConstraint(cons_f1429)
|
|
|
|
def cons_f1430(A, B):
|
|
return ZeroQ(A - B)
|
|
|
|
cons1430 = CustomConstraint(cons_f1430)
|
|
|
|
def cons_f1431(A, B):
|
|
return NonzeroQ(A - B)
|
|
|
|
cons1431 = CustomConstraint(cons_f1431)
|
|
|
|
def cons_f1432(n):
|
|
return Equal(n**S(2), S(1)/4)
|
|
|
|
cons1432 = CustomConstraint(cons_f1432)
|
|
|
|
def cons_f1433(B, C, b, e, f, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(b, e, f, B, C, m), x)
|
|
|
|
cons1433 = CustomConstraint(cons_f1433)
|
|
|
|
def cons_f1434(A, C, m):
|
|
return ZeroQ(A*(m + S(2)) + C*(m + S(1)))
|
|
|
|
cons1434 = CustomConstraint(cons_f1434)
|
|
|
|
def cons_f1435(A, C, a, b):
|
|
return ZeroQ(A*b**S(2) + C*a**S(2))
|
|
|
|
cons1435 = CustomConstraint(cons_f1435)
|
|
|
|
def cons_f1436(A, B, C):
|
|
return ZeroQ(A - B + C)
|
|
|
|
cons1436 = CustomConstraint(cons_f1436)
|
|
|
|
def cons_f1437(A, C):
|
|
return ZeroQ(A + C)
|
|
|
|
cons1437 = CustomConstraint(cons_f1437)
|
|
|
|
def cons_f1438(m, n):
|
|
return Or(And(RationalQ(m), Less(m, S(-1)/2)), And(ZeroQ(m + n + S(2)), NonzeroQ(S(2)*m + S(1))))
|
|
|
|
cons1438 = CustomConstraint(cons_f1438)
|
|
|
|
def cons_f1439(m, n):
|
|
return Or(And(RationalQ(n), Less(n, S(-1))), ZeroQ(m + n + S(2)))
|
|
|
|
cons1439 = CustomConstraint(cons_f1439)
|
|
|
|
def cons_f1440(a, c, m, n):
|
|
return Not(And(IntegerQ(n), Greater(n, S(0)), Or(Not(IntegerQ(m)), And(ZeroQ(a), NonzeroQ(c)))))
|
|
|
|
cons1440 = CustomConstraint(cons_f1440)
|
|
|
|
def cons_f1441(a, b):
|
|
return ZeroQ(a**S(2) + b**S(2))
|
|
|
|
cons1441 = CustomConstraint(cons_f1441)
|
|
|
|
def cons_f1442(a, b):
|
|
return NonzeroQ(a**S(2) + b**S(2))
|
|
|
|
cons1442 = CustomConstraint(cons_f1442)
|
|
|
|
def cons_f1443(n):
|
|
return Not(OddQ(n))
|
|
|
|
cons1443 = CustomConstraint(cons_f1443)
|
|
|
|
def cons_f1444(n):
|
|
return Unequal(n, S(-2))
|
|
|
|
cons1444 = CustomConstraint(cons_f1444)
|
|
|
|
def cons_f1445(n):
|
|
return Not(And(RationalQ(n), Or(GreaterEqual(n, S(1)), LessEqual(n, S(-1)))))
|
|
|
|
cons1445 = CustomConstraint(cons_f1445)
|
|
|
|
def cons_f1446(a, b):
|
|
return PositiveQ(a**S(2) + b**S(2))
|
|
|
|
cons1446 = CustomConstraint(cons_f1446)
|
|
|
|
def cons_f1447(a, b):
|
|
return Not(Or(PositiveQ(a**S(2) + b**S(2)), ZeroQ(a**S(2) + b**S(2))))
|
|
|
|
cons1447 = CustomConstraint(cons_f1447)
|
|
|
|
def cons_f1448(m, n):
|
|
return IntegerQ(m/S(2) + n/S(2))
|
|
|
|
cons1448 = CustomConstraint(cons_f1448)
|
|
|
|
def cons_f1449(m, n):
|
|
return Not(And(Greater(n, S(0)), Greater(m, S(1))))
|
|
|
|
cons1449 = CustomConstraint(cons_f1449)
|
|
|
|
def cons_f1450(a, b, c):
|
|
return ZeroQ(a**S(2) - b**S(2) - c**S(2))
|
|
|
|
cons1450 = CustomConstraint(cons_f1450)
|
|
|
|
def cons_f1451(b, c):
|
|
return ZeroQ(b**S(2) + c**S(2))
|
|
|
|
cons1451 = CustomConstraint(cons_f1451)
|
|
|
|
def cons_f1452(b, c):
|
|
return NonzeroQ(b**S(2) + c**S(2))
|
|
|
|
cons1452 = CustomConstraint(cons_f1452)
|
|
|
|
def cons_f1453(a, b, c):
|
|
return PositiveQ(a + sqrt(b**S(2) + c**S(2)))
|
|
|
|
cons1453 = CustomConstraint(cons_f1453)
|
|
|
|
def cons_f1454(a, b, c):
|
|
return NonzeroQ(a**S(2) - b**S(2) - c**S(2))
|
|
|
|
cons1454 = CustomConstraint(cons_f1454)
|
|
|
|
def cons_f1455(a, b, c):
|
|
return Not(PositiveQ(a + sqrt(b**S(2) + c**S(2))))
|
|
|
|
cons1455 = CustomConstraint(cons_f1455)
|
|
|
|
def cons_f1456(a, b):
|
|
return ZeroQ(a + b)
|
|
|
|
cons1456 = CustomConstraint(cons_f1456)
|
|
|
|
def cons_f1457(a, c):
|
|
return ZeroQ(a - c)
|
|
|
|
cons1457 = CustomConstraint(cons_f1457)
|
|
|
|
def cons_f1458(a, b):
|
|
return NonzeroQ(a - b)
|
|
|
|
cons1458 = CustomConstraint(cons_f1458)
|
|
|
|
def cons_f1459(n):
|
|
return Unequal(n, S(-3)/2)
|
|
|
|
cons1459 = CustomConstraint(cons_f1459)
|
|
|
|
def cons_f1460(A, B, C, a, b, c):
|
|
return ZeroQ(A*(b**S(2) + c**S(2)) - a*(B*b + C*c))
|
|
|
|
cons1460 = CustomConstraint(cons_f1460)
|
|
|
|
def cons_f1461(A, C, a, b, c):
|
|
return ZeroQ(A*(b**S(2) + c**S(2)) - C*a*c)
|
|
|
|
cons1461 = CustomConstraint(cons_f1461)
|
|
|
|
def cons_f1462(A, B, a, b, c):
|
|
return ZeroQ(A*(b**S(2) + c**S(2)) - B*a*b)
|
|
|
|
cons1462 = CustomConstraint(cons_f1462)
|
|
|
|
def cons_f1463(A, B, C, a, b, c):
|
|
return NonzeroQ(A*(b**S(2) + c**S(2)) - a*(B*b + C*c))
|
|
|
|
cons1463 = CustomConstraint(cons_f1463)
|
|
|
|
def cons_f1464(A, C, a, b, c):
|
|
return NonzeroQ(A*(b**S(2) + c**S(2)) - C*a*c)
|
|
|
|
cons1464 = CustomConstraint(cons_f1464)
|
|
|
|
def cons_f1465(A, B, a, b, c):
|
|
return NonzeroQ(A*(b**S(2) + c**S(2)) - B*a*b)
|
|
|
|
cons1465 = CustomConstraint(cons_f1465)
|
|
|
|
def cons_f1466(A, B, C, a, b, c, n):
|
|
return ZeroQ(A*a*(n + S(1)) + n*(B*b + C*c))
|
|
|
|
cons1466 = CustomConstraint(cons_f1466)
|
|
|
|
def cons_f1467(A, C, a, c, n):
|
|
return ZeroQ(A*a*(n + S(1)) + C*c*n)
|
|
|
|
cons1467 = CustomConstraint(cons_f1467)
|
|
|
|
def cons_f1468(A, B, a, b, n):
|
|
return ZeroQ(A*a*(n + S(1)) + B*b*n)
|
|
|
|
cons1468 = CustomConstraint(cons_f1468)
|
|
|
|
def cons_f1469(A, B, C, a, b, c, n):
|
|
return NonzeroQ(A*a*(n + S(1)) + n*(B*b + C*c))
|
|
|
|
cons1469 = CustomConstraint(cons_f1469)
|
|
|
|
def cons_f1470(A, C, a, c, n):
|
|
return NonzeroQ(A*a*(n + S(1)) + C*c*n)
|
|
|
|
cons1470 = CustomConstraint(cons_f1470)
|
|
|
|
def cons_f1471(A, B, a, b, n):
|
|
return NonzeroQ(A*a*(n + S(1)) + B*b*n)
|
|
|
|
cons1471 = CustomConstraint(cons_f1471)
|
|
|
|
def cons_f1472(B, C, b, c):
|
|
return ZeroQ(B*b + C*c)
|
|
|
|
cons1472 = CustomConstraint(cons_f1472)
|
|
|
|
def cons_f1473(B, C, b, c):
|
|
return ZeroQ(B*c - C*b)
|
|
|
|
cons1473 = CustomConstraint(cons_f1473)
|
|
|
|
def cons_f1474(A, B, C, a, b, c):
|
|
return ZeroQ(A*a - B*b - C*c)
|
|
|
|
cons1474 = CustomConstraint(cons_f1474)
|
|
|
|
def cons_f1475(A, C, a, c):
|
|
return ZeroQ(A*a - C*c)
|
|
|
|
cons1475 = CustomConstraint(cons_f1475)
|
|
|
|
def cons_f1476(A, B, a, b):
|
|
return ZeroQ(A*a - B*b)
|
|
|
|
cons1476 = CustomConstraint(cons_f1476)
|
|
|
|
def cons_f1477(A, B, C, a, b, c):
|
|
return NonzeroQ(A*a - B*b - C*c)
|
|
|
|
cons1477 = CustomConstraint(cons_f1477)
|
|
|
|
def cons_f1478(A, C, a, c):
|
|
return NonzeroQ(A*a - C*c)
|
|
|
|
cons1478 = CustomConstraint(cons_f1478)
|
|
|
|
def cons_f1479(A, B, a, b):
|
|
return NonzeroQ(A*a - B*b)
|
|
|
|
cons1479 = CustomConstraint(cons_f1479)
|
|
|
|
def cons_f1480(a, b):
|
|
return NonzeroQ(a + b)
|
|
|
|
cons1480 = CustomConstraint(cons_f1480)
|
|
|
|
def cons_f1481(n):
|
|
return EvenQ(n)
|
|
|
|
cons1481 = CustomConstraint(cons_f1481)
|
|
|
|
def cons_f1482(m):
|
|
return EvenQ(m)
|
|
|
|
cons1482 = CustomConstraint(cons_f1482)
|
|
|
|
def cons_f1483(m):
|
|
return OddQ(m)
|
|
|
|
cons1483 = CustomConstraint(cons_f1483)
|
|
|
|
def cons_f1484(n):
|
|
return OddQ(n)
|
|
|
|
cons1484 = CustomConstraint(cons_f1484)
|
|
|
|
def cons_f1485(m):
|
|
return Not(OddQ(m))
|
|
|
|
cons1485 = CustomConstraint(cons_f1485)
|
|
|
|
def cons_f1486(p):
|
|
return EvenQ(p)
|
|
|
|
cons1486 = CustomConstraint(cons_f1486)
|
|
|
|
def cons_f1487(q):
|
|
return EvenQ(q)
|
|
|
|
cons1487 = CustomConstraint(cons_f1487)
|
|
|
|
def cons_f1488(p, q):
|
|
return Inequality(S(0), Less, p, LessEqual, q)
|
|
|
|
cons1488 = CustomConstraint(cons_f1488)
|
|
|
|
def cons_f1489(p, q):
|
|
return Less(S(0), q, p)
|
|
|
|
cons1489 = CustomConstraint(cons_f1489)
|
|
|
|
def cons_f1490(c, d, e, f, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(c, d, e, f, m), x)
|
|
|
|
cons1490 = CustomConstraint(cons_f1490)
|
|
|
|
def cons_f1491(m):
|
|
return Or(Not(RationalQ(m)), Inequality(S(-1), LessEqual, m, Less, S(1)))
|
|
|
|
cons1491 = CustomConstraint(cons_f1491)
|
|
|
|
def cons_f1492(a, b, m, n):
|
|
return Or(Equal(n, S(1)), PositiveIntegerQ(m), NonzeroQ(a**S(2) - b**S(2)))
|
|
|
|
cons1492 = CustomConstraint(cons_f1492)
|
|
|
|
def cons_f1493(m, n):
|
|
return Or(Greater(n, S(0)), PositiveIntegerQ(m))
|
|
|
|
cons1493 = CustomConstraint(cons_f1493)
|
|
|
|
def cons_f1494(a, b):
|
|
return ZeroQ(a - b)
|
|
|
|
cons1494 = CustomConstraint(cons_f1494)
|
|
|
|
def cons_f1495(n):
|
|
return NegativeIntegerQ(n + S(2))
|
|
|
|
cons1495 = CustomConstraint(cons_f1495)
|
|
|
|
def cons_f1496(n, p):
|
|
return Or(Equal(n, S(2)), Equal(p, S(-1)))
|
|
|
|
cons1496 = CustomConstraint(cons_f1496)
|
|
|
|
def cons_f1497(a, b, c, d, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, n, p), x)
|
|
|
|
cons1497 = CustomConstraint(cons_f1497)
|
|
|
|
def cons_f1498(m, n):
|
|
return Or(Greater(m - n + S(1), S(0)), Greater(n, S(2)))
|
|
|
|
cons1498 = CustomConstraint(cons_f1498)
|
|
|
|
def cons_f1499(a, b, c, d, e, m, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, m, n, p), x)
|
|
|
|
cons1499 = CustomConstraint(cons_f1499)
|
|
|
|
def cons_f1500(c, d, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(c, d, n), x)
|
|
|
|
cons1500 = CustomConstraint(cons_f1500)
|
|
|
|
def cons_f1501(d, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(d, n), x)
|
|
|
|
cons1501 = CustomConstraint(cons_f1501)
|
|
|
|
def cons_f1502(m, n):
|
|
return ZeroQ(m - n/S(2) + S(1))
|
|
|
|
cons1502 = CustomConstraint(cons_f1502)
|
|
|
|
def cons_f1503(m, n):
|
|
return Less(S(0), n, m + S(1))
|
|
|
|
cons1503 = CustomConstraint(cons_f1503)
|
|
|
|
def cons_f1504(n):
|
|
return NonzeroQ(n + S(-1))
|
|
|
|
cons1504 = CustomConstraint(cons_f1504)
|
|
|
|
def cons_f1505(m, n):
|
|
return Less(S(0), S(2)*n, m + S(1))
|
|
|
|
cons1505 = CustomConstraint(cons_f1505)
|
|
|
|
def cons_f1506(m, n):
|
|
return Less(S(0), S(2)*n, S(1) - m)
|
|
|
|
cons1506 = CustomConstraint(cons_f1506)
|
|
|
|
def cons_f1507(p):
|
|
return Unequal(p, S(-2))
|
|
|
|
cons1507 = CustomConstraint(cons_f1507)
|
|
|
|
def cons_f1508(c, d, e, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(c, d, e, m, n), x)
|
|
|
|
cons1508 = CustomConstraint(cons_f1508)
|
|
|
|
def cons_f1509(a, b, c, d, e, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, m), x)
|
|
|
|
cons1509 = CustomConstraint(cons_f1509)
|
|
|
|
def cons_f1510(m, n):
|
|
return ZeroQ(m + n + S(-1))
|
|
|
|
cons1510 = CustomConstraint(cons_f1510)
|
|
|
|
def cons_f1511(m, n):
|
|
return IntegersQ(m, n, m/S(2) + n/S(2) + S(-1)/2)
|
|
|
|
cons1511 = CustomConstraint(cons_f1511)
|
|
|
|
def cons_f1512(m):
|
|
return Unequal(m, S(-2))
|
|
|
|
cons1512 = CustomConstraint(cons_f1512)
|
|
|
|
def cons_f1513(m):
|
|
return Not(And(RationalQ(m), Greater(m, S(1)), Not(IntegerQ(m/S(2) + S(-1)/2))))
|
|
|
|
cons1513 = CustomConstraint(cons_f1513)
|
|
|
|
def cons_f1514(n):
|
|
return IntegerQ(n/S(2) + S(1)/2)
|
|
|
|
cons1514 = CustomConstraint(cons_f1514)
|
|
|
|
def cons_f1515(m, n):
|
|
return Not(IntegersQ(S(2)*m, S(2)*n))
|
|
|
|
cons1515 = CustomConstraint(cons_f1515)
|
|
|
|
def cons_f1516(m, n):
|
|
return Not(And(IntegerQ(m/S(2)), Less(S(0), m, n + S(1))))
|
|
|
|
cons1516 = CustomConstraint(cons_f1516)
|
|
|
|
def cons_f1517(m):
|
|
return IntegerQ(m/S(2))
|
|
|
|
cons1517 = CustomConstraint(cons_f1517)
|
|
|
|
def cons_f1518(m, n):
|
|
return Not(And(IntegerQ(n/S(2) + S(-1)/2), Less(S(0), n, m + S(-1))))
|
|
|
|
cons1518 = CustomConstraint(cons_f1518)
|
|
|
|
def cons_f1519(m, n):
|
|
return Or(Greater(m, S(1)), And(Equal(m, S(1)), Equal(n, S(-3)/2)))
|
|
|
|
cons1519 = CustomConstraint(cons_f1519)
|
|
|
|
def cons_f1520(m, n):
|
|
return Or(Less(m, S(-1)), And(Equal(m, S(-1)), Equal(n, S(3)/2)))
|
|
|
|
cons1520 = CustomConstraint(cons_f1520)
|
|
|
|
def cons_f1521(m, n):
|
|
return NonzeroQ(m + n + S(-1))
|
|
|
|
cons1521 = CustomConstraint(cons_f1521)
|
|
|
|
def cons_f1522(m, n):
|
|
return Or(Less(m, S(-1)), And(Equal(m, S(-1)), RationalQ(n), Equal(n, S(-1)/2)))
|
|
|
|
cons1522 = CustomConstraint(cons_f1522)
|
|
|
|
def cons_f1523(m, n):
|
|
return Or(Greater(m, S(1)), And(Equal(m, S(1)), RationalQ(n), Equal(n, S(1)/2)))
|
|
|
|
cons1523 = CustomConstraint(cons_f1523)
|
|
|
|
def cons_f1524(b, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(b, e, f), x)
|
|
|
|
cons1524 = CustomConstraint(cons_f1524)
|
|
|
|
def cons_f1525(n):
|
|
return Not(IntegerQ(n/S(2) + S(-1)/2))
|
|
|
|
cons1525 = CustomConstraint(cons_f1525)
|
|
|
|
def cons_f1526(m):
|
|
return Not(IntegerQ(m/S(2)))
|
|
|
|
cons1526 = CustomConstraint(cons_f1526)
|
|
|
|
def cons_f1527(m, n, p):
|
|
return NonzeroQ(m*p + n + S(-1))
|
|
|
|
cons1527 = CustomConstraint(cons_f1527)
|
|
|
|
def cons_f1528(m, n, p):
|
|
return IntegersQ(S(2)*m*p, S(2)*n)
|
|
|
|
cons1528 = CustomConstraint(cons_f1528)
|
|
|
|
def cons_f1529(m, n, p):
|
|
return NonzeroQ(m*p + n + S(1))
|
|
|
|
cons1529 = CustomConstraint(cons_f1529)
|
|
|
|
def cons_f1530(a, b, m):
|
|
return Or(IntegerQ(S(2)*m), NonzeroQ(a**S(2) + b**S(2)))
|
|
|
|
cons1530 = CustomConstraint(cons_f1530)
|
|
|
|
def cons_f1531(m, n):
|
|
return ZeroQ(m/S(2) + n)
|
|
|
|
cons1531 = CustomConstraint(cons_f1531)
|
|
|
|
def cons_f1532(m, n):
|
|
return ZeroQ(m/S(2) + n + S(-1))
|
|
|
|
cons1532 = CustomConstraint(cons_f1532)
|
|
|
|
def cons_f1533(m, n):
|
|
return PositiveIntegerQ(m/S(2) + n + S(-1))
|
|
|
|
cons1533 = CustomConstraint(cons_f1533)
|
|
|
|
def cons_f1534(m, n):
|
|
return Or(And(PositiveIntegerQ(n/S(2)), NegativeIntegerQ(m + S(-1)/2)), And(Equal(n, S(2)), Less(m, S(0))), And(LessEqual(m, S(-1)), Greater(m + n, S(0))), And(NegativeIntegerQ(m), Less(m/S(2) + n + S(-1), S(0)), IntegerQ(n)), And(Equal(n, S(3)/2), Equal(m, S(-1)/2)))
|
|
|
|
cons1534 = CustomConstraint(cons_f1534)
|
|
|
|
def cons_f1535(m, n):
|
|
return Or(And(PositiveIntegerQ(n/S(2)), NegativeIntegerQ(m + S(-1)/2)), And(Equal(n, S(2)), Less(m, S(0))), And(LessEqual(m, S(-1)), Greater(m + n, S(0))), And(NegativeIntegerQ(m), Less(m/S(2) + n + S(-1), S(0))), And(Equal(n, S(3)/2), Equal(m, S(-1)/2)))
|
|
|
|
cons1535 = CustomConstraint(cons_f1535)
|
|
|
|
def cons_f1536(m, n):
|
|
return Or(And(NegativeIntegerQ(n/S(2)), PositiveIntegerQ(m + S(-1)/2)), Equal(n, S(-2)), PositiveIntegerQ(m + n), And(IntegersQ(n, m + S(1)/2), Greater(S(2)*m + n + S(1), S(0))))
|
|
|
|
cons1536 = CustomConstraint(cons_f1536)
|
|
|
|
def cons_f1537(m, n):
|
|
return Not(NegativeIntegerQ(m + n))
|
|
|
|
cons1537 = CustomConstraint(cons_f1537)
|
|
|
|
def cons_f1538(m, n):
|
|
return NonzeroQ(m + S(2)*n)
|
|
|
|
cons1538 = CustomConstraint(cons_f1538)
|
|
|
|
def cons_f1539(m, n):
|
|
return PositiveIntegerQ(m + n + S(-1))
|
|
|
|
cons1539 = CustomConstraint(cons_f1539)
|
|
|
|
def cons_f1540(m, n):
|
|
return NegativeIntegerQ(m + n)
|
|
|
|
cons1540 = CustomConstraint(cons_f1540)
|
|
|
|
def cons_f1541(m):
|
|
return PositiveIntegerQ(m + S(-1))
|
|
|
|
cons1541 = CustomConstraint(cons_f1541)
|
|
|
|
def cons_f1542(m, n):
|
|
return Or(And(Less(m, S(5)), Greater(n, S(-4))), And(Equal(m, S(5)), Equal(n, S(-1))))
|
|
|
|
cons1542 = CustomConstraint(cons_f1542)
|
|
|
|
def cons_f1543(m, n):
|
|
return Not(And(IntegerQ(n), Greater(n, S(0)), Or(Less(m, S(0)), Less(n, m))))
|
|
|
|
cons1543 = CustomConstraint(cons_f1543)
|
|
|
|
def cons_f1544(a, b, c, d):
|
|
return ZeroQ(a*c + b*d)
|
|
|
|
cons1544 = CustomConstraint(cons_f1544)
|
|
|
|
def cons_f1545(a, b, c, d):
|
|
return NonzeroQ(a*c + b*d)
|
|
|
|
cons1545 = CustomConstraint(cons_f1545)
|
|
|
|
def cons_f1546(c, d):
|
|
return ZeroQ(c**S(2) + d**S(2))
|
|
|
|
cons1546 = CustomConstraint(cons_f1546)
|
|
|
|
def cons_f1547(c, d):
|
|
return NonzeroQ(c**S(2) + d**S(2))
|
|
|
|
cons1547 = CustomConstraint(cons_f1547)
|
|
|
|
def cons_f1548(a, b, c, d):
|
|
return ZeroQ(S(2)*a*c*d - b*(c**S(2) - d**S(2)))
|
|
|
|
cons1548 = CustomConstraint(cons_f1548)
|
|
|
|
def cons_f1549(a, b, c, d):
|
|
return NonzeroQ(S(2)*a*c*d - b*(c**S(2) - d**S(2)))
|
|
|
|
cons1549 = CustomConstraint(cons_f1549)
|
|
|
|
def cons_f1550(a, b, c, d):
|
|
return Or(PerfectSquareQ(a**S(2) + b**S(2)), RationalQ(a, b, c, d))
|
|
|
|
cons1550 = CustomConstraint(cons_f1550)
|
|
|
|
def cons_f1551(m):
|
|
return Not(And(RationalQ(m), LessEqual(m, S(-1))))
|
|
|
|
cons1551 = CustomConstraint(cons_f1551)
|
|
|
|
def cons_f1552(a, m):
|
|
return Not(And(ZeroQ(m + S(-2)), ZeroQ(a)))
|
|
|
|
cons1552 = CustomConstraint(cons_f1552)
|
|
|
|
def cons_f1553(m, n):
|
|
return Equal(m + n, S(0))
|
|
|
|
cons1553 = CustomConstraint(cons_f1553)
|
|
|
|
def cons_f1554(m):
|
|
return IntegersQ(S(2)*m)
|
|
|
|
cons1554 = CustomConstraint(cons_f1554)
|
|
|
|
def cons_f1555(m, n):
|
|
return Or(IntegerQ(n), IntegersQ(S(2)*m, S(2)*n))
|
|
|
|
cons1555 = CustomConstraint(cons_f1555)
|
|
|
|
def cons_f1556(m, n):
|
|
return Or(And(RationalQ(n), GreaterEqual(n, S(-1))), IntegerQ(m))
|
|
|
|
cons1556 = CustomConstraint(cons_f1556)
|
|
|
|
def cons_f1557(a, c, m, n):
|
|
return Not(And(IntegerQ(n), Greater(n, S(2)), Or(Not(IntegerQ(m)), And(ZeroQ(c), NonzeroQ(a)))))
|
|
|
|
cons1557 = CustomConstraint(cons_f1557)
|
|
|
|
def cons_f1558(m, n):
|
|
return Or(And(RationalQ(n), Less(n, S(0))), IntegerQ(m))
|
|
|
|
cons1558 = CustomConstraint(cons_f1558)
|
|
|
|
def cons_f1559(a, c, m, n):
|
|
return Not(And(IntegerQ(n), Less(n, S(-1)), Or(Not(IntegerQ(m)), And(ZeroQ(c), NonzeroQ(a)))))
|
|
|
|
cons1559 = CustomConstraint(cons_f1559)
|
|
|
|
def cons_f1560(A, B):
|
|
return ZeroQ(A**S(2) + B**S(2))
|
|
|
|
cons1560 = CustomConstraint(cons_f1560)
|
|
|
|
def cons_f1561(A, B):
|
|
return NonzeroQ(A**S(2) + B**S(2))
|
|
|
|
cons1561 = CustomConstraint(cons_f1561)
|
|
|
|
def cons_f1562(a, c, m, n):
|
|
return Not(And(IntegerQ(n), Greater(n, S(1)), Or(Not(IntegerQ(m)), And(ZeroQ(c), NonzeroQ(a)))))
|
|
|
|
cons1562 = CustomConstraint(cons_f1562)
|
|
|
|
def cons_f1563(A, C):
|
|
return ZeroQ(A - C)
|
|
|
|
cons1563 = CustomConstraint(cons_f1563)
|
|
|
|
def cons_f1564(A, B, C, a, b):
|
|
return NonzeroQ(A*b**S(2) - B*a*b + C*a**S(2))
|
|
|
|
cons1564 = CustomConstraint(cons_f1564)
|
|
|
|
def cons_f1565(A, C, a, b):
|
|
return NonzeroQ(A*b**S(2) + C*a**S(2))
|
|
|
|
cons1565 = CustomConstraint(cons_f1565)
|
|
|
|
def cons_f1566(A, B, C, a, b):
|
|
return ZeroQ(A*b - B*a - C*b)
|
|
|
|
cons1566 = CustomConstraint(cons_f1566)
|
|
|
|
def cons_f1567(A, C):
|
|
return NonzeroQ(A - C)
|
|
|
|
cons1567 = CustomConstraint(cons_f1567)
|
|
|
|
def cons_f1568(A, B, C, a, b):
|
|
return NonzeroQ(A*b - B*a - C*b)
|
|
|
|
cons1568 = CustomConstraint(cons_f1568)
|
|
|
|
def cons_f1569(m, n):
|
|
return Or(And(RationalQ(m), Less(m, S(0))), ZeroQ(m + n + S(1)))
|
|
|
|
cons1569 = CustomConstraint(cons_f1569)
|
|
|
|
def cons_f1570(a, c, m, n):
|
|
return Not(And(IntegerQ(n), Greater(n, S(0)), Or(Not(IntegerQ(m)), And(ZeroQ(c), NonzeroQ(a)))))
|
|
|
|
cons1570 = CustomConstraint(cons_f1570)
|
|
|
|
def cons_f1571(n):
|
|
return Not(And(RationalQ(n), LessEqual(n, S(-1))))
|
|
|
|
cons1571 = CustomConstraint(cons_f1571)
|
|
|
|
def cons_f1572(a, b, c, d, e, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, n, p), x)
|
|
|
|
cons1572 = CustomConstraint(cons_f1572)
|
|
|
|
def cons_f1573(m, n):
|
|
return NegativeIntegerQ(m, n)
|
|
|
|
cons1573 = CustomConstraint(cons_f1573)
|
|
|
|
def cons_f1574(n):
|
|
return NegativeIntegerQ(n + S(1))
|
|
|
|
cons1574 = CustomConstraint(cons_f1574)
|
|
|
|
def cons_f1575(n):
|
|
return PositiveIntegerQ(S(1)/n)
|
|
|
|
cons1575 = CustomConstraint(cons_f1575)
|
|
|
|
def cons_f1576(m, n):
|
|
return PositiveIntegerQ((m + S(1))/n)
|
|
|
|
cons1576 = CustomConstraint(cons_f1576)
|
|
|
|
def cons_f1577(c, d, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(c, d, m, n), x)
|
|
|
|
cons1577 = CustomConstraint(cons_f1577)
|
|
|
|
def cons_f1578(a, b, c, d, m, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, m, n, p), x)
|
|
|
|
cons1578 = CustomConstraint(cons_f1578)
|
|
|
|
def cons_f1579(m, n):
|
|
return GreaterEqual(m - n, S(0))
|
|
|
|
cons1579 = CustomConstraint(cons_f1579)
|
|
|
|
def cons_f1580(q):
|
|
return SameQ(q, S(1))
|
|
|
|
cons1580 = CustomConstraint(cons_f1580)
|
|
|
|
def cons_f1581(a, b, c, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, n), x)
|
|
|
|
cons1581 = CustomConstraint(cons_f1581)
|
|
|
|
def cons_f1582(a, b, c, d, e, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, m, n), x)
|
|
|
|
cons1582 = CustomConstraint(cons_f1582)
|
|
|
|
def cons_f1583(m, n):
|
|
return ZeroQ(m + n + S(-2))
|
|
|
|
cons1583 = CustomConstraint(cons_f1583)
|
|
|
|
def cons_f1584(m, n):
|
|
return IntegersQ(m, n, m/S(2) + n/S(2))
|
|
|
|
cons1584 = CustomConstraint(cons_f1584)
|
|
|
|
def cons_f1585(m, n):
|
|
return Not(And(IntegerQ(m/S(2) + S(1)/2), Less(S(0), m, n)))
|
|
|
|
cons1585 = CustomConstraint(cons_f1585)
|
|
|
|
def cons_f1586(m, n):
|
|
return Not(PositiveIntegerQ(m/S(2), n/S(2) + S(-1)/2))
|
|
|
|
cons1586 = CustomConstraint(cons_f1586)
|
|
|
|
def cons_f1587(n):
|
|
return ZeroQ(n**S(2) + S(-1)/4)
|
|
|
|
cons1587 = CustomConstraint(cons_f1587)
|
|
|
|
def cons_f1588(n):
|
|
return LessEqual(n, S(-1))
|
|
|
|
cons1588 = CustomConstraint(cons_f1588)
|
|
|
|
def cons_f1589(a, b, d, e, f, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, d, e, f, n), x)
|
|
|
|
cons1589 = CustomConstraint(cons_f1589)
|
|
|
|
def cons_f1590(a, b, d):
|
|
return PositiveQ(a*d/b)
|
|
|
|
cons1590 = CustomConstraint(cons_f1590)
|
|
|
|
def cons_f1591(a, b, d):
|
|
return Not(PositiveQ(a*d/b))
|
|
|
|
cons1591 = CustomConstraint(cons_f1591)
|
|
|
|
def cons_f1592(n):
|
|
return Less(n, S(-1)/2)
|
|
|
|
cons1592 = CustomConstraint(cons_f1592)
|
|
|
|
def cons_f1593(m, n):
|
|
return Or(Less(n, S(-1)), And(Equal(m, S(3)/2), Equal(n, S(-1)/2)))
|
|
|
|
cons1593 = CustomConstraint(cons_f1593)
|
|
|
|
def cons_f1594(m, n):
|
|
return Or(IntegersQ(S(2)*m, S(2)*n), IntegerQ(m))
|
|
|
|
cons1594 = CustomConstraint(cons_f1594)
|
|
|
|
def cons_f1595(a, b, d):
|
|
return NegativeQ(a*d/b)
|
|
|
|
cons1595 = CustomConstraint(cons_f1595)
|
|
|
|
def cons_f1596(m, n):
|
|
return Or(And(IntegerQ(m), Less(n, S(-1))), And(IntegersQ(m + S(1)/2, S(2)*n), LessEqual(n, S(-1))))
|
|
|
|
cons1596 = CustomConstraint(cons_f1596)
|
|
|
|
def cons_f1597(m, n):
|
|
return Not(And(IntegerQ(n), Greater(n, S(2)), Not(IntegerQ(m))))
|
|
|
|
cons1597 = CustomConstraint(cons_f1597)
|
|
|
|
def cons_f1598(m, n):
|
|
return Or(And(IntegerQ(n), Greater(n, S(3))), And(IntegersQ(n + S(1)/2, S(2)*m), Greater(n, S(2))))
|
|
|
|
cons1598 = CustomConstraint(cons_f1598)
|
|
|
|
def cons_f1599(m, n):
|
|
return NegativeIntegerQ(m + S(1)/2, n)
|
|
|
|
cons1599 = CustomConstraint(cons_f1599)
|
|
|
|
def cons_f1600(n):
|
|
return Greater(n, S(3))
|
|
|
|
cons1600 = CustomConstraint(cons_f1600)
|
|
|
|
def cons_f1601(n):
|
|
return IntegersQ(S(2)*n)
|
|
|
|
cons1601 = CustomConstraint(cons_f1601)
|
|
|
|
def cons_f1602(m):
|
|
return Not(And(IntegerQ(m), Greater(m, S(2))))
|
|
|
|
cons1602 = CustomConstraint(cons_f1602)
|
|
|
|
def cons_f1603(n):
|
|
return Less(S(0), n, S(3))
|
|
|
|
cons1603 = CustomConstraint(cons_f1603)
|
|
|
|
def cons_f1604(m):
|
|
return Less(S(-1), m, S(2))
|
|
|
|
cons1604 = CustomConstraint(cons_f1604)
|
|
|
|
def cons_f1605(n):
|
|
return Less(S(1), n, S(3))
|
|
|
|
cons1605 = CustomConstraint(cons_f1605)
|
|
|
|
def cons_f1606(a, b, d, e, f, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, d, e, f, m, n), x)
|
|
|
|
cons1606 = CustomConstraint(cons_f1606)
|
|
|
|
def cons_f1607(a, b, e, f, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, e, f, m), x)
|
|
|
|
cons1607 = CustomConstraint(cons_f1607)
|
|
|
|
def cons_f1608(a, b, m, p):
|
|
return Or(ZeroQ(a**S(2) - b**S(2)), IntegersQ(S(2)*m, p))
|
|
|
|
cons1608 = CustomConstraint(cons_f1608)
|
|
|
|
def cons_f1609(n):
|
|
return IntegerQ(n + S(-1)/2)
|
|
|
|
cons1609 = CustomConstraint(cons_f1609)
|
|
|
|
def cons_f1610(m):
|
|
return NegativeIntegerQ(m + S(1)/2)
|
|
|
|
cons1610 = CustomConstraint(cons_f1610)
|
|
|
|
def cons_f1611(m):
|
|
return Or(IntegerQ(m/S(2)), LessEqual(m, S(1)))
|
|
|
|
cons1611 = CustomConstraint(cons_f1611)
|
|
|
|
def cons_f1612(m, n):
|
|
return Less(m + n, S(2))
|
|
|
|
cons1612 = CustomConstraint(cons_f1612)
|
|
|
|
def cons_f1613(m, n):
|
|
return Not(And(IntegerQ(n), Greater(m - n, S(0))))
|
|
|
|
cons1613 = CustomConstraint(cons_f1613)
|
|
|
|
def cons_f1614(n):
|
|
return Greater(n, S(1)/2)
|
|
|
|
cons1614 = CustomConstraint(cons_f1614)
|
|
|
|
def cons_f1615(n):
|
|
return Not(And(RationalQ(n), LessEqual(n, S(-1)/2)))
|
|
|
|
cons1615 = CustomConstraint(cons_f1615)
|
|
|
|
def cons_f1616(m, n):
|
|
return MemberQ(List(S(0), S(-1), S(-2)), m + n)
|
|
|
|
cons1616 = CustomConstraint(cons_f1616)
|
|
|
|
def cons_f1617(m, n):
|
|
return Not(And(PositiveIntegerQ(n + S(1)/2), Less(n + S(1)/2, -m - n)))
|
|
|
|
cons1617 = CustomConstraint(cons_f1617)
|
|
|
|
def cons_f1618(m, n):
|
|
return Not(And(PositiveIntegerQ(m + S(-1)/2), Less(m, n)))
|
|
|
|
cons1618 = CustomConstraint(cons_f1618)
|
|
|
|
def cons_f1619(m, n):
|
|
return GreaterEqual(-m + n, S(0))
|
|
|
|
cons1619 = CustomConstraint(cons_f1619)
|
|
|
|
def cons_f1620(m, n):
|
|
return Greater(m*n, S(0))
|
|
|
|
cons1620 = CustomConstraint(cons_f1620)
|
|
|
|
def cons_f1621(m, n):
|
|
return Or(NegativeIntegerQ(m, n + S(-1)/2), And(NegativeIntegerQ(m + S(-1)/2, n + S(-1)/2), Less(m, n)))
|
|
|
|
cons1621 = CustomConstraint(cons_f1621)
|
|
|
|
def cons_f1622(m, p):
|
|
return Or(ZeroQ(p + S(-1)), IntegerQ(m + S(-1)/2))
|
|
|
|
cons1622 = CustomConstraint(cons_f1622)
|
|
|
|
def cons_f1623(m, n, p):
|
|
return ZeroQ(m + n + p)
|
|
|
|
cons1623 = CustomConstraint(cons_f1623)
|
|
|
|
def cons_f1624(m, n, p):
|
|
return MemberQ(List(S(-1), S(-2)), m + n + p)
|
|
|
|
cons1624 = CustomConstraint(cons_f1624)
|
|
|
|
def cons_f1625(A, B, a, b, m):
|
|
return ZeroQ(A*b*(m + S(1)) + B*a*m)
|
|
|
|
cons1625 = CustomConstraint(cons_f1625)
|
|
|
|
def cons_f1626(A, B, a, b, m):
|
|
return NonzeroQ(A*b*(m + S(1)) + B*a*m)
|
|
|
|
cons1626 = CustomConstraint(cons_f1626)
|
|
|
|
def cons_f1627(A, B):
|
|
return ZeroQ(A**S(2) - B**S(2))
|
|
|
|
cons1627 = CustomConstraint(cons_f1627)
|
|
|
|
def cons_f1628(A, B):
|
|
return NonzeroQ(A**S(2) - B**S(2))
|
|
|
|
cons1628 = CustomConstraint(cons_f1628)
|
|
|
|
def cons_f1629(A, B, a, b, m, n):
|
|
return ZeroQ(A*a*m - B*b*n)
|
|
|
|
cons1629 = CustomConstraint(cons_f1629)
|
|
|
|
def cons_f1630(A, B, a, b, n):
|
|
return ZeroQ(A*b*(S(2)*n + S(1)) + S(2)*B*a*n)
|
|
|
|
cons1630 = CustomConstraint(cons_f1630)
|
|
|
|
def cons_f1631(A, B, a, b, n):
|
|
return NonzeroQ(A*b*(S(2)*n + S(1)) + S(2)*B*a*n)
|
|
|
|
cons1631 = CustomConstraint(cons_f1631)
|
|
|
|
def cons_f1632(m, n):
|
|
return Not(And(IntegerQ(n), Greater(n, S(1)), Not(IntegerQ(m))))
|
|
|
|
cons1632 = CustomConstraint(cons_f1632)
|
|
|
|
def cons_f1633(m, n):
|
|
return Not(NegativeIntegerQ(m + S(1)/2, n))
|
|
|
|
cons1633 = CustomConstraint(cons_f1633)
|
|
|
|
def cons_f1634(m):
|
|
return Not(And(IntegerQ(m), Greater(m, S(1))))
|
|
|
|
cons1634 = CustomConstraint(cons_f1634)
|
|
|
|
def cons_f1635(A, C, m):
|
|
return ZeroQ(A*(m + S(1)) + C*m)
|
|
|
|
cons1635 = CustomConstraint(cons_f1635)
|
|
|
|
def cons_f1636(A, C, m):
|
|
return NonzeroQ(A*(m + S(1)) + C*m)
|
|
|
|
cons1636 = CustomConstraint(cons_f1636)
|
|
|
|
def cons_f1637(A, B, C, b, e, f, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(b, e, f, A, B, C, m), x)
|
|
|
|
cons1637 = CustomConstraint(cons_f1637)
|
|
|
|
def cons_f1638(A, B, C, a, b, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, e, f, A, B, C), x)
|
|
|
|
cons1638 = CustomConstraint(cons_f1638)
|
|
|
|
def cons_f1639(A, C, a, b, e, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, e, f, A, C), x)
|
|
|
|
cons1639 = CustomConstraint(cons_f1639)
|
|
|
|
def cons_f1640(m):
|
|
return PositiveIntegerQ(S(2)*m)
|
|
|
|
cons1640 = CustomConstraint(cons_f1640)
|
|
|
|
def cons_f1641(m, n):
|
|
return Or(And(RationalQ(n), Less(n, S(-1)/2)), ZeroQ(m + n + S(1)))
|
|
|
|
cons1641 = CustomConstraint(cons_f1641)
|
|
|
|
def cons_f1642(n):
|
|
return Not(And(RationalQ(n), Less(n, S(-1)/2)))
|
|
|
|
cons1642 = CustomConstraint(cons_f1642)
|
|
|
|
def cons_f1643(A, B, C, a, b, d, e, f, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, d, e, f, A, B, C, m, n), x)
|
|
|
|
cons1643 = CustomConstraint(cons_f1643)
|
|
|
|
def cons_f1644(A, C, a, b, d, e, f, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, d, e, f, A, C, m, n), x)
|
|
|
|
cons1644 = CustomConstraint(cons_f1644)
|
|
|
|
def cons_f1645(b, c, d, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(b, c, d, n), x)
|
|
|
|
cons1645 = CustomConstraint(cons_f1645)
|
|
|
|
def cons_f1646(n):
|
|
return Unequal(n, S(2))
|
|
|
|
cons1646 = CustomConstraint(cons_f1646)
|
|
|
|
def cons_f1647(p):
|
|
return NonzeroQ(p + S(-1))
|
|
|
|
cons1647 = CustomConstraint(cons_f1647)
|
|
|
|
def cons_f1648(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return KnownSineIntegrandQ(u, x)
|
|
|
|
cons1648 = CustomConstraint(cons_f1648)
|
|
|
|
def cons_f1649(A, B, C, a, b, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, A, B, C), x)
|
|
|
|
cons1649 = CustomConstraint(cons_f1649)
|
|
|
|
def cons_f1650(n, n1):
|
|
return ZeroQ(-n + n1 + S(-1))
|
|
|
|
cons1650 = CustomConstraint(cons_f1650)
|
|
|
|
def cons_f1651(n, n2):
|
|
return ZeroQ(-n + n2 + S(-2))
|
|
|
|
cons1651 = CustomConstraint(cons_f1651)
|
|
|
|
def cons_f1652(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return KnownTangentIntegrandQ(u, x)
|
|
|
|
cons1652 = CustomConstraint(cons_f1652)
|
|
|
|
def cons_f1653(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return KnownCotangentIntegrandQ(u, x)
|
|
|
|
cons1653 = CustomConstraint(cons_f1653)
|
|
|
|
def cons_f1654(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return KnownSecantIntegrandQ(u, x)
|
|
|
|
cons1654 = CustomConstraint(cons_f1654)
|
|
|
|
def cons_f1655(b, d):
|
|
return NonzeroQ(b**S(2) - d**S(2))
|
|
|
|
cons1655 = CustomConstraint(cons_f1655)
|
|
|
|
def cons_f1656(b, d):
|
|
return ZeroQ(S(-2) + d/b)
|
|
|
|
cons1656 = CustomConstraint(cons_f1656)
|
|
|
|
def cons_f1657(m, p):
|
|
return Or(Greater(m, S(3)), Equal(p, S(-3)/2))
|
|
|
|
cons1657 = CustomConstraint(cons_f1657)
|
|
|
|
def cons_f1658(m, p):
|
|
return Or(Less(p, S(-2)), Equal(m, S(2)))
|
|
|
|
cons1658 = CustomConstraint(cons_f1658)
|
|
|
|
def cons_f1659(m, n, p):
|
|
return ZeroQ(m + n + S(2)*p + S(2))
|
|
|
|
cons1659 = CustomConstraint(cons_f1659)
|
|
|
|
def cons_f1660(m):
|
|
return Greater(m, S(3))
|
|
|
|
cons1660 = CustomConstraint(cons_f1660)
|
|
|
|
def cons_f1661(n, p):
|
|
return NonzeroQ(n + p + S(1))
|
|
|
|
cons1661 = CustomConstraint(cons_f1661)
|
|
|
|
def cons_f1662(m, n, p):
|
|
return NonzeroQ(m + n + S(2)*p + S(2))
|
|
|
|
cons1662 = CustomConstraint(cons_f1662)
|
|
|
|
def cons_f1663(m, p):
|
|
return Or(Less(p, S(-2)), Equal(m, S(2)), Equal(m, S(3)))
|
|
|
|
cons1663 = CustomConstraint(cons_f1663)
|
|
|
|
def cons_f1664(m, n, p):
|
|
return NonzeroQ(m + n + S(2)*p)
|
|
|
|
cons1664 = CustomConstraint(cons_f1664)
|
|
|
|
def cons_f1665(b, d, m):
|
|
return ZeroQ(-Abs(m + S(2)) + d/b)
|
|
|
|
cons1665 = CustomConstraint(cons_f1665)
|
|
|
|
def cons_f1666(F):
|
|
return InertTrigQ(F)
|
|
|
|
cons1666 = CustomConstraint(cons_f1666)
|
|
|
|
def cons_f1667(F, G):
|
|
return InertTrigQ(F, G)
|
|
|
|
cons1667 = CustomConstraint(cons_f1667)
|
|
|
|
def cons_f1668(F):
|
|
return Or(SameQ(F, Cos), SameQ(F, cos))
|
|
|
|
cons1668 = CustomConstraint(cons_f1668)
|
|
|
|
def cons_f1669(F):
|
|
return Or(SameQ(F, Sin), SameQ(F, sin))
|
|
|
|
cons1669 = CustomConstraint(cons_f1669)
|
|
|
|
def cons_f1670(F):
|
|
return Or(SameQ(F, Cot), SameQ(F, cot))
|
|
|
|
cons1670 = CustomConstraint(cons_f1670)
|
|
|
|
def cons_f1671(F):
|
|
return Or(SameQ(F, Tan), SameQ(F, tan))
|
|
|
|
cons1671 = CustomConstraint(cons_f1671)
|
|
|
|
def cons_f1672(F):
|
|
return Or(SameQ(F, Sec), SameQ(F, sec))
|
|
|
|
cons1672 = CustomConstraint(cons_f1672)
|
|
|
|
def cons_f1673(F):
|
|
return Or(SameQ(F, Csc), SameQ(F, csc))
|
|
|
|
cons1673 = CustomConstraint(cons_f1673)
|
|
|
|
def cons_f1674(F):
|
|
return Or(SameQ(F, sin), SameQ(F, cos))
|
|
|
|
cons1674 = CustomConstraint(cons_f1674)
|
|
|
|
def cons_f1675(G):
|
|
return Or(SameQ(G, sin), SameQ(G, cos))
|
|
|
|
cons1675 = CustomConstraint(cons_f1675)
|
|
|
|
def cons_f1676(H):
|
|
return Or(SameQ(H, sin), SameQ(H, cos))
|
|
|
|
cons1676 = CustomConstraint(cons_f1676)
|
|
|
|
def cons_f1677(b, c):
|
|
return ZeroQ(b - c)
|
|
|
|
cons1677 = CustomConstraint(cons_f1677)
|
|
|
|
def cons_f1678(b, c):
|
|
return ZeroQ(b + c)
|
|
|
|
cons1678 = CustomConstraint(cons_f1678)
|
|
|
|
def cons_f1679(u):
|
|
return Not(InertTrigFreeQ(u))
|
|
|
|
cons1679 = CustomConstraint(cons_f1679)
|
|
|
|
def cons_f1680(p):
|
|
return NegQ(p)
|
|
|
|
cons1680 = CustomConstraint(cons_f1680)
|
|
|
|
def cons_f1681(u):
|
|
return TrigSimplifyQ(u)
|
|
|
|
cons1681 = CustomConstraint(cons_f1681)
|
|
|
|
def cons_f1682(v):
|
|
return Not(InertTrigFreeQ(v))
|
|
|
|
cons1682 = CustomConstraint(cons_f1682)
|
|
|
|
def cons_f1683(v, w):
|
|
return Or(Not(InertTrigFreeQ(v)), Not(InertTrigFreeQ(w)))
|
|
|
|
cons1683 = CustomConstraint(cons_f1683)
|
|
|
|
def cons_f1684(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return Not(FalseQ(FunctionOfTrig(u, x)))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons1684 = CustomConstraint(cons_f1684)
|
|
|
|
def cons_f1685(p):
|
|
return SameQ(p, S(1))
|
|
|
|
cons1685 = CustomConstraint(cons_f1685)
|
|
|
|
def cons_f1686(n, p):
|
|
return Or(EvenQ(n), OddQ(p))
|
|
|
|
cons1686 = CustomConstraint(cons_f1686)
|
|
|
|
def cons_f1687(n, p):
|
|
return Unequal(n, p)
|
|
|
|
cons1687 = CustomConstraint(cons_f1687)
|
|
|
|
def cons_f1688(F):
|
|
return TrigQ(F)
|
|
|
|
cons1688 = CustomConstraint(cons_f1688)
|
|
|
|
def cons_f1689(G):
|
|
return TrigQ(G)
|
|
|
|
cons1689 = CustomConstraint(cons_f1689)
|
|
|
|
def cons_f1690(v, w):
|
|
return ZeroQ(v - w)
|
|
|
|
cons1690 = CustomConstraint(cons_f1690)
|
|
|
|
def cons_f1691(F):
|
|
return MemberQ(List(Sin, Cos), F)
|
|
|
|
cons1691 = CustomConstraint(cons_f1691)
|
|
|
|
def cons_f1692(G):
|
|
return MemberQ(List(Sec, Csc), G)
|
|
|
|
cons1692 = CustomConstraint(cons_f1692)
|
|
|
|
def cons_f1693(b, d):
|
|
return PositiveIntegerQ(b/d + S(-1))
|
|
|
|
cons1693 = CustomConstraint(cons_f1693)
|
|
|
|
def cons_f1694(F, b, c, e):
|
|
return NonzeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2))
|
|
|
|
cons1694 = CustomConstraint(cons_f1694)
|
|
|
|
def cons_f1695(F, b, c, e, n):
|
|
return NonzeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*n**S(2))
|
|
|
|
cons1695 = CustomConstraint(cons_f1695)
|
|
|
|
def cons_f1696(F, b, c, e, m):
|
|
return NonzeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*m**S(2))
|
|
|
|
cons1696 = CustomConstraint(cons_f1696)
|
|
|
|
def cons_f1697(F, b, c, e, n):
|
|
return ZeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(2))**S(2))
|
|
|
|
cons1697 = CustomConstraint(cons_f1697)
|
|
|
|
def cons_f1698(F, b, c, e, n):
|
|
return NonzeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(2))**S(2))
|
|
|
|
cons1698 = CustomConstraint(cons_f1698)
|
|
|
|
def cons_f1699(F, b, c, e, n):
|
|
return ZeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(-2))**S(2))
|
|
|
|
cons1699 = CustomConstraint(cons_f1699)
|
|
|
|
def cons_f1700(F, b, c, e, n):
|
|
return NonzeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(-2))**S(2))
|
|
|
|
cons1700 = CustomConstraint(cons_f1700)
|
|
|
|
def cons_f1701(f, g):
|
|
return ZeroQ(f**S(2) - g**S(2))
|
|
|
|
cons1701 = CustomConstraint(cons_f1701)
|
|
|
|
def cons_f1702(f, g):
|
|
return ZeroQ(f - g)
|
|
|
|
cons1702 = CustomConstraint(cons_f1702)
|
|
|
|
def cons_f1703(h, i):
|
|
return ZeroQ(h**S(2) - i**S(2))
|
|
|
|
cons1703 = CustomConstraint(cons_f1703)
|
|
|
|
def cons_f1704(f, g, h, i):
|
|
return ZeroQ(-f*i + g*h)
|
|
|
|
cons1704 = CustomConstraint(cons_f1704)
|
|
|
|
def cons_f1705(f, g, h, i):
|
|
return ZeroQ(f*i + g*h)
|
|
|
|
cons1705 = CustomConstraint(cons_f1705)
|
|
|
|
def cons_f1706(m, n, p):
|
|
return PositiveIntegerQ(m, n, p)
|
|
|
|
cons1706 = CustomConstraint(cons_f1706)
|
|
|
|
def cons_f1707(H):
|
|
return TrigQ(H)
|
|
|
|
cons1707 = CustomConstraint(cons_f1707)
|
|
|
|
def cons_f1708(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(LinearQ(u, x), PolyQ(u, x, S(2)))
|
|
|
|
cons1708 = CustomConstraint(cons_f1708)
|
|
|
|
def cons_f1709(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(LinearQ(v, x), PolyQ(v, x, S(2)))
|
|
|
|
cons1709 = CustomConstraint(cons_f1709)
|
|
|
|
def cons_f1710(b, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + S(1))
|
|
|
|
cons1710 = CustomConstraint(cons_f1710)
|
|
|
|
def cons_f1711(b, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*p**S(2) + S(1))
|
|
|
|
cons1711 = CustomConstraint(cons_f1711)
|
|
|
|
def cons_f1712(b, n):
|
|
return NonzeroQ(b**S(2)*n**S(2) + S(1))
|
|
|
|
cons1712 = CustomConstraint(cons_f1712)
|
|
|
|
def cons_f1713(b, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*p**S(2) + S(1))
|
|
|
|
cons1713 = CustomConstraint(cons_f1713)
|
|
|
|
def cons_f1714(b, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + S(1))
|
|
|
|
cons1714 = CustomConstraint(cons_f1714)
|
|
|
|
def cons_f1715(b, m, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + (m + S(1))**S(2))
|
|
|
|
cons1715 = CustomConstraint(cons_f1715)
|
|
|
|
def cons_f1716(b, m, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*p**S(2) + (m + S(1))**S(2))
|
|
|
|
cons1716 = CustomConstraint(cons_f1716)
|
|
|
|
def cons_f1717(b, m, n):
|
|
return NonzeroQ(b**S(2)*n**S(2) + (m + S(1))**S(2))
|
|
|
|
cons1717 = CustomConstraint(cons_f1717)
|
|
|
|
def cons_f1718(b, m, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*p**S(2) + (m + S(1))**S(2))
|
|
|
|
cons1718 = CustomConstraint(cons_f1718)
|
|
|
|
def cons_f1719(b, m, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + (m + S(1))**S(2))
|
|
|
|
cons1719 = CustomConstraint(cons_f1719)
|
|
|
|
def cons_f1720(b, n):
|
|
return ZeroQ(b**S(2)*n**S(2) + S(1))
|
|
|
|
cons1720 = CustomConstraint(cons_f1720)
|
|
|
|
def cons_f1721(b, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + S(1))
|
|
|
|
cons1721 = CustomConstraint(cons_f1721)
|
|
|
|
def cons_f1722(p):
|
|
return Unequal(p, S(2))
|
|
|
|
cons1722 = CustomConstraint(cons_f1722)
|
|
|
|
def cons_f1723(b, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + S(1))
|
|
|
|
cons1723 = CustomConstraint(cons_f1723)
|
|
|
|
def cons_f1724(b, m, n):
|
|
return ZeroQ(b**S(2)*n**S(2) + (m + S(1))**S(2))
|
|
|
|
cons1724 = CustomConstraint(cons_f1724)
|
|
|
|
def cons_f1725(b, m, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + (m + S(1))**S(2))
|
|
|
|
cons1725 = CustomConstraint(cons_f1725)
|
|
|
|
def cons_f1726(b, m, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + (m + S(1))**S(2))
|
|
|
|
cons1726 = CustomConstraint(cons_f1726)
|
|
|
|
def cons_f1727(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return QuotientOfLinearsQ(u, x)
|
|
|
|
cons1727 = CustomConstraint(cons_f1727)
|
|
|
|
def cons_f1728(v, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(And(PolynomialQ(v, x), PolynomialQ(w, x)), And(BinomialQ(List(v, w), x), IndependentQ(v/w, x)))
|
|
|
|
cons1728 = CustomConstraint(cons_f1728)
|
|
|
|
def cons_f1729(m, p, q):
|
|
return PositiveIntegerQ(m, p, q)
|
|
|
|
cons1729 = CustomConstraint(cons_f1729)
|
|
|
|
def cons_f1730(v, w):
|
|
return NonzeroQ(v - w)
|
|
|
|
cons1730 = CustomConstraint(cons_f1730)
|
|
|
|
def cons_f1731(m, n):
|
|
return Or(Equal(n, S(-1)), And(Equal(m, S(1)), Equal(n, S(-2))))
|
|
|
|
cons1731 = CustomConstraint(cons_f1731)
|
|
|
|
def cons_f1732(a, c):
|
|
return NonzeroQ(a + c)
|
|
|
|
cons1732 = CustomConstraint(cons_f1732)
|
|
|
|
def cons_f1733(a, b):
|
|
return PosQ(a**S(2) - b**S(2))
|
|
|
|
cons1733 = CustomConstraint(cons_f1733)
|
|
|
|
def cons_f1734(a, b):
|
|
return NegQ(a**S(2) - b**S(2))
|
|
|
|
cons1734 = CustomConstraint(cons_f1734)
|
|
|
|
def cons_f1735(b, d):
|
|
return ZeroQ(b**S(2) - d**S(2))
|
|
|
|
cons1735 = CustomConstraint(cons_f1735)
|
|
|
|
def cons_f1736(n):
|
|
return Inequality(S(-2), LessEqual, n, Less, S(-1))
|
|
|
|
cons1736 = CustomConstraint(cons_f1736)
|
|
|
|
def cons_f1737(n):
|
|
return Less(n, S(-2))
|
|
|
|
cons1737 = CustomConstraint(cons_f1737)
|
|
|
|
def cons_f1738(a, b, c, d, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, m, n), x)
|
|
|
|
cons1738 = CustomConstraint(cons_f1738)
|
|
|
|
def cons_f1739(c, d, e):
|
|
return ZeroQ(c**S(2)*d + e)
|
|
|
|
cons1739 = CustomConstraint(cons_f1739)
|
|
|
|
def cons_f1740(d):
|
|
return Not(PositiveQ(d))
|
|
|
|
cons1740 = CustomConstraint(cons_f1740)
|
|
|
|
def cons_f1741(p):
|
|
return PositiveIntegerQ(S(2)*p)
|
|
|
|
cons1741 = CustomConstraint(cons_f1741)
|
|
|
|
def cons_f1742(d, p):
|
|
return Or(IntegerQ(p), PositiveQ(d))
|
|
|
|
cons1742 = CustomConstraint(cons_f1742)
|
|
|
|
def cons_f1743(d, p):
|
|
return Not(Or(IntegerQ(p), PositiveQ(d)))
|
|
|
|
cons1743 = CustomConstraint(cons_f1743)
|
|
|
|
def cons_f1744(c, d, e):
|
|
return NonzeroQ(c**S(2)*d + e)
|
|
|
|
cons1744 = CustomConstraint(cons_f1744)
|
|
|
|
def cons_f1745(p):
|
|
return Or(PositiveIntegerQ(p), NegativeIntegerQ(p + S(1)/2))
|
|
|
|
cons1745 = CustomConstraint(cons_f1745)
|
|
|
|
def cons_f1746(n, p):
|
|
return Or(Greater(p, S(0)), PositiveIntegerQ(n))
|
|
|
|
cons1746 = CustomConstraint(cons_f1746)
|
|
|
|
def cons_f1747(c, f, g):
|
|
return ZeroQ(c**S(2)*f**S(2) - g**S(2))
|
|
|
|
cons1747 = CustomConstraint(cons_f1747)
|
|
|
|
def cons_f1748(m):
|
|
return NegativeIntegerQ(m/S(2) + S(1)/2)
|
|
|
|
cons1748 = CustomConstraint(cons_f1748)
|
|
|
|
def cons_f1749(m, p):
|
|
return Or(PositiveIntegerQ(m/S(2) + S(1)/2), NegativeIntegerQ(m/S(2) + p + S(3)/2))
|
|
|
|
cons1749 = CustomConstraint(cons_f1749)
|
|
|
|
def cons_f1750(m, n):
|
|
return Or(RationalQ(m), ZeroQ(n + S(-1)))
|
|
|
|
cons1750 = CustomConstraint(cons_f1750)
|
|
|
|
def cons_f1751(m, n, p):
|
|
return Or(IntegerQ(m), IntegerQ(p), Equal(n, S(1)))
|
|
|
|
cons1751 = CustomConstraint(cons_f1751)
|
|
|
|
def cons_f1752(m, n):
|
|
return Or(IntegerQ(m), Equal(n, S(1)))
|
|
|
|
cons1752 = CustomConstraint(cons_f1752)
|
|
|
|
def cons_f1753(m):
|
|
return Greater(m, S(-3))
|
|
|
|
cons1753 = CustomConstraint(cons_f1753)
|
|
|
|
def cons_f1754(p):
|
|
return Greater(p, S(-1))
|
|
|
|
cons1754 = CustomConstraint(cons_f1754)
|
|
|
|
def cons_f1755(m):
|
|
return Not(PositiveIntegerQ(m/S(2) + S(1)/2))
|
|
|
|
cons1755 = CustomConstraint(cons_f1755)
|
|
|
|
def cons_f1756(m):
|
|
return Less(S(-3), m, S(0))
|
|
|
|
cons1756 = CustomConstraint(cons_f1756)
|
|
|
|
def cons_f1757(m, p):
|
|
return Or(Greater(p, S(0)), And(PositiveIntegerQ(m/S(2) + S(-1)/2), LessEqual(m + p, S(0))))
|
|
|
|
cons1757 = CustomConstraint(cons_f1757)
|
|
|
|
def cons_f1758(a, b, c, d, e, f, m, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, m, n, p), x)
|
|
|
|
cons1758 = CustomConstraint(cons_f1758)
|
|
|
|
def cons_f1759(m, p):
|
|
return Less(m + p + S(1), S(0))
|
|
|
|
cons1759 = CustomConstraint(cons_f1759)
|
|
|
|
def cons_f1760(d, e, g, h):
|
|
return ZeroQ(-S(2)*d*h + e*g)
|
|
|
|
cons1760 = CustomConstraint(cons_f1760)
|
|
|
|
def cons_f1761(m, p):
|
|
return Or(Less(m, -S(2)*p + S(-1)), Greater(m, S(3)))
|
|
|
|
cons1761 = CustomConstraint(cons_f1761)
|
|
|
|
def cons_f1762(m, n, p):
|
|
return Or(And(Equal(n, S(1)), Greater(p, S(-1))), Greater(p, S(0)), Equal(m, S(1)), And(Equal(m, S(2)), Less(p, S(-2))))
|
|
|
|
cons1762 = CustomConstraint(cons_f1762)
|
|
|
|
def cons_f1763(m, n):
|
|
return Or(Greater(m, S(0)), PositiveIntegerQ(n))
|
|
|
|
cons1763 = CustomConstraint(cons_f1763)
|
|
|
|
def cons_f1764(A, B, c, d):
|
|
return ZeroQ(S(2)*A*c*d + B*(S(1) - c**S(2)))
|
|
|
|
cons1764 = CustomConstraint(cons_f1764)
|
|
|
|
def cons_f1765(B, C, c, d):
|
|
return ZeroQ(-B*d + S(2)*C*c)
|
|
|
|
cons1765 = CustomConstraint(cons_f1765)
|
|
|
|
def cons_f1766(c):
|
|
return ZeroQ(c**S(2) + S(-1))
|
|
|
|
cons1766 = CustomConstraint(cons_f1766)
|
|
|
|
def cons_f1767(a, b, d, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, d), x)
|
|
|
|
cons1767 = CustomConstraint(cons_f1767)
|
|
|
|
def cons_f1768(a, b, c, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, n, m), x)
|
|
|
|
cons1768 = CustomConstraint(cons_f1768)
|
|
|
|
def cons_f1769(b, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(b, n), x)
|
|
|
|
cons1769 = CustomConstraint(cons_f1769)
|
|
|
|
def cons_f1770(b, c):
|
|
return EqQ(b**S(2)*c, S(1))
|
|
|
|
cons1770 = CustomConstraint(cons_f1770)
|
|
|
|
def cons_f1771(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(FunctionOfExponentialQ(u, x))
|
|
|
|
cons1771 = CustomConstraint(cons_f1771)
|
|
|
|
def cons_f1772(c, d, m, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(FunctionOfQ((c + d*x)**(m + S(1)), u, x))
|
|
|
|
cons1772 = CustomConstraint(cons_f1772)
|
|
|
|
def cons_f1773(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1772(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1772 = CustomConstraint(_cons_f_1772)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1772)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1773 = CustomConstraint(cons_f1773)
|
|
|
|
def cons_f1774(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1773(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1773 = CustomConstraint(_cons_f_1773)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1773)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1774 = CustomConstraint(cons_f1774)
|
|
|
|
def cons_f1775(c, d, e):
|
|
return ZeroQ(c**S(2)*d**S(2) + e**S(2))
|
|
|
|
cons1775 = CustomConstraint(cons_f1775)
|
|
|
|
def cons_f1776(c, d, e):
|
|
return PositiveQ(I*c*d/e + S(1))
|
|
|
|
cons1776 = CustomConstraint(cons_f1776)
|
|
|
|
def cons_f1777(c, d, e):
|
|
return NegativeQ(I*c*d/e + S(-1))
|
|
|
|
cons1777 = CustomConstraint(cons_f1777)
|
|
|
|
def cons_f1778(c, d, e, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(c, d, e), x)
|
|
|
|
cons1778 = CustomConstraint(cons_f1778)
|
|
|
|
def cons_f1779(a, m, p):
|
|
return Or(Greater(p, S(0)), NonzeroQ(a), IntegerQ(m))
|
|
|
|
cons1779 = CustomConstraint(cons_f1779)
|
|
|
|
def cons_f1780(c, d, e):
|
|
return ZeroQ(-c**S(2)*d + e)
|
|
|
|
cons1780 = CustomConstraint(cons_f1780)
|
|
|
|
def cons_f1781(p):
|
|
return NegativeIntegerQ(S(2)*p + S(2))
|
|
|
|
cons1781 = CustomConstraint(cons_f1781)
|
|
|
|
def cons_f1782(p):
|
|
return Or(IntegerQ(p), NegativeIntegerQ(p + S(1)/2))
|
|
|
|
cons1782 = CustomConstraint(cons_f1782)
|
|
|
|
def cons_f1783(a, m):
|
|
return Not(And(Equal(m, S(1)), NonzeroQ(a)))
|
|
|
|
cons1783 = CustomConstraint(cons_f1783)
|
|
|
|
def cons_f1784(p):
|
|
return Unequal(p, S(-5)/2)
|
|
|
|
cons1784 = CustomConstraint(cons_f1784)
|
|
|
|
def cons_f1785(m, n, p):
|
|
return Or(RationalQ(m), And(EqQ(n, S(1)), IntegerQ(p)))
|
|
|
|
cons1785 = CustomConstraint(cons_f1785)
|
|
|
|
def cons_f1786(m, n, p):
|
|
return IntegersQ(m, n, S(2)*p)
|
|
|
|
cons1786 = CustomConstraint(cons_f1786)
|
|
|
|
def cons_f1787(m, p):
|
|
return NegativeIntegerQ(m + S(2)*p + S(1))
|
|
|
|
cons1787 = CustomConstraint(cons_f1787)
|
|
|
|
def cons_f1788(m, p):
|
|
return Or(And(PositiveIntegerQ(p), Not(And(NegativeIntegerQ(m/S(2) + S(-1)/2), Greater(m + S(2)*p + S(3), S(0))))), And(PositiveIntegerQ(m/S(2) + S(1)/2), Not(And(NegativeIntegerQ(p), Greater(m + S(2)*p + S(3), S(0))))), And(NegativeIntegerQ(m/S(2) + p + S(1)/2), Not(NegativeIntegerQ(m/S(2) + S(-1)/2))))
|
|
|
|
cons1788 = CustomConstraint(cons_f1788)
|
|
|
|
def cons_f1789(m, p):
|
|
return Or(Greater(p, S(0)), And(Less(p, S(-1)), IntegerQ(m), Unequal(m, S(1))))
|
|
|
|
cons1789 = CustomConstraint(cons_f1789)
|
|
|
|
def cons_f1790(a, b, c, d, e, m, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, m, p), x)
|
|
|
|
cons1790 = CustomConstraint(cons_f1790)
|
|
|
|
def cons_f1791(c, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(u**S(2) - (S(1) - S(2)*I/(c*x + I))**S(2))
|
|
|
|
cons1791 = CustomConstraint(cons_f1791)
|
|
|
|
def cons_f1792(c, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(u**S(2) - (S(1) - S(2)*I/(-c*x + I))**S(2))
|
|
|
|
cons1792 = CustomConstraint(cons_f1792)
|
|
|
|
def cons_f1793(c, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ((S(1) - u)**S(2) - (S(1) - S(2)*I/(c*x + I))**S(2))
|
|
|
|
cons1793 = CustomConstraint(cons_f1793)
|
|
|
|
def cons_f1794(c, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ((S(1) - u)**S(2) - (S(1) - S(2)*I/(-c*x + I))**S(2))
|
|
|
|
cons1794 = CustomConstraint(cons_f1794)
|
|
|
|
def cons_f1795(m, n):
|
|
return Inequality(S(0), Less, n, LessEqual, m)
|
|
|
|
cons1795 = CustomConstraint(cons_f1795)
|
|
|
|
def cons_f1796(m, n):
|
|
return Less(S(0), n, m)
|
|
|
|
cons1796 = CustomConstraint(cons_f1796)
|
|
|
|
def cons_f1797(a, c, d, n):
|
|
return Not(And(Equal(n, S(2)), ZeroQ(-a**S(2)*c + d)))
|
|
|
|
cons1797 = CustomConstraint(cons_f1797)
|
|
|
|
def cons_f1798(a, b, c, d, e, f, g, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, e, f, g), x)
|
|
|
|
cons1798 = CustomConstraint(cons_f1798)
|
|
|
|
def cons_f1799(m):
|
|
return PositiveIntegerQ(m/S(2) + S(1)/2)
|
|
|
|
cons1799 = CustomConstraint(cons_f1799)
|
|
|
|
def cons_f1800(c, f, g):
|
|
return ZeroQ(-c**S(2)*f + g)
|
|
|
|
cons1800 = CustomConstraint(cons_f1800)
|
|
|
|
def cons_f1801(n):
|
|
return OddQ(I*n)
|
|
|
|
cons1801 = CustomConstraint(cons_f1801)
|
|
|
|
def cons_f1802(n):
|
|
return Not(OddQ(I*n))
|
|
|
|
cons1802 = CustomConstraint(cons_f1802)
|
|
|
|
def cons_f1803(a, c, d):
|
|
return ZeroQ(a**S(2)*c**S(2) + d**S(2))
|
|
|
|
cons1803 = CustomConstraint(cons_f1803)
|
|
|
|
def cons_f1804(c, p):
|
|
return Or(IntegerQ(p), PositiveQ(c))
|
|
|
|
cons1804 = CustomConstraint(cons_f1804)
|
|
|
|
def cons_f1805(c, p):
|
|
return Not(Or(IntegerQ(p), PositiveQ(c)))
|
|
|
|
cons1805 = CustomConstraint(cons_f1805)
|
|
|
|
def cons_f1806(a, c, d):
|
|
return ZeroQ(a**S(2)*d**S(2) + c**S(2))
|
|
|
|
cons1806 = CustomConstraint(cons_f1806)
|
|
|
|
def cons_f1807(n):
|
|
return IntegerQ(I*n/S(2))
|
|
|
|
cons1807 = CustomConstraint(cons_f1807)
|
|
|
|
def cons_f1808(a, c, d):
|
|
return ZeroQ(-a**S(2)*c + d)
|
|
|
|
cons1808 = CustomConstraint(cons_f1808)
|
|
|
|
def cons_f1809(n):
|
|
return Not(IntegerQ(I*n))
|
|
|
|
cons1809 = CustomConstraint(cons_f1809)
|
|
|
|
def cons_f1810(n, p):
|
|
return NonzeroQ(n**S(2) + S(4)*(p + S(1))**S(2))
|
|
|
|
cons1810 = CustomConstraint(cons_f1810)
|
|
|
|
def cons_f1811(n):
|
|
return IntegerQ(I*n/S(2) + S(1)/2)
|
|
|
|
cons1811 = CustomConstraint(cons_f1811)
|
|
|
|
def cons_f1812(n, p):
|
|
return Not(IntegerQ(-I*n/S(2) + p))
|
|
|
|
cons1812 = CustomConstraint(cons_f1812)
|
|
|
|
def cons_f1813(n):
|
|
return PositiveIntegerQ(I*n/S(2))
|
|
|
|
cons1813 = CustomConstraint(cons_f1813)
|
|
|
|
def cons_f1814(n):
|
|
return NegativeIntegerQ(I*n/S(2))
|
|
|
|
cons1814 = CustomConstraint(cons_f1814)
|
|
|
|
def cons_f1815(n, p):
|
|
return ZeroQ(n**S(2) - S(2)*p + S(-2))
|
|
|
|
cons1815 = CustomConstraint(cons_f1815)
|
|
|
|
def cons_f1816(n):
|
|
return Not(IntegerQ(I*n/S(2)))
|
|
|
|
cons1816 = CustomConstraint(cons_f1816)
|
|
|
|
def cons_f1817(a, c, d):
|
|
return ZeroQ(-a**S(2)*d + c)
|
|
|
|
cons1817 = CustomConstraint(cons_f1817)
|
|
|
|
def cons_f1818(n):
|
|
return RationalQ(I*n)
|
|
|
|
cons1818 = CustomConstraint(cons_f1818)
|
|
|
|
def cons_f1819(n):
|
|
return Less(S(-1), I*n, S(1))
|
|
|
|
cons1819 = CustomConstraint(cons_f1819)
|
|
|
|
def cons_f1820(a, b, d, e):
|
|
return ZeroQ(-S(2)*a*e + b*d)
|
|
|
|
cons1820 = CustomConstraint(cons_f1820)
|
|
|
|
def cons_f1821(a, b, c, e):
|
|
return ZeroQ(b**S(2)*c - e*(a**S(2) + S(1)))
|
|
|
|
cons1821 = CustomConstraint(cons_f1821)
|
|
|
|
def cons_f1822(a, c, p):
|
|
return Or(IntegerQ(p), PositiveQ(c/(a**S(2) + S(1))))
|
|
|
|
cons1822 = CustomConstraint(cons_f1822)
|
|
|
|
def cons_f1823(a, c, p):
|
|
return Not(Or(IntegerQ(p), PositiveQ(c/(a**S(2) + S(1)))))
|
|
|
|
cons1823 = CustomConstraint(cons_f1823)
|
|
|
|
def cons_f1824(n, p):
|
|
return Not(And(IntegerQ(p), EvenQ(I*n)))
|
|
|
|
cons1824 = CustomConstraint(cons_f1824)
|
|
|
|
def cons_f1825(n, p):
|
|
return Not(And(Not(IntegerQ(p)), OddQ(I*n)))
|
|
|
|
cons1825 = CustomConstraint(cons_f1825)
|
|
|
|
def cons_f1826(p):
|
|
return LessEqual(p, S(-1))
|
|
|
|
cons1826 = CustomConstraint(cons_f1826)
|
|
|
|
def cons_f1827(n):
|
|
return NonzeroQ(n**S(2) + S(1))
|
|
|
|
cons1827 = CustomConstraint(cons_f1827)
|
|
|
|
def cons_f1828(n, p):
|
|
return NonzeroQ(n**S(2) - S(2)*p + S(-2))
|
|
|
|
cons1828 = CustomConstraint(cons_f1828)
|
|
|
|
def cons_f1829(m, p):
|
|
return LessEqual(S(3), m, -S(2)*p + S(-2))
|
|
|
|
cons1829 = CustomConstraint(cons_f1829)
|
|
|
|
def cons_f1830(n, p):
|
|
return IntegersQ(S(2)*p, I*n/S(2) + p)
|
|
|
|
cons1830 = CustomConstraint(cons_f1830)
|
|
|
|
def cons_f1831(n, p):
|
|
return Not(IntegersQ(S(2)*p, I*n/S(2) + p))
|
|
|
|
cons1831 = CustomConstraint(cons_f1831)
|
|
|
|
def cons_f1832(A, B, c, d):
|
|
return ZeroQ(-S(2)*A*c*d + B*(c**S(2) + S(1)))
|
|
|
|
cons1832 = CustomConstraint(cons_f1832)
|
|
|
|
def cons_f1833(a, b, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, n), x)
|
|
|
|
cons1833 = CustomConstraint(cons_f1833)
|
|
|
|
def cons_f1834(m):
|
|
return Unequal(m + S(1), S(0))
|
|
|
|
cons1834 = CustomConstraint(cons_f1834)
|
|
|
|
def cons_f1835(m, n):
|
|
return Unequal(m + S(1), n)
|
|
|
|
cons1835 = CustomConstraint(cons_f1835)
|
|
|
|
def cons_f1836(a, b, c, d, f, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, f), x)
|
|
|
|
cons1836 = CustomConstraint(cons_f1836)
|
|
|
|
def cons_f1837(b, c):
|
|
return ZeroQ(b + c**S(2))
|
|
|
|
cons1837 = CustomConstraint(cons_f1837)
|
|
|
|
def cons_f1838(s):
|
|
return ZeroQ(s**S(2) + S(-1))
|
|
|
|
cons1838 = CustomConstraint(cons_f1838)
|
|
|
|
def cons_f1839(v, w):
|
|
return ZeroQ(-v**S(2) + w + S(-1))
|
|
|
|
cons1839 = CustomConstraint(cons_f1839)
|
|
|
|
def cons_f1840(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return NegQ(Discriminant(v, x))
|
|
|
|
cons1840 = CustomConstraint(cons_f1840)
|
|
|
|
def cons_f1841(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1840(f, r, w):
|
|
return FreeQ(f, x)
|
|
_cons_1840 = CustomConstraint(_cons_f_1840)
|
|
pat = Pattern(UtilityOperator(f_**w_*WC('r', S(1)), x), _cons_1840)
|
|
result_matchq = is_match(UtilityOperator(u, x), pat)
|
|
return result_matchq
|
|
|
|
cons1841 = CustomConstraint(cons_f1841)
|
|
|
|
def cons_f1842(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1841(f, r, w):
|
|
return FreeQ(f, x)
|
|
_cons_1841 = CustomConstraint(_cons_f_1841)
|
|
pat = Pattern(UtilityOperator(f_**w_*WC('r', S(1)), x), _cons_1841)
|
|
result_matchq = is_match(UtilityOperator(u, x), pat)
|
|
return result_matchq
|
|
|
|
cons1842 = CustomConstraint(cons_f1842)
|
|
|
|
def cons_f1843(c, d):
|
|
return ZeroQ((c + I*d)**S(2) + S(1))
|
|
|
|
cons1843 = CustomConstraint(cons_f1843)
|
|
|
|
def cons_f1844(c, d):
|
|
return ZeroQ((c - I*d)**S(2) + S(1))
|
|
|
|
cons1844 = CustomConstraint(cons_f1844)
|
|
|
|
def cons_f1845(c, d):
|
|
return NonzeroQ((c + I*d)**S(2) + S(1))
|
|
|
|
cons1845 = CustomConstraint(cons_f1845)
|
|
|
|
def cons_f1846(c, d):
|
|
return NonzeroQ((c - I*d)**S(2) + S(1))
|
|
|
|
cons1846 = CustomConstraint(cons_f1846)
|
|
|
|
def cons_f1847(c, d):
|
|
return ZeroQ((c - d)**S(2) + S(1))
|
|
|
|
cons1847 = CustomConstraint(cons_f1847)
|
|
|
|
def cons_f1848(c, d):
|
|
return NonzeroQ((c - d)**S(2) + S(1))
|
|
|
|
cons1848 = CustomConstraint(cons_f1848)
|
|
|
|
def cons_f1849(m, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return FalseQ(PowerVariableExpn(u, m + S(1), x))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons1849 = CustomConstraint(cons_f1849)
|
|
|
|
def cons_f1850(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1849(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1849 = CustomConstraint(_cons_f_1849)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1849)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1850 = CustomConstraint(cons_f1850)
|
|
|
|
def cons_f1851(a, b, u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return FalseQ(FunctionOfLinear(v*(a + b*ArcTan(u)), x))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons1851 = CustomConstraint(cons_f1851)
|
|
|
|
def cons_f1852(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1851(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1851 = CustomConstraint(_cons_f_1851)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1851)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1852 = CustomConstraint(cons_f1852)
|
|
|
|
def cons_f1853(a, b, u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return FalseQ(FunctionOfLinear(v*(a + b*acot(u)), x))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons1853 = CustomConstraint(cons_f1853)
|
|
|
|
def cons_f1854(a, b, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(D(v/(a + b*x), x))
|
|
|
|
cons1854 = CustomConstraint(cons_f1854)
|
|
|
|
def cons_f1855(a, b, w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(D(w/(a + b*x), x))
|
|
|
|
cons1855 = CustomConstraint(cons_f1855)
|
|
|
|
def cons_f1856(a, b, c, m, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, m, n), x)
|
|
|
|
cons1856 = CustomConstraint(cons_f1856)
|
|
|
|
def cons_f1857(d):
|
|
return Negative(d)
|
|
|
|
cons1857 = CustomConstraint(cons_f1857)
|
|
|
|
def cons_f1858(d, e):
|
|
return Not(And(PositiveQ(e), Negative(d)))
|
|
|
|
cons1858 = CustomConstraint(cons_f1858)
|
|
|
|
def cons_f1859(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1858(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1858 = CustomConstraint(_cons_f_1858)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1858)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1859 = CustomConstraint(cons_f1859)
|
|
|
|
def cons_f1860(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1859(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1859 = CustomConstraint(_cons_f_1859)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1859)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1860 = CustomConstraint(cons_f1860)
|
|
|
|
def cons_f1861(a, b, m, n):
|
|
return Or(Equal(n, S(1)), PositiveIntegerQ(m), NonzeroQ(a**S(2) + b**S(2)))
|
|
|
|
cons1861 = CustomConstraint(cons_f1861)
|
|
|
|
def cons_f1862(F):
|
|
return HyperbolicQ(F)
|
|
|
|
cons1862 = CustomConstraint(cons_f1862)
|
|
|
|
def cons_f1863(G):
|
|
return HyperbolicQ(G)
|
|
|
|
cons1863 = CustomConstraint(cons_f1863)
|
|
|
|
def cons_f1864(F):
|
|
return MemberQ(List(Sinh, Cosh), F)
|
|
|
|
cons1864 = CustomConstraint(cons_f1864)
|
|
|
|
def cons_f1865(G):
|
|
return MemberQ(List(Sech, Csch), G)
|
|
|
|
cons1865 = CustomConstraint(cons_f1865)
|
|
|
|
def cons_f1866(F, b, c, e):
|
|
return NonzeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2))
|
|
|
|
cons1866 = CustomConstraint(cons_f1866)
|
|
|
|
def cons_f1867(F, b, c, e, n):
|
|
return NonzeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*n**S(2))
|
|
|
|
cons1867 = CustomConstraint(cons_f1867)
|
|
|
|
def cons_f1868(F, b, c, e, n):
|
|
return ZeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(2))**S(2))
|
|
|
|
cons1868 = CustomConstraint(cons_f1868)
|
|
|
|
def cons_f1869(F, b, c, e, n):
|
|
return NonzeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(2))**S(2))
|
|
|
|
cons1869 = CustomConstraint(cons_f1869)
|
|
|
|
def cons_f1870(F, b, c, e, n):
|
|
return ZeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(-2))**S(2))
|
|
|
|
cons1870 = CustomConstraint(cons_f1870)
|
|
|
|
def cons_f1871(F, b, c, e, n):
|
|
return NonzeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(-2))**S(2))
|
|
|
|
cons1871 = CustomConstraint(cons_f1871)
|
|
|
|
def cons_f1872(f, g):
|
|
return ZeroQ(f**S(2) + g**S(2))
|
|
|
|
cons1872 = CustomConstraint(cons_f1872)
|
|
|
|
def cons_f1873(h, i):
|
|
return ZeroQ(h**S(2) + i**S(2))
|
|
|
|
cons1873 = CustomConstraint(cons_f1873)
|
|
|
|
def cons_f1874(H):
|
|
return HyperbolicQ(H)
|
|
|
|
cons1874 = CustomConstraint(cons_f1874)
|
|
|
|
def cons_f1875(b, n, p):
|
|
return RationalQ(b, n, p)
|
|
|
|
cons1875 = CustomConstraint(cons_f1875)
|
|
|
|
def cons_f1876(b, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + S(-1))
|
|
|
|
cons1876 = CustomConstraint(cons_f1876)
|
|
|
|
def cons_f1877(b, n):
|
|
return ZeroQ(b*n + S(-2))
|
|
|
|
cons1877 = CustomConstraint(cons_f1877)
|
|
|
|
def cons_f1878(b, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*p**S(2) + S(-1))
|
|
|
|
cons1878 = CustomConstraint(cons_f1878)
|
|
|
|
def cons_f1879(b, n):
|
|
return NonzeroQ(b**S(2)*n**S(2) + S(-1))
|
|
|
|
cons1879 = CustomConstraint(cons_f1879)
|
|
|
|
def cons_f1880(b, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*p**S(2) + S(-1))
|
|
|
|
cons1880 = CustomConstraint(cons_f1880)
|
|
|
|
def cons_f1881(b, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + S(-1))
|
|
|
|
cons1881 = CustomConstraint(cons_f1881)
|
|
|
|
def cons_f1882(b, m, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) - (m + S(1))**S(2))
|
|
|
|
cons1882 = CustomConstraint(cons_f1882)
|
|
|
|
def cons_f1883(b, m, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*p**S(2) - (m + S(1))**S(2))
|
|
|
|
cons1883 = CustomConstraint(cons_f1883)
|
|
|
|
def cons_f1884(b, m, n):
|
|
return NonzeroQ(b**S(2)*n**S(2) - (m + S(1))**S(2))
|
|
|
|
cons1884 = CustomConstraint(cons_f1884)
|
|
|
|
def cons_f1885(b, m, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*p**S(2) - (m + S(1))**S(2))
|
|
|
|
cons1885 = CustomConstraint(cons_f1885)
|
|
|
|
def cons_f1886(b, m, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) - (m + S(1))**S(2))
|
|
|
|
cons1886 = CustomConstraint(cons_f1886)
|
|
|
|
def cons_f1887(b, n):
|
|
return ZeroQ(b**S(2)*n**S(2) + S(-1))
|
|
|
|
cons1887 = CustomConstraint(cons_f1887)
|
|
|
|
def cons_f1888(b, n, p):
|
|
return ZeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + S(-1))
|
|
|
|
cons1888 = CustomConstraint(cons_f1888)
|
|
|
|
def cons_f1889(b, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + S(-1))
|
|
|
|
cons1889 = CustomConstraint(cons_f1889)
|
|
|
|
def cons_f1890(b, m, n, p):
|
|
return RationalQ(b, m, n, p)
|
|
|
|
cons1890 = CustomConstraint(cons_f1890)
|
|
|
|
def cons_f1891(b, m, n):
|
|
return ZeroQ(b**S(2)*n**S(2) - (m + S(1))**S(2))
|
|
|
|
cons1891 = CustomConstraint(cons_f1891)
|
|
|
|
def cons_f1892(b, m, n, p):
|
|
return NonzeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) - (m + S(1))**S(2))
|
|
|
|
cons1892 = CustomConstraint(cons_f1892)
|
|
|
|
def cons_f1893(A, B, a, b):
|
|
return ZeroQ(A*a + B*b)
|
|
|
|
cons1893 = CustomConstraint(cons_f1893)
|
|
|
|
def cons_f1894(c, d1, e1):
|
|
return ZeroQ(-c*d1 + e1)
|
|
|
|
cons1894 = CustomConstraint(cons_f1894)
|
|
|
|
def cons_f1895(c, d2, e2):
|
|
return ZeroQ(c*d2 + e2)
|
|
|
|
cons1895 = CustomConstraint(cons_f1895)
|
|
|
|
def cons_f1896(d1):
|
|
return PositiveQ(d1)
|
|
|
|
cons1896 = CustomConstraint(cons_f1896)
|
|
|
|
def cons_f1897(d2):
|
|
return NegativeQ(d2)
|
|
|
|
cons1897 = CustomConstraint(cons_f1897)
|
|
|
|
def cons_f1898(d1, d2):
|
|
return Not(And(PositiveQ(d1), NegativeQ(d2)))
|
|
|
|
cons1898 = CustomConstraint(cons_f1898)
|
|
|
|
def cons_f1899(d1, d2):
|
|
return And(PositiveQ(d1), NegativeQ(d2))
|
|
|
|
cons1899 = CustomConstraint(cons_f1899)
|
|
|
|
def cons_f1900(c, d, e):
|
|
return NonzeroQ(-c**S(2)*d + e)
|
|
|
|
cons1900 = CustomConstraint(cons_f1900)
|
|
|
|
def cons_f1901(a, b, c, d1, d2, e1, e2, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d1, e1, d2, e2, n, p), x)
|
|
|
|
cons1901 = CustomConstraint(cons_f1901)
|
|
|
|
def cons_f1902(c, f, g):
|
|
return ZeroQ(c**S(2)*f**S(2) + g**S(2))
|
|
|
|
cons1902 = CustomConstraint(cons_f1902)
|
|
|
|
def cons_f1903(d1, d2, p):
|
|
return Not(Or(IntegerQ(p), And(PositiveQ(d1), NegativeQ(d2))))
|
|
|
|
cons1903 = CustomConstraint(cons_f1903)
|
|
|
|
def cons_f1904(m):
|
|
return NonzeroQ(m + S(3))
|
|
|
|
cons1904 = CustomConstraint(cons_f1904)
|
|
|
|
def cons_f1905(a, b, c, d1, d2, e1, e2, f, m, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d1, e1, d2, e2, f, m, n, p), x)
|
|
|
|
cons1905 = CustomConstraint(cons_f1905)
|
|
|
|
def cons_f1906(c):
|
|
return ZeroQ(c**S(2) + S(1))
|
|
|
|
cons1906 = CustomConstraint(cons_f1906)
|
|
|
|
def cons_f1907(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1906(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1906 = CustomConstraint(_cons_f_1906)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1906)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1907 = CustomConstraint(cons_f1907)
|
|
|
|
def cons_f1908(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1907(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1907 = CustomConstraint(_cons_f_1907)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1907)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1908 = CustomConstraint(cons_f1908)
|
|
|
|
def cons_f1909(c, d, e):
|
|
return ZeroQ(c**S(2)*d**S(2) - e**S(2))
|
|
|
|
cons1909 = CustomConstraint(cons_f1909)
|
|
|
|
def cons_f1910(c, d, e):
|
|
return PositiveQ(c*d/e + S(1))
|
|
|
|
cons1910 = CustomConstraint(cons_f1910)
|
|
|
|
def cons_f1911(c, d, e):
|
|
return NegativeQ(c*d/e + S(-1))
|
|
|
|
cons1911 = CustomConstraint(cons_f1911)
|
|
|
|
def cons_f1912(c, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(u**S(2) - (S(1) - S(2)/(c*x + S(1)))**S(2))
|
|
|
|
cons1912 = CustomConstraint(cons_f1912)
|
|
|
|
def cons_f1913(c, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ(u**S(2) - (S(1) - S(2)/(-c*x + S(1)))**S(2))
|
|
|
|
cons1913 = CustomConstraint(cons_f1913)
|
|
|
|
def cons_f1914(c, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ((S(1) - u)**S(2) - (S(1) - S(2)/(c*x + S(1)))**S(2))
|
|
|
|
cons1914 = CustomConstraint(cons_f1914)
|
|
|
|
def cons_f1915(c, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return ZeroQ((S(1) - u)**S(2) - (S(1) - S(2)/(-c*x + S(1)))**S(2))
|
|
|
|
cons1915 = CustomConstraint(cons_f1915)
|
|
|
|
def cons_f1916(a, c, d, n):
|
|
return Not(And(Equal(n, S(2)), ZeroQ(a**S(2)*c + d)))
|
|
|
|
cons1916 = CustomConstraint(cons_f1916)
|
|
|
|
def cons_f1917(c, f, g):
|
|
return ZeroQ(c**S(2)*f + g)
|
|
|
|
cons1917 = CustomConstraint(cons_f1917)
|
|
|
|
def cons_f1918(a, c, d):
|
|
return ZeroQ(a*c + d)
|
|
|
|
cons1918 = CustomConstraint(cons_f1918)
|
|
|
|
def cons_f1919(n, p):
|
|
return Or(IntegerQ(p), ZeroQ(-n/S(2) + p), ZeroQ(-n/S(2) + p + S(-1)))
|
|
|
|
cons1919 = CustomConstraint(cons_f1919)
|
|
|
|
def cons_f1920(a, c, d):
|
|
return ZeroQ(a**S(2)*c**S(2) - d**S(2))
|
|
|
|
cons1920 = CustomConstraint(cons_f1920)
|
|
|
|
def cons_f1921(a, c, d):
|
|
return ZeroQ(-a**S(2)*d**S(2) + c**S(2))
|
|
|
|
cons1921 = CustomConstraint(cons_f1921)
|
|
|
|
def cons_f1922(a, c, d):
|
|
return ZeroQ(a**S(2)*c + d)
|
|
|
|
cons1922 = CustomConstraint(cons_f1922)
|
|
|
|
def cons_f1923(n, p):
|
|
return NonzeroQ(n**S(2) - S(4)*(p + S(1))**S(2))
|
|
|
|
cons1923 = CustomConstraint(cons_f1923)
|
|
|
|
def cons_f1924(n):
|
|
return Not(IntegerQ(n/S(2)))
|
|
|
|
cons1924 = CustomConstraint(cons_f1924)
|
|
|
|
def cons_f1925(n):
|
|
return PositiveIntegerQ(n/S(2) + S(1)/2)
|
|
|
|
cons1925 = CustomConstraint(cons_f1925)
|
|
|
|
def cons_f1926(n, p):
|
|
return Not(IntegerQ(-n/S(2) + p))
|
|
|
|
cons1926 = CustomConstraint(cons_f1926)
|
|
|
|
def cons_f1927(n):
|
|
return NegativeIntegerQ(n/S(2) + S(-1)/2)
|
|
|
|
cons1927 = CustomConstraint(cons_f1927)
|
|
|
|
def cons_f1928(n):
|
|
return NegativeIntegerQ(n/S(2))
|
|
|
|
cons1928 = CustomConstraint(cons_f1928)
|
|
|
|
def cons_f1929(n, p):
|
|
return ZeroQ(n**S(2) + S(2)*p + S(2))
|
|
|
|
cons1929 = CustomConstraint(cons_f1929)
|
|
|
|
def cons_f1930(a, c, d):
|
|
return ZeroQ(a**S(2)*d + c)
|
|
|
|
cons1930 = CustomConstraint(cons_f1930)
|
|
|
|
def cons_f1931(a, b, c, e):
|
|
return ZeroQ(b**S(2)*c + e*(S(1) - a**S(2)))
|
|
|
|
cons1931 = CustomConstraint(cons_f1931)
|
|
|
|
def cons_f1932(a, c, p):
|
|
return Or(IntegerQ(p), PositiveQ(c/(S(1) - a**S(2))))
|
|
|
|
cons1932 = CustomConstraint(cons_f1932)
|
|
|
|
def cons_f1933(a, c, p):
|
|
return Not(Or(IntegerQ(p), PositiveQ(c/(S(1) - a**S(2)))))
|
|
|
|
cons1933 = CustomConstraint(cons_f1933)
|
|
|
|
def cons_f1934(n, p):
|
|
return ZeroQ(-n/S(2) + p)
|
|
|
|
cons1934 = CustomConstraint(cons_f1934)
|
|
|
|
def cons_f1935(a, c, d):
|
|
return ZeroQ(a*d + c)
|
|
|
|
cons1935 = CustomConstraint(cons_f1935)
|
|
|
|
def cons_f1936(m, n, p):
|
|
return Or(IntegerQ(p), ZeroQ(-n/S(2) + p), ZeroQ(-n/S(2) + p + S(-1)), Less(S(-5), m, S(-1)))
|
|
|
|
cons1936 = CustomConstraint(cons_f1936)
|
|
|
|
def cons_f1937(n, p):
|
|
return Or(IntegerQ(p), Not(IntegerQ(n)))
|
|
|
|
cons1937 = CustomConstraint(cons_f1937)
|
|
|
|
def cons_f1938(n, p):
|
|
return NonzeroQ(n**S(2) + S(2)*p + S(2))
|
|
|
|
cons1938 = CustomConstraint(cons_f1938)
|
|
|
|
def cons_f1939(n, p):
|
|
return IntegersQ(S(2)*p, n/S(2) + p)
|
|
|
|
cons1939 = CustomConstraint(cons_f1939)
|
|
|
|
def cons_f1940(n, p):
|
|
return Not(IntegersQ(S(2)*p, n/S(2) + p))
|
|
|
|
cons1940 = CustomConstraint(cons_f1940)
|
|
|
|
def cons_f1941(b, c):
|
|
return ZeroQ(b - c**S(2))
|
|
|
|
cons1941 = CustomConstraint(cons_f1941)
|
|
|
|
def cons_f1942(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PosQ(Discriminant(v, x))
|
|
|
|
cons1942 = CustomConstraint(cons_f1942)
|
|
|
|
def cons_f1943(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1942(f, r, w):
|
|
return FreeQ(f, x)
|
|
_cons_1942 = CustomConstraint(_cons_f_1942)
|
|
pat = Pattern(UtilityOperator(f_**w_*WC('r', S(1)), x), _cons_1942)
|
|
result_matchq = is_match(UtilityOperator(u, x), pat)
|
|
return result_matchq
|
|
|
|
cons1943 = CustomConstraint(cons_f1943)
|
|
|
|
def cons_f1944(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1943(f, r, w):
|
|
return FreeQ(f, x)
|
|
_cons_1943 = CustomConstraint(_cons_f_1943)
|
|
pat = Pattern(UtilityOperator(f_**w_*WC('r', S(1)), x), _cons_1943)
|
|
result_matchq = is_match(UtilityOperator(u, x), pat)
|
|
return result_matchq
|
|
|
|
cons1944 = CustomConstraint(cons_f1944)
|
|
|
|
def cons_f1945(c, d):
|
|
return ZeroQ((c - d)**S(2) + S(-1))
|
|
|
|
cons1945 = CustomConstraint(cons_f1945)
|
|
|
|
def cons_f1946(c, d):
|
|
return NonzeroQ((c - d)**S(2) + S(-1))
|
|
|
|
cons1946 = CustomConstraint(cons_f1946)
|
|
|
|
def cons_f1947(c, d):
|
|
return ZeroQ((c + I*d)**S(2) + S(-1))
|
|
|
|
cons1947 = CustomConstraint(cons_f1947)
|
|
|
|
def cons_f1948(c, d):
|
|
return ZeroQ((c - I*d)**S(2) + S(-1))
|
|
|
|
cons1948 = CustomConstraint(cons_f1948)
|
|
|
|
def cons_f1949(c, d):
|
|
return NonzeroQ((c + I*d)**S(2) + S(-1))
|
|
|
|
cons1949 = CustomConstraint(cons_f1949)
|
|
|
|
def cons_f1950(c, d):
|
|
return NonzeroQ((c - I*d)**S(2) + S(-1))
|
|
|
|
cons1950 = CustomConstraint(cons_f1950)
|
|
|
|
def cons_f1951(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1950(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1950 = CustomConstraint(_cons_f_1950)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1950)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1951 = CustomConstraint(cons_f1951)
|
|
|
|
def cons_f1952(a, b, u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return FalseQ(FunctionOfLinear(v*(a + b*atanh(u)), x))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons1952 = CustomConstraint(cons_f1952)
|
|
|
|
def cons_f1953(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1952(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1952 = CustomConstraint(_cons_f_1952)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1952)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1953 = CustomConstraint(cons_f1953)
|
|
|
|
def cons_f1954(a, b, u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
try:
|
|
return FalseQ(FunctionOfLinear(v*(a + b*acoth(u)), x))
|
|
except (TypeError, AttributeError):
|
|
return False
|
|
|
|
cons1954 = CustomConstraint(cons_f1954)
|
|
|
|
def cons_f1955(a, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, p), x)
|
|
|
|
cons1955 = CustomConstraint(cons_f1955)
|
|
|
|
def cons_f1956(a, m, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, m, p), x)
|
|
|
|
cons1956 = CustomConstraint(cons_f1956)
|
|
|
|
def cons_f1957(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1956(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1956 = CustomConstraint(_cons_f_1956)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1956)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1957 = CustomConstraint(cons_f1957)
|
|
|
|
def cons_f1958(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_1957(c, d, m):
|
|
return FreeQ(List(c, d, m), x)
|
|
_cons_1957 = CustomConstraint(_cons_f_1957)
|
|
pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1957)
|
|
result_matchq = is_match(UtilityOperator(v, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons1958 = CustomConstraint(cons_f1958)
|
|
|
|
def cons_f1959(b, d):
|
|
return ZeroQ(-b**S(2) + d)
|
|
|
|
cons1959 = CustomConstraint(cons_f1959)
|
|
|
|
def cons_f1960(b, d):
|
|
return ZeroQ(b**S(2) + d)
|
|
|
|
cons1960 = CustomConstraint(cons_f1960)
|
|
|
|
def cons_f1961(m):
|
|
return Or(Greater(m, S(0)), OddQ(m))
|
|
|
|
cons1961 = CustomConstraint(cons_f1961)
|
|
|
|
def cons_f1962(m):
|
|
return Or(And(Greater(m, S(0)), EvenQ(m)), Equal(Mod(m, S(4)), S(3)))
|
|
|
|
cons1962 = CustomConstraint(cons_f1962)
|
|
|
|
def cons_f1963(b, c):
|
|
return ZeroQ(-Pi*b**S(2)/S(2) + c)
|
|
|
|
cons1963 = CustomConstraint(cons_f1963)
|
|
|
|
def cons_f1964(m):
|
|
return Not(Equal(Mod(m, S(4)), S(2)))
|
|
|
|
cons1964 = CustomConstraint(cons_f1964)
|
|
|
|
def cons_f1965(m):
|
|
return Equal(Mod(m, S(4)), S(0))
|
|
|
|
cons1965 = CustomConstraint(cons_f1965)
|
|
|
|
def cons_f1966(m):
|
|
return Not(Equal(Mod(m, S(4)), S(0)))
|
|
|
|
cons1966 = CustomConstraint(cons_f1966)
|
|
|
|
def cons_f1967(m):
|
|
return Equal(Mod(m, S(4)), S(2))
|
|
|
|
cons1967 = CustomConstraint(cons_f1967)
|
|
|
|
def cons_f1968(m, n):
|
|
return Or(PositiveIntegerQ(m), NegativeIntegerQ(n), And(RationalQ(m, n), Greater(m, S(0)), Less(n, S(-1))))
|
|
|
|
cons1968 = CustomConstraint(cons_f1968)
|
|
|
|
def cons_f1969(m, n):
|
|
return Or(PositiveIntegerQ(n), And(RationalQ(m, n), Less(m, S(-1)), Greater(n, S(0))))
|
|
|
|
cons1969 = CustomConstraint(cons_f1969)
|
|
|
|
def cons_f1970(n):
|
|
return Not(And(IntegerQ(n), LessEqual(n, S(0))))
|
|
|
|
cons1970 = CustomConstraint(cons_f1970)
|
|
|
|
def cons_f1971(m, n):
|
|
return Or(PositiveIntegerQ(m), PositiveIntegerQ(n), IntegersQ(m, n))
|
|
|
|
cons1971 = CustomConstraint(cons_f1971)
|
|
|
|
def cons_f1972(a, c):
|
|
return ZeroQ(a - c + S(1))
|
|
|
|
cons1972 = CustomConstraint(cons_f1972)
|
|
|
|
def cons_f1973(s):
|
|
return NonzeroQ(s + S(-1))
|
|
|
|
cons1973 = CustomConstraint(cons_f1973)
|
|
|
|
def cons_f1974(s):
|
|
return NonzeroQ(s + S(-2))
|
|
|
|
cons1974 = CustomConstraint(cons_f1974)
|
|
|
|
def cons_f1975(a, b, n, p, q, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, n, p, q), x)
|
|
|
|
cons1975 = CustomConstraint(cons_f1975)
|
|
|
|
def cons_f1976(r):
|
|
return RationalQ(r)
|
|
|
|
cons1976 = CustomConstraint(cons_f1976)
|
|
|
|
def cons_f1977(r):
|
|
return Greater(r, S(0))
|
|
|
|
cons1977 = CustomConstraint(cons_f1977)
|
|
|
|
def cons_f1978(F, a, b, c, d, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(F, a, b, c, d, n, p), x)
|
|
|
|
cons1978 = CustomConstraint(cons_f1978)
|
|
|
|
def cons_f1979(n, p):
|
|
return Or(ZeroQ(n*(p + S(-1)) + S(1)), And(IntegerQ(p + S(-1)/2), ZeroQ(n*(p + S(-1)/2) + S(1))))
|
|
|
|
cons1979 = CustomConstraint(cons_f1979)
|
|
|
|
def cons_f1980(n, p):
|
|
return Or(And(IntegerQ(p), ZeroQ(n*(p + S(1)) + S(1))), And(IntegerQ(p + S(-1)/2), ZeroQ(n*(p + S(1)/2) + S(1))))
|
|
|
|
cons1980 = CustomConstraint(cons_f1980)
|
|
|
|
def cons_f1981(m, n, p):
|
|
return Or(And(IntegerQ(p + S(-1)/2), IntegerQ(S(2)*(m + n*p + S(1))/n), Greater((m + n*p + S(1))/n, S(0))), And(Not(IntegerQ(p + S(-1)/2)), IntegerQ((m + n*p + S(1))/n), GreaterEqual((m + n*p + S(1))/n, S(0))))
|
|
|
|
cons1981 = CustomConstraint(cons_f1981)
|
|
|
|
def cons_f1982(m, n, p):
|
|
return Or(ZeroQ(m + S(1)), And(IntegerQ(p + S(-1)/2), IntegerQ(S(-1)/2 + (m + n*p + S(1))/n), Less((m + n*p + S(1))/n, S(0))), And(Not(IntegerQ(p + S(-1)/2)), IntegerQ((m + n*p + S(1))/n), Less((m + n*p + S(1))/n, S(0))))
|
|
|
|
cons1982 = CustomConstraint(cons_f1982)
|
|
|
|
def cons_f1983(a, c, m, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, m), x)
|
|
|
|
cons1983 = CustomConstraint(cons_f1983)
|
|
|
|
def cons_f1984(a, b, c, d, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, c, d, p), x)
|
|
|
|
cons1984 = CustomConstraint(cons_f1984)
|
|
|
|
def cons_f1985(n, p):
|
|
return ZeroQ(n*(p + S(-1)) + S(1))
|
|
|
|
cons1985 = CustomConstraint(cons_f1985)
|
|
|
|
def cons_f1986(n, p):
|
|
return ZeroQ(p + S(1)/n)
|
|
|
|
cons1986 = CustomConstraint(cons_f1986)
|
|
|
|
def cons_f1987(n, p):
|
|
return ZeroQ(p + S(-1)/2 + S(1)/n)
|
|
|
|
cons1987 = CustomConstraint(cons_f1987)
|
|
|
|
def cons_f1988(c, n):
|
|
return PosQ(c*n)
|
|
|
|
cons1988 = CustomConstraint(cons_f1988)
|
|
|
|
def cons_f1989(c, n):
|
|
return NegQ(c*n)
|
|
|
|
cons1989 = CustomConstraint(cons_f1989)
|
|
|
|
def cons_f1990(n, p):
|
|
return Greater(n*(p + S(-1)) + S(1), S(0))
|
|
|
|
cons1990 = CustomConstraint(cons_f1990)
|
|
|
|
def cons_f1991(n, p):
|
|
return Less(n*p + S(1), S(0))
|
|
|
|
cons1991 = CustomConstraint(cons_f1991)
|
|
|
|
def cons_f1992(a, d, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, d), x)
|
|
|
|
cons1992 = CustomConstraint(cons_f1992)
|
|
|
|
def cons_f1993(a, d, n, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, d, n), x)
|
|
|
|
cons1993 = CustomConstraint(cons_f1993)
|
|
|
|
def cons_f1994(a, c, d, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, c, d, n, p), x)
|
|
|
|
cons1994 = CustomConstraint(cons_f1994)
|
|
|
|
def cons_f1995(m, n, p):
|
|
return ZeroQ(m + n*(p + S(-1)) + S(1))
|
|
|
|
cons1995 = CustomConstraint(cons_f1995)
|
|
|
|
def cons_f1996(m, n, p):
|
|
return ZeroQ(m + n*p + S(1))
|
|
|
|
cons1996 = CustomConstraint(cons_f1996)
|
|
|
|
def cons_f1997(m, n, p):
|
|
return ZeroQ(m + n*(p + S(-1)/2) + S(1))
|
|
|
|
cons1997 = CustomConstraint(cons_f1997)
|
|
|
|
def cons_f1998(c, p):
|
|
return PosQ(c/(p + S(-1)/2))
|
|
|
|
cons1998 = CustomConstraint(cons_f1998)
|
|
|
|
def cons_f1999(c, p):
|
|
return NegQ(c/(p + S(-1)/2))
|
|
|
|
cons1999 = CustomConstraint(cons_f1999)
|
|
|
|
def cons_f2000(m, n, p):
|
|
return RationalQ((m + n*p + S(1))/n)
|
|
|
|
cons2000 = CustomConstraint(cons_f2000)
|
|
|
|
def cons_f2001(m, n, p):
|
|
return Greater((m + n*p + S(1))/n, S(1))
|
|
|
|
cons2001 = CustomConstraint(cons_f2001)
|
|
|
|
def cons_f2002(m, n, p):
|
|
return Less((m + n*p + S(1))/n, S(0))
|
|
|
|
cons2002 = CustomConstraint(cons_f2002)
|
|
|
|
def cons_f2003(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FunctionOfQ(ProductLog(x), u, x)
|
|
|
|
cons2003 = CustomConstraint(cons_f2003)
|
|
|
|
def cons_f2004(n, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
def _cons_f_2003(n1, v):
|
|
return ZeroQ(n - n1 - 1)
|
|
_cons_2003 = CustomConstraint(_cons_f_2003)
|
|
pat = Pattern(UtilityOperator(x**WC('n1', S(1))*WC('v', S(1)), x), _cons_2003)
|
|
result_matchq = is_match(UtilityOperator(u, x), pat)
|
|
return Not(result_matchq)
|
|
|
|
cons2004 = CustomConstraint(cons_f2004)
|
|
|
|
def cons_f2005(e, g):
|
|
return ZeroQ(e + g)
|
|
|
|
cons2005 = CustomConstraint(cons_f2005)
|
|
|
|
def cons_f2006(d, f):
|
|
return ZeroQ(d + f + S(-2))
|
|
|
|
cons2006 = CustomConstraint(cons_f2006)
|
|
|
|
def cons_f2007(A, C, d, e, f):
|
|
return ZeroQ(A*e**S(2) + C*d*f)
|
|
|
|
cons2007 = CustomConstraint(cons_f2007)
|
|
|
|
def cons_f2008(B, C, d, e):
|
|
return ZeroQ(-B*e + S(2)*C*(d + S(-1)))
|
|
|
|
cons2008 = CustomConstraint(cons_f2008)
|
|
|
|
def cons_f2009(A, C, e):
|
|
return ZeroQ(A*e**S(2) + C)
|
|
|
|
cons2009 = CustomConstraint(cons_f2009)
|
|
|
|
def cons_f2010(n):
|
|
return Not(PositiveQ(n))
|
|
|
|
cons2010 = CustomConstraint(cons_f2010)
|
|
|
|
def cons_f2011(v, y):
|
|
return ZeroQ(-v + y)
|
|
|
|
cons2011 = CustomConstraint(cons_f2011)
|
|
|
|
def cons_f2012(w, y):
|
|
return ZeroQ(-w + y)
|
|
|
|
cons2012 = CustomConstraint(cons_f2012)
|
|
|
|
def cons_f2013(y, z):
|
|
return ZeroQ(y - z)
|
|
|
|
cons2013 = CustomConstraint(cons_f2013)
|
|
|
|
def cons_f2014(a, b, m, n, p, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FreeQ(List(a, b, m, n, p), x)
|
|
|
|
cons2014 = CustomConstraint(cons_f2014)
|
|
|
|
def cons_f2015(v, w):
|
|
return ZeroQ(-v + w)
|
|
|
|
cons2015 = CustomConstraint(cons_f2015)
|
|
|
|
def cons_f2016(p, q, r):
|
|
return ZeroQ(p - q*(r + S(1)))
|
|
|
|
cons2016 = CustomConstraint(cons_f2016)
|
|
|
|
def cons_f2017(r):
|
|
return NonzeroQ(r + S(1))
|
|
|
|
cons2017 = CustomConstraint(cons_f2017)
|
|
|
|
def cons_f2018(p, r):
|
|
return IntegerQ(p/(r + S(1)))
|
|
|
|
cons2018 = CustomConstraint(cons_f2018)
|
|
|
|
def cons_f2019(p, q, r, s):
|
|
return ZeroQ(p*(s + S(1)) - q*(r + S(1)))
|
|
|
|
cons2019 = CustomConstraint(cons_f2019)
|
|
|
|
def cons_f2020(m, p, q):
|
|
return ZeroQ(p + q*(m*p + S(1)))
|
|
|
|
cons2020 = CustomConstraint(cons_f2020)
|
|
|
|
def cons_f2021(m, p, q, r):
|
|
return ZeroQ(p + q*(m*p + r + S(1)))
|
|
|
|
cons2021 = CustomConstraint(cons_f2021)
|
|
|
|
def cons_f2022(m, p, q, s):
|
|
return ZeroQ(p*(s + S(1)) + q*(m*p + S(1)))
|
|
|
|
cons2022 = CustomConstraint(cons_f2022)
|
|
|
|
def cons_f2023(s):
|
|
return NonzeroQ(s + S(1))
|
|
|
|
cons2023 = CustomConstraint(cons_f2023)
|
|
|
|
def cons_f2024(q, s):
|
|
return IntegerQ(q/(s + S(1)))
|
|
|
|
cons2024 = CustomConstraint(cons_f2024)
|
|
|
|
def cons_f2025(m, p, q, r, s):
|
|
return ZeroQ(p*(s + S(1)) + q*(m*p + r + S(1)))
|
|
|
|
cons2025 = CustomConstraint(cons_f2025)
|
|
|
|
def cons_f2026(m, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return FunctionOfQ(x**(m + S(1)), u, x)
|
|
|
|
cons2026 = CustomConstraint(cons_f2026)
|
|
|
|
def cons_f2027(w, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(FreeQ(w, x))
|
|
|
|
cons2027 = CustomConstraint(cons_f2027)
|
|
|
|
def cons_f2028(x, z):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(FreeQ(z, x))
|
|
|
|
cons2028 = CustomConstraint(cons_f2028)
|
|
|
|
def cons_f2029(a, m):
|
|
return Not(And(EqQ(a, S(1)), EqQ(m, S(1))))
|
|
|
|
cons2029 = CustomConstraint(cons_f2029)
|
|
|
|
def cons_f2030(m, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(And(EqQ(v, x), EqQ(m, S(1))))
|
|
|
|
cons2030 = CustomConstraint(cons_f2030)
|
|
|
|
def cons_f2031(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(RationalFunctionQ(u, x))
|
|
|
|
cons2031 = CustomConstraint(cons_f2031)
|
|
|
|
def cons_f2032(v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(LinearQ(v, x))
|
|
|
|
cons2032 = CustomConstraint(cons_f2032)
|
|
|
|
def cons_f2033(r, s):
|
|
return PosQ(-r + s)
|
|
|
|
cons2033 = CustomConstraint(cons_f2033)
|
|
|
|
def cons_f2034(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Not(AlgebraicFunctionQ(u, x))
|
|
|
|
cons2034 = CustomConstraint(cons_f2034)
|
|
|
|
def cons_f2035(m, u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return Or(Greater(m, S(0)), Not(AlgebraicFunctionQ(u, x)))
|
|
|
|
cons2035 = CustomConstraint(cons_f2035)
|
|
|
|
def cons_f2036(u, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return EulerIntegrandQ(u, x)
|
|
|
|
cons2036 = CustomConstraint(cons_f2036)
|
|
|
|
def cons_f2037(u, v, x):
|
|
if isinstance(x, (int, Integer, float, Float)):
|
|
return False
|
|
return PolynomialInQ(v, u, x)
|
|
|
|
cons2037 = CustomConstraint(cons_f2037)
|
|
|
|
def cons_f2038(a, d):
|
|
return ZeroQ(a + d)
|
|
|
|
cons2038 = CustomConstraint(cons_f2038)
|
|
|
|
def cons_f2039(p, q):
|
|
return ZeroQ(p + q)
|
|
|
|
cons2039 = CustomConstraint(cons_f2039)
|