1""" 2This code is automatically generated. Never edit it manually. 3For details of generating the code see `rubi_parsing_guide.md` in `parsetools`. 4""" 5 6from sympy.external import import_module 7matchpy = import_module("matchpy") 8 9if matchpy: 10 from matchpy import Pattern, ReplacementRule, CustomConstraint, is_match 11 from sympy.integrals.rubi.utility_function import ( 12 Int, Sum, Set, With, Module, Scan, MapAnd, FalseQ, 13 ZeroQ, NegativeQ, NonzeroQ, FreeQ, NFreeQ, List, Log, PositiveQ, 14 PositiveIntegerQ, NegativeIntegerQ, IntegerQ, IntegersQ, 15 ComplexNumberQ, PureComplexNumberQ, RealNumericQ, PositiveOrZeroQ, 16 NegativeOrZeroQ, FractionOrNegativeQ, NegQ, Equal, Unequal, IntPart, 17 FracPart, RationalQ, ProductQ, SumQ, NonsumQ, Subst, First, Rest, 18 SqrtNumberQ, SqrtNumberSumQ, LinearQ, Sqrt, ArcCosh, Coefficient, 19 Denominator, Hypergeometric2F1, Not, Simplify, FractionalPart, 20 IntegerPart, AppellF1, EllipticPi, EllipticE, EllipticF, ArcTan, 21 ArcCot, ArcCoth, ArcTanh, ArcSin, ArcSinh, ArcCos, ArcCsc, ArcSec, 22 ArcCsch, ArcSech, Sinh, Tanh, Cosh, Sech, Csch, Coth, LessEqual, Less, 23 Greater, GreaterEqual, FractionQ, IntLinearcQ, Expand, IndependentQ, 24 PowerQ, IntegerPowerQ, PositiveIntegerPowerQ, FractionalPowerQ, AtomQ, 25 ExpQ, LogQ, Head, MemberQ, TrigQ, SinQ, CosQ, TanQ, CotQ, SecQ, CscQ, 26 Sin, Cos, Tan, Cot, Sec, Csc, HyperbolicQ, SinhQ, CoshQ, TanhQ, CothQ, 27 SechQ, CschQ, InverseTrigQ, SinCosQ, SinhCoshQ, LeafCount, Numerator, 28 NumberQ, NumericQ, Length, ListQ, Im, Re, InverseHyperbolicQ, 29 InverseFunctionQ, TrigHyperbolicFreeQ, InverseFunctionFreeQ, RealQ, 30 EqQ, FractionalPowerFreeQ, ComplexFreeQ, PolynomialQ, FactorSquareFree, 31 PowerOfLinearQ, Exponent, QuadraticQ, LinearPairQ, BinomialParts, 32 TrinomialParts, PolyQ, EvenQ, OddQ, PerfectSquareQ, NiceSqrtAuxQ, 33 NiceSqrtQ, Together, PosAux, PosQ, CoefficientList, ReplaceAll, 34 ExpandLinearProduct, GCD, ContentFactor, NumericFactor, 35 NonnumericFactors, MakeAssocList, GensymSubst, KernelSubst, 36 ExpandExpression, Apart, SmartApart, MatchQ, 37 PolynomialQuotientRemainder, FreeFactors, NonfreeFactors, 38 RemoveContentAux, RemoveContent, FreeTerms, NonfreeTerms, 39 ExpandAlgebraicFunction, CollectReciprocals, ExpandCleanup, 40 AlgebraicFunctionQ, Coeff, LeadTerm, RemainingTerms, LeadFactor, 41 RemainingFactors, LeadBase, LeadDegree, Numer, Denom, hypergeom, Expon, 42 MergeMonomials, PolynomialDivide, BinomialQ, TrinomialQ, 43 GeneralizedBinomialQ, GeneralizedTrinomialQ, FactorSquareFreeList, 44 PerfectPowerTest, SquareFreeFactorTest, RationalFunctionQ, 45 RationalFunctionFactors, NonrationalFunctionFactors, Reverse, 46 RationalFunctionExponents, RationalFunctionExpand, ExpandIntegrand, 47 SimplerQ, SimplerSqrtQ, SumSimplerQ, BinomialDegree, TrinomialDegree, 48 CancelCommonFactors, SimplerIntegrandQ, GeneralizedBinomialDegree, 49 GeneralizedBinomialParts, GeneralizedTrinomialDegree, 50 GeneralizedTrinomialParts, MonomialQ, MonomialSumQ, 51 MinimumMonomialExponent, MonomialExponent, LinearMatchQ, 52 PowerOfLinearMatchQ, QuadraticMatchQ, CubicMatchQ, BinomialMatchQ, 53 TrinomialMatchQ, GeneralizedBinomialMatchQ, GeneralizedTrinomialMatchQ, 54 QuotientOfLinearsMatchQ, PolynomialTermQ, PolynomialTerms, 55 NonpolynomialTerms, PseudoBinomialParts, NormalizePseudoBinomial, 56 PseudoBinomialPairQ, PseudoBinomialQ, PolynomialGCD, PolyGCD, 57 AlgebraicFunctionFactors, NonalgebraicFunctionFactors, 58 QuotientOfLinearsP, QuotientOfLinearsParts, QuotientOfLinearsQ, 59 Flatten, Sort, AbsurdNumberQ, AbsurdNumberFactors, 60 NonabsurdNumberFactors, SumSimplerAuxQ, Prepend, Drop, 61 CombineExponents, FactorInteger, FactorAbsurdNumber, 62 SubstForInverseFunction, SubstForFractionalPower, 63 SubstForFractionalPowerOfQuotientOfLinears, 64 FractionalPowerOfQuotientOfLinears, SubstForFractionalPowerQ, 65 SubstForFractionalPowerAuxQ, FractionalPowerOfSquareQ, 66 FractionalPowerSubexpressionQ, Apply, FactorNumericGcd, 67 MergeableFactorQ, MergeFactor, MergeFactors, TrigSimplifyQ, 68 TrigSimplify, TrigSimplifyRecur, Order, FactorOrder, Smallest, 69 OrderedQ, MinimumDegree, PositiveFactors, Sign, NonpositiveFactors, 70 PolynomialInAuxQ, PolynomialInQ, ExponentInAux, ExponentIn, 71 PolynomialInSubstAux, PolynomialInSubst, Distrib, DistributeDegree, 72 FunctionOfPower, DivideDegreesOfFactors, MonomialFactor, FullSimplify, 73 FunctionOfLinearSubst, FunctionOfLinear, NormalizeIntegrand, 74 NormalizeIntegrandAux, NormalizeIntegrandFactor, 75 NormalizeIntegrandFactorBase, NormalizeTogether, 76 NormalizeLeadTermSigns, AbsorbMinusSign, NormalizeSumFactors, 77 SignOfFactor, NormalizePowerOfLinear, SimplifyIntegrand, SimplifyTerm, 78 TogetherSimplify, SmartSimplify, SubstForExpn, ExpandToSum, UnifySum, 79 UnifyTerms, UnifyTerm, CalculusQ, FunctionOfInverseLinear, 80 PureFunctionOfSinhQ, PureFunctionOfTanhQ, PureFunctionOfCoshQ, 81 IntegerQuotientQ, OddQuotientQ, EvenQuotientQ, FindTrigFactor, 82 FunctionOfSinhQ, FunctionOfCoshQ, OddHyperbolicPowerQ, FunctionOfTanhQ, 83 FunctionOfTanhWeight, FunctionOfHyperbolicQ, SmartNumerator, 84 SmartDenominator, SubstForAux, ActivateTrig, ExpandTrig, TrigExpand, 85 SubstForTrig, SubstForHyperbolic, InertTrigFreeQ, LCM, 86 SubstForFractionalPowerOfLinear, FractionalPowerOfLinear, 87 InverseFunctionOfLinear, InertTrigQ, InertReciprocalQ, DeactivateTrig, 88 FixInertTrigFunction, DeactivateTrigAux, PowerOfInertTrigSumQ, 89 PiecewiseLinearQ, KnownTrigIntegrandQ, KnownSineIntegrandQ, 90 KnownTangentIntegrandQ, KnownCotangentIntegrandQ, 91 KnownSecantIntegrandQ, TryPureTanSubst, TryTanhSubst, TryPureTanhSubst, 92 AbsurdNumberGCD, AbsurdNumberGCDList, ExpandTrigExpand, 93 ExpandTrigReduce, ExpandTrigReduceAux, NormalizeTrig, TrigToExp, 94 ExpandTrigToExp, TrigReduce, FunctionOfTrig, AlgebraicTrigFunctionQ, 95 FunctionOfHyperbolic, FunctionOfQ, FunctionOfExpnQ, PureFunctionOfSinQ, 96 PureFunctionOfCosQ, PureFunctionOfTanQ, PureFunctionOfCotQ, 97 FunctionOfCosQ, FunctionOfSinQ, OddTrigPowerQ, FunctionOfTanQ, 98 FunctionOfTanWeight, FunctionOfTrigQ, FunctionOfDensePolynomialsQ, 99 FunctionOfLog, PowerVariableExpn, PowerVariableDegree, 100 PowerVariableSubst, EulerIntegrandQ, FunctionOfSquareRootOfQuadratic, 101 SquareRootOfQuadraticSubst, Divides, EasyDQ, ProductOfLinearPowersQ, 102 Rt, NthRoot, AtomBaseQ, SumBaseQ, NegSumBaseQ, AllNegTermQ, 103 SomeNegTermQ, TrigSquareQ, RtAux, TrigSquare, IntSum, IntTerm, Map2, 104 ConstantFactor, SameQ, ReplacePart, CommonFactors, 105 MostMainFactorPosition, FunctionOfExponentialQ, FunctionOfExponential, 106 FunctionOfExponentialFunction, FunctionOfExponentialFunctionAux, 107 FunctionOfExponentialTest, FunctionOfExponentialTestAux, stdev, 108 rubi_test, If, IntQuadraticQ, IntBinomialQ, RectifyTangent, 109 RectifyCotangent, Inequality, Condition, Simp, SimpHelp, SplitProduct, 110 SplitSum, SubstFor, SubstForAux, FresnelS, FresnelC, Erfc, Erfi, Gamma, 111 FunctionOfTrigOfLinearQ, ElementaryFunctionQ, Complex, UnsameQ, 112 _SimpFixFactor, SimpFixFactor, _FixSimplify, FixSimplify, 113 _SimplifyAntiderivativeSum, SimplifyAntiderivativeSum, 114 _SimplifyAntiderivative, SimplifyAntiderivative, _TrigSimplifyAux, 115 TrigSimplifyAux, Cancel, Part, PolyLog, D, Dist, Sum_doit, PolynomialQuotient, Floor, 116 PolynomialRemainder, Factor, PolyLog, CosIntegral, SinIntegral, LogIntegral, SinhIntegral, 117 CoshIntegral, Rule, Erf, PolyGamma, ExpIntegralEi, ExpIntegralE, LogGamma , UtilityOperator, Factorial, 118 Zeta, ProductLog, DerivativeDivides, HypergeometricPFQ, IntHide, OneQ, Null, rubi_exp as exp, rubi_log as log, Discriminant, 119 Negative, Quotient 120 ) 121 from sympy import (Integral, S, sqrt, And, Or, Integer, Float, Mod, I, Abs, simplify, Mul, 122 Add, Pow, sign, EulerGamma) 123 from sympy.integrals.rubi.symbol import WC 124 from sympy.core.symbol import symbols, Symbol 125 from sympy.functions import (sin, cos, tan, cot, csc, sec, sqrt, erf) 126 from sympy.functions.elementary.hyperbolic import (acosh, asinh, atanh, acoth, acsch, asech, cosh, sinh, tanh, coth, sech, csch) 127 from sympy.functions.elementary.trigonometric import (atan, acsc, asin, acot, acos, asec, atan2) 128 from sympy import pi as Pi 129 130 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'] 131 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']] 132 i, ii, Pqq, Q, R, r, C, k, u = symbols('i ii Pqq Q R r C k u') 133 _UseGamma = False 134 ShowSteps = False 135 StepCounter = None 136 137 138 139 def cons_f1(a): 140 return ZeroQ(a) 141 142 cons1 = CustomConstraint(cons_f1) 143 144 def cons_f2(a, x): 145 return FreeQ(a, x) 146 147 cons2 = CustomConstraint(cons_f2) 148 149 def cons_f3(b, x): 150 return FreeQ(b, x) 151 152 cons3 = CustomConstraint(cons_f3) 153 154 def cons_f4(n, x): 155 return FreeQ(n, x) 156 157 cons4 = CustomConstraint(cons_f4) 158 159 def cons_f5(p, x): 160 return FreeQ(p, x) 161 162 cons5 = CustomConstraint(cons_f5) 163 164 def cons_f6(b): 165 return ZeroQ(b) 166 167 cons6 = CustomConstraint(cons_f6) 168 169 def cons_f7(j, n): 170 return ZeroQ(j - S(2)*n) 171 172 cons7 = CustomConstraint(cons_f7) 173 174 def cons_f8(c, x): 175 return FreeQ(c, x) 176 177 cons8 = CustomConstraint(cons_f8) 178 179 def cons_f9(c): 180 return ZeroQ(c) 181 182 cons9 = CustomConstraint(cons_f9) 183 184 def cons_f10(v, x): 185 if isinstance(x, (int, Integer, float, Float)): 186 return False 187 return Not(FreeQ(v, x)) 188 189 cons10 = CustomConstraint(cons_f10) 190 191 def cons_f11(Pm, x): 192 if isinstance(x, (int, Integer, float, Float)): 193 return False 194 return PolyQ(Pm, x) 195 196 cons11 = CustomConstraint(cons_f11) 197 198 def cons_f12(p): 199 return Not(RationalQ(p)) 200 201 cons12 = CustomConstraint(cons_f12) 202 203 def cons_f13(p): 204 return RationalQ(p) 205 206 cons13 = CustomConstraint(cons_f13) 207 208 def cons_f14(a, b, c, x): 209 if isinstance(x, (int, Integer, float, Float)): 210 return False 211 return FreeQ(List(a, b, c), x) 212 213 cons14 = CustomConstraint(cons_f14) 214 215 def cons_f15(a): 216 return EqQ(a**S(2), S(1)) 217 218 cons15 = CustomConstraint(cons_f15) 219 220 def cons_f16(u, x): 221 if isinstance(x, (int, Integer, float, Float)): 222 return False 223 def _cons_f_15(b, v): 224 return FreeQ(b, x) 225 _cons_15 = CustomConstraint(_cons_f_15) 226 pat = Pattern(UtilityOperator(b_*v_, x), _cons_15) 227 result_matchq = is_match(UtilityOperator(u, x), pat) 228 return Not(result_matchq) 229 230 cons16 = CustomConstraint(cons_f16) 231 232 def cons_f17(u): 233 return SumQ(u) 234 235 cons17 = CustomConstraint(cons_f17) 236 237 def cons_f18(u, x): 238 if isinstance(x, (int, Integer, float, Float)): 239 return False 240 def _cons_f_17(a, b, v): 241 return And(FreeQ(List(a, b), x), InverseFunctionQ(v)) 242 _cons_17 = CustomConstraint(_cons_f_17) 243 pat = Pattern(UtilityOperator(a_ + v_*WC('b', S(1)), x), _cons_17) 244 result_matchq = is_match(UtilityOperator(u, x), pat) 245 return Not(result_matchq) 246 247 cons18 = CustomConstraint(cons_f18) 248 249 def cons_f19(m, x): 250 return FreeQ(m, x) 251 252 cons19 = CustomConstraint(cons_f19) 253 254 def cons_f20(m): 255 return IntegerQ(m) 256 257 cons20 = CustomConstraint(cons_f20) 258 259 def cons_f21(m): 260 return Not(IntegerQ(m)) 261 262 cons21 = CustomConstraint(cons_f21) 263 264 def cons_f22(n): 265 return PositiveIntegerQ(n + S(1)/2) 266 267 cons22 = CustomConstraint(cons_f22) 268 269 def cons_f23(m, n): 270 return IntegerQ(m + n) 271 272 cons23 = CustomConstraint(cons_f23) 273 274 def cons_f24(n): 275 return NegativeIntegerQ(n + S(-1)/2) 276 277 cons24 = CustomConstraint(cons_f24) 278 279 def cons_f25(n): 280 return Not(IntegerQ(n)) 281 282 cons25 = CustomConstraint(cons_f25) 283 284 def cons_f26(m, n): 285 return Not(IntegerQ(m + n)) 286 287 cons26 = CustomConstraint(cons_f26) 288 289 def cons_f27(a, b, c, d): 290 return ZeroQ(-a*d + b*c) 291 292 cons27 = CustomConstraint(cons_f27) 293 294 def cons_f28(a, b, c, d, n, x): 295 if isinstance(x, (int, Integer, float, Float)): 296 return False 297 return Or(Not(IntegerQ(n)), SimplerQ(c + d*x, a + b*x)) 298 299 cons28 = CustomConstraint(cons_f28) 300 301 def cons_f29(d, x): 302 return FreeQ(d, x) 303 304 cons29 = CustomConstraint(cons_f29) 305 306 def cons_f30(b, d): 307 return PositiveQ(b/d) 308 309 cons30 = CustomConstraint(cons_f30) 310 311 def cons_f31(m, n): 312 return Not(Or(IntegerQ(m), IntegerQ(n))) 313 314 cons31 = CustomConstraint(cons_f31) 315 316 def cons_f32(b, d, m, n): 317 return Not(Or(IntegerQ(m), IntegerQ(n), PositiveQ(b/d))) 318 319 cons32 = CustomConstraint(cons_f32) 320 321 def cons_f33(m): 322 return RationalQ(m) 323 324 cons33 = CustomConstraint(cons_f33) 325 326 def cons_f34(m): 327 return LessEqual(m, S(-1)) 328 329 cons34 = CustomConstraint(cons_f34) 330 331 def cons_f35(A, B, C, a, b): 332 return ZeroQ(A*b**S(2) - B*a*b + C*a**S(2)) 333 334 cons35 = CustomConstraint(cons_f35) 335 336 def cons_f36(A, x): 337 return FreeQ(A, x) 338 339 cons36 = CustomConstraint(cons_f36) 340 341 def cons_f37(B, x): 342 return FreeQ(B, x) 343 344 cons37 = CustomConstraint(cons_f37) 345 346 def cons_f38(C, x): 347 return FreeQ(C, x) 348 349 cons38 = CustomConstraint(cons_f38) 350 351 def cons_f39(n, q): 352 return ZeroQ(n + q) 353 354 cons39 = CustomConstraint(cons_f39) 355 356 def cons_f40(p): 357 return IntegerQ(p) 358 359 cons40 = CustomConstraint(cons_f40) 360 361 def cons_f41(a, b, c, d): 362 return ZeroQ(a*c - b*d) 363 364 cons41 = CustomConstraint(cons_f41) 365 366 def cons_f42(m, n): 367 return Not(And(IntegerQ(m), NegQ(n))) 368 369 cons42 = CustomConstraint(cons_f42) 370 371 def cons_f43(m, p): 372 return ZeroQ(m + p) 373 374 cons43 = CustomConstraint(cons_f43) 375 376 def cons_f44(a, b, c, d): 377 return ZeroQ(a**S(2)*d + b**S(2)*c) 378 379 cons44 = CustomConstraint(cons_f44) 380 381 def cons_f45(a): 382 return PositiveQ(a) 383 384 cons45 = CustomConstraint(cons_f45) 385 386 def cons_f46(d): 387 return NegativeQ(d) 388 389 cons46 = CustomConstraint(cons_f46) 390 391 def cons_f47(a, b, c): 392 return ZeroQ(-S(4)*a*c + b**S(2)) 393 394 cons47 = CustomConstraint(cons_f47) 395 396 def cons_f48(n, n2): 397 return ZeroQ(-S(2)*n + n2) 398 399 cons48 = CustomConstraint(cons_f48) 400 401 def cons_f49(b, c, d, e): 402 return ZeroQ(-b*e + S(2)*c*d) 403 404 cons49 = CustomConstraint(cons_f49) 405 406 def cons_f50(e, x): 407 return FreeQ(e, x) 408 409 cons50 = CustomConstraint(cons_f50) 410 411 def cons_f51(p, q): 412 return PosQ(-p + q) 413 414 cons51 = CustomConstraint(cons_f51) 415 416 def cons_f52(q, x): 417 return FreeQ(q, x) 418 419 cons52 = CustomConstraint(cons_f52) 420 421 def cons_f53(p, r): 422 return PosQ(-p + r) 423 424 cons53 = CustomConstraint(cons_f53) 425 426 def cons_f54(r, x): 427 return FreeQ(r, x) 428 429 cons54 = CustomConstraint(cons_f54) 430 431 def cons_f55(m, n): 432 return ZeroQ(m - n + S(1)) 433 434 cons55 = CustomConstraint(cons_f55) 435 436 def cons_f56(p): 437 return NonzeroQ(p + S(1)) 438 439 cons56 = CustomConstraint(cons_f56) 440 441 def cons_f57(a1, a2, b1, b2): 442 return ZeroQ(a1*b2 + a2*b1) 443 444 cons57 = CustomConstraint(cons_f57) 445 446 def cons_f58(m, n): 447 return ZeroQ(m - S(2)*n + S(1)) 448 449 cons58 = CustomConstraint(cons_f58) 450 451 def cons_f59(a1, x): 452 return FreeQ(a1, x) 453 454 cons59 = CustomConstraint(cons_f59) 455 456 def cons_f60(b1, x): 457 return FreeQ(b1, x) 458 459 cons60 = CustomConstraint(cons_f60) 460 461 def cons_f61(a2, x): 462 return FreeQ(a2, x) 463 464 cons61 = CustomConstraint(cons_f61) 465 466 def cons_f62(b2, x): 467 return FreeQ(b2, x) 468 469 cons62 = CustomConstraint(cons_f62) 470 471 def cons_f63(Qm, x): 472 if isinstance(x, (int, Integer, float, Float)): 473 return False 474 return PolyQ(Qm, x) 475 476 cons63 = CustomConstraint(cons_f63) 477 478 def cons_f64(m): 479 return PositiveIntegerQ(m) 480 481 cons64 = CustomConstraint(cons_f64) 482 483 def cons_f65(p): 484 return NegativeIntegerQ(p) 485 486 cons65 = CustomConstraint(cons_f65) 487 488 def cons_f66(Pq, x): 489 if isinstance(x, (int, Integer, float, Float)): 490 return False 491 return PolyQ(Pq, x) 492 493 cons66 = CustomConstraint(cons_f66) 494 495 def cons_f67(Qr, x): 496 if isinstance(x, (int, Integer, float, Float)): 497 return False 498 return PolyQ(Qr, x) 499 500 cons67 = CustomConstraint(cons_f67) 501 502 def cons_f68(m): 503 return NonzeroQ(m + S(1)) 504 505 cons68 = CustomConstraint(cons_f68) 506 507 def cons_f69(a, b, x): 508 if isinstance(x, (int, Integer, float, Float)): 509 return False 510 return FreeQ(List(a, b), x) 511 512 cons69 = CustomConstraint(cons_f69) 513 514 def cons_f70(u, x): 515 if isinstance(x, (int, Integer, float, Float)): 516 return False 517 return LinearQ(u, x) 518 519 cons70 = CustomConstraint(cons_f70) 520 521 def cons_f71(u, x): 522 if isinstance(x, (int, Integer, float, Float)): 523 return False 524 return NonzeroQ(u - x) 525 526 cons71 = CustomConstraint(cons_f71) 527 528 def cons_f72(a, b, c, d): 529 return ZeroQ(a*d + b*c) 530 531 cons72 = CustomConstraint(cons_f72) 532 533 def cons_f73(a, b, c, d): 534 return NonzeroQ(-a*d + b*c) 535 536 cons73 = CustomConstraint(cons_f73) 537 538 def cons_f74(m, n): 539 return ZeroQ(m + n + S(2)) 540 541 cons74 = CustomConstraint(cons_f74) 542 543 def cons_f75(m): 544 return PositiveIntegerQ(m + S(1)/2) 545 546 cons75 = CustomConstraint(cons_f75) 547 548 def cons_f76(m): 549 return NegativeIntegerQ(m + S(3)/2) 550 551 cons76 = CustomConstraint(cons_f76) 552 553 def cons_f77(a, c, m): 554 return Or(IntegerQ(m), And(PositiveQ(a), PositiveQ(c))) 555 556 cons77 = CustomConstraint(cons_f77) 557 558 def cons_f78(a, c): 559 return ZeroQ(a + c) 560 561 cons78 = CustomConstraint(cons_f78) 562 563 def cons_f79(m): 564 return Not(IntegerQ(S(2)*m)) 565 566 cons79 = CustomConstraint(cons_f79) 567 568 def cons_f80(a, b, c, d): 569 return PosQ(b*d/(a*c)) 570 571 cons80 = CustomConstraint(cons_f80) 572 573 def cons_f81(m): 574 return IntegerQ(m + S(1)/2) 575 576 cons81 = CustomConstraint(cons_f81) 577 578 def cons_f82(n): 579 return IntegerQ(n + S(1)/2) 580 581 cons82 = CustomConstraint(cons_f82) 582 583 def cons_f83(m, n): 584 return Less(S(0), m, n) 585 586 cons83 = CustomConstraint(cons_f83) 587 588 def cons_f84(m, n): 589 return Less(m, n, S(0)) 590 591 cons84 = CustomConstraint(cons_f84) 592 593 def cons_f85(c, m, n): 594 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))) 595 596 cons85 = CustomConstraint(cons_f85) 597 598 def cons_f86(m): 599 return NegativeIntegerQ(m) 600 601 cons86 = CustomConstraint(cons_f86) 602 603 def cons_f87(n): 604 return IntegerQ(n) 605 606 cons87 = CustomConstraint(cons_f87) 607 608 def cons_f88(m, n): 609 return Not(And(PositiveIntegerQ(n), Less(m + n + S(2), S(0)))) 610 611 cons88 = CustomConstraint(cons_f88) 612 613 def cons_f89(n): 614 return RationalQ(n) 615 616 cons89 = CustomConstraint(cons_f89) 617 618 def cons_f90(n): 619 return Greater(n, S(0)) 620 621 cons90 = CustomConstraint(cons_f90) 622 623 def cons_f91(n): 624 return Less(n, S(-1)) 625 626 cons91 = CustomConstraint(cons_f91) 627 628 def cons_f92(a, b, c, d): 629 return PosQ((-a*d + b*c)/b) 630 631 cons92 = CustomConstraint(cons_f92) 632 633 def cons_f93(a, b, c, d): 634 return NegQ((-a*d + b*c)/b) 635 636 cons93 = CustomConstraint(cons_f93) 637 638 def cons_f94(n): 639 return Less(S(-1), n, S(0)) 640 641 cons94 = CustomConstraint(cons_f94) 642 643 def cons_f95(m, n): 644 return RationalQ(m, n) 645 646 cons95 = CustomConstraint(cons_f95) 647 648 def cons_f96(m): 649 return Less(m, S(-1)) 650 651 cons96 = CustomConstraint(cons_f96) 652 653 def cons_f97(m, n): 654 return Not(And(IntegerQ(n), Not(IntegerQ(m)))) 655 656 cons97 = CustomConstraint(cons_f97) 657 658 def cons_f98(m, n): 659 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))))) 660 661 cons98 = CustomConstraint(cons_f98) 662 663 def cons_f99(a, b, c, d, m, n, x): 664 if isinstance(x, (int, Integer, float, Float)): 665 return False 666 return IntLinearcQ(a, b, c, d, m, n, x) 667 668 cons99 = CustomConstraint(cons_f99) 669 670 def cons_f100(a, c, m, n): 671 return Not(And(Less(n, S(-1)), Or(ZeroQ(a), And(NonzeroQ(c), Less(m, n), IntegerQ(n))))) 672 673 cons100 = CustomConstraint(cons_f100) 674 675 def cons_f101(m, n): 676 return Unequal(m + n + S(1), S(0)) 677 678 cons101 = CustomConstraint(cons_f101) 679 680 def cons_f102(m, n): 681 return Not(And(PositiveIntegerQ(m), Or(Not(IntegerQ(n)), Less(S(0), m, n)))) 682 683 cons102 = CustomConstraint(cons_f102) 684 685 def cons_f103(m, n): 686 return Not(And(IntegerQ(m + n), Less(m + n + S(2), S(0)))) 687 688 cons103 = CustomConstraint(cons_f103) 689 690 def cons_f104(b, d): 691 return ZeroQ(b + d) 692 693 cons104 = CustomConstraint(cons_f104) 694 695 def cons_f105(a, c): 696 return PositiveQ(a + c) 697 698 cons105 = CustomConstraint(cons_f105) 699 700 def cons_f106(a, b, c, d): 701 return PositiveQ(-a*d + b*c) 702 703 cons106 = CustomConstraint(cons_f106) 704 705 def cons_f107(b): 706 return PositiveQ(b) 707 708 cons107 = CustomConstraint(cons_f107) 709 710 def cons_f108(b, d): 711 return ZeroQ(b - d) 712 713 cons108 = CustomConstraint(cons_f108) 714 715 def cons_f109(m): 716 return Less(S(-1), m, S(0)) 717 718 cons109 = CustomConstraint(cons_f109) 719 720 def cons_f110(m): 721 return LessEqual(S(3), Denominator(m), S(4)) 722 723 cons110 = CustomConstraint(cons_f110) 724 725 def cons_f111(b, d): 726 return PosQ(d/b) 727 728 cons111 = CustomConstraint(cons_f111) 729 730 def cons_f112(b, d): 731 return NegQ(d/b) 732 733 cons112 = CustomConstraint(cons_f112) 734 735 def cons_f113(m, n): 736 return Equal(m + n + S(1), S(0)) 737 738 cons113 = CustomConstraint(cons_f113) 739 740 def cons_f114(m, n): 741 return LessEqual(Denominator(n), Denominator(m)) 742 743 cons114 = CustomConstraint(cons_f114) 744 745 def cons_f115(m, n): 746 return NegativeIntegerQ(m + n + S(2)) 747 748 cons115 = CustomConstraint(cons_f115) 749 750 def cons_f116(m, n): 751 return Or(SumSimplerQ(m, S(1)), Not(SumSimplerQ(n, S(1)))) 752 753 cons116 = CustomConstraint(cons_f116) 754 755 def cons_f117(b, c, d, n): 756 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)))))) 757 758 cons117 = CustomConstraint(cons_f117) 759 760 def cons_f118(b, c, d, m): 761 return Or(IntegerQ(m), PositiveQ(-d/(b*c))) 762 763 cons118 = CustomConstraint(cons_f118) 764 765 def cons_f119(c): 766 return Not(PositiveQ(c)) 767 768 cons119 = CustomConstraint(cons_f119) 769 770 def cons_f120(b, c, d): 771 return Not(PositiveQ(-d/(b*c))) 772 773 cons120 = CustomConstraint(cons_f120) 774 775 def cons_f121(c, d, m, n): 776 return Or(And(RationalQ(m), Not(And(ZeroQ(n + S(1)/2), ZeroQ(c**S(2) - d**S(2))))), Not(RationalQ(n))) 777 778 cons121 = CustomConstraint(cons_f121) 779 780 def cons_f122(a, b, c, d): 781 return PositiveQ(b/(-a*d + b*c)) 782 783 cons122 = CustomConstraint(cons_f122) 784 785 def cons_f123(a, b, c, d, m, n): 786 return Or(RationalQ(m), Not(And(RationalQ(n), PositiveQ(-d/(-a*d + b*c))))) 787 788 cons123 = CustomConstraint(cons_f123) 789 790 def cons_f124(m, n): 791 return Or(RationalQ(m), Not(SimplerQ(n + S(1), m + S(1)))) 792 793 cons124 = CustomConstraint(cons_f124) 794 795 def cons_f125(u, x): 796 if isinstance(x, (int, Integer, float, Float)): 797 return False 798 return NonzeroQ(Coefficient(u, x, S(0))) 799 800 cons125 = CustomConstraint(cons_f125) 801 802 def cons_f126(m, n): 803 return ZeroQ(m - n) 804 805 cons126 = CustomConstraint(cons_f126) 806 807 def cons_f127(f, x): 808 return FreeQ(f, x) 809 810 cons127 = CustomConstraint(cons_f127) 811 812 def cons_f128(n, p): 813 return NonzeroQ(n + p + S(2)) 814 815 cons128 = CustomConstraint(cons_f128) 816 817 def cons_f129(a, b, c, d, e, f, n, p): 818 return ZeroQ(a*d*f*(n + p + S(2)) - b*(c*f*(p + S(1)) + d*e*(n + S(1)))) 819 820 cons129 = CustomConstraint(cons_f129) 821 822 def cons_f130(p): 823 return PositiveIntegerQ(p) 824 825 cons130 = CustomConstraint(cons_f130) 826 827 def cons_f131(a, b, e, f): 828 return ZeroQ(a*f + b*e) 829 830 cons131 = CustomConstraint(cons_f131) 831 832 def cons_f132(n, p): 833 return Not(And(NegativeIntegerQ(n + p + S(2)), Greater(n + S(2)*p, S(0)))) 834 835 cons132 = CustomConstraint(cons_f132) 836 837 def cons_f133(n, p): 838 return Or(NonzeroQ(n + S(1)), Equal(p, S(1))) 839 840 cons133 = CustomConstraint(cons_f133) 841 842 def cons_f134(a, b, e, f): 843 return NonzeroQ(a*f + b*e) 844 845 cons134 = CustomConstraint(cons_f134) 846 847 def cons_f135(a, b, d, e, f, n, p): 848 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))) 849 850 cons135 = CustomConstraint(cons_f135) 851 852 def cons_f136(a, b, c, d, e, f, n, p): 853 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))))) 854 855 cons136 = CustomConstraint(cons_f136) 856 857 def cons_f137(n, p): 858 return ZeroQ(n + p + S(2)) 859 860 cons137 = CustomConstraint(cons_f137) 861 862 def cons_f138(n, p): 863 return Not(And(SumSimplerQ(n, S(1)), Not(SumSimplerQ(p, S(1))))) 864 865 cons138 = CustomConstraint(cons_f138) 866 867 def cons_f139(p): 868 return Less(p, S(-1)) 869 870 cons139 = CustomConstraint(cons_f139) 871 872 def cons_f140(c, e, n, p): 873 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)))))))) 874 875 cons140 = CustomConstraint(cons_f140) 876 877 def cons_f141(p): 878 return SumSimplerQ(p, S(1)) 879 880 cons141 = CustomConstraint(cons_f141) 881 882 def cons_f142(n, p): 883 return NonzeroQ(n + p + S(3)) 884 885 cons142 = CustomConstraint(cons_f142) 886 887 def cons_f143(a, b, c, d, e, f, n, p): 888 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))) 889 890 cons143 = CustomConstraint(cons_f143) 891 892 def cons_f144(m, n): 893 return ZeroQ(m - n + S(-1)) 894 895 cons144 = CustomConstraint(cons_f144) 896 897 def cons_f145(m): 898 return Not(PositiveIntegerQ(m)) 899 900 cons145 = CustomConstraint(cons_f145) 901 902 def cons_f146(m, n, p): 903 return NonzeroQ(m + n + p + S(2)) 904 905 cons146 = CustomConstraint(cons_f146) 906 907 def cons_f147(p): 908 return Less(S(0), p, S(1)) 909 910 cons147 = CustomConstraint(cons_f147) 911 912 def cons_f148(p): 913 return Greater(p, S(1)) 914 915 cons148 = CustomConstraint(cons_f148) 916 917 def cons_f149(p): 918 return Not(IntegerQ(p)) 919 920 cons149 = CustomConstraint(cons_f149) 921 922 def cons_f150(n): 923 return PositiveIntegerQ(n) 924 925 cons150 = CustomConstraint(cons_f150) 926 927 def cons_f151(p): 928 return FractionQ(p) 929 930 cons151 = CustomConstraint(cons_f151) 931 932 def cons_f152(m, n): 933 return IntegersQ(m, n) 934 935 cons152 = CustomConstraint(cons_f152) 936 937 def cons_f153(m, n, p): 938 return Or(IntegerQ(p), And(Greater(m, S(0)), GreaterEqual(n, S(-1)))) 939 940 cons153 = CustomConstraint(cons_f153) 941 942 def cons_f154(n, p): 943 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)))))) 944 945 cons154 = CustomConstraint(cons_f154) 946 947 def cons_f155(a, b, c, d, e, f, x): 948 if isinstance(x, (int, Integer, float, Float)): 949 return False 950 return FreeQ(List(a, b, c, d, e, f), x) 951 952 cons155 = CustomConstraint(cons_f155) 953 954 def cons_f156(a, b, c, d, e, f): 955 return ZeroQ(S(2)*b*d*e - f*(a*d + b*c)) 956 957 cons156 = CustomConstraint(cons_f156) 958 959 def cons_f157(m, n): 960 return ZeroQ(m + n + S(1)) 961 962 cons157 = CustomConstraint(cons_f157) 963 964 def cons_f158(a, b, c, d, x): 965 if isinstance(x, (int, Integer, float, Float)): 966 return False 967 return SimplerQ(a + b*x, c + d*x) 968 969 cons158 = CustomConstraint(cons_f158) 970 971 def cons_f159(m, n, p): 972 return ZeroQ(m + n + p + S(2)) 973 974 cons159 = CustomConstraint(cons_f159) 975 976 def cons_f160(m, p): 977 return Not(And(SumSimplerQ(p, S(1)), Not(SumSimplerQ(m, S(1))))) 978 979 cons160 = CustomConstraint(cons_f160) 980 981 def cons_f161(m, n, p): 982 return ZeroQ(m + n + p + S(3)) 983 984 cons161 = CustomConstraint(cons_f161) 985 986 def cons_f162(a, b, c, d, e, f, m, n, p): 987 return ZeroQ(a*d*f*(m + S(1)) + b*c*f*(n + S(1)) + b*d*e*(p + S(1))) 988 989 cons162 = CustomConstraint(cons_f162) 990 991 def cons_f163(m): 992 return Or(And(RationalQ(m), Less(m, S(-1))), SumSimplerQ(m, S(1))) 993 994 cons163 = CustomConstraint(cons_f163) 995 996 def cons_f164(m, n, p): 997 return RationalQ(m, n, p) 998 999 cons164 = CustomConstraint(cons_f164) 1000 1001 def cons_f165(p): 1002 return Greater(p, S(0)) 1003 1004 cons165 = CustomConstraint(cons_f165) 1005 1006 def cons_f166(m, n, p): 1007 return Or(IntegersQ(S(2)*m, S(2)*n, S(2)*p), IntegersQ(m, n + p), IntegersQ(p, m + n)) 1008 1009 cons166 = CustomConstraint(cons_f166) 1010 1011 def cons_f167(n): 1012 return Greater(n, S(1)) 1013 1014 cons167 = CustomConstraint(cons_f167) 1015 1016 def cons_f168(m): 1017 return Greater(m, S(1)) 1018 1019 cons168 = CustomConstraint(cons_f168) 1020 1021 def cons_f169(m, n, p): 1022 return NonzeroQ(m + n + p + S(1)) 1023 1024 cons169 = CustomConstraint(cons_f169) 1025 1026 def cons_f170(m): 1027 return Greater(m, S(0)) 1028 1029 cons170 = CustomConstraint(cons_f170) 1030 1031 def cons_f171(m, n, p): 1032 return Or(IntegersQ(S(2)*m, S(2)*n, S(2)*p), Or(IntegersQ(m, n + p), IntegersQ(p, m + n))) 1033 1034 cons171 = CustomConstraint(cons_f171) 1035 1036 def cons_f172(m, n, p): 1037 return IntegersQ(S(2)*m, S(2)*n, S(2)*p) 1038 1039 cons172 = CustomConstraint(cons_f172) 1040 1041 def cons_f173(n, p): 1042 return Or(IntegerQ(n), IntegersQ(S(2)*n, S(2)*p)) 1043 1044 cons173 = CustomConstraint(cons_f173) 1045 1046 def cons_f174(m, n): 1047 return PositiveIntegerQ(m + n + S(1)) 1048 1049 cons174 = CustomConstraint(cons_f174) 1050 1051 def cons_f175(m, n): 1052 return Or(And(RationalQ(m), Greater(m, S(0))), And(Not(RationalQ(m)), Or(SumSimplerQ(m, S(-1)), Not(SumSimplerQ(n, S(-1)))))) 1053 1054 cons175 = CustomConstraint(cons_f175) 1055 1056 def cons_f176(c, d, e, f): 1057 return PositiveQ(-f/(-c*f + d*e)) 1058 1059 cons176 = CustomConstraint(cons_f176) 1060 1061 def cons_f177(c, d, e, f): 1062 return Not(PositiveQ(-f/(-c*f + d*e))) 1063 1064 cons177 = CustomConstraint(cons_f177) 1065 1066 def cons_f178(c, d, e, f): 1067 return NonzeroQ(-c*f + d*e) 1068 1069 cons178 = CustomConstraint(cons_f178) 1070 1071 def cons_f179(c): 1072 return PositiveQ(c) 1073 1074 cons179 = CustomConstraint(cons_f179) 1075 1076 def cons_f180(e): 1077 return PositiveQ(e) 1078 1079 cons180 = CustomConstraint(cons_f180) 1080 1081 def cons_f181(b, d): 1082 return Not(NegativeQ(-b/d)) 1083 1084 cons181 = CustomConstraint(cons_f181) 1085 1086 def cons_f182(b, d): 1087 return NegativeQ(-b/d) 1088 1089 cons182 = CustomConstraint(cons_f182) 1090 1091 def cons_f183(c, e): 1092 return Not(And(PositiveQ(c), PositiveQ(e))) 1093 1094 cons183 = CustomConstraint(cons_f183) 1095 1096 def cons_f184(a, b, e, f): 1097 return PositiveQ(b/(-a*f + b*e)) 1098 1099 cons184 = CustomConstraint(cons_f184) 1100 1101 def cons_f185(a, b, c, d): 1102 return Not(NegativeQ(-(-a*d + b*c)/d)) 1103 1104 cons185 = CustomConstraint(cons_f185) 1105 1106 def cons_f186(a, b, c, d, e, f, x): 1107 if isinstance(x, (int, Integer, float, Float)): 1108 return False 1109 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)))) 1110 1111 cons186 = CustomConstraint(cons_f186) 1112 1113 def cons_f187(a, b, c, d, e, f): 1114 return Not(And(PositiveQ(b/(-a*d + b*c)), PositiveQ(b/(-a*f + b*e)))) 1115 1116 cons187 = CustomConstraint(cons_f187) 1117 1118 def cons_f188(b, d, f): 1119 return Or(PositiveQ(-b/d), NegativeQ(-b/f)) 1120 1121 cons188 = CustomConstraint(cons_f188) 1122 1123 def cons_f189(b, d, f): 1124 return Or(PosQ(-b/d), NegQ(-b/f)) 1125 1126 cons189 = CustomConstraint(cons_f189) 1127 1128 def cons_f190(a, b, e, f, x): 1129 if isinstance(x, (int, Integer, float, Float)): 1130 return False 1131 return SimplerQ(a + b*x, e + f*x) 1132 1133 cons190 = CustomConstraint(cons_f190) 1134 1135 def cons_f191(a, b, c, d, e, f): 1136 return Or(PositiveQ(-(-a*d + b*c)/d), NegativeQ(-(-a*f + b*e)/f)) 1137 1138 cons191 = CustomConstraint(cons_f191) 1139 1140 def cons_f192(a, b, c, d, e, f): 1141 return Or(PosQ(-(-a*d + b*c)/d), NegQ(-(-a*f + b*e)/f)) 1142 1143 cons192 = CustomConstraint(cons_f192) 1144 1145 def cons_f193(a, b, c, d, e, f): 1146 return ZeroQ(-a*d*f - b*c*f + S(2)*b*d*e) 1147 1148 cons193 = CustomConstraint(cons_f193) 1149 1150 def cons_f194(m, n): 1151 return PositiveIntegerQ(m - n) 1152 1153 cons194 = CustomConstraint(cons_f194) 1154 1155 def cons_f195(m, n): 1156 return Or(PositiveIntegerQ(m), NegativeIntegerQ(m, n)) 1157 1158 cons195 = CustomConstraint(cons_f195) 1159 1160 def cons_f196(m, n, p): 1161 return NegativeIntegerQ(m + n + p + S(2)) 1162 1163 cons196 = CustomConstraint(cons_f196) 1164 1165 def cons_f197(m, n, p): 1166 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)))))) 1167 1168 cons197 = CustomConstraint(cons_f197) 1169 1170 def cons_f198(n): 1171 return NegativeIntegerQ(n) 1172 1173 cons198 = CustomConstraint(cons_f198) 1174 1175 def cons_f199(e, p): 1176 return Or(IntegerQ(p), PositiveQ(e)) 1177 1178 cons199 = CustomConstraint(cons_f199) 1179 1180 def cons_f200(b, c, d): 1181 return PositiveQ(-d/(b*c)) 1182 1183 cons200 = CustomConstraint(cons_f200) 1184 1185 def cons_f201(c, d, e, f, p): 1186 return Or(IntegerQ(p), PositiveQ(d/(-c*f + d*e))) 1187 1188 cons201 = CustomConstraint(cons_f201) 1189 1190 def cons_f202(a, b, c, d, x): 1191 if isinstance(x, (int, Integer, float, Float)): 1192 return False 1193 return Not(And(PositiveQ(d/(a*d - b*c)), SimplerQ(c + d*x, a + b*x))) 1194 1195 cons202 = CustomConstraint(cons_f202) 1196 1197 def cons_f203(a, b, c, d): 1198 return Not(PositiveQ(b/(-a*d + b*c))) 1199 1200 cons203 = CustomConstraint(cons_f203) 1201 1202 def cons_f204(a, b, c, d, x): 1203 if isinstance(x, (int, Integer, float, Float)): 1204 return False 1205 return Not(SimplerQ(c + d*x, a + b*x)) 1206 1207 cons204 = CustomConstraint(cons_f204) 1208 1209 def cons_f205(a, b, c, d, e, f, x): 1210 if isinstance(x, (int, Integer, float, Float)): 1211 return False 1212 return Not(And(PositiveQ(d/(a*d - b*c)), PositiveQ(d/(-c*f + d*e)), SimplerQ(c + d*x, a + b*x))) 1213 1214 cons205 = CustomConstraint(cons_f205) 1215 1216 def cons_f206(a, b, c, d, e, f, x): 1217 if isinstance(x, (int, Integer, float, Float)): 1218 return False 1219 return Not(And(PositiveQ(f/(a*f - b*e)), PositiveQ(f/(c*f - d*e)), SimplerQ(e + f*x, a + b*x))) 1220 1221 cons206 = CustomConstraint(cons_f206) 1222 1223 def cons_f207(a, b, e, f): 1224 return Not(PositiveQ(b/(-a*f + b*e))) 1225 1226 cons207 = CustomConstraint(cons_f207) 1227 1228 def cons_f208(a, b, e, f, x): 1229 if isinstance(x, (int, Integer, float, Float)): 1230 return False 1231 return Not(SimplerQ(e + f*x, a + b*x)) 1232 1233 cons208 = CustomConstraint(cons_f208) 1234 1235 def cons_f209(m, n): 1236 return Or(PositiveIntegerQ(m), IntegersQ(m, n)) 1237 1238 cons209 = CustomConstraint(cons_f209) 1239 1240 def cons_f210(g, x): 1241 return FreeQ(g, x) 1242 1243 cons210 = CustomConstraint(cons_f210) 1244 1245 def cons_f211(h, x): 1246 return FreeQ(h, x) 1247 1248 cons211 = CustomConstraint(cons_f211) 1249 1250 def cons_f212(m, n): 1251 return Not(And(SumSimplerQ(n, S(1)), Not(SumSimplerQ(m, S(1))))) 1252 1253 cons212 = CustomConstraint(cons_f212) 1254 1255 def cons_f213(m, n): 1256 return Or(And(RationalQ(m), Less(m, S(-2))), And(ZeroQ(m + n + S(3)), Not(And(RationalQ(n), Less(n, S(-2)))))) 1257 1258 cons213 = CustomConstraint(cons_f213) 1259 1260 def cons_f214(m): 1261 return Or(And(RationalQ(m), Inequality(S(-2), LessEqual, m, Less, S(-1))), SumSimplerQ(m, S(1))) 1262 1263 cons214 = CustomConstraint(cons_f214) 1264 1265 def cons_f215(m, n): 1266 return NonzeroQ(m + n + S(3)) 1267 1268 cons215 = CustomConstraint(cons_f215) 1269 1270 def cons_f216(m, n): 1271 return NonzeroQ(m + n + S(2)) 1272 1273 cons216 = CustomConstraint(cons_f216) 1274 1275 def cons_f217(m, n, p): 1276 return Or(IntegersQ(m, n, p), PositiveIntegerQ(n, p)) 1277 1278 cons217 = CustomConstraint(cons_f217) 1279 1280 def cons_f218(a, b, c, d, e, f, g, h, x): 1281 if isinstance(x, (int, Integer, float, Float)): 1282 return False 1283 return FreeQ(List(a, b, c, d, e, f, g, h), x) 1284 1285 cons218 = CustomConstraint(cons_f218) 1286 1287 def cons_f219(a, b, c, d, e, f, g, h, n, p, x): 1288 if isinstance(x, (int, Integer, float, Float)): 1289 return False 1290 return FreeQ(List(a, b, c, d, e, f, g, h, n, p), x) 1291 1292 cons219 = CustomConstraint(cons_f219) 1293 1294 def cons_f220(c, d, e, f, x): 1295 if isinstance(x, (int, Integer, float, Float)): 1296 return False 1297 return SimplerQ(c + d*x, e + f*x) 1298 1299 cons220 = CustomConstraint(cons_f220) 1300 1301 def cons_f221(m, n, p): 1302 return Or(SumSimplerQ(m, S(1)), And(Not(SumSimplerQ(n, S(1))), Not(SumSimplerQ(p, S(1))))) 1303 1304 cons221 = CustomConstraint(cons_f221) 1305 1306 def cons_f222(p, q): 1307 return IntegersQ(p, q) 1308 1309 cons222 = CustomConstraint(cons_f222) 1310 1311 def cons_f223(q): 1312 return PositiveIntegerQ(q) 1313 1314 cons223 = CustomConstraint(cons_f223) 1315 1316 def cons_f224(a, b, c, d, e, f, g, h, m, n, p, q, x): 1317 if isinstance(x, (int, Integer, float, Float)): 1318 return False 1319 return FreeQ(List(a, b, c, d, e, f, g, h, m, n, p, q), x) 1320 1321 cons224 = CustomConstraint(cons_f224) 1322 1323 def cons_f225(a, b, c, d, e, f, g, h, i, m, n, p, q, r, x): 1324 if isinstance(x, (int, Integer, float, Float)): 1325 return False 1326 return FreeQ(List(a, b, c, d, e, f, g, h, i, m, n, p, q, r), x) 1327 1328 cons225 = CustomConstraint(cons_f225) 1329 1330 def cons_f226(i, x): 1331 return FreeQ(i, x) 1332 1333 cons226 = CustomConstraint(cons_f226) 1334 1335 def cons_f227(p): 1336 return NonzeroQ(S(2)*p + S(1)) 1337 1338 cons227 = CustomConstraint(cons_f227) 1339 1340 def cons_f228(a, b, c): 1341 return NonzeroQ(-S(4)*a*c + b**S(2)) 1342 1343 cons228 = CustomConstraint(cons_f228) 1344 1345 def cons_f229(a, b, c): 1346 return PerfectSquareQ(-S(4)*a*c + b**S(2)) 1347 1348 cons229 = CustomConstraint(cons_f229) 1349 1350 def cons_f230(a, b, c): 1351 return Not(PerfectSquareQ(-S(4)*a*c + b**S(2))) 1352 1353 cons230 = CustomConstraint(cons_f230) 1354 1355 def cons_f231(p): 1356 return IntegerQ(S(4)*p) 1357 1358 cons231 = CustomConstraint(cons_f231) 1359 1360 def cons_f232(p): 1361 return Unequal(p, S(-3)/2) 1362 1363 cons232 = CustomConstraint(cons_f232) 1364 1365 def cons_f233(a, b, c): 1366 return PosQ(-S(4)*a*c + b**S(2)) 1367 1368 cons233 = CustomConstraint(cons_f233) 1369 1370 def cons_f234(a, b, c): 1371 return PositiveQ(S(4)*a - b**S(2)/c) 1372 1373 cons234 = CustomConstraint(cons_f234) 1374 1375 def cons_f235(b, c, x): 1376 if isinstance(x, (int, Integer, float, Float)): 1377 return False 1378 return FreeQ(List(b, c), x) 1379 1380 cons235 = CustomConstraint(cons_f235) 1381 1382 def cons_f236(p): 1383 return LessEqual(S(3), Denominator(p), S(4)) 1384 1385 cons236 = CustomConstraint(cons_f236) 1386 1387 def cons_f237(p): 1388 return Not(IntegerQ(S(4)*p)) 1389 1390 cons237 = CustomConstraint(cons_f237) 1391 1392 def cons_f238(m): 1393 return IntegerQ(m/S(2) + S(1)/2) 1394 1395 cons238 = CustomConstraint(cons_f238) 1396 1397 def cons_f239(m, p): 1398 return ZeroQ(m + S(2)*p + S(1)) 1399 1400 cons239 = CustomConstraint(cons_f239) 1401 1402 def cons_f240(m, p): 1403 return NonzeroQ(m + S(2)*p + S(1)) 1404 1405 cons240 = CustomConstraint(cons_f240) 1406 1407 def cons_f241(b, c, d, e): 1408 return NonzeroQ(-b*e + S(2)*c*d) 1409 1410 cons241 = CustomConstraint(cons_f241) 1411 1412 def cons_f242(m, p): 1413 return ZeroQ(m + S(2)*p + S(2)) 1414 1415 cons242 = CustomConstraint(cons_f242) 1416 1417 def cons_f243(m): 1418 return NonzeroQ(m + S(2)) 1419 1420 cons243 = CustomConstraint(cons_f243) 1421 1422 def cons_f244(m, p): 1423 return ZeroQ(m + S(2)*p + S(3)) 1424 1425 cons244 = CustomConstraint(cons_f244) 1426 1427 def cons_f245(p): 1428 return NonzeroQ(p + S(3)/2) 1429 1430 cons245 = CustomConstraint(cons_f245) 1431 1432 def cons_f246(m, p): 1433 return RationalQ(m, p) 1434 1435 cons246 = CustomConstraint(cons_f246) 1436 1437 def cons_f247(m): 1438 return Inequality(S(-2), LessEqual, m, Less, S(-1)) 1439 1440 cons247 = CustomConstraint(cons_f247) 1441 1442 def cons_f248(p): 1443 return IntegerQ(S(2)*p) 1444 1445 cons248 = CustomConstraint(cons_f248) 1446 1447 def cons_f249(m): 1448 return Less(m, S(-2)) 1449 1450 cons249 = CustomConstraint(cons_f249) 1451 1452 def cons_f250(m, p): 1453 return Not(And(NegativeIntegerQ(m + S(2)*p + S(3)), Greater(m + S(3)*p + S(3), S(0)))) 1454 1455 cons250 = CustomConstraint(cons_f250) 1456 1457 def cons_f251(m, p): 1458 return NonzeroQ(m + S(2)*p) 1459 1460 cons251 = CustomConstraint(cons_f251) 1461 1462 def cons_f252(m): 1463 return Not(And(RationalQ(m), Less(m, S(-2)))) 1464 1465 cons252 = CustomConstraint(cons_f252) 1466 1467 def cons_f253(m, p): 1468 return Not(And(IntegerQ(m), Less(S(0), m, S(2)*p))) 1469 1470 cons253 = CustomConstraint(cons_f253) 1471 1472 def cons_f254(m): 1473 return Inequality(S(0), Less, m, LessEqual, S(1)) 1474 1475 cons254 = CustomConstraint(cons_f254) 1476 1477 def cons_f255(m, p): 1478 return NonzeroQ(m + p + S(1)) 1479 1480 cons255 = CustomConstraint(cons_f255) 1481 1482 def cons_f256(m, p): 1483 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)))) 1484 1485 cons256 = CustomConstraint(cons_f256) 1486 1487 def cons_f257(m, p): 1488 return Or(IntegerQ(m), IntegerQ(S(2)*p)) 1489 1490 cons257 = CustomConstraint(cons_f257) 1491 1492 def cons_f258(a, b, c, d, e): 1493 return ZeroQ(a*e**S(2) - b*d*e + c*d**S(2)) 1494 1495 cons258 = CustomConstraint(cons_f258) 1496 1497 def cons_f259(a, c, d, e): 1498 return ZeroQ(a*e**S(2) + c*d**S(2)) 1499 1500 cons259 = CustomConstraint(cons_f259) 1501 1502 def cons_f260(a, d, m, p): 1503 return Or(IntegerQ(p), And(PositiveQ(a), PositiveQ(d), IntegerQ(m + p))) 1504 1505 cons260 = CustomConstraint(cons_f260) 1506 1507 def cons_f261(m, p): 1508 return Or(Less(S(0), -m, p), Less(p, -m, S(0))) 1509 1510 cons261 = CustomConstraint(cons_f261) 1511 1512 def cons_f262(m): 1513 return Unequal(m, S(2)) 1514 1515 cons262 = CustomConstraint(cons_f262) 1516 1517 def cons_f263(m): 1518 return Unequal(m, S(-1)) 1519 1520 cons263 = CustomConstraint(cons_f263) 1521 1522 def cons_f264(m, p): 1523 return PositiveIntegerQ(m + p) 1524 1525 cons264 = CustomConstraint(cons_f264) 1526 1527 def cons_f265(m, p): 1528 return NegativeIntegerQ(m + S(2)*p + S(2)) 1529 1530 cons265 = CustomConstraint(cons_f265) 1531 1532 def cons_f266(m, p): 1533 return Or(Less(m, S(-2)), ZeroQ(m + S(2)*p + S(1))) 1534 1535 cons266 = CustomConstraint(cons_f266) 1536 1537 def cons_f267(m, p): 1538 return Or(Inequality(S(-2), LessEqual, m, Less, S(0)), Equal(m + p + S(1), S(0))) 1539 1540 cons267 = CustomConstraint(cons_f267) 1541 1542 def cons_f268(m): 1543 return GreaterEqual(m, S(1)) 1544 1545 cons268 = CustomConstraint(cons_f268) 1546 1547 def cons_f269(m): 1548 return Less(m, S(0)) 1549 1550 cons269 = CustomConstraint(cons_f269) 1551 1552 def cons_f270(d): 1553 return PositiveQ(d) 1554 1555 cons270 = CustomConstraint(cons_f270) 1556 1557 def cons_f271(m, p): 1558 return Not(And(ZeroQ(m + S(-3)), Unequal(p, S(1)))) 1559 1560 cons271 = CustomConstraint(cons_f271) 1561 1562 def cons_f272(m, p): 1563 return NonzeroQ(m + S(2)*p + S(3)) 1564 1565 cons272 = CustomConstraint(cons_f272) 1566 1567 def cons_f273(m, p): 1568 return Not(And(EvenQ(m), Less(m + S(2)*p + S(3), S(0)))) 1569 1570 cons273 = CustomConstraint(cons_f273) 1571 1572 def cons_f274(m): 1573 return Not(And(RationalQ(m), Less(m, S(-1)))) 1574 1575 cons274 = CustomConstraint(cons_f274) 1576 1577 def cons_f275(m, p): 1578 return Not(And(PositiveIntegerQ(m/S(2) + S(-1)/2), Or(Not(IntegerQ(p)), Less(m, S(2)*p)))) 1579 1580 cons275 = CustomConstraint(cons_f275) 1581 1582 def cons_f276(m): 1583 return Not(And(RationalQ(m), Greater(m, S(1)))) 1584 1585 cons276 = CustomConstraint(cons_f276) 1586 1587 def cons_f277(a, b, c): 1588 return NegativeQ(c/(-S(4)*a*c + b**S(2))) 1589 1590 cons277 = CustomConstraint(cons_f277) 1591 1592 def cons_f278(m): 1593 return EqQ(m**S(2), S(1)/4) 1594 1595 cons278 = CustomConstraint(cons_f278) 1596 1597 def cons_f279(m, p): 1598 return Or(IntegerQ(S(2)*p), And(IntegerQ(m), RationalQ(p)), OddQ(m)) 1599 1600 cons279 = CustomConstraint(cons_f279) 1601 1602 def cons_f280(m, p): 1603 return Or(IntegerQ(S(2)*p), And(IntegerQ(m), RationalQ(p)), IntegerQ(m/S(2) + p + S(3)/2)) 1604 1605 cons280 = CustomConstraint(cons_f280) 1606 1607 def cons_f281(a, b, c, d, e): 1608 return NonzeroQ(a*e**S(2) - b*d*e + c*d**S(2)) 1609 1610 cons281 = CustomConstraint(cons_f281) 1611 1612 def cons_f282(a, c, d, e): 1613 return NonzeroQ(a*e**S(2) + c*d**S(2)) 1614 1615 cons282 = CustomConstraint(cons_f282) 1616 1617 def cons_f283(m, p): 1618 return Not(And(ZeroQ(m + S(-1)), Greater(p, S(1)))) 1619 1620 cons283 = CustomConstraint(cons_f283) 1621 1622 def cons_f284(a, b, c): 1623 return NiceSqrtQ(-S(4)*a*c + b**S(2)) 1624 1625 cons284 = CustomConstraint(cons_f284) 1626 1627 def cons_f285(a, c): 1628 return NiceSqrtQ(-a*c) 1629 1630 cons285 = CustomConstraint(cons_f285) 1631 1632 def cons_f286(a, b, c): 1633 return Not(NiceSqrtQ(-S(4)*a*c + b**S(2))) 1634 1635 cons286 = CustomConstraint(cons_f286) 1636 1637 def cons_f287(a, c): 1638 return Not(NiceSqrtQ(-a*c)) 1639 1640 cons287 = CustomConstraint(cons_f287) 1641 1642 def cons_f288(d, m): 1643 return Or(NonzeroQ(d), Greater(m, S(2))) 1644 1645 cons288 = CustomConstraint(cons_f288) 1646 1647 def cons_f289(p): 1648 return Not(And(RationalQ(p), LessEqual(p, S(-1)))) 1649 1650 cons289 = CustomConstraint(cons_f289) 1651 1652 def cons_f290(a, b, d, e): 1653 return ZeroQ(a*e + b*d) 1654 1655 cons290 = CustomConstraint(cons_f290) 1656 1657 def cons_f291(b, c, d, e): 1658 return ZeroQ(b*e + c*d) 1659 1660 cons291 = CustomConstraint(cons_f291) 1661 1662 def cons_f292(m, p): 1663 return PositiveIntegerQ(m - p + S(1)) 1664 1665 cons292 = CustomConstraint(cons_f292) 1666 1667 def cons_f293(b, c, d, e): 1668 return NonzeroQ(-b*e + c*d) 1669 1670 cons293 = CustomConstraint(cons_f293) 1671 1672 def cons_f294(m): 1673 return Equal(m**S(2), S(1)/4) 1674 1675 cons294 = CustomConstraint(cons_f294) 1676 1677 def cons_f295(c): 1678 return NegativeQ(c) 1679 1680 cons295 = CustomConstraint(cons_f295) 1681 1682 def cons_f296(b): 1683 return RationalQ(b) 1684 1685 cons296 = CustomConstraint(cons_f296) 1686 1687 def cons_f297(m): 1688 return ZeroQ(m**S(2) + S(-1)/4) 1689 1690 cons297 = CustomConstraint(cons_f297) 1691 1692 def cons_f298(m, p): 1693 return Equal(m + S(2)*p + S(2), S(0)) 1694 1695 cons298 = CustomConstraint(cons_f298) 1696 1697 def cons_f299(a, c, d, e, x): 1698 if isinstance(x, (int, Integer, float, Float)): 1699 return False 1700 return FreeQ(List(a, c, d, e), x) 1701 1702 cons299 = CustomConstraint(cons_f299) 1703 1704 def cons_f300(m, p): 1705 return Or(IntegerQ(p), And(RationalQ(m), Less(m, S(-1)))) 1706 1707 cons300 = CustomConstraint(cons_f300) 1708 1709 def cons_f301(m, p): 1710 return Not(NegativeIntegerQ(m + S(2)*p + S(1))) 1711 1712 cons301 = CustomConstraint(cons_f301) 1713 1714 def cons_f302(a, b, c, d, e, m, p, x): 1715 if isinstance(x, (int, Integer, float, Float)): 1716 return False 1717 return IntQuadraticQ(a, b, c, d, e, m, p, x) 1718 1719 cons302 = CustomConstraint(cons_f302) 1720 1721 def cons_f303(a, c, d, e, m, p, x): 1722 if isinstance(x, (int, Integer, float, Float)): 1723 return False 1724 return IntQuadraticQ(a, S(0), c, d, e, m, p, x) 1725 1726 cons303 = CustomConstraint(cons_f303) 1727 1728 def cons_f304(m): 1729 return Or(Not(RationalQ(m)), Less(m, S(1))) 1730 1731 cons304 = CustomConstraint(cons_f304) 1732 1733 def cons_f305(m, p): 1734 return Not(NegativeIntegerQ(m + S(2)*p)) 1735 1736 cons305 = CustomConstraint(cons_f305) 1737 1738 def cons_f306(m, p): 1739 return Or(Less(m, S(1)), And(NegativeIntegerQ(m + S(2)*p + S(3)), Unequal(m, S(2)))) 1740 1741 cons306 = CustomConstraint(cons_f306) 1742 1743 def cons_f307(m): 1744 return If(RationalQ(m), Greater(m, S(1)), SumSimplerQ(m, S(-2))) 1745 1746 cons307 = CustomConstraint(cons_f307) 1747 1748 def cons_f308(a, b, c, d, e, m, p, x): 1749 if isinstance(x, (int, Integer, float, Float)): 1750 return False 1751 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)))) 1752 1753 cons308 = CustomConstraint(cons_f308) 1754 1755 def cons_f309(a, c, d, e, m, p, x): 1756 if isinstance(x, (int, Integer, float, Float)): 1757 return False 1758 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)))) 1759 1760 cons309 = CustomConstraint(cons_f309) 1761 1762 def cons_f310(a, b, c, d, e): 1763 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)) 1764 1765 cons310 = CustomConstraint(cons_f310) 1766 1767 def cons_f311(b, c, d, e): 1768 return PosQ(c*e**S(2)*(-b*e + S(2)*c*d)) 1769 1770 cons311 = CustomConstraint(cons_f311) 1771 1772 def cons_f312(a, c, d, e): 1773 return ZeroQ(-S(3)*a*e**S(2) + c*d**S(2)) 1774 1775 cons312 = CustomConstraint(cons_f312) 1776 1777 def cons_f313(b, c, d, e): 1778 return NegQ(c*e**S(2)*(-b*e + S(2)*c*d)) 1779 1780 cons313 = CustomConstraint(cons_f313) 1781 1782 def cons_f314(a, b, c, d, e): 1783 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)) 1784 1785 cons314 = CustomConstraint(cons_f314) 1786 1787 def cons_f315(a, b, c): 1788 return Not(PositiveQ(S(4)*a - b**S(2)/c)) 1789 1790 cons315 = CustomConstraint(cons_f315) 1791 1792 def cons_f316(p): 1793 return Not(IntegerQ(S(2)*p)) 1794 1795 cons316 = CustomConstraint(cons_f316) 1796 1797 def cons_f317(d, e, f, g): 1798 return NonzeroQ(-d*g + e*f) 1799 1800 cons317 = CustomConstraint(cons_f317) 1801 1802 def cons_f318(b, c, f, g): 1803 return ZeroQ(-b*g + S(2)*c*f) 1804 1805 cons318 = CustomConstraint(cons_f318) 1806 1807 def cons_f319(m): 1808 return Not(And(RationalQ(m), Greater(m, S(0)))) 1809 1810 cons319 = CustomConstraint(cons_f319) 1811 1812 def cons_f320(m, p): 1813 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))))) 1814 1815 cons320 = CustomConstraint(cons_f320) 1816 1817 def cons_f321(m, p): 1818 return NonzeroQ(m + S(2)*p + S(2)) 1819 1820 cons321 = CustomConstraint(cons_f321) 1821 1822 def cons_f322(m, p): 1823 return Or(Not(RationalQ(p)), Less(m, S(2)*p + S(2))) 1824 1825 cons322 = CustomConstraint(cons_f322) 1826 1827 def cons_f323(b, c, f, g): 1828 return NonzeroQ(-b*g + S(2)*c*f) 1829 1830 cons323 = CustomConstraint(cons_f323) 1831 1832 def cons_f324(p): 1833 return Less(p, S(0)) 1834 1835 cons324 = CustomConstraint(cons_f324) 1836 1837 def cons_f325(b, c, d, e, m, p): 1838 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)))) 1839 1840 cons325 = CustomConstraint(cons_f325) 1841 1842 def cons_f326(d, e, f, g, m, x): 1843 if isinstance(x, (int, Integer, float, Float)): 1844 return False 1845 return Not(And(ZeroQ(m + S(-1)), SimplerQ(f + g*x, d + e*x))) 1846 1847 cons326 = CustomConstraint(cons_f326) 1848 1849 def cons_f327(a, d, m, p): 1850 return Or(IntegerQ(p), And(PositiveQ(a), PositiveQ(d), ZeroQ(m + p))) 1851 1852 cons327 = CustomConstraint(cons_f327) 1853 1854 def cons_f328(b, c, d, e, f, g, m, p): 1855 return ZeroQ(e*(p + S(1))*(-b*g + S(2)*c*f) + m*(c*e*f + g*(-b*e + c*d))) 1856 1857 cons328 = CustomConstraint(cons_f328) 1858 1859 def cons_f329(d, e, f, g, m, p): 1860 return ZeroQ(S(2)*e*f*(p + S(1)) + m*(d*g + e*f)) 1861 1862 cons329 = CustomConstraint(cons_f329) 1863 1864 def cons_f330(m): 1865 return SumSimplerQ(m, S(-1)) 1866 1867 cons330 = CustomConstraint(cons_f330) 1868 1869 def cons_f331(m, p): 1870 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))) 1871 1872 cons331 = CustomConstraint(cons_f331) 1873 1874 def cons_f332(a, c, f, g): 1875 return ZeroQ(a*g**S(2) + c*f**S(2)) 1876 1877 cons332 = CustomConstraint(cons_f332) 1878 1879 def cons_f333(p): 1880 return Less(p, S(-2)) 1881 1882 cons333 = CustomConstraint(cons_f333) 1883 1884 def cons_f334(m, p): 1885 return Or(Less(S(0), -m, p + S(1)), Less(p, -m, S(0))) 1886 1887 cons334 = CustomConstraint(cons_f334) 1888 1889 def cons_f335(n, p): 1890 return NegativeIntegerQ(n + S(2)*p) 1891 1892 cons335 = CustomConstraint(cons_f335) 1893 1894 def cons_f336(b, c, d, e, f, g): 1895 return ZeroQ(-b*e*g + c*d*g + c*e*f) 1896 1897 cons336 = CustomConstraint(cons_f336) 1898 1899 def cons_f337(m, n): 1900 return NonzeroQ(m - n + S(-1)) 1901 1902 cons337 = CustomConstraint(cons_f337) 1903 1904 def cons_f338(d, e, f, g): 1905 return ZeroQ(d*g + e*f) 1906 1907 cons338 = CustomConstraint(cons_f338) 1908 1909 def cons_f339(m, n): 1910 return ZeroQ(m - n + S(-2)) 1911 1912 cons339 = CustomConstraint(cons_f339) 1913 1914 def cons_f340(n, p): 1915 return RationalQ(n, p) 1916 1917 cons340 = CustomConstraint(cons_f340) 1918 1919 def cons_f341(n, p): 1920 return Not(And(IntegerQ(n + p), LessEqual(n + p + S(2), S(0)))) 1921 1922 cons341 = CustomConstraint(cons_f341) 1923 1924 def cons_f342(n): 1925 return Not(PositiveIntegerQ(n)) 1926 1927 cons342 = CustomConstraint(cons_f342) 1928 1929 def cons_f343(n, p): 1930 return Not(And(IntegerQ(n + p), Less(n + p + S(2), S(0)))) 1931 1932 cons343 = CustomConstraint(cons_f343) 1933 1934 def cons_f344(n, p): 1935 return Or(IntegerQ(S(2)*p), IntegerQ(n)) 1936 1937 cons344 = CustomConstraint(cons_f344) 1938 1939 def cons_f345(m, p): 1940 return ZeroQ(m + p + S(-1)) 1941 1942 cons345 = CustomConstraint(cons_f345) 1943 1944 def cons_f346(b, c, d, e, f, g, n, p): 1945 return ZeroQ(b*e*g*(n + S(1)) - c*d*g*(S(2)*n + p + S(3)) + c*e*f*(p + S(1))) 1946 1947 cons346 = CustomConstraint(cons_f346) 1948 1949 def cons_f347(d, e, f, g, n, p): 1950 return ZeroQ(-d*g*(S(2)*n + p + S(3)) + e*f*(p + S(1))) 1951 1952 cons347 = CustomConstraint(cons_f347) 1953 1954 def cons_f348(n): 1955 return Not(And(RationalQ(n), Less(n, S(-1)))) 1956 1957 cons348 = CustomConstraint(cons_f348) 1958 1959 def cons_f349(p): 1960 return IntegerQ(p + S(-1)/2) 1961 1962 cons349 = CustomConstraint(cons_f349) 1963 1964 def cons_f350(m, p): 1965 return Not(And(Less(m, S(0)), Less(p, S(0)))) 1966 1967 cons350 = CustomConstraint(cons_f350) 1968 1969 def cons_f351(p): 1970 return Unequal(p, S(1)/2) 1971 1972 cons351 = CustomConstraint(cons_f351) 1973 1974 def cons_f352(a, b, c, d, e, f, g): 1975 return ZeroQ(-S(2)*a*e*g + b*(d*g + e*f) - S(2)*c*d*f) 1976 1977 cons352 = CustomConstraint(cons_f352) 1978 1979 def cons_f353(a, c, d, e, f, g): 1980 return ZeroQ(a*e*g + c*d*f) 1981 1982 cons353 = CustomConstraint(cons_f353) 1983 1984 def cons_f354(b, c, d, e, m): 1985 return Not(And(Equal(m, S(1)), Or(ZeroQ(d), ZeroQ(-b*e + S(2)*c*d)))) 1986 1987 cons354 = CustomConstraint(cons_f354) 1988 1989 def cons_f355(d, m): 1990 return Not(And(Equal(m, S(1)), ZeroQ(d))) 1991 1992 cons355 = CustomConstraint(cons_f355) 1993 1994 def cons_f356(a, b, c, d, e, f, g, p): 1995 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)) 1996 1997 cons356 = CustomConstraint(cons_f356) 1998 1999 def cons_f357(a, c, d, e, f, g, p): 2000 return ZeroQ(a*e*g - c*d*f*(S(2)*p + S(3))) 2001 2002 cons357 = CustomConstraint(cons_f357) 2003 2004 def cons_f358(m): 2005 return Not(RationalQ(m)) 2006 2007 cons358 = CustomConstraint(cons_f358) 2008 2009 def cons_f359(p): 2010 return Not(PositiveIntegerQ(p)) 2011 2012 cons359 = CustomConstraint(cons_f359) 2013 2014 def cons_f360(m, p): 2015 return ZeroQ(m - p) 2016 2017 cons360 = CustomConstraint(cons_f360) 2018 2019 def cons_f361(m, p): 2020 return Less(m + S(2)*p, S(0)) 2021 2022 cons361 = CustomConstraint(cons_f361) 2023 2024 def cons_f362(m, p): 2025 return Not(NegativeIntegerQ(m + S(2)*p + S(3))) 2026 2027 cons362 = CustomConstraint(cons_f362) 2028 2029 def cons_f363(m, p): 2030 return Or(And(RationalQ(m), Less(m, S(-1))), Equal(p, S(1)), And(IntegerQ(p), Not(RationalQ(m)))) 2031 2032 cons363 = CustomConstraint(cons_f363) 2033 2034 def cons_f364(m, p): 2035 return Or(IntegerQ(m), IntegerQ(p), IntegersQ(S(2)*m, S(2)*p)) 2036 2037 cons364 = CustomConstraint(cons_f364) 2038 2039 def cons_f365(m, p): 2040 return Or(IntegerQ(p), Not(RationalQ(m)), Inequality(S(-1), LessEqual, m, Less, S(0))) 2041 2042 cons365 = CustomConstraint(cons_f365) 2043 2044 def cons_f366(a, b, c, d, e, f, g, m, p): 2045 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)))) 2046 2047 cons366 = CustomConstraint(cons_f366) 2048 2049 def cons_f367(a, c, d, e, f, g, m, p): 2050 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)))) 2051 2052 cons367 = CustomConstraint(cons_f367) 2053 2054 def cons_f368(d, e, f, g, m, x): 2055 if isinstance(x, (int, Integer, float, Float)): 2056 return False 2057 return Not(And(Equal(m, S(1)), SimplerQ(d + e*x, f + g*x))) 2058 2059 cons368 = CustomConstraint(cons_f368) 2060 2061 def cons_f369(m): 2062 return FractionQ(m) 2063 2064 cons369 = CustomConstraint(cons_f369) 2065 2066 def cons_f370(d, e, f, g, m, x): 2067 if isinstance(x, (int, Integer, float, Float)): 2068 return False 2069 return Not(And(Equal(m, S(1)), SimplerQ(f + g*x, d + e*x))) 2070 2071 cons370 = CustomConstraint(cons_f370) 2072 2073 def cons_f371(m, p): 2074 return NegativeIntegerQ(m + S(2)*p + S(3)) 2075 2076 cons371 = CustomConstraint(cons_f371) 2077 2078 def cons_f372(a, b, c, d, e): 2079 return ZeroQ(S(4)*c*(a - d) - (b - e)**S(2)) 2080 2081 cons372 = CustomConstraint(cons_f372) 2082 2083 def cons_f373(a, b, d, e, f, g): 2084 return ZeroQ(e*f*(b - e) - S(2)*g*(-a*e + b*d)) 2085 2086 cons373 = CustomConstraint(cons_f373) 2087 2088 def cons_f374(a, b, d, e): 2089 return NonzeroQ(-a*e + b*d) 2090 2091 cons374 = CustomConstraint(cons_f374) 2092 2093 def cons_f375(a, c, f, g, x): 2094 if isinstance(x, (int, Integer, float, Float)): 2095 return False 2096 return FreeQ(List(a, c, f, g), x) 2097 2098 cons375 = CustomConstraint(cons_f375) 2099 2100 def cons_f376(a, c, e, f, g, x): 2101 if isinstance(x, (int, Integer, float, Float)): 2102 return False 2103 return FreeQ(List(a, c, e, f, g), x) 2104 2105 cons376 = CustomConstraint(cons_f376) 2106 2107 def cons_f377(m, n, p): 2108 return IntegersQ(m, n, p) 2109 2110 cons377 = CustomConstraint(cons_f377) 2111 2112 def cons_f378(n, p): 2113 return IntegersQ(n, p) 2114 2115 cons378 = CustomConstraint(cons_f378) 2116 2117 def cons_f379(d, f, m): 2118 return Or(IntegerQ(m), And(PositiveQ(d), PositiveQ(f))) 2119 2120 cons379 = CustomConstraint(cons_f379) 2121 2122 def cons_f380(m, n, p): 2123 return Or(IntegerQ(p), IntegersQ(m, n)) 2124 2125 cons380 = CustomConstraint(cons_f380) 2126 2127 def cons_f381(a, c, e, f, g, m, p, x): 2128 if isinstance(x, (int, Integer, float, Float)): 2129 return False 2130 return FreeQ(List(a, c, e, f, g, m, p), x) 2131 2132 cons381 = CustomConstraint(cons_f381) 2133 2134 def cons_f382(a, b, c, d, e, f, g, m, n, p, x): 2135 if isinstance(x, (int, Integer, float, Float)): 2136 return False 2137 return FreeQ(List(a, b, c, d, e, f, g, m, n, p), x) 2138 2139 cons382 = CustomConstraint(cons_f382) 2140 2141 def cons_f383(a, c, d, e, f, g, m, n, p, x): 2142 if isinstance(x, (int, Integer, float, Float)): 2143 return False 2144 return FreeQ(List(a, c, d, e, f, g, m, n, p), x) 2145 2146 cons383 = CustomConstraint(cons_f383) 2147 2148 def cons_f384(a, c, d, f): 2149 return ZeroQ(-a*f + c*d) 2150 2151 cons384 = CustomConstraint(cons_f384) 2152 2153 def cons_f385(a, b, d, e): 2154 return ZeroQ(-a*e + b*d) 2155 2156 cons385 = CustomConstraint(cons_f385) 2157 2158 def cons_f386(c, f, p): 2159 return Or(IntegerQ(p), PositiveQ(c/f)) 2160 2161 cons386 = CustomConstraint(cons_f386) 2162 2163 def cons_f387(a, b, c, d, e, f, q, x): 2164 if isinstance(x, (int, Integer, float, Float)): 2165 return False 2166 return Or(Not(IntegerQ(q)), LessEqual(LeafCount(d + e*x + f*x**S(2)), LeafCount(a + b*x + c*x**S(2)))) 2167 2168 cons387 = CustomConstraint(cons_f387) 2169 2170 def cons_f388(q): 2171 return Not(IntegerQ(q)) 2172 2173 cons388 = CustomConstraint(cons_f388) 2174 2175 def cons_f389(c, f): 2176 return Not(PositiveQ(c/f)) 2177 2178 cons389 = CustomConstraint(cons_f389) 2179 2180 def cons_f390(a, b, c, d, e, f, q): 2181 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)) 2182 2183 cons390 = CustomConstraint(cons_f390) 2184 2185 def cons_f391(q): 2186 return NonzeroQ(q + S(1)) 2187 2188 cons391 = CustomConstraint(cons_f391) 2189 2190 def cons_f392(q): 2191 return NonzeroQ(S(2)*q + S(3)) 2192 2193 cons392 = CustomConstraint(cons_f392) 2194 2195 def cons_f393(a, c, d, e, f, q): 2196 return ZeroQ(S(2)*a*f**S(2)*(S(2)*q + S(3)) + c*(-S(2)*d*f + e**S(2)*(q + S(2)))) 2197 2198 cons393 = CustomConstraint(cons_f393) 2199 2200 def cons_f394(a, c, d, f, q): 2201 return ZeroQ(S(2)*a*f*q + S(3)*a*f - c*d) 2202 2203 cons394 = CustomConstraint(cons_f394) 2204 2205 def cons_f395(q): 2206 return PositiveIntegerQ(q + S(2)) 2207 2208 cons395 = CustomConstraint(cons_f395) 2209 2210 def cons_f396(d, e, f): 2211 return NonzeroQ(-S(4)*d*f + e**S(2)) 2212 2213 cons396 = CustomConstraint(cons_f396) 2214 2215 def cons_f397(q): 2216 return RationalQ(q) 2217 2218 cons397 = CustomConstraint(cons_f397) 2219 2220 def cons_f398(q): 2221 return Less(q, S(-1)) 2222 2223 cons398 = CustomConstraint(cons_f398) 2224 2225 def cons_f399(a, b, c, d, e, f, q): 2226 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)) 2227 2228 cons399 = CustomConstraint(cons_f399) 2229 2230 def cons_f400(a, c, d, e, f, q): 2231 return NonzeroQ(S(2)*a*f**S(2)*(S(2)*q + S(3)) + c*(-S(2)*d*f + e**S(2)*(q + S(2)))) 2232 2233 cons400 = CustomConstraint(cons_f400) 2234 2235 def cons_f401(a, c, d, f, q): 2236 return NonzeroQ(S(2)*a*f*q + S(3)*a*f - c*d) 2237 2238 cons401 = CustomConstraint(cons_f401) 2239 2240 def cons_f402(q): 2241 return Not(PositiveIntegerQ(q)) 2242 2243 cons402 = CustomConstraint(cons_f402) 2244 2245 def cons_f403(q): 2246 return Not(And(RationalQ(q), LessEqual(q, S(-1)))) 2247 2248 cons403 = CustomConstraint(cons_f403) 2249 2250 def cons_f404(p, q): 2251 return RationalQ(p, q) 2252 2253 cons404 = CustomConstraint(cons_f404) 2254 2255 def cons_f405(q): 2256 return Greater(q, S(0)) 2257 2258 cons405 = CustomConstraint(cons_f405) 2259 2260 def cons_f406(a, b, c, d, e, f): 2261 return NonzeroQ(-(-a*e + b*d)*(-b*f + c*e) + (-a*f + c*d)**S(2)) 2262 2263 cons406 = CustomConstraint(cons_f406) 2264 2265 def cons_f407(p, q): 2266 return Not(And(Not(IntegerQ(p)), IntegerQ(q), Less(q, S(-1)))) 2267 2268 cons407 = CustomConstraint(cons_f407) 2269 2270 def cons_f408(a, b, c, d, f): 2271 return NonzeroQ(b**S(2)*d*f + (-a*f + c*d)**S(2)) 2272 2273 cons408 = CustomConstraint(cons_f408) 2274 2275 def cons_f409(a, c, d, e, f): 2276 return NonzeroQ(a*c*e**S(2) + (-a*f + c*d)**S(2)) 2277 2278 cons409 = CustomConstraint(cons_f409) 2279 2280 def cons_f410(p, q): 2281 return NonzeroQ(p + q) 2282 2283 cons410 = CustomConstraint(cons_f410) 2284 2285 def cons_f411(p, q): 2286 return NonzeroQ(S(2)*p + S(2)*q + S(1)) 2287 2288 cons411 = CustomConstraint(cons_f411) 2289 2290 def cons_f412(b, c, e, f): 2291 return ZeroQ(-b*f + c*e) 2292 2293 cons412 = CustomConstraint(cons_f412) 2294 2295 def cons_f413(b, c, e, f): 2296 return NonzeroQ(-b*f + c*e) 2297 2298 cons413 = CustomConstraint(cons_f413) 2299 2300 def cons_f414(a, c): 2301 return PosQ(-a*c) 2302 2303 cons414 = CustomConstraint(cons_f414) 2304 2305 def cons_f415(a, b, c): 2306 return NegQ(-S(4)*a*c + b**S(2)) 2307 2308 cons415 = CustomConstraint(cons_f415) 2309 2310 def cons_f416(a, c): 2311 return NegQ(-a*c) 2312 2313 cons416 = CustomConstraint(cons_f416) 2314 2315 def cons_f417(a, b, c, d, e, f, p, q, x): 2316 if isinstance(x, (int, Integer, float, Float)): 2317 return False 2318 return FreeQ(List(a, b, c, d, e, f, p, q), x) 2319 2320 cons417 = CustomConstraint(cons_f417) 2321 2322 def cons_f418(a, c, d, e, f, p, q, x): 2323 if isinstance(x, (int, Integer, float, Float)): 2324 return False 2325 return FreeQ(List(a, c, d, e, f, p, q), x) 2326 2327 cons418 = CustomConstraint(cons_f418) 2328 2329 def cons_f419(a, b, c, g, h): 2330 return ZeroQ(a*h**S(2) - b*g*h + c*g**S(2)) 2331 2332 cons419 = CustomConstraint(cons_f419) 2333 2334 def cons_f420(a, c, d, e, f, g, h): 2335 return ZeroQ(a**S(2)*f*h**S(2) - a*c*e*g*h + c**S(2)*d*g**S(2)) 2336 2337 cons420 = CustomConstraint(cons_f420) 2338 2339 def cons_f421(a, c, g, h): 2340 return ZeroQ(a*h**S(2) + c*g**S(2)) 2341 2342 cons421 = CustomConstraint(cons_f421) 2343 2344 def cons_f422(a, c, d, f, g, h): 2345 return ZeroQ(a**S(2)*f*h**S(2) + c**S(2)*d*g**S(2)) 2346 2347 cons422 = CustomConstraint(cons_f422) 2348 2349 def cons_f423(a, b, c, e, f): 2350 return ZeroQ(a*f**S(2) - b*e*f + c*e**S(2)) 2351 2352 cons423 = CustomConstraint(cons_f423) 2353 2354 def cons_f424(a, c, e, f): 2355 return ZeroQ(a*f**S(2) + c*e**S(2)) 2356 2357 cons424 = CustomConstraint(cons_f424) 2358 2359 def cons_f425(b, c, e, f, g, h, m, p): 2360 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)))) 2361 2362 cons425 = CustomConstraint(cons_f425) 2363 2364 def cons_f426(a, b, c, d, f, g, h, m, p): 2365 return ZeroQ(b*f*g*(p + S(1)) + h*(a*f*(m + S(1)) - c*d*(m + S(2)*p + S(3)))) 2366 2367 cons426 = CustomConstraint(cons_f426) 2368 2369 def cons_f427(c, e, f, g, h, m, p): 2370 return ZeroQ(c*(-e*h*(m + S(2)*p + S(3)) + S(2)*f*g*(p + S(1)))) 2371 2372 cons427 = CustomConstraint(cons_f427) 2373 2374 def cons_f428(a, c, d, f, h, m, p): 2375 return ZeroQ(h*(a*f*(m + S(1)) - c*d*(m + S(2)*p + S(3)))) 2376 2377 cons428 = CustomConstraint(cons_f428) 2378 2379 def cons_f429(b, c, f, g, h, m, p): 2380 return ZeroQ(b*f*h*(m + p + S(2)) + S(2)*c*f*g*(p + S(1))) 2381 2382 cons429 = CustomConstraint(cons_f429) 2383 2384 def cons_f430(m, p): 2385 return Or(IntegersQ(m, p), PositiveIntegerQ(p)) 2386 2387 cons430 = CustomConstraint(cons_f430) 2388 2389 def cons_f431(a, b, c, g, h): 2390 return NonzeroQ(a*h**S(2) - b*g*h + c*g**S(2)) 2391 2392 cons431 = CustomConstraint(cons_f431) 2393 2394 def cons_f432(a, c, g, h): 2395 return NonzeroQ(a*h**S(2) + c*g**S(2)) 2396 2397 cons432 = CustomConstraint(cons_f432) 2398 2399 def cons_f433(a, b, c, g, h): 2400 return NonzeroQ(c*g**S(2) - h*(-a*h + b*g)) 2401 2402 cons433 = CustomConstraint(cons_f433) 2403 2404 def cons_f434(p, q): 2405 return Or(Greater(p, S(0)), Greater(q, S(0))) 2406 2407 cons434 = CustomConstraint(cons_f434) 2408 2409 def cons_f435(p, q): 2410 return NonzeroQ(p + q + S(1)) 2411 2412 cons435 = CustomConstraint(cons_f435) 2413 2414 def cons_f436(a, c): 2415 return PositiveQ(a*c) 2416 2417 cons436 = CustomConstraint(cons_f436) 2418 2419 def cons_f437(a, c): 2420 return Not(PositiveQ(a*c)) 2421 2422 cons437 = CustomConstraint(cons_f437) 2423 2424 def cons_f438(e, f, g, h): 2425 return ZeroQ(e*h - S(2)*f*g) 2426 2427 cons438 = CustomConstraint(cons_f438) 2428 2429 def cons_f439(e, f, g, h): 2430 return NonzeroQ(e*h - S(2)*f*g) 2431 2432 cons439 = CustomConstraint(cons_f439) 2433 2434 def cons_f440(d, e, g, h): 2435 return ZeroQ(S(2)*d*h - e*g) 2436 2437 cons440 = CustomConstraint(cons_f440) 2438 2439 def cons_f441(d, e, g, h): 2440 return NonzeroQ(S(2)*d*h - e*g) 2441 2442 cons441 = CustomConstraint(cons_f441) 2443 2444 def cons_f442(a, b, c, d, e, f, g, h): 2445 return ZeroQ(g**S(2)*(-b*f + c*e) - S(2)*g*h*(-a*f + c*d) + h**S(2)*(-a*e + b*d)) 2446 2447 cons442 = CustomConstraint(cons_f442) 2448 2449 def cons_f443(a, c, d, e, f, g, h): 2450 return ZeroQ(a*e*h**S(2) - c*e*g**S(2) + S(2)*g*h*(-a*f + c*d)) 2451 2452 cons443 = CustomConstraint(cons_f443) 2453 2454 def cons_f444(a, b, c, d, f, g, h): 2455 return ZeroQ(b*d*h**S(2) - b*f*g**S(2) - S(2)*g*h*(-a*f + c*d)) 2456 2457 cons444 = CustomConstraint(cons_f444) 2458 2459 def cons_f445(a, b, c, d, f): 2460 return ZeroQ(c**S(2)*d - f*(-S(3)*a*c + b**S(2))) 2461 2462 cons445 = CustomConstraint(cons_f445) 2463 2464 def cons_f446(a, b, c, g, h): 2465 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)) 2466 2467 cons446 = CustomConstraint(cons_f446) 2468 2469 def cons_f447(b, c, g, h): 2470 return PositiveQ(-S(9)*c*h**S(2)/(-b*h + S(2)*c*g)**S(2)) 2471 2472 cons447 = CustomConstraint(cons_f447) 2473 2474 def cons_f448(a, c, d, f): 2475 return ZeroQ(S(3)*a*f + c*d) 2476 2477 cons448 = CustomConstraint(cons_f448) 2478 2479 def cons_f449(a, c, g, h): 2480 return ZeroQ(S(9)*a*h**S(2) + c*g**S(2)) 2481 2482 cons449 = CustomConstraint(cons_f449) 2483 2484 def cons_f450(a): 2485 return Not(PositiveQ(a)) 2486 2487 cons450 = CustomConstraint(cons_f450) 2488 2489 def cons_f451(a, b, c, d, e, f, g, h, p, q, x): 2490 if isinstance(x, (int, Integer, float, Float)): 2491 return False 2492 return FreeQ(List(a, b, c, d, e, f, g, h, p, q), x) 2493 2494 cons451 = CustomConstraint(cons_f451) 2495 2496 def cons_f452(a, c, d, e, f, g, h, p, q, x): 2497 if isinstance(x, (int, Integer, float, Float)): 2498 return False 2499 return FreeQ(List(a, c, d, e, f, g, h, p, q), x) 2500 2501 cons452 = CustomConstraint(cons_f452) 2502 2503 def cons_f453(x, z): 2504 if isinstance(x, (int, Integer, float, Float)): 2505 return False 2506 return LinearQ(z, x) 2507 2508 cons453 = CustomConstraint(cons_f453) 2509 2510 def cons_f454(u, v, x): 2511 if isinstance(x, (int, Integer, float, Float)): 2512 return False 2513 return QuadraticQ(List(u, v), x) 2514 2515 cons454 = CustomConstraint(cons_f454) 2516 2517 def cons_f455(u, v, x, z): 2518 if isinstance(x, (int, Integer, float, Float)): 2519 return False 2520 return Not(And(LinearMatchQ(z, x), QuadraticMatchQ(List(u, v), x))) 2521 2522 cons455 = CustomConstraint(cons_f455) 2523 2524 def cons_f456(p, q): 2525 return NonzeroQ(S(2)*p + S(2)*q + S(3)) 2526 2527 cons456 = CustomConstraint(cons_f456) 2528 2529 def cons_f457(A, B, C, a, b, c, d, e, f, p, q, x): 2530 if isinstance(x, (int, Integer, float, Float)): 2531 return False 2532 return FreeQ(List(a, b, c, d, e, f, A, B, C, p, q), x) 2533 2534 cons457 = CustomConstraint(cons_f457) 2535 2536 def cons_f458(A, C, a, b, c, d, e, f, p, q, x): 2537 if isinstance(x, (int, Integer, float, Float)): 2538 return False 2539 return FreeQ(List(a, b, c, d, e, f, A, C, p, q), x) 2540 2541 cons458 = CustomConstraint(cons_f458) 2542 2543 def cons_f459(A, B, C, a, c, d, e, f, p, q, x): 2544 if isinstance(x, (int, Integer, float, Float)): 2545 return False 2546 return FreeQ(List(a, c, d, e, f, A, B, C, p, q), x) 2547 2548 cons459 = CustomConstraint(cons_f459) 2549 2550 def cons_f460(A, C, a, c, d, e, f, p, q, x): 2551 if isinstance(x, (int, Integer, float, Float)): 2552 return False 2553 return FreeQ(List(a, c, d, e, f, A, C, p, q), x) 2554 2555 cons460 = CustomConstraint(cons_f460) 2556 2557 def cons_f461(b, n, p, x): 2558 if isinstance(x, (int, Integer, float, Float)): 2559 return False 2560 return FreeQ(List(b, n, p), x) 2561 2562 cons461 = CustomConstraint(cons_f461) 2563 2564 def cons_f462(n, p): 2565 return ZeroQ(p + S(1) + S(1)/n) 2566 2567 cons462 = CustomConstraint(cons_f462) 2568 2569 def cons_f463(n, p): 2570 return NegativeIntegerQ(p + S(1) + S(1)/n) 2571 2572 cons463 = CustomConstraint(cons_f463) 2573 2574 def cons_f464(n): 2575 return NonzeroQ(S(3)*n + S(1)) 2576 2577 cons464 = CustomConstraint(cons_f464) 2578 2579 def cons_f465(n): 2580 return Less(n, S(0)) 2581 2582 cons465 = CustomConstraint(cons_f465) 2583 2584 def cons_f466(n, p): 2585 return PositiveIntegerQ(n, p) 2586 2587 cons466 = CustomConstraint(cons_f466) 2588 2589 def cons_f467(n, p): 2590 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))) 2591 2592 cons467 = CustomConstraint(cons_f467) 2593 2594 def cons_f468(a, b): 2595 return PosQ(b/a) 2596 2597 cons468 = CustomConstraint(cons_f468) 2598 2599 def cons_f469(n): 2600 return PositiveIntegerQ(n/S(2) + S(-3)/2) 2601 2602 cons469 = CustomConstraint(cons_f469) 2603 2604 def cons_f470(a, b): 2605 return PosQ(a/b) 2606 2607 cons470 = CustomConstraint(cons_f470) 2608 2609 def cons_f471(a, b): 2610 return NegQ(a/b) 2611 2612 cons471 = CustomConstraint(cons_f471) 2613 2614 def cons_f472(a, b): 2615 return Or(PositiveQ(a), PositiveQ(b)) 2616 2617 cons472 = CustomConstraint(cons_f472) 2618 2619 def cons_f473(a, b): 2620 return Or(NegativeQ(a), NegativeQ(b)) 2621 2622 cons473 = CustomConstraint(cons_f473) 2623 2624 def cons_f474(a, b): 2625 return Or(PositiveQ(a), NegativeQ(b)) 2626 2627 cons474 = CustomConstraint(cons_f474) 2628 2629 def cons_f475(a, b): 2630 return Or(NegativeQ(a), PositiveQ(b)) 2631 2632 cons475 = CustomConstraint(cons_f475) 2633 2634 def cons_f476(n): 2635 return PositiveIntegerQ(n/S(4) + S(-1)/2) 2636 2637 cons476 = CustomConstraint(cons_f476) 2638 2639 def cons_f477(a, b): 2640 try: 2641 return Or(PositiveQ(a/b), And(PosQ(a/b), AtomQ(SplitProduct(SumBaseQ, a)), AtomQ(SplitProduct(SumBaseQ, b)))) 2642 except (TypeError, AttributeError): 2643 return False 2644 2645 cons477 = CustomConstraint(cons_f477) 2646 2647 def cons_f478(a, b): 2648 return Not(PositiveQ(a/b)) 2649 2650 cons478 = CustomConstraint(cons_f478) 2651 2652 def cons_f479(n): 2653 return PositiveIntegerQ(n/S(4) + S(-1)) 2654 2655 cons479 = CustomConstraint(cons_f479) 2656 2657 def cons_f480(a, b): 2658 return PositiveQ(a/b) 2659 2660 cons480 = CustomConstraint(cons_f480) 2661 2662 def cons_f481(b): 2663 return PosQ(b) 2664 2665 cons481 = CustomConstraint(cons_f481) 2666 2667 def cons_f482(b): 2668 return NegQ(b) 2669 2670 cons482 = CustomConstraint(cons_f482) 2671 2672 def cons_f483(a): 2673 return PosQ(a) 2674 2675 cons483 = CustomConstraint(cons_f483) 2676 2677 def cons_f484(a): 2678 return NegQ(a) 2679 2680 cons484 = CustomConstraint(cons_f484) 2681 2682 def cons_f485(a, b): 2683 return NegQ(b/a) 2684 2685 cons485 = CustomConstraint(cons_f485) 2686 2687 def cons_f486(a): 2688 return NegativeQ(a) 2689 2690 cons486 = CustomConstraint(cons_f486) 2691 2692 def cons_f487(p): 2693 return Less(S(-1), p, S(0)) 2694 2695 cons487 = CustomConstraint(cons_f487) 2696 2697 def cons_f488(p): 2698 return Unequal(p, S(-1)/2) 2699 2700 cons488 = CustomConstraint(cons_f488) 2701 2702 def cons_f489(n, p): 2703 return IntegerQ(p + S(1)/n) 2704 2705 cons489 = CustomConstraint(cons_f489) 2706 2707 def cons_f490(n, p): 2708 return Less(Denominator(p + S(1)/n), Denominator(p)) 2709 2710 cons490 = CustomConstraint(cons_f490) 2711 2712 def cons_f491(n): 2713 return FractionQ(n) 2714 2715 cons491 = CustomConstraint(cons_f491) 2716 2717 def cons_f492(n): 2718 return Not(IntegerQ(S(1)/n)) 2719 2720 cons492 = CustomConstraint(cons_f492) 2721 2722 def cons_f493(n, p): 2723 return Not(NegativeIntegerQ(p + S(1)/n)) 2724 2725 cons493 = CustomConstraint(cons_f493) 2726 2727 def cons_f494(a, p): 2728 return Or(IntegerQ(p), PositiveQ(a)) 2729 2730 cons494 = CustomConstraint(cons_f494) 2731 2732 def cons_f495(a, p): 2733 return Not(Or(IntegerQ(p), PositiveQ(a))) 2734 2735 cons495 = CustomConstraint(cons_f495) 2736 2737 def cons_f496(a1, a2, p): 2738 return Or(IntegerQ(p), And(PositiveQ(a1), PositiveQ(a2))) 2739 2740 cons496 = CustomConstraint(cons_f496) 2741 2742 def cons_f497(n): 2743 return PositiveIntegerQ(S(2)*n) 2744 2745 cons497 = CustomConstraint(cons_f497) 2746 2747 def cons_f498(n, p): 2748 return Or(IntegerQ(S(2)*p), Less(Denominator(p + S(1)/n), Denominator(p))) 2749 2750 cons498 = CustomConstraint(cons_f498) 2751 2752 def cons_f499(n): 2753 return NegativeIntegerQ(S(2)*n) 2754 2755 cons499 = CustomConstraint(cons_f499) 2756 2757 def cons_f500(n): 2758 return FractionQ(S(2)*n) 2759 2760 cons500 = CustomConstraint(cons_f500) 2761 2762 def cons_f501(c, m): 2763 return Or(IntegerQ(m), PositiveQ(c)) 2764 2765 cons501 = CustomConstraint(cons_f501) 2766 2767 def cons_f502(m, n): 2768 return IntegerQ((m + S(1))/n) 2769 2770 cons502 = CustomConstraint(cons_f502) 2771 2772 def cons_f503(m, n): 2773 return Not(IntegerQ((m + S(1))/n)) 2774 2775 cons503 = CustomConstraint(cons_f503) 2776 2777 def cons_f504(n): 2778 return NegQ(n) 2779 2780 cons504 = CustomConstraint(cons_f504) 2781 2782 def cons_f505(m, n, p): 2783 return ZeroQ(p + S(1) + (m + S(1))/n) 2784 2785 cons505 = CustomConstraint(cons_f505) 2786 2787 def cons_f506(m, n, p): 2788 return ZeroQ(p + S(1) + (m + S(1))/(S(2)*n)) 2789 2790 cons506 = CustomConstraint(cons_f506) 2791 2792 def cons_f507(m, n): 2793 return IntegerQ((m + S(1))/(S(2)*n)) 2794 2795 cons507 = CustomConstraint(cons_f507) 2796 2797 def cons_f508(m, n, p): 2798 return NegativeIntegerQ((m + n*(p + S(1)) + S(1))/n) 2799 2800 cons508 = CustomConstraint(cons_f508) 2801 2802 def cons_f509(m, n, p): 2803 return NegativeIntegerQ((m + S(2)*n*(p + S(1)) + S(1))/(S(2)*n)) 2804 2805 cons509 = CustomConstraint(cons_f509) 2806 2807 def cons_f510(m, n, p): 2808 return Not(NegativeIntegerQ((m + n*p + n + S(1))/n)) 2809 2810 cons510 = CustomConstraint(cons_f510) 2811 2812 def cons_f511(a, b, c, m, n, p, x): 2813 if isinstance(x, (int, Integer, float, Float)): 2814 return False 2815 return IntBinomialQ(a, b, c, n, m, p, x) 2816 2817 cons511 = CustomConstraint(cons_f511) 2818 2819 def cons_f512(m, n, p): 2820 return NonzeroQ(m + S(2)*n*p + S(1)) 2821 2822 cons512 = CustomConstraint(cons_f512) 2823 2824 def cons_f513(a1, a2, b1, b2, c, m, n, p, x): 2825 if isinstance(x, (int, Integer, float, Float)): 2826 return False 2827 return IntBinomialQ(a1*a2, b1*b2, c, n, m, p, x) 2828 2829 cons513 = CustomConstraint(cons_f513) 2830 2831 def cons_f514(m, n, p): 2832 return NonzeroQ(m + n*p + S(1)) 2833 2834 cons514 = CustomConstraint(cons_f514) 2835 2836 def cons_f515(m): 2837 return PositiveIntegerQ(m/S(4) + S(-1)/2) 2838 2839 cons515 = CustomConstraint(cons_f515) 2840 2841 def cons_f516(m): 2842 return NegativeIntegerQ(m/S(4) + S(-1)/2) 2843 2844 cons516 = CustomConstraint(cons_f516) 2845 2846 def cons_f517(m): 2847 return IntegerQ(S(2)*m) 2848 2849 cons517 = CustomConstraint(cons_f517) 2850 2851 def cons_f518(m): 2852 return Greater(m, S(3)/2) 2853 2854 cons518 = CustomConstraint(cons_f518) 2855 2856 def cons_f519(m, n): 2857 return Greater(m + S(1), n) 2858 2859 cons519 = CustomConstraint(cons_f519) 2860 2861 def cons_f520(m, n, p): 2862 return Not(NegativeIntegerQ((m + n*(p + S(1)) + S(1))/n)) 2863 2864 cons520 = CustomConstraint(cons_f520) 2865 2866 def cons_f521(m, n): 2867 return Greater(m + S(1), S(2)*n) 2868 2869 cons521 = CustomConstraint(cons_f521) 2870 2871 def cons_f522(m, n, p): 2872 return Not(NegativeIntegerQ((m + S(2)*n*(p + S(1)) + S(1))/(S(2)*n))) 2873 2874 cons522 = CustomConstraint(cons_f522) 2875 2876 def cons_f523(n): 2877 return PositiveIntegerQ(n/S(2) + S(-1)/2) 2878 2879 cons523 = CustomConstraint(cons_f523) 2880 2881 def cons_f524(m, n): 2882 return Less(m, n + S(-1)) 2883 2884 cons524 = CustomConstraint(cons_f524) 2885 2886 def cons_f525(m, n): 2887 return PositiveIntegerQ(m, n/S(2) + S(-1)/2) 2888 2889 cons525 = CustomConstraint(cons_f525) 2890 2891 def cons_f526(m, n): 2892 return PositiveIntegerQ(m, n/S(4) + S(-1)/2) 2893 2894 cons526 = CustomConstraint(cons_f526) 2895 2896 def cons_f527(m, n): 2897 return PositiveIntegerQ(m, n/S(4)) 2898 2899 cons527 = CustomConstraint(cons_f527) 2900 2901 def cons_f528(m, n): 2902 return Less(m, n/S(2)) 2903 2904 cons528 = CustomConstraint(cons_f528) 2905 2906 def cons_f529(m, n): 2907 return Inequality(n/S(2), LessEqual, m, Less, n) 2908 2909 cons529 = CustomConstraint(cons_f529) 2910 2911 def cons_f530(m, n): 2912 return PositiveIntegerQ(m, n) 2913 2914 cons530 = CustomConstraint(cons_f530) 2915 2916 def cons_f531(m, n): 2917 return Greater(m, S(2)*n + S(-1)) 2918 2919 cons531 = CustomConstraint(cons_f531) 2920 2921 def cons_f532(m, n): 2922 return Greater(m, n + S(-1)) 2923 2924 cons532 = CustomConstraint(cons_f532) 2925 2926 def cons_f533(m, n): 2927 return SumSimplerQ(m, -n) 2928 2929 cons533 = CustomConstraint(cons_f533) 2930 2931 def cons_f534(m, n, p): 2932 return NegativeIntegerQ((m + n*p + S(1))/n) 2933 2934 cons534 = CustomConstraint(cons_f534) 2935 2936 def cons_f535(m, n): 2937 return SumSimplerQ(m, -S(2)*n) 2938 2939 cons535 = CustomConstraint(cons_f535) 2940 2941 def cons_f536(m, n, p): 2942 return NegativeIntegerQ((m + S(2)*n*p + S(1))/(S(2)*n)) 2943 2944 cons536 = CustomConstraint(cons_f536) 2945 2946 def cons_f537(m, n): 2947 return SumSimplerQ(m, n) 2948 2949 cons537 = CustomConstraint(cons_f537) 2950 2951 def cons_f538(m, n): 2952 return SumSimplerQ(m, S(2)*n) 2953 2954 cons538 = CustomConstraint(cons_f538) 2955 2956 def cons_f539(m, n, p): 2957 return IntegersQ(m, p + (m + S(1))/n) 2958 2959 cons539 = CustomConstraint(cons_f539) 2960 2961 def cons_f540(m, n, p): 2962 return IntegersQ(m, p + (m + S(1))/(S(2)*n)) 2963 2964 cons540 = CustomConstraint(cons_f540) 2965 2966 def cons_f541(m, n, p): 2967 return Less(Denominator(p + (m + S(1))/n), Denominator(p)) 2968 2969 cons541 = CustomConstraint(cons_f541) 2970 2971 def cons_f542(m, n, p): 2972 return Less(Denominator(p + (m + S(1))/(S(2)*n)), Denominator(p)) 2973 2974 cons542 = CustomConstraint(cons_f542) 2975 2976 def cons_f543(m, n): 2977 return IntegerQ(n/(m + S(1))) 2978 2979 cons543 = CustomConstraint(cons_f543) 2980 2981 def cons_f544(m, n): 2982 return IntegerQ(S(2)*n/(m + S(1))) 2983 2984 cons544 = CustomConstraint(cons_f544) 2985 2986 def cons_f545(n): 2987 return Not(IntegerQ(S(2)*n)) 2988 2989 cons545 = CustomConstraint(cons_f545) 2990 2991 def cons_f546(m, n, p): 2992 return ZeroQ(p + (m + S(1))/n) 2993 2994 cons546 = CustomConstraint(cons_f546) 2995 2996 def cons_f547(m, n, p): 2997 return ZeroQ(p + (m + S(1))/(S(2)*n)) 2998 2999 cons547 = CustomConstraint(cons_f547) 3000 3001 def cons_f548(m, n, p): 3002 return IntegerQ(p + (m + S(1))/n) 3003 3004 cons548 = CustomConstraint(cons_f548) 3005 3006 def cons_f549(m, n, p): 3007 return IntegerQ(p + (m + S(1))/(S(2)*n)) 3008 3009 cons549 = CustomConstraint(cons_f549) 3010 3011 def cons_f550(m, n): 3012 return FractionQ((m + S(1))/n) 3013 3014 cons550 = CustomConstraint(cons_f550) 3015 3016 def cons_f551(m, n): 3017 return Or(SumSimplerQ(m, n), SumSimplerQ(m, -n)) 3018 3019 cons551 = CustomConstraint(cons_f551) 3020 3021 def cons_f552(a, p): 3022 return Or(NegativeIntegerQ(p), PositiveQ(a)) 3023 3024 cons552 = CustomConstraint(cons_f552) 3025 3026 def cons_f553(a, p): 3027 return Not(Or(NegativeIntegerQ(p), PositiveQ(a))) 3028 3029 cons553 = CustomConstraint(cons_f553) 3030 3031 def cons_f554(v, x): 3032 if isinstance(x, (int, Integer, float, Float)): 3033 return False 3034 return LinearQ(v, x) 3035 3036 cons554 = CustomConstraint(cons_f554) 3037 3038 def cons_f555(v, x): 3039 if isinstance(x, (int, Integer, float, Float)): 3040 return False 3041 return NonzeroQ(v - x) 3042 3043 cons555 = CustomConstraint(cons_f555) 3044 3045 def cons_f556(u, v, x): 3046 if isinstance(x, (int, Integer, float, Float)): 3047 return False 3048 return LinearPairQ(u, v, x) 3049 3050 cons556 = CustomConstraint(cons_f556) 3051 3052 def cons_f557(p, q): 3053 return PositiveIntegerQ(p, q) 3054 3055 cons557 = CustomConstraint(cons_f557) 3056 3057 def cons_f558(n, p): 3058 return ZeroQ(n*p + S(1)) 3059 3060 cons558 = CustomConstraint(cons_f558) 3061 3062 def cons_f559(n, p, q): 3063 return ZeroQ(n*(p + q + S(1)) + S(1)) 3064 3065 cons559 = CustomConstraint(cons_f559) 3066 3067 def cons_f560(n, p, q): 3068 return ZeroQ(n*(p + q + S(2)) + S(1)) 3069 3070 cons560 = CustomConstraint(cons_f560) 3071 3072 def cons_f561(a, b, c, d, p, q): 3073 return ZeroQ(a*d*(p + S(1)) + b*c*(q + S(1))) 3074 3075 cons561 = CustomConstraint(cons_f561) 3076 3077 def cons_f562(p, q): 3078 return Or(And(RationalQ(p), Less(p, S(-1))), Not(And(RationalQ(q), Less(q, S(-1))))) 3079 3080 cons562 = CustomConstraint(cons_f562) 3081 3082 def cons_f563(a, b, c, d, n, p): 3083 return ZeroQ(a*d - b*c*(n*(p + S(1)) + S(1))) 3084 3085 cons563 = CustomConstraint(cons_f563) 3086 3087 def cons_f564(n, p): 3088 return Or(And(RationalQ(p), Less(p, S(-1))), NegativeIntegerQ(p + S(1)/n)) 3089 3090 cons564 = CustomConstraint(cons_f564) 3091 3092 def cons_f565(n, p): 3093 return NonzeroQ(n*(p + S(1)) + S(1)) 3094 3095 cons565 = CustomConstraint(cons_f565) 3096 3097 def cons_f566(q): 3098 return NegativeIntegerQ(q) 3099 3100 cons566 = CustomConstraint(cons_f566) 3101 3102 def cons_f567(p, q): 3103 return GreaterEqual(p, -q) 3104 3105 cons567 = CustomConstraint(cons_f567) 3106 3107 def cons_f568(a, b, c, d): 3108 return ZeroQ(S(3)*a*d + b*c) 3109 3110 cons568 = CustomConstraint(cons_f568) 3111 3112 def cons_f569(p): 3113 return Or(Equal(p, S(1)/2), Equal(Denominator(p), S(4))) 3114 3115 cons569 = CustomConstraint(cons_f569) 3116 3117 def cons_f570(p): 3118 return Equal(Denominator(p), S(4)) 3119 3120 cons570 = CustomConstraint(cons_f570) 3121 3122 def cons_f571(p): 3123 return Or(Equal(p, S(-5)/4), Equal(p, S(-7)/4)) 3124 3125 cons571 = CustomConstraint(cons_f571) 3126 3127 def cons_f572(a, b): 3128 return PosQ(a*b) 3129 3130 cons572 = CustomConstraint(cons_f572) 3131 3132 def cons_f573(a, b): 3133 return NegQ(a*b) 3134 3135 cons573 = CustomConstraint(cons_f573) 3136 3137 def cons_f574(p): 3138 return Or(Equal(p, S(3)/4), Equal(p, S(5)/4)) 3139 3140 cons574 = CustomConstraint(cons_f574) 3141 3142 def cons_f575(c, d): 3143 return PosQ(d/c) 3144 3145 cons575 = CustomConstraint(cons_f575) 3146 3147 def cons_f576(q): 3148 return Less(S(0), q, S(1)) 3149 3150 cons576 = CustomConstraint(cons_f576) 3151 3152 def cons_f577(a, b, c, d, n, p, q, x): 3153 if isinstance(x, (int, Integer, float, Float)): 3154 return False 3155 return IntBinomialQ(a, b, c, d, n, p, q, x) 3156 3157 cons577 = CustomConstraint(cons_f577) 3158 3159 def cons_f578(q): 3160 return Greater(q, S(1)) 3161 3162 cons578 = CustomConstraint(cons_f578) 3163 3164 def cons_f579(p, q): 3165 return Greater(p + q, S(0)) 3166 3167 cons579 = CustomConstraint(cons_f579) 3168 3169 def cons_f580(n, p, q): 3170 return NonzeroQ(n*(p + q) + S(1)) 3171 3172 cons580 = CustomConstraint(cons_f580) 3173 3174 def cons_f581(p): 3175 return Not(And(IntegerQ(p), Greater(p, S(1)))) 3176 3177 cons581 = CustomConstraint(cons_f581) 3178 3179 def cons_f582(a, b, c, d): 3180 return Not(SimplerSqrtQ(b/a, d/c)) 3181 3182 cons582 = CustomConstraint(cons_f582) 3183 3184 def cons_f583(c, d): 3185 return NegQ(d/c) 3186 3187 cons583 = CustomConstraint(cons_f583) 3188 3189 def cons_f584(a, b, c, d): 3190 return Not(And(NegQ(b/a), SimplerSqrtQ(-b/a, -d/c))) 3191 3192 cons584 = CustomConstraint(cons_f584) 3193 3194 def cons_f585(a, b, c, d): 3195 return PositiveQ(a - b*c/d) 3196 3197 cons585 = CustomConstraint(cons_f585) 3198 3199 def cons_f586(n): 3200 return NonzeroQ(n + S(1)) 3201 3202 cons586 = CustomConstraint(cons_f586) 3203 3204 def cons_f587(mn, n): 3205 return EqQ(mn, -n) 3206 3207 cons587 = CustomConstraint(cons_f587) 3208 3209 def cons_f588(q): 3210 return IntegerQ(q) 3211 3212 cons588 = CustomConstraint(cons_f588) 3213 3214 def cons_f589(n, p): 3215 return Or(PosQ(n), Not(IntegerQ(p))) 3216 3217 cons589 = CustomConstraint(cons_f589) 3218 3219 def cons_f590(u, v, x): 3220 if isinstance(x, (int, Integer, float, Float)): 3221 return False 3222 return PseudoBinomialPairQ(u, v, x) 3223 3224 cons590 = CustomConstraint(cons_f590) 3225 3226 def cons_f591(m, p): 3227 return IntegersQ(p, m/p) 3228 3229 cons591 = CustomConstraint(cons_f591) 3230 3231 def cons_f592(m, p, u, v, x): 3232 if isinstance(x, (int, Integer, float, Float)): 3233 return False 3234 return PseudoBinomialPairQ(u*x**(m/p), v, x) 3235 3236 cons592 = CustomConstraint(cons_f592) 3237 3238 def cons_f593(e, m): 3239 return Or(IntegerQ(m), PositiveQ(e)) 3240 3241 cons593 = CustomConstraint(cons_f593) 3242 3243 def cons_f594(a, b, c, d, m, n, p): 3244 return ZeroQ(a*d*(m + S(1)) - b*c*(m + n*(p + S(1)) + S(1))) 3245 3246 cons594 = CustomConstraint(cons_f594) 3247 3248 def cons_f595(n, non2): 3249 return ZeroQ(-n/S(2) + non2) 3250 3251 cons595 = CustomConstraint(cons_f595) 3252 3253 def cons_f596(a1, a2, b1, b2, c, d, m, n, p): 3254 return ZeroQ(a1*a2*d*(m + S(1)) - b1*b2*c*(m + n*(p + S(1)) + S(1))) 3255 3256 cons596 = CustomConstraint(cons_f596) 3257 3258 def cons_f597(m, n, p): 3259 return ZeroQ(m + n*(p + S(1)) + S(1)) 3260 3261 cons597 = CustomConstraint(cons_f597) 3262 3263 def cons_f598(e, n): 3264 return Or(IntegerQ(n), PositiveQ(e)) 3265 3266 cons598 = CustomConstraint(cons_f598) 3267 3268 def cons_f599(m, n): 3269 return Or(And(Greater(n, S(0)), Less(m, S(-1))), And(Less(n, S(0)), Greater(m + n, S(-1)))) 3270 3271 cons599 = CustomConstraint(cons_f599) 3272 3273 def cons_f600(p): 3274 return Not(And(IntegerQ(p), Less(p, S(-1)))) 3275 3276 cons600 = CustomConstraint(cons_f600) 3277 3278 def cons_f601(m): 3279 return PositiveIntegerQ(m/S(2)) 3280 3281 cons601 = CustomConstraint(cons_f601) 3282 3283 def cons_f602(m, p): 3284 return Or(IntegerQ(p), Equal(m + S(2)*p + S(1), S(0))) 3285 3286 cons602 = CustomConstraint(cons_f602) 3287 3288 def cons_f603(m): 3289 return NegativeIntegerQ(m/S(2)) 3290 3291 cons603 = CustomConstraint(cons_f603) 3292 3293 def cons_f604(m, n, p): 3294 return Or(IntegerQ(p), Not(RationalQ(m)), And(PositiveIntegerQ(n), NegativeIntegerQ(p + S(1)/2), LessEqual(S(-1), m, -n*(p + S(1))))) 3295 3296 cons604 = CustomConstraint(cons_f604) 3297 3298 def cons_f605(m, n, p): 3299 return NonzeroQ(m + n*(p + S(1)) + S(1)) 3300 3301 cons605 = CustomConstraint(cons_f605) 3302 3303 def cons_f606(m): 3304 return Or(IntegerQ(m), PositiveIntegerQ(S(2)*m + S(2)), Not(RationalQ(m))) 3305 3306 cons606 = CustomConstraint(cons_f606) 3307 3308 def cons_f607(m, n, p): 3309 return NonzeroQ(m + n*(p + S(2)) + S(1)) 3310 3311 cons607 = CustomConstraint(cons_f607) 3312 3313 def cons_f608(m, p, q): 3314 return RationalQ(m, p, q) 3315 3316 cons608 = CustomConstraint(cons_f608) 3317 3318 def cons_f609(m, n): 3319 return Greater(m - n + S(1), S(0)) 3320 3321 cons609 = CustomConstraint(cons_f609) 3322 3323 def cons_f610(a, b, c, d, e, m, n, p, q, x): 3324 if isinstance(x, (int, Integer, float, Float)): 3325 return False 3326 return IntBinomialQ(a, b, c, d, e, m, n, p, q, x) 3327 3328 cons610 = CustomConstraint(cons_f610) 3329 3330 def cons_f611(m, n): 3331 return Greater(m - n + S(1), n) 3332 3333 cons611 = CustomConstraint(cons_f611) 3334 3335 def cons_f612(m, n): 3336 return Inequality(n, GreaterEqual, m - n + S(1), Greater, S(0)) 3337 3338 cons612 = CustomConstraint(cons_f612) 3339 3340 def cons_f613(m, q): 3341 return RationalQ(m, q) 3342 3343 cons613 = CustomConstraint(cons_f613) 3344 3345 def cons_f614(m, n): 3346 return LessEqual(n, m, S(2)*n + S(-1)) 3347 3348 cons614 = CustomConstraint(cons_f614) 3349 3350 def cons_f615(m, n): 3351 return IntegersQ(m/S(2), n/S(2)) 3352 3353 cons615 = CustomConstraint(cons_f615) 3354 3355 def cons_f616(m, n): 3356 return Less(S(0), m - n + S(1), n) 3357 3358 cons616 = CustomConstraint(cons_f616) 3359 3360 def cons_f617(n): 3361 return LessEqual(n, S(4)) 3362 3363 cons617 = CustomConstraint(cons_f617) 3364 3365 def cons_f618(a, b, c, d): 3366 return ZeroQ(-a*d + S(4)*b*c) 3367 3368 cons618 = CustomConstraint(cons_f618) 3369 3370 def cons_f619(m): 3371 return PositiveIntegerQ(m/S(3) + S(-1)/3) 3372 3373 cons619 = CustomConstraint(cons_f619) 3374 3375 def cons_f620(m): 3376 return NegativeIntegerQ(m/S(3) + S(-1)/3) 3377 3378 cons620 = CustomConstraint(cons_f620) 3379 3380 def cons_f621(m): 3381 return IntegerQ(m/S(3) + S(-1)/3) 3382 3383 cons621 = CustomConstraint(cons_f621) 3384 3385 def cons_f622(n): 3386 return Or(EqQ(n, S(2)), EqQ(n, S(4))) 3387 3388 cons622 = CustomConstraint(cons_f622) 3389 3390 def cons_f623(a, b, c, d, n): 3391 return Not(And(EqQ(n, S(2)), SimplerSqrtQ(-b/a, -d/c))) 3392 3393 cons623 = CustomConstraint(cons_f623) 3394 3395 def cons_f624(m, n, p, q): 3396 return IntegersQ(p + (m + S(1))/n, q) 3397 3398 cons624 = CustomConstraint(cons_f624) 3399 3400 def cons_f625(m, n): 3401 return Or(ZeroQ(m - n), ZeroQ(m - S(2)*n + S(1))) 3402 3403 cons625 = CustomConstraint(cons_f625) 3404 3405 def cons_f626(m, p, q): 3406 return IntegersQ(m, p, q) 3407 3408 cons626 = CustomConstraint(cons_f626) 3409 3410 def cons_f627(p): 3411 return GreaterEqual(p, S(-2)) 3412 3413 cons627 = CustomConstraint(cons_f627) 3414 3415 def cons_f628(m, q): 3416 return Or(GreaterEqual(q, S(-2)), And(Equal(q, S(-3)), IntegerQ(m/S(2) + S(-1)/2))) 3417 3418 cons628 = CustomConstraint(cons_f628) 3419 3420 def cons_f629(m, n): 3421 return NonzeroQ(m - n + S(1)) 3422 3423 cons629 = CustomConstraint(cons_f629) 3424 3425 def cons_f630(p, q, r): 3426 return PositiveIntegerQ(p, q, r) 3427 3428 cons630 = CustomConstraint(cons_f630) 3429 3430 def cons_f631(a, b, c, d, e, f, n, x): 3431 if isinstance(x, (int, Integer, float, Float)): 3432 return False 3433 return FreeQ(List(a, b, c, d, e, f, n), x) 3434 3435 cons631 = CustomConstraint(cons_f631) 3436 3437 def cons_f632(a, b, c, d, n): 3438 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)))))))) 3439 3440 cons632 = CustomConstraint(cons_f632) 3441 3442 def cons_f633(n, p, q): 3443 return NonzeroQ(n*(p + q + S(1)) + S(1)) 3444 3445 cons633 = CustomConstraint(cons_f633) 3446 3447 def cons_f634(a, b, c, d, e, f, n, p, x): 3448 if isinstance(x, (int, Integer, float, Float)): 3449 return False 3450 return FreeQ(List(a, b, c, d, e, f, p, n), x) 3451 3452 cons634 = CustomConstraint(cons_f634) 3453 3454 def cons_f635(a, b, c, d, e, f, n, p, q, x): 3455 if isinstance(x, (int, Integer, float, Float)): 3456 return False 3457 return FreeQ(List(a, b, c, d, e, f, n, p, q), x) 3458 3459 cons635 = CustomConstraint(cons_f635) 3460 3461 def cons_f636(c, d): 3462 return PositiveQ(d/c) 3463 3464 cons636 = CustomConstraint(cons_f636) 3465 3466 def cons_f637(e, f): 3467 return PositiveQ(f/e) 3468 3469 cons637 = CustomConstraint(cons_f637) 3470 3471 def cons_f638(c, d, e, f): 3472 return Not(SimplerSqrtQ(d/c, f/e)) 3473 3474 cons638 = CustomConstraint(cons_f638) 3475 3476 def cons_f639(c, d, e, f): 3477 return Not(SimplerSqrtQ(-f/e, -d/c)) 3478 3479 cons639 = CustomConstraint(cons_f639) 3480 3481 def cons_f640(e, f): 3482 return PosQ(f/e) 3483 3484 cons640 = CustomConstraint(cons_f640) 3485 3486 def cons_f641(c, d, e, f): 3487 return Not(And(NegQ(f/e), SimplerSqrtQ(-f/e, -d/c))) 3488 3489 cons641 = CustomConstraint(cons_f641) 3490 3491 def cons_f642(q, r): 3492 return RationalQ(q, r) 3493 3494 cons642 = CustomConstraint(cons_f642) 3495 3496 def cons_f643(r): 3497 return Greater(r, S(1)) 3498 3499 cons643 = CustomConstraint(cons_f643) 3500 3501 def cons_f644(q): 3502 return LessEqual(q, S(-1)) 3503 3504 cons644 = CustomConstraint(cons_f644) 3505 3506 def cons_f645(c, d, e, f): 3507 return PosQ((-c*f + d*e)/c) 3508 3509 cons645 = CustomConstraint(cons_f645) 3510 3511 def cons_f646(c, d, e, f): 3512 return NegQ((-c*f + d*e)/c) 3513 3514 cons646 = CustomConstraint(cons_f646) 3515 3516 def cons_f647(a, b, c, d, e, f, n, p, q, r, x): 3517 if isinstance(x, (int, Integer, float, Float)): 3518 return False 3519 return FreeQ(List(a, b, c, d, e, f, n, p, q, r), x) 3520 3521 cons647 = CustomConstraint(cons_f647) 3522 3523 def cons_f648(u, v): 3524 return ZeroQ(u - v) 3525 3526 cons648 = CustomConstraint(cons_f648) 3527 3528 def cons_f649(u, w): 3529 return ZeroQ(u - w) 3530 3531 cons649 = CustomConstraint(cons_f649) 3532 3533 def cons_f650(r): 3534 return IntegerQ(r) 3535 3536 cons650 = CustomConstraint(cons_f650) 3537 3538 def cons_f651(n, n2): 3539 return ZeroQ(-n/S(2) + n2) 3540 3541 cons651 = CustomConstraint(cons_f651) 3542 3543 def cons_f652(e1, e2, f1, f2): 3544 return ZeroQ(e1*f2 + e2*f1) 3545 3546 cons652 = CustomConstraint(cons_f652) 3547 3548 def cons_f653(e1, e2, r): 3549 return Or(IntegerQ(r), And(PositiveQ(e1), PositiveQ(e2))) 3550 3551 cons653 = CustomConstraint(cons_f653) 3552 3553 def cons_f654(e1, x): 3554 return FreeQ(e1, x) 3555 3556 cons654 = CustomConstraint(cons_f654) 3557 3558 def cons_f655(f1, x): 3559 return FreeQ(f1, x) 3560 3561 cons655 = CustomConstraint(cons_f655) 3562 3563 def cons_f656(e2, x): 3564 return FreeQ(e2, x) 3565 3566 cons656 = CustomConstraint(cons_f656) 3567 3568 def cons_f657(f2, x): 3569 return FreeQ(f2, x) 3570 3571 cons657 = CustomConstraint(cons_f657) 3572 3573 def cons_f658(g, m): 3574 return Or(IntegerQ(m), PositiveQ(g)) 3575 3576 cons658 = CustomConstraint(cons_f658) 3577 3578 def cons_f659(p, q, r): 3579 return PositiveIntegerQ(p + S(2), q, r) 3580 3581 cons659 = CustomConstraint(cons_f659) 3582 3583 def cons_f660(p, q, r): 3584 return IntegersQ(p, q, r) 3585 3586 cons660 = CustomConstraint(cons_f660) 3587 3588 def cons_f661(a, b, c, d, e, f, q): 3589 return Not(And(Equal(q, S(1)), SimplerQ(-a*d + b*c, -a*f + b*e))) 3590 3591 cons661 = CustomConstraint(cons_f661) 3592 3593 def cons_f662(c, d, e, f, n, q, x): 3594 if isinstance(x, (int, Integer, float, Float)): 3595 return False 3596 return Not(And(Equal(q, S(1)), SimplerQ(e + f*x**n, c + d*x**n))) 3597 3598 cons662 = CustomConstraint(cons_f662) 3599 3600 def cons_f663(r): 3601 return PositiveIntegerQ(r) 3602 3603 cons663 = CustomConstraint(cons_f663) 3604 3605 def cons_f664(a, b, c, d, e, f, g, m, n, p, q, x): 3606 if isinstance(x, (int, Integer, float, Float)): 3607 return False 3608 return FreeQ(List(a, b, c, d, e, f, g, m, n, p, q), x) 3609 3610 cons664 = CustomConstraint(cons_f664) 3611 3612 def cons_f665(a, b, c, d, e, f, g, m, n, p, q, r, x): 3613 if isinstance(x, (int, Integer, float, Float)): 3614 return False 3615 return FreeQ(List(a, b, c, d, e, f, g, m, n, p, q, r), x) 3616 3617 cons665 = CustomConstraint(cons_f665) 3618 3619 def cons_f666(n, p): 3620 return ZeroQ(n*(S(2)*p + S(1)) + S(1)) 3621 3622 cons666 = CustomConstraint(cons_f666) 3623 3624 def cons_f667(n, p): 3625 return ZeroQ(S(2)*n*(p + S(1)) + S(1)) 3626 3627 cons667 = CustomConstraint(cons_f667) 3628 3629 def cons_f668(n, p): 3630 return Or(ZeroQ(S(2)*n*p + S(1)), ZeroQ(n*(S(2)*p + S(-1)) + S(1))) 3631 3632 cons668 = CustomConstraint(cons_f668) 3633 3634 def cons_f669(p): 3635 return IntegerQ(p + S(1)/2) 3636 3637 cons669 = CustomConstraint(cons_f669) 3638 3639 def cons_f670(n): 3640 return NonzeroQ(S(2)*n + S(1)) 3641 3642 cons670 = CustomConstraint(cons_f670) 3643 3644 def cons_f671(n, p): 3645 return NonzeroQ(S(2)*n*p + S(1)) 3646 3647 cons671 = CustomConstraint(cons_f671) 3648 3649 def cons_f672(n, p): 3650 return NonzeroQ(n*(S(2)*p + S(-1)) + S(1)) 3651 3652 cons672 = CustomConstraint(cons_f672) 3653 3654 def cons_f673(n, p): 3655 return NonzeroQ(n*(S(2)*p + S(1)) + S(1)) 3656 3657 cons673 = CustomConstraint(cons_f673) 3658 3659 def cons_f674(n, p): 3660 return NonzeroQ(S(2)*n*(p + S(1)) + S(1)) 3661 3662 cons674 = CustomConstraint(cons_f674) 3663 3664 def cons_f675(n, p): 3665 return Or(IntegerQ(p), ZeroQ(n + S(-2))) 3666 3667 cons675 = CustomConstraint(cons_f675) 3668 3669 def cons_f676(n): 3670 return PositiveIntegerQ(n/S(2)) 3671 3672 cons676 = CustomConstraint(cons_f676) 3673 3674 def cons_f677(a, b, c): 3675 return PositiveQ(-S(4)*a*c + b**S(2)) 3676 3677 cons677 = CustomConstraint(cons_f677) 3678 3679 def cons_f678(a, c): 3680 return PositiveQ(c/a) 3681 3682 cons678 = CustomConstraint(cons_f678) 3683 3684 def cons_f679(a, b): 3685 return NegativeQ(b/a) 3686 3687 cons679 = CustomConstraint(cons_f679) 3688 3689 def cons_f680(a, c): 3690 return PosQ(c/a) 3691 3692 cons680 = CustomConstraint(cons_f680) 3693 3694 def cons_f681(a, c): 3695 return NegQ(c/a) 3696 3697 cons681 = CustomConstraint(cons_f681) 3698 3699 def cons_f682(n, n2): 3700 return EqQ(n2, S(2)*n) 3701 3702 cons682 = CustomConstraint(cons_f682) 3703 3704 def cons_f683(n): 3705 return PosQ(n) 3706 3707 cons683 = CustomConstraint(cons_f683) 3708 3709 def cons_f684(m, n, p): 3710 return ZeroQ(m + n*(S(2)*p + S(1)) + S(1)) 3711 3712 cons684 = CustomConstraint(cons_f684) 3713 3714 def cons_f685(m, n): 3715 return NonzeroQ(m + n + S(1)) 3716 3717 cons685 = CustomConstraint(cons_f685) 3718 3719 def cons_f686(m, n, p): 3720 return ZeroQ(m + S(2)*n*(p + S(1)) + S(1)) 3721 3722 cons686 = CustomConstraint(cons_f686) 3723 3724 def cons_f687(m, n): 3725 return Inequality(S(-1), LessEqual, m + n, Less, S(0)) 3726 3727 cons687 = CustomConstraint(cons_f687) 3728 3729 def cons_f688(m, n): 3730 return Less(m + n, S(-1)) 3731 3732 cons688 = CustomConstraint(cons_f688) 3733 3734 def cons_f689(m, n, p): 3735 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)))) 3736 3737 cons689 = CustomConstraint(cons_f689) 3738 3739 def cons_f690(m, n, p): 3740 return NonzeroQ(m + n*(S(2)*p + S(-1)) + S(1)) 3741 3742 cons690 = CustomConstraint(cons_f690) 3743 3744 def cons_f691(m, n, p): 3745 return Not(And(PositiveIntegerQ(m), IntegerQ((m + S(1))/n), Less(S(-1) + (m + S(1))/n, S(2)*p))) 3746 3747 cons691 = CustomConstraint(cons_f691) 3748 3749 def cons_f692(m, n): 3750 return Inequality(n + S(-1), Less, m, LessEqual, S(2)*n + S(-1)) 3751 3752 cons692 = CustomConstraint(cons_f692) 3753 3754 def cons_f693(m, n, p): 3755 return Or(IntegerQ(S(2)*p), PositiveIntegerQ((m + S(1))/n)) 3756 3757 cons693 = CustomConstraint(cons_f693) 3758 3759 def cons_f694(m, n, p): 3760 return Unequal(m + S(2)*n*p + S(1), S(0)) 3761 3762 cons694 = CustomConstraint(cons_f694) 3763 3764 def cons_f695(m, n, p): 3765 return Unequal(m + n*(S(2)*p + S(-1)) + S(1), S(0)) 3766 3767 cons695 = CustomConstraint(cons_f695) 3768 3769 def cons_f696(m, n, p): 3770 return Or(IntegerQ(p), And(IntegerQ(S(2)*p), IntegerQ(m), Equal(n, S(2)))) 3771 3772 cons696 = CustomConstraint(cons_f696) 3773 3774 def cons_f697(m, n): 3775 return Greater(m, S(3)*n + S(-1)) 3776 3777 cons697 = CustomConstraint(cons_f697) 3778 3779 def cons_f698(a, b, c): 3780 return NegativeQ(-S(4)*a*c + b**S(2)) 3781 3782 cons698 = CustomConstraint(cons_f698) 3783 3784 def cons_f699(a, c): 3785 return PosQ(a*c) 3786 3787 cons699 = CustomConstraint(cons_f699) 3788 3789 def cons_f700(m, n): 3790 return PositiveIntegerQ(n/S(2), m) 3791 3792 cons700 = CustomConstraint(cons_f700) 3793 3794 def cons_f701(m, n): 3795 return Inequality(S(3)*n/S(2), LessEqual, m, Less, S(2)*n) 3796 3797 cons701 = CustomConstraint(cons_f701) 3798 3799 def cons_f702(m, n): 3800 return Inequality(n/S(2), LessEqual, m, Less, S(3)*n/S(2)) 3801 3802 cons702 = CustomConstraint(cons_f702) 3803 3804 def cons_f703(m, n): 3805 return GreaterEqual(m, n) 3806 3807 cons703 = CustomConstraint(cons_f703) 3808 3809 def cons_f704(p): 3810 return NegativeIntegerQ(p + S(1)) 3811 3812 cons704 = CustomConstraint(cons_f704) 3813 3814 def cons_f705(b, c, d, e, n, p): 3815 return ZeroQ(b*e*(n*p + S(1)) - c*d*(n*(S(2)*p + S(1)) + S(1))) 3816 3817 cons705 = CustomConstraint(cons_f705) 3818 3819 def cons_f706(b, c, d, e, n, p): 3820 return NonzeroQ(b*e*(n*p + S(1)) - c*d*(n*(S(2)*p + S(1)) + S(1))) 3821 3822 cons706 = CustomConstraint(cons_f706) 3823 3824 def cons_f707(a, c, d, e): 3825 return ZeroQ(-a*e**S(2) + c*d**S(2)) 3826 3827 cons707 = CustomConstraint(cons_f707) 3828 3829 def cons_f708(d, e): 3830 return PosQ(d*e) 3831 3832 cons708 = CustomConstraint(cons_f708) 3833 3834 def cons_f709(d, e): 3835 return NegQ(d*e) 3836 3837 cons709 = CustomConstraint(cons_f709) 3838 3839 def cons_f710(a, c, d, e): 3840 return NonzeroQ(-a*e**S(2) + c*d**S(2)) 3841 3842 cons710 = CustomConstraint(cons_f710) 3843 3844 def cons_f711(a, c): 3845 return NegQ(a*c) 3846 3847 cons711 = CustomConstraint(cons_f711) 3848 3849 def cons_f712(a, c, n): 3850 return Or(PosQ(a*c), Not(IntegerQ(n))) 3851 3852 cons712 = CustomConstraint(cons_f712) 3853 3854 def cons_f713(a, b, c, d, e): 3855 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))))) 3856 3857 cons713 = CustomConstraint(cons_f713) 3858 3859 def cons_f714(a, b, c): 3860 return Not(PositiveQ(-S(4)*a*c + b**S(2))) 3861 3862 cons714 = CustomConstraint(cons_f714) 3863 3864 def cons_f715(a, b, c, n): 3865 return Or(PosQ(-S(4)*a*c + b**S(2)), Not(PositiveIntegerQ(n/S(2)))) 3866 3867 cons715 = CustomConstraint(cons_f715) 3868 3869 def cons_f716(n, p): 3870 return NonzeroQ(S(2)*n*p + n + S(1)) 3871 3872 cons716 = CustomConstraint(cons_f716) 3873 3874 def cons_f717(a, c): 3875 return PositiveQ(-a*c) 3876 3877 cons717 = CustomConstraint(cons_f717) 3878 3879 def cons_f718(n, p, q): 3880 return NonzeroQ(S(2)*n*p + n*q + S(1)) 3881 3882 cons718 = CustomConstraint(cons_f718) 3883 3884 def cons_f719(p): 3885 return PositiveIntegerQ(p + S(-1)/2) 3886 3887 cons719 = CustomConstraint(cons_f719) 3888 3889 def cons_f720(c): 3890 return Not(NegativeQ(c)) 3891 3892 cons720 = CustomConstraint(cons_f720) 3893 3894 def cons_f721(p): 3895 return NegativeIntegerQ(p + S(1)/2) 3896 3897 cons721 = CustomConstraint(cons_f721) 3898 3899 def cons_f722(b, c, d, e): 3900 return ZeroQ(-b*e + c*d) 3901 3902 cons722 = CustomConstraint(cons_f722) 3903 3904 def cons_f723(a, d): 3905 return Not(And(PositiveQ(a), PositiveQ(d))) 3906 3907 cons723 = CustomConstraint(cons_f723) 3908 3909 def cons_f724(n, p, q): 3910 return Or(And(IntegersQ(p, q), Not(IntegerQ(n))), PositiveIntegerQ(p), And(PositiveIntegerQ(q), Not(IntegerQ(n)))) 3911 3912 cons724 = CustomConstraint(cons_f724) 3913 3914 def cons_f725(n, p): 3915 return Not(IntegersQ(n, S(2)*p)) 3916 3917 cons725 = CustomConstraint(cons_f725) 3918 3919 def cons_f726(n, q): 3920 return Not(IntegersQ(n, q)) 3921 3922 cons726 = CustomConstraint(cons_f726) 3923 3924 def cons_f727(mn, n2): 3925 return EqQ(n2, -S(2)*mn) 3926 3927 cons727 = CustomConstraint(cons_f727) 3928 3929 def cons_f728(mn, x): 3930 return FreeQ(mn, x) 3931 3932 cons728 = CustomConstraint(cons_f728) 3933 3934 def cons_f729(n2): 3935 return PosQ(n2) 3936 3937 cons729 = CustomConstraint(cons_f729) 3938 3939 def cons_f730(n2): 3940 return NegQ(n2) 3941 3942 cons730 = CustomConstraint(cons_f730) 3943 3944 def cons_f731(d1, d2, e1, e2): 3945 return ZeroQ(d1*e2 + d2*e1) 3946 3947 cons731 = CustomConstraint(cons_f731) 3948 3949 def cons_f732(d1, d2, q): 3950 return Or(IntegerQ(q), And(PositiveQ(d1), PositiveQ(d2))) 3951 3952 cons732 = CustomConstraint(cons_f732) 3953 3954 def cons_f733(d1, x): 3955 return FreeQ(d1, x) 3956 3957 cons733 = CustomConstraint(cons_f733) 3958 3959 def cons_f734(d2, x): 3960 return FreeQ(d2, x) 3961 3962 cons734 = CustomConstraint(cons_f734) 3963 3964 def cons_f735(f, m): 3965 return Or(IntegerQ(m), PositiveQ(f)) 3966 3967 cons735 = CustomConstraint(cons_f735) 3968 3969 def cons_f736(m, n): 3970 return PositiveIntegerQ(m, n, (m + S(1))/n) 3971 3972 cons736 = CustomConstraint(cons_f736) 3973 3974 def cons_f737(m, q): 3975 return IntegersQ(m, q) 3976 3977 cons737 = CustomConstraint(cons_f737) 3978 3979 def cons_f738(n, p): 3980 return Greater(S(2)*n*p, n + S(-1)) 3981 3982 cons738 = CustomConstraint(cons_f738) 3983 3984 def cons_f739(m, n, p, q): 3985 return NonzeroQ(m + S(2)*n*p + n*q + S(1)) 3986 3987 cons739 = CustomConstraint(cons_f739) 3988 3989 def cons_f740(m, n, p): 3990 return Unequal(m + n*(S(2)*p + S(1)) + S(1), S(0)) 3991 3992 cons740 = CustomConstraint(cons_f740) 3993 3994 def cons_f741(m, n, p): 3995 return NonzeroQ(m + n*(S(2)*p + S(1)) + S(1)) 3996 3997 cons741 = CustomConstraint(cons_f741) 3998 3999 def cons_f742(m, n): 4000 return IntegersQ(m, n/S(2)) 4001 4002 cons742 = CustomConstraint(cons_f742) 4003 4004 def cons_f743(d, e): 4005 return PositiveQ(d/e) 4006 4007 cons743 = CustomConstraint(cons_f743) 4008 4009 def cons_f744(b, c, d, e): 4010 return PosQ(c*(-b*e + S(2)*c*d)/e) 4011 4012 cons744 = CustomConstraint(cons_f744) 4013 4014 def cons_f745(n): 4015 return IntegerQ(n/S(2)) 4016 4017 cons745 = CustomConstraint(cons_f745) 4018 4019 def cons_f746(n): 4020 return Greater(n, S(2)) 4021 4022 cons746 = CustomConstraint(cons_f746) 4023 4024 def cons_f747(m, n): 4025 return Less(m, -n) 4026 4027 cons747 = CustomConstraint(cons_f747) 4028 4029 def cons_f748(m, n): 4030 return Greater(m, n) 4031 4032 cons748 = CustomConstraint(cons_f748) 4033 4034 def cons_f749(m, q): 4035 return Or(PositiveIntegerQ(q), IntegersQ(m, q)) 4036 4037 cons749 = CustomConstraint(cons_f749) 4038 4039 def cons_f750(p, q): 4040 return Or(PositiveIntegerQ(p), PositiveIntegerQ(q)) 4041 4042 cons750 = CustomConstraint(cons_f750) 4043 4044 def cons_f751(f, m): 4045 return Not(Or(IntegerQ(m), PositiveQ(f))) 4046 4047 cons751 = CustomConstraint(cons_f751) 4048 4049 def cons_f752(n, q): 4050 return ZeroQ(n - q) 4051 4052 cons752 = CustomConstraint(cons_f752) 4053 4054 def cons_f753(n, r): 4055 return ZeroQ(-n + r) 4056 4057 cons753 = CustomConstraint(cons_f753) 4058 4059 def cons_f754(n, q, r): 4060 return ZeroQ(-S(2)*n + q + r) 4061 4062 cons754 = CustomConstraint(cons_f754) 4063 4064 def cons_f755(n, q): 4065 return PosQ(n - q) 4066 4067 cons755 = CustomConstraint(cons_f755) 4068 4069 def cons_f756(n, p, q): 4070 return NonzeroQ(p*(S(2)*n - q) + S(1)) 4071 4072 cons756 = CustomConstraint(cons_f756) 4073 4074 def cons_f757(n, q): 4075 return ZeroQ(-n + q) 4076 4077 cons757 = CustomConstraint(cons_f757) 4078 4079 def cons_f758(m, n, q): 4080 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)))) 4081 4082 cons758 = CustomConstraint(cons_f758) 4083 4084 def cons_f759(m, n): 4085 return ZeroQ(m - S(3)*n/S(2) + S(3)/2) 4086 4087 cons759 = CustomConstraint(cons_f759) 4088 4089 def cons_f760(n, q): 4090 return ZeroQ(-n + q + S(1)) 4091 4092 cons760 = CustomConstraint(cons_f760) 4093 4094 def cons_f761(n, r): 4095 return ZeroQ(-n + r + S(-1)) 4096 4097 cons761 = CustomConstraint(cons_f761) 4098 4099 def cons_f762(m, n): 4100 return ZeroQ(m - S(3)*n/S(2) + S(1)/2) 4101 4102 cons762 = CustomConstraint(cons_f762) 4103 4104 def cons_f763(m, n, p): 4105 return Equal(m + p*(n + S(-1)) + S(-1), S(0)) 4106 4107 cons763 = CustomConstraint(cons_f763) 4108 4109 def cons_f764(m, n, p, q): 4110 return Equal(m + p*q + S(1), n - q) 4111 4112 cons764 = CustomConstraint(cons_f764) 4113 4114 def cons_f765(m, n, p, q): 4115 return Greater(m + p*q + S(1), n - q) 4116 4117 cons765 = CustomConstraint(cons_f765) 4118 4119 def cons_f766(m, n, p, q): 4120 return Unequal(m + p*(S(2)*n - q) + S(1), S(0)) 4121 4122 cons766 = CustomConstraint(cons_f766) 4123 4124 def cons_f767(m, n, p, q): 4125 return Unequal(m + p*q + (n - q)*(S(2)*p + S(-1)) + S(1), S(0)) 4126 4127 cons767 = CustomConstraint(cons_f767) 4128 4129 def cons_f768(m, n, p, q): 4130 return LessEqual(m + p*q + S(1), -n + q + S(1)) 4131 4132 cons768 = CustomConstraint(cons_f768) 4133 4134 def cons_f769(m, p, q): 4135 return NonzeroQ(m + p*q + S(1)) 4136 4137 cons769 = CustomConstraint(cons_f769) 4138 4139 def cons_f770(m, n, p, q): 4140 return Greater(m + p*q + S(1), -n + q) 4141 4142 cons770 = CustomConstraint(cons_f770) 4143 4144 def cons_f771(m, n, p, q): 4145 return Equal(m + p*q + S(1), -(n - q)*(S(2)*p + S(3))) 4146 4147 cons771 = CustomConstraint(cons_f771) 4148 4149 def cons_f772(m, n, p, q): 4150 return Greater(m + p*q + S(1), S(2)*n - S(2)*q) 4151 4152 cons772 = CustomConstraint(cons_f772) 4153 4154 def cons_f773(m, n, p, q): 4155 return Less(m + p*q + S(1), n - q) 4156 4157 cons773 = CustomConstraint(cons_f773) 4158 4159 def cons_f774(m, n, p, q): 4160 return Less(n - q, m + p*q + S(1), S(2)*n - S(2)*q) 4161 4162 cons774 = CustomConstraint(cons_f774) 4163 4164 def cons_f775(p): 4165 return Inequality(S(-1), LessEqual, p, Less, S(0)) 4166 4167 cons775 = CustomConstraint(cons_f775) 4168 4169 def cons_f776(m, n, p, q): 4170 return Equal(m + p*q + S(1), S(2)*n - S(2)*q) 4171 4172 cons776 = CustomConstraint(cons_f776) 4173 4174 def cons_f777(m, n, p, q): 4175 return Equal(m + p*q + S(1), -S(2)*(n - q)*(p + S(1))) 4176 4177 cons777 = CustomConstraint(cons_f777) 4178 4179 def cons_f778(m, p, q): 4180 return Less(m + p*q + S(1), S(0)) 4181 4182 cons778 = CustomConstraint(cons_f778) 4183 4184 def cons_f779(n, q, r): 4185 return ZeroQ(-n + q + r) 4186 4187 cons779 = CustomConstraint(cons_f779) 4188 4189 def cons_f780(j, n, q): 4190 return ZeroQ(j - S(2)*n + q) 4191 4192 cons780 = CustomConstraint(cons_f780) 4193 4194 def cons_f781(j, n, q): 4195 return ZeroQ(j - n + q) 4196 4197 cons781 = CustomConstraint(cons_f781) 4198 4199 def cons_f782(n): 4200 return ZeroQ(n + S(-3)) 4201 4202 cons782 = CustomConstraint(cons_f782) 4203 4204 def cons_f783(q): 4205 return ZeroQ(q + S(-2)) 4206 4207 cons783 = CustomConstraint(cons_f783) 4208 4209 def cons_f784(n, p, q): 4210 return NonzeroQ(p*q + (n - q)*(S(2)*p + S(1)) + S(1)) 4211 4212 cons784 = CustomConstraint(cons_f784) 4213 4214 def cons_f785(m, n, p, q): 4215 return LessEqual(m + p*q, -n + q) 4216 4217 cons785 = CustomConstraint(cons_f785) 4218 4219 def cons_f786(m, p, q): 4220 return Unequal(m + p*q + S(1), S(0)) 4221 4222 cons786 = CustomConstraint(cons_f786) 4223 4224 def cons_f787(m, n, p, q): 4225 return Unequal(m + p*q + (n - q)*(S(2)*p + S(1)) + S(1), S(0)) 4226 4227 cons787 = CustomConstraint(cons_f787) 4228 4229 def cons_f788(m, n, p, q): 4230 return Greater(m + p*q, n - q + S(-1)) 4231 4232 cons788 = CustomConstraint(cons_f788) 4233 4234 def cons_f789(m, n, p, q): 4235 return Greater(m + p*q, -n + q + S(-1)) 4236 4237 cons789 = CustomConstraint(cons_f789) 4238 4239 def cons_f790(m, n, p, q): 4240 return Less(m + p*q, n - q + S(-1)) 4241 4242 cons790 = CustomConstraint(cons_f790) 4243 4244 def cons_f791(m, n, p, q): 4245 return GreaterEqual(m + p*q, n - q + S(-1)) 4246 4247 cons791 = CustomConstraint(cons_f791) 4248 4249 def cons_f792(m, n, p, q): 4250 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))) 4251 4252 cons792 = CustomConstraint(cons_f792) 4253 4254 def cons_f793(m): 4255 return Or(ZeroQ(m + S(-1)/2), ZeroQ(m + S(1)/2)) 4256 4257 cons793 = CustomConstraint(cons_f793) 4258 4259 def cons_f794(q): 4260 return ZeroQ(q + S(-1)) 4261 4262 cons794 = CustomConstraint(cons_f794) 4263 4264 def cons_f795(j, k, q): 4265 return ZeroQ(j - k + q) 4266 4267 cons795 = CustomConstraint(cons_f795) 4268 4269 def cons_f796(j, k, n): 4270 return ZeroQ(j - S(2)*k + n) 4271 4272 cons796 = CustomConstraint(cons_f796) 4273 4274 def cons_f797(j, k): 4275 return PosQ(-j + k) 4276 4277 cons797 = CustomConstraint(cons_f797) 4278 4279 def cons_f798(j, x): 4280 return FreeQ(j, x) 4281 4282 cons798 = CustomConstraint(cons_f798) 4283 4284 def cons_f799(k, x): 4285 return FreeQ(k, x) 4286 4287 cons799 = CustomConstraint(cons_f799) 4288 4289 def cons_f800(n, q): 4290 return IntegerQ(n*q) 4291 4292 cons800 = CustomConstraint(cons_f800) 4293 4294 def cons_f801(a, b, c, d, e, f, m, n, p, q, r, s, x): 4295 if isinstance(x, (int, Integer, float, Float)): 4296 return False 4297 return FreeQ(List(a, b, c, d, e, f, m, n, p, q, r, s), x) 4298 4299 cons801 = CustomConstraint(cons_f801) 4300 4301 def cons_f802(s, x): 4302 return FreeQ(s, x) 4303 4304 cons802 = CustomConstraint(cons_f802) 4305 4306 def cons_f803(b, d, e): 4307 return PositiveQ(b*d*e) 4308 4309 cons803 = CustomConstraint(cons_f803) 4310 4311 def cons_f804(a, b, c, d): 4312 return PositiveQ(-a*d/b + c) 4313 4314 cons804 = CustomConstraint(cons_f804) 4315 4316 def cons_f805(n): 4317 return IntegerQ(S(1)/n) 4318 4319 cons805 = CustomConstraint(cons_f805) 4320 4321 def cons_f806(u, x): 4322 if isinstance(x, (int, Integer, float, Float)): 4323 return False 4324 return PolynomialQ(u, x) 4325 4326 cons806 = CustomConstraint(cons_f806) 4327 4328 def cons_f807(m, r): 4329 return IntegersQ(m, r) 4330 4331 cons807 = CustomConstraint(cons_f807) 4332 4333 def cons_f808(a, b, c, n, p, x): 4334 if isinstance(x, (int, Integer, float, Float)): 4335 return False 4336 return FreeQ(List(a, b, c, n, p), x) 4337 4338 cons808 = CustomConstraint(cons_f808) 4339 4340 def cons_f809(n, n2): 4341 return ZeroQ(S(2)*n + n2) 4342 4343 cons809 = CustomConstraint(cons_f809) 4344 4345 def cons_f810(n): 4346 return IntegerQ(S(2)*n) 4347 4348 cons810 = CustomConstraint(cons_f810) 4349 4350 def cons_f811(u, x): 4351 if isinstance(x, (int, Integer, float, Float)): 4352 return False 4353 return Not(LinearMatchQ(u, x)) 4354 4355 cons811 = CustomConstraint(cons_f811) 4356 4357 def cons_f812(u, v, x): 4358 if isinstance(x, (int, Integer, float, Float)): 4359 return False 4360 return LinearQ(List(u, v), x) 4361 4362 cons812 = CustomConstraint(cons_f812) 4363 4364 def cons_f813(u, v, x): 4365 if isinstance(x, (int, Integer, float, Float)): 4366 return False 4367 return Not(LinearMatchQ(List(u, v), x)) 4368 4369 cons813 = CustomConstraint(cons_f813) 4370 4371 def cons_f814(u, v, w, x): 4372 if isinstance(x, (int, Integer, float, Float)): 4373 return False 4374 return LinearQ(List(u, v, w), x) 4375 4376 cons814 = CustomConstraint(cons_f814) 4377 4378 def cons_f815(u, v, w, x): 4379 if isinstance(x, (int, Integer, float, Float)): 4380 return False 4381 return Not(LinearMatchQ(List(u, v, w), x)) 4382 4383 cons815 = CustomConstraint(cons_f815) 4384 4385 def cons_f816(u, v, w, x, z): 4386 if isinstance(x, (int, Integer, float, Float)): 4387 return False 4388 return LinearQ(List(u, v, w, z), x) 4389 4390 cons816 = CustomConstraint(cons_f816) 4391 4392 def cons_f817(u, v, w, x, z): 4393 if isinstance(x, (int, Integer, float, Float)): 4394 return False 4395 return Not(LinearMatchQ(List(u, v, w, z), x)) 4396 4397 cons817 = CustomConstraint(cons_f817) 4398 4399 def cons_f818(u, x): 4400 if isinstance(x, (int, Integer, float, Float)): 4401 return False 4402 return QuadraticQ(u, x) 4403 4404 cons818 = CustomConstraint(cons_f818) 4405 4406 def cons_f819(u, x): 4407 if isinstance(x, (int, Integer, float, Float)): 4408 return False 4409 return Not(QuadraticMatchQ(u, x)) 4410 4411 cons819 = CustomConstraint(cons_f819) 4412 4413 def cons_f820(v, x): 4414 if isinstance(x, (int, Integer, float, Float)): 4415 return False 4416 return QuadraticQ(v, x) 4417 4418 cons820 = CustomConstraint(cons_f820) 4419 4420 def cons_f821(u, v, x): 4421 if isinstance(x, (int, Integer, float, Float)): 4422 return False 4423 return Not(And(LinearMatchQ(u, x), QuadraticMatchQ(v, x))) 4424 4425 cons821 = CustomConstraint(cons_f821) 4426 4427 def cons_f822(w, x): 4428 if isinstance(x, (int, Integer, float, Float)): 4429 return False 4430 return QuadraticQ(w, x) 4431 4432 cons822 = CustomConstraint(cons_f822) 4433 4434 def cons_f823(u, v, w, x): 4435 if isinstance(x, (int, Integer, float, Float)): 4436 return False 4437 return Not(And(LinearMatchQ(List(u, v), x), QuadraticMatchQ(w, x))) 4438 4439 cons823 = CustomConstraint(cons_f823) 4440 4441 def cons_f824(u, v, x): 4442 if isinstance(x, (int, Integer, float, Float)): 4443 return False 4444 return Not(QuadraticMatchQ(List(u, v), x)) 4445 4446 cons824 = CustomConstraint(cons_f824) 4447 4448 def cons_f825(u, x): 4449 if isinstance(x, (int, Integer, float, Float)): 4450 return False 4451 return BinomialQ(u, x) 4452 4453 cons825 = CustomConstraint(cons_f825) 4454 4455 def cons_f826(u, x): 4456 if isinstance(x, (int, Integer, float, Float)): 4457 return False 4458 return Not(BinomialMatchQ(u, x)) 4459 4460 cons826 = CustomConstraint(cons_f826) 4461 4462 def cons_f827(u, v, x): 4463 if isinstance(x, (int, Integer, float, Float)): 4464 return False 4465 return BinomialQ(List(u, v), x) 4466 4467 cons827 = CustomConstraint(cons_f827) 4468 4469 def cons_f828(u, v, x): 4470 if isinstance(x, (int, Integer, float, Float)): 4471 return False 4472 try: 4473 return ZeroQ(BinomialDegree(u, x) - BinomialDegree(v, x)) 4474 except (TypeError, AttributeError): 4475 return False 4476 4477 cons828 = CustomConstraint(cons_f828) 4478 4479 def cons_f829(u, v, x): 4480 if isinstance(x, (int, Integer, float, Float)): 4481 return False 4482 return Not(BinomialMatchQ(List(u, v), x)) 4483 4484 cons829 = CustomConstraint(cons_f829) 4485 4486 def cons_f830(u, v, w, x): 4487 if isinstance(x, (int, Integer, float, Float)): 4488 return False 4489 return BinomialQ(List(u, v, w), x) 4490 4491 cons830 = CustomConstraint(cons_f830) 4492 4493 def cons_f831(u, w, x): 4494 if isinstance(x, (int, Integer, float, Float)): 4495 return False 4496 try: 4497 return ZeroQ(BinomialDegree(u, x) - BinomialDegree(w, x)) 4498 except (TypeError, AttributeError): 4499 return False 4500 4501 cons831 = CustomConstraint(cons_f831) 4502 4503 def cons_f832(u, v, w, x): 4504 if isinstance(x, (int, Integer, float, Float)): 4505 return False 4506 return Not(BinomialMatchQ(List(u, v, w), x)) 4507 4508 cons832 = CustomConstraint(cons_f832) 4509 4510 def cons_f833(u, v, x, z): 4511 if isinstance(x, (int, Integer, float, Float)): 4512 return False 4513 return BinomialQ(List(u, v, z), x) 4514 4515 cons833 = CustomConstraint(cons_f833) 4516 4517 def cons_f834(u, x, z): 4518 if isinstance(x, (int, Integer, float, Float)): 4519 return False 4520 try: 4521 return ZeroQ(BinomialDegree(u, x) - BinomialDegree(z, x)) 4522 except (TypeError, AttributeError): 4523 return False 4524 4525 cons834 = CustomConstraint(cons_f834) 4526 4527 def cons_f835(u, v, x, z): 4528 if isinstance(x, (int, Integer, float, Float)): 4529 return False 4530 return Not(BinomialMatchQ(List(u, v, z), x)) 4531 4532 cons835 = CustomConstraint(cons_f835) 4533 4534 def cons_f836(u, x): 4535 if isinstance(x, (int, Integer, float, Float)): 4536 return False 4537 return GeneralizedBinomialQ(u, x) 4538 4539 cons836 = CustomConstraint(cons_f836) 4540 4541 def cons_f837(u, x): 4542 if isinstance(x, (int, Integer, float, Float)): 4543 return False 4544 return Not(GeneralizedBinomialMatchQ(u, x)) 4545 4546 cons837 = CustomConstraint(cons_f837) 4547 4548 def cons_f838(u, x): 4549 if isinstance(x, (int, Integer, float, Float)): 4550 return False 4551 return TrinomialQ(u, x) 4552 4553 cons838 = CustomConstraint(cons_f838) 4554 4555 def cons_f839(u, x): 4556 if isinstance(x, (int, Integer, float, Float)): 4557 return False 4558 return Not(TrinomialMatchQ(u, x)) 4559 4560 cons839 = CustomConstraint(cons_f839) 4561 4562 def cons_f840(v, x): 4563 if isinstance(x, (int, Integer, float, Float)): 4564 return False 4565 return TrinomialQ(v, x) 4566 4567 cons840 = CustomConstraint(cons_f840) 4568 4569 def cons_f841(u, v, x): 4570 if isinstance(x, (int, Integer, float, Float)): 4571 return False 4572 return Not(And(BinomialMatchQ(u, x), TrinomialMatchQ(v, x))) 4573 4574 cons841 = CustomConstraint(cons_f841) 4575 4576 def cons_f842(v, x): 4577 if isinstance(x, (int, Integer, float, Float)): 4578 return False 4579 return BinomialQ(v, x) 4580 4581 cons842 = CustomConstraint(cons_f842) 4582 4583 def cons_f843(u, v, x): 4584 if isinstance(x, (int, Integer, float, Float)): 4585 return False 4586 return Not(And(BinomialMatchQ(u, x), BinomialMatchQ(v, x))) 4587 4588 cons843 = CustomConstraint(cons_f843) 4589 4590 def cons_f844(x, z): 4591 if isinstance(x, (int, Integer, float, Float)): 4592 return False 4593 return BinomialQ(z, x) 4594 4595 cons844 = CustomConstraint(cons_f844) 4596 4597 def cons_f845(u, x, z): 4598 if isinstance(x, (int, Integer, float, Float)): 4599 return False 4600 return Not(And(BinomialMatchQ(z, x), TrinomialMatchQ(u, x))) 4601 4602 cons845 = CustomConstraint(cons_f845) 4603 4604 def cons_f846(u, x, z): 4605 if isinstance(x, (int, Integer, float, Float)): 4606 return False 4607 return Not(And(BinomialMatchQ(z, x), BinomialMatchQ(u, x))) 4608 4609 cons846 = CustomConstraint(cons_f846) 4610 4611 def cons_f847(u, x): 4612 if isinstance(x, (int, Integer, float, Float)): 4613 return False 4614 return GeneralizedTrinomialQ(u, x) 4615 4616 cons847 = CustomConstraint(cons_f847) 4617 4618 def cons_f848(u, x): 4619 if isinstance(x, (int, Integer, float, Float)): 4620 return False 4621 return Not(GeneralizedTrinomialMatchQ(u, x)) 4622 4623 cons848 = CustomConstraint(cons_f848) 4624 4625 def cons_f849(u, x, z): 4626 if isinstance(x, (int, Integer, float, Float)): 4627 return False 4628 try: 4629 return ZeroQ(BinomialDegree(z, x) - GeneralizedTrinomialDegree(u, x)) 4630 except (TypeError, AttributeError): 4631 return False 4632 4633 cons849 = CustomConstraint(cons_f849) 4634 4635 def cons_f850(u, x, z): 4636 if isinstance(x, (int, Integer, float, Float)): 4637 return False 4638 return Not(And(BinomialMatchQ(z, x), GeneralizedTrinomialMatchQ(u, x))) 4639 4640 cons850 = CustomConstraint(cons_f850) 4641 4642 def cons_f851(n, q): 4643 return ZeroQ(-n/S(4) + q) 4644 4645 cons851 = CustomConstraint(cons_f851) 4646 4647 def cons_f852(n, r): 4648 return ZeroQ(-S(3)*n/S(4) + r) 4649 4650 cons852 = CustomConstraint(cons_f852) 4651 4652 def cons_f853(m, n): 4653 return ZeroQ(S(4)*m - n + S(4)) 4654 4655 cons853 = CustomConstraint(cons_f853) 4656 4657 def cons_f854(a, c, e, h): 4658 return ZeroQ(a*h + c*e) 4659 4660 cons854 = CustomConstraint(cons_f854) 4661 4662 def cons_f855(m): 4663 return NegativeIntegerQ(m + S(1)) 4664 4665 cons855 = CustomConstraint(cons_f855) 4666 4667 def cons_f856(m, n): 4668 return PositiveIntegerQ(n/(m + S(1))) 4669 4670 cons856 = CustomConstraint(cons_f856) 4671 4672 def cons_f857(Pq, m, x): 4673 if isinstance(x, (int, Integer, float, Float)): 4674 return False 4675 return PolyQ(Pq, x**(m + S(1))) 4676 4677 cons857 = CustomConstraint(cons_f857) 4678 4679 def cons_f858(Pq, n, x): 4680 if isinstance(x, (int, Integer, float, Float)): 4681 return False 4682 return NonzeroQ(Coeff(Pq, x, n + S(-1))) 4683 4684 cons858 = CustomConstraint(cons_f858) 4685 4686 def cons_f859(n, p): 4687 return Or(PositiveIntegerQ(p), ZeroQ(n + S(-1))) 4688 4689 cons859 = CustomConstraint(cons_f859) 4690 4691 def cons_f860(Pq, n, x): 4692 if isinstance(x, (int, Integer, float, Float)): 4693 return False 4694 return PolyQ(Pq, x**n) 4695 4696 cons860 = CustomConstraint(cons_f860) 4697 4698 def cons_f861(Pq, x): 4699 if isinstance(x, (int, Integer, float, Float)): 4700 return False 4701 return ZeroQ(Coeff(Pq, x, S(0))) 4702 4703 cons861 = CustomConstraint(cons_f861) 4704 4705 def cons_f862(Pq): 4706 return SumQ(Pq) 4707 4708 cons862 = CustomConstraint(cons_f862) 4709 4710 def cons_f863(Pq, m, x): 4711 if isinstance(x, (int, Integer, float, Float)): 4712 return False 4713 return Less(m + Expon(Pq, x) + S(1), S(0)) 4714 4715 cons863 = CustomConstraint(cons_f863) 4716 4717 def cons_f864(Pq, n, x): 4718 if isinstance(x, (int, Integer, float, Float)): 4719 return False 4720 return Less(Expon(Pq, x), n + S(-1)) 4721 4722 cons864 = CustomConstraint(cons_f864) 4723 4724 def cons_f865(a, b, d, g): 4725 return ZeroQ(a*g + b*d) 4726 4727 cons865 = CustomConstraint(cons_f865) 4728 4729 def cons_f866(a, b, e, h): 4730 return ZeroQ(-S(3)*a*h + b*e) 4731 4732 cons866 = CustomConstraint(cons_f866) 4733 4734 def cons_f867(A, B, a, b): 4735 return ZeroQ(-A**S(3)*b + B**S(3)*a) 4736 4737 cons867 = CustomConstraint(cons_f867) 4738 4739 def cons_f868(A, B, a, b): 4740 return NonzeroQ(-A**S(3)*b + B**S(3)*a) 4741 4742 cons868 = CustomConstraint(cons_f868) 4743 4744 def cons_f869(A, B, C): 4745 return ZeroQ(-A*C + B**S(2)) 4746 4747 cons869 = CustomConstraint(cons_f869) 4748 4749 def cons_f870(B, C, a, b): 4750 return ZeroQ(B**S(3)*b + C**S(3)*a) 4751 4752 cons870 = CustomConstraint(cons_f870) 4753 4754 def cons_f871(A, B, C, a, b): 4755 return ZeroQ(A*b**(S(2)/3) - B*a**(S(1)/3)*b**(S(1)/3) - S(2)*C*a**(S(2)/3)) 4756 4757 cons871 = CustomConstraint(cons_f871) 4758 4759 def cons_f872(B, C, a, b): 4760 return ZeroQ(B*a**(S(1)/3)*b**(S(1)/3) + S(2)*C*a**(S(2)/3)) 4761 4762 cons872 = CustomConstraint(cons_f872) 4763 4764 def cons_f873(A, C, a, b): 4765 return ZeroQ(A*b**(S(2)/3) - S(2)*C*a**(S(2)/3)) 4766 4767 cons873 = CustomConstraint(cons_f873) 4768 4769 def cons_f874(A, B, C, a, b): 4770 return ZeroQ(A*(-b)**(S(2)/3) - B*(-a)**(S(1)/3)*(-b)**(S(1)/3) - S(2)*C*(-a)**(S(2)/3)) 4771 4772 cons874 = CustomConstraint(cons_f874) 4773 4774 def cons_f875(B, C, a, b): 4775 return ZeroQ(B*(-a)**(S(1)/3)*(-b)**(S(1)/3) + S(2)*C*(-a)**(S(2)/3)) 4776 4777 cons875 = CustomConstraint(cons_f875) 4778 4779 def cons_f876(A, C, a, b): 4780 return ZeroQ(A*(-b)**(S(2)/3) - S(2)*C*(-a)**(S(2)/3)) 4781 4782 cons876 = CustomConstraint(cons_f876) 4783 4784 def cons_f877(A, B, C, a, b): 4785 return ZeroQ(A*b**(S(2)/3) + B*b**(S(1)/3)*(-a)**(S(1)/3) - S(2)*C*(-a)**(S(2)/3)) 4786 4787 cons877 = CustomConstraint(cons_f877) 4788 4789 def cons_f878(B, C, a, b): 4790 return ZeroQ(B*b**(S(1)/3)*(-a)**(S(1)/3) - S(2)*C*(-a)**(S(2)/3)) 4791 4792 cons878 = CustomConstraint(cons_f878) 4793 4794 def cons_f879(A, C, a, b): 4795 return ZeroQ(A*b**(S(2)/3) - S(2)*C*(-a)**(S(2)/3)) 4796 4797 cons879 = CustomConstraint(cons_f879) 4798 4799 def cons_f880(A, B, C, a, b): 4800 return ZeroQ(A*(-b)**(S(2)/3) + B*a**(S(1)/3)*(-b)**(S(1)/3) - S(2)*C*a**(S(2)/3)) 4801 4802 cons880 = CustomConstraint(cons_f880) 4803 4804 def cons_f881(B, C, a, b): 4805 return ZeroQ(B*a**(S(1)/3)*(-b)**(S(1)/3) - S(2)*C*a**(S(2)/3)) 4806 4807 cons881 = CustomConstraint(cons_f881) 4808 4809 def cons_f882(A, C, a, b): 4810 return ZeroQ(A*(-b)**(S(2)/3) - S(2)*C*a**(S(2)/3)) 4811 4812 cons882 = CustomConstraint(cons_f882) 4813 4814 def cons_f883(A, B, C, a, b): 4815 return ZeroQ(A - B*(a/b)**(S(1)/3) - S(2)*C*(a/b)**(S(2)/3)) 4816 4817 cons883 = CustomConstraint(cons_f883) 4818 4819 def cons_f884(B, C, a, b): 4820 return ZeroQ(B*(a/b)**(S(1)/3) + S(2)*C*(a/b)**(S(2)/3)) 4821 4822 cons884 = CustomConstraint(cons_f884) 4823 4824 def cons_f885(A, C, a, b): 4825 return ZeroQ(A - S(2)*C*(a/b)**(S(2)/3)) 4826 4827 cons885 = CustomConstraint(cons_f885) 4828 4829 def cons_f886(A, B, C, a, b): 4830 return ZeroQ(A - B*Rt(a/b, S(3)) - S(2)*C*Rt(a/b, S(3))**S(2)) 4831 4832 cons886 = CustomConstraint(cons_f886) 4833 4834 def cons_f887(B, C, a, b): 4835 return ZeroQ(B*Rt(a/b, S(3)) + S(2)*C*Rt(a/b, S(3))**S(2)) 4836 4837 cons887 = CustomConstraint(cons_f887) 4838 4839 def cons_f888(A, C, a, b): 4840 return ZeroQ(A - S(2)*C*Rt(a/b, S(3))**S(2)) 4841 4842 cons888 = CustomConstraint(cons_f888) 4843 4844 def cons_f889(A, B, C, a, b): 4845 return ZeroQ(A + B*(-a/b)**(S(1)/3) - S(2)*C*(-a/b)**(S(2)/3)) 4846 4847 cons889 = CustomConstraint(cons_f889) 4848 4849 def cons_f890(B, C, a, b): 4850 return ZeroQ(B*(-a/b)**(S(1)/3) - S(2)*C*(-a/b)**(S(2)/3)) 4851 4852 cons890 = CustomConstraint(cons_f890) 4853 4854 def cons_f891(A, C, a, b): 4855 return ZeroQ(A - S(2)*C*(-a/b)**(S(2)/3)) 4856 4857 cons891 = CustomConstraint(cons_f891) 4858 4859 def cons_f892(A, B, C, a, b): 4860 return ZeroQ(A + B*Rt(-a/b, S(3)) - S(2)*C*Rt(-a/b, S(3))**S(2)) 4861 4862 cons892 = CustomConstraint(cons_f892) 4863 4864 def cons_f893(B, C, a, b): 4865 return ZeroQ(B*Rt(-a/b, S(3)) - S(2)*C*Rt(-a/b, S(3))**S(2)) 4866 4867 cons893 = CustomConstraint(cons_f893) 4868 4869 def cons_f894(A, C, a, b): 4870 return ZeroQ(A - S(2)*C*Rt(-a/b, S(3))**S(2)) 4871 4872 cons894 = CustomConstraint(cons_f894) 4873 4874 def cons_f895(A, B, a, b): 4875 return Or(ZeroQ(-A**S(3)*b + B**S(3)*a), Not(RationalQ(a/b))) 4876 4877 cons895 = CustomConstraint(cons_f895) 4878 4879 def cons_f896(a, b): 4880 return Not(RationalQ(a/b)) 4881 4882 cons896 = CustomConstraint(cons_f896) 4883 4884 def cons_f897(A, C, a, b): 4885 return Not(RationalQ(a, b, A, C)) 4886 4887 cons897 = CustomConstraint(cons_f897) 4888 4889 def cons_f898(A, B, C, a, b): 4890 return ZeroQ(A - B*(a/b)**(S(1)/3) + C*(a/b)**(S(2)/3)) 4891 4892 cons898 = CustomConstraint(cons_f898) 4893 4894 def cons_f899(B, C, a, b): 4895 return ZeroQ(B*(a/b)**(S(1)/3) - C*(a/b)**(S(2)/3)) 4896 4897 cons899 = CustomConstraint(cons_f899) 4898 4899 def cons_f900(A, C, a, b): 4900 return ZeroQ(A + C*(a/b)**(S(2)/3)) 4901 4902 cons900 = CustomConstraint(cons_f900) 4903 4904 def cons_f901(A, B, C, a, b): 4905 return ZeroQ(A + B*(-a/b)**(S(1)/3) + C*(-a/b)**(S(2)/3)) 4906 4907 cons901 = CustomConstraint(cons_f901) 4908 4909 def cons_f902(B, C, a, b): 4910 return ZeroQ(B*(-a/b)**(S(1)/3) + C*(-a/b)**(S(2)/3)) 4911 4912 cons902 = CustomConstraint(cons_f902) 4913 4914 def cons_f903(A, C, a, b): 4915 return ZeroQ(A + C*(-a/b)**(S(2)/3)) 4916 4917 cons903 = CustomConstraint(cons_f903) 4918 4919 def cons_f904(a, b): 4920 return RationalQ(a/b) 4921 4922 cons904 = CustomConstraint(cons_f904) 4923 4924 def cons_f905(a, b): 4925 return Greater(a/b, S(0)) 4926 4927 cons905 = CustomConstraint(cons_f905) 4928 4929 def cons_f906(a, b): 4930 return Less(a/b, S(0)) 4931 4932 cons906 = CustomConstraint(cons_f906) 4933 4934 def cons_f907(Pq, n, x): 4935 if isinstance(x, (int, Integer, float, Float)): 4936 return False 4937 return Less(Expon(Pq, x), n) 4938 4939 cons907 = CustomConstraint(cons_f907) 4940 4941 def cons_f908(a, b, c, d): 4942 return ZeroQ(c*Rt(b/a, S(3)) - d*(S(1) - sqrt(S(3)))) 4943 4944 cons908 = CustomConstraint(cons_f908) 4945 4946 def cons_f909(a, b, c, d): 4947 return NonzeroQ(c*Rt(b/a, S(3)) - d*(S(1) - sqrt(S(3)))) 4948 4949 cons909 = CustomConstraint(cons_f909) 4950 4951 def cons_f910(a, b, c, d): 4952 return ZeroQ(c*Rt(b/a, S(3)) - d*(S(1) + sqrt(S(3)))) 4953 4954 cons910 = CustomConstraint(cons_f910) 4955 4956 def cons_f911(a, b, c, d): 4957 return NonzeroQ(c*Rt(b/a, S(3)) - d*(S(1) + sqrt(S(3)))) 4958 4959 cons911 = CustomConstraint(cons_f911) 4960 4961 def cons_f912(a, b, c, d): 4962 return ZeroQ(S(2)*c*Rt(b/a, S(3))**S(2) - d*(S(1) - sqrt(S(3)))) 4963 4964 cons912 = CustomConstraint(cons_f912) 4965 4966 def cons_f913(a, b, c, d): 4967 return NonzeroQ(S(2)*c*Rt(b/a, S(3))**S(2) - d*(S(1) - sqrt(S(3)))) 4968 4969 cons913 = CustomConstraint(cons_f913) 4970 4971 def cons_f914(a, b, c, d): 4972 return ZeroQ(-a*d**S(4) + b*c**S(4)) 4973 4974 cons914 = CustomConstraint(cons_f914) 4975 4976 def cons_f915(a, b, c, d): 4977 return NonzeroQ(-a*d**S(4) + b*c**S(4)) 4978 4979 cons915 = CustomConstraint(cons_f915) 4980 4981 def cons_f916(Pq, x): 4982 if isinstance(x, (int, Integer, float, Float)): 4983 return False 4984 return NonzeroQ(Coeff(Pq, x, S(0))) 4985 4986 cons916 = CustomConstraint(cons_f916) 4987 4988 def cons_f917(Pq, n, x): 4989 if isinstance(x, (int, Integer, float, Float)): 4990 return False 4991 return Not(PolyQ(Pq, x**(n/S(2)))) 4992 4993 cons917 = CustomConstraint(cons_f917) 4994 4995 def cons_f918(Pq, n, x): 4996 if isinstance(x, (int, Integer, float, Float)): 4997 return False 4998 return Equal(Expon(Pq, x), n + S(-1)) 4999 5000 cons918 = CustomConstraint(cons_f918) 5001 5002 def cons_f919(Pq, n, x): 5003 if isinstance(x, (int, Integer, float, Float)): 5004 return False 5005 return LessEqual(n + S(-1), Expon(Pq, x)) 5006 5007 cons919 = CustomConstraint(cons_f919) 5008 5009 def cons_f920(Pq, n, x): 5010 if isinstance(x, (int, Integer, float, Float)): 5011 return False 5012 return Or(PolyQ(Pq, x), PolyQ(Pq, x**n)) 5013 5014 cons920 = CustomConstraint(cons_f920) 5015 5016 def cons_f921(Pq, n, v): 5017 return PolyQ(Pq, v**n) 5018 5019 cons921 = CustomConstraint(cons_f921) 5020 5021 def cons_f922(a, b, c, d, e, f, n, p): 5022 return ZeroQ(a*c*f - e*(a*d + b*c)*(n*(p + S(1)) + S(1))) 5023 5024 cons922 = CustomConstraint(cons_f922) 5025 5026 def cons_f923(a, b, c, d, e, g, n, p): 5027 return ZeroQ(a*c*g - b*d*e*(S(2)*n*(p + S(1)) + S(1))) 5028 5029 cons923 = CustomConstraint(cons_f923) 5030 5031 def cons_f924(n, p): 5032 return ZeroQ(n*(p + S(1)) + S(1)) 5033 5034 cons924 = CustomConstraint(cons_f924) 5035 5036 def cons_f925(a, b, c, d, e, f, m, n, p): 5037 return ZeroQ(a*c*f*(m + S(1)) - e*(a*d + b*c)*(m + n*(p + S(1)) + S(1))) 5038 5039 cons925 = CustomConstraint(cons_f925) 5040 5041 def cons_f926(a, b, c, d, e, g, m, n, p): 5042 return ZeroQ(a*c*g*(m + S(1)) - b*d*e*(m + S(2)*n*(p + S(1)) + S(1))) 5043 5044 cons926 = CustomConstraint(cons_f926) 5045 5046 def cons_f927(Px, x): 5047 if isinstance(x, (int, Integer, float, Float)): 5048 return False 5049 return PolynomialQ(Px, x) 5050 5051 cons927 = CustomConstraint(cons_f927) 5052 5053 def cons_f928(a, b, d, e, n, p): 5054 return ZeroQ(a*e - b*d*(n*(p + S(1)) + S(1))) 5055 5056 cons928 = CustomConstraint(cons_f928) 5057 5058 def cons_f929(a, c, d, f, n, p): 5059 return ZeroQ(a*f - c*d*(S(2)*n*(p + S(1)) + S(1))) 5060 5061 cons929 = CustomConstraint(cons_f929) 5062 5063 def cons_f930(a, c, d, f): 5064 return ZeroQ(a*f + c*d) 5065 5066 cons930 = CustomConstraint(cons_f930) 5067 5068 def cons_f931(a, b, d, e, m, n, p): 5069 return ZeroQ(a*e*(m + S(1)) - b*d*(m + n*(p + S(1)) + S(1))) 5070 5071 cons931 = CustomConstraint(cons_f931) 5072 5073 def cons_f932(a, c, d, f, m, n, p): 5074 return ZeroQ(a*f*(m + S(1)) - c*d*(m + S(2)*n*(p + S(1)) + S(1))) 5075 5076 cons932 = CustomConstraint(cons_f932) 5077 5078 def cons_f933(n, n3): 5079 return ZeroQ(-S(3)*n + n3) 5080 5081 cons933 = CustomConstraint(cons_f933) 5082 5083 def cons_f934(a, b, c, d, e, g, n, p): 5084 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))) 5085 5086 cons934 = CustomConstraint(cons_f934) 5087 5088 def cons_f935(a, b, c, d, e, f, n, p): 5089 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))) 5090 5091 cons935 = CustomConstraint(cons_f935) 5092 5093 def cons_f936(a, b, c, d, g, n, p): 5094 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))) 5095 5096 cons936 = CustomConstraint(cons_f936) 5097 5098 def cons_f937(a, b, c, d, f, n, p): 5099 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))) 5100 5101 cons937 = CustomConstraint(cons_f937) 5102 5103 def cons_f938(a, b, c, d, e, n, p): 5104 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))) 5105 5106 cons938 = CustomConstraint(cons_f938) 5107 5108 def cons_f939(a, b, c, d, n, p): 5109 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))) 5110 5111 cons939 = CustomConstraint(cons_f939) 5112 5113 def cons_f940(n, q): 5114 return ZeroQ(-n/S(2) + q) 5115 5116 cons940 = CustomConstraint(cons_f940) 5117 5118 def cons_f941(n, r): 5119 return ZeroQ(-S(3)*n/S(2) + r) 5120 5121 cons941 = CustomConstraint(cons_f941) 5122 5123 def cons_f942(n, s): 5124 return ZeroQ(-S(2)*n + s) 5125 5126 cons942 = CustomConstraint(cons_f942) 5127 5128 def cons_f943(m, n): 5129 return ZeroQ(S(2)*m - n + S(2)) 5130 5131 cons943 = CustomConstraint(cons_f943) 5132 5133 def cons_f944(a, c, d, g): 5134 return ZeroQ(a*g + c*d) 5135 5136 cons944 = CustomConstraint(cons_f944) 5137 5138 def cons_f945(a, c, e, h): 5139 return ZeroQ(-S(3)*a*h + c*e) 5140 5141 cons945 = CustomConstraint(cons_f945) 5142 5143 def cons_f946(b, c, g, h): 5144 return ZeroQ(-S(2)*b*h + c*g) 5145 5146 cons946 = CustomConstraint(cons_f946) 5147 5148 def cons_f947(a, b, c, d, e, g): 5149 return ZeroQ(S(3)*a*g - S(2)*b*e + S(3)*c*d) 5150 5151 cons947 = CustomConstraint(cons_f947) 5152 5153 def cons_f948(b, c, d, e): 5154 return ZeroQ(-S(2)*b*e + S(3)*c*d) 5155 5156 cons948 = CustomConstraint(cons_f948) 5157 5158 def cons_f949(Pq, a, b, c, n, x): 5159 if isinstance(x, (int, Integer, float, Float)): 5160 return False 5161 return Or(NiceSqrtQ(-S(4)*a*c + b**S(2)), Less(Expon(Pq, x), n)) 5162 5163 cons949 = CustomConstraint(cons_f949) 5164 5165 def cons_f950(c): 5166 return PosQ(c) 5167 5168 cons950 = CustomConstraint(cons_f950) 5169 5170 def cons_f951(c): 5171 return NegQ(c) 5172 5173 cons951 = CustomConstraint(cons_f951) 5174 5175 def cons_f952(Pq, n, x): 5176 if isinstance(x, (int, Integer, float, Float)): 5177 return False 5178 return Not(PolyQ(Pq, x**n)) 5179 5180 cons952 = CustomConstraint(cons_f952) 5181 5182 def cons_f953(m): 5183 return NegativeIntegerQ(m + S(-1)/2) 5184 5185 cons953 = CustomConstraint(cons_f953) 5186 5187 def cons_f954(j, n): 5188 return NonzeroQ(-j + n) 5189 5190 cons954 = CustomConstraint(cons_f954) 5191 5192 def cons_f955(j, n, p): 5193 return ZeroQ(j*p + j - n + S(1)) 5194 5195 cons955 = CustomConstraint(cons_f955) 5196 5197 def cons_f956(j, n, p): 5198 return NegativeIntegerQ((j - n*p - n + S(-1))/(j - n)) 5199 5200 cons956 = CustomConstraint(cons_f956) 5201 5202 def cons_f957(j, p): 5203 return NonzeroQ(j*p + S(1)) 5204 5205 cons957 = CustomConstraint(cons_f957) 5206 5207 def cons_f958(j, n, p): 5208 return RationalQ(j, n, p) 5209 5210 cons958 = CustomConstraint(cons_f958) 5211 5212 def cons_f959(j, n): 5213 return Less(S(0), j, n) 5214 5215 cons959 = CustomConstraint(cons_f959) 5216 5217 def cons_f960(j, p): 5218 return Less(j*p + S(1), S(0)) 5219 5220 cons960 = CustomConstraint(cons_f960) 5221 5222 def cons_f961(n, p): 5223 return NonzeroQ(n*p + S(1)) 5224 5225 cons961 = CustomConstraint(cons_f961) 5226 5227 def cons_f962(j, n, p): 5228 return Greater(j*p + S(1), -j + n) 5229 5230 cons962 = CustomConstraint(cons_f962) 5231 5232 def cons_f963(p): 5233 return PositiveIntegerQ(p + S(1)/2) 5234 5235 cons963 = CustomConstraint(cons_f963) 5236 5237 def cons_f964(j, p): 5238 return ZeroQ(j*p + S(1)) 5239 5240 cons964 = CustomConstraint(cons_f964) 5241 5242 def cons_f965(n): 5243 return NonzeroQ(n + S(-2)) 5244 5245 cons965 = CustomConstraint(cons_f965) 5246 5247 def cons_f966(j, n): 5248 return RationalQ(j, n) 5249 5250 cons966 = CustomConstraint(cons_f966) 5251 5252 def cons_f967(j, n): 5253 return Less(S(2)*n + S(-2), j, n) 5254 5255 cons967 = CustomConstraint(cons_f967) 5256 5257 def cons_f968(j, n): 5258 return PosQ(-j + n) 5259 5260 cons968 = CustomConstraint(cons_f968) 5261 5262 def cons_f969(j, n): 5263 return IntegerQ(j/n) 5264 5265 cons969 = CustomConstraint(cons_f969) 5266 5267 def cons_f970(j, m, n, p): 5268 return ZeroQ(-j + m + n*p + n + S(1)) 5269 5270 cons970 = CustomConstraint(cons_f970) 5271 5272 def cons_f971(c, j): 5273 return Or(IntegerQ(j), PositiveQ(c)) 5274 5275 cons971 = CustomConstraint(cons_f971) 5276 5277 def cons_f972(j, m, n, p): 5278 return NegativeIntegerQ((j - m - n*p - n + S(-1))/(j - n)) 5279 5280 cons972 = CustomConstraint(cons_f972) 5281 5282 def cons_f973(j, m, p): 5283 return NonzeroQ(j*p + m + S(1)) 5284 5285 cons973 = CustomConstraint(cons_f973) 5286 5287 def cons_f974(c, j, n): 5288 return Or(IntegersQ(j, n), PositiveQ(c)) 5289 5290 cons974 = CustomConstraint(cons_f974) 5291 5292 def cons_f975(n): 5293 return NonzeroQ(n**S(2) + S(-1)) 5294 5295 cons975 = CustomConstraint(cons_f975) 5296 5297 def cons_f976(j, m, n, p): 5298 return RationalQ(j, m, n, p) 5299 5300 cons976 = CustomConstraint(cons_f976) 5301 5302 def cons_f977(j, m, p): 5303 return Less(j*p + m + S(1), S(0)) 5304 5305 cons977 = CustomConstraint(cons_f977) 5306 5307 def cons_f978(j, m, n, p): 5308 return Greater(j*p + m + S(1), -j + n) 5309 5310 cons978 = CustomConstraint(cons_f978) 5311 5312 def cons_f979(j, m, n, p): 5313 return PositiveQ(j*p + j + m - n + S(1)) 5314 5315 cons979 = CustomConstraint(cons_f979) 5316 5317 def cons_f980(j, m, p): 5318 return NegativeQ(j*p + m + S(1)) 5319 5320 cons980 = CustomConstraint(cons_f980) 5321 5322 def cons_f981(j, m, p): 5323 return ZeroQ(j*p + m + S(1)) 5324 5325 cons981 = CustomConstraint(cons_f981) 5326 5327 def cons_f982(j, m): 5328 return ZeroQ(-j/S(2) + m + S(1)) 5329 5330 cons982 = CustomConstraint(cons_f982) 5331 5332 def cons_f983(j, k): 5333 return NonzeroQ(-j + k) 5334 5335 cons983 = CustomConstraint(cons_f983) 5336 5337 def cons_f984(k, n): 5338 return IntegerQ(k/n) 5339 5340 cons984 = CustomConstraint(cons_f984) 5341 5342 def cons_f985(jn, j, n): 5343 return ZeroQ(jn - j - n) 5344 5345 cons985 = CustomConstraint(cons_f985) 5346 5347 def cons_f986(a, b, c, d, j, m, n, p): 5348 return ZeroQ(a*d*(j*p + m + S(1)) - b*c*(m + n + p*(j + n) + S(1))) 5349 5350 cons986 = CustomConstraint(cons_f986) 5351 5352 def cons_f987(e, j): 5353 return Or(PositiveQ(e), IntegersQ(j)) 5354 5355 cons987 = CustomConstraint(cons_f987) 5356 5357 def cons_f988(j, m, p): 5358 return RationalQ(j, m, p) 5359 5360 cons988 = CustomConstraint(cons_f988) 5361 5362 def cons_f989(j, m): 5363 return Inequality(S(0), Less, j, LessEqual, m) 5364 5365 cons989 = CustomConstraint(cons_f989) 5366 5367 def cons_f990(e, j): 5368 return Or(PositiveQ(e), IntegerQ(j)) 5369 5370 cons990 = CustomConstraint(cons_f990) 5371 5372 def cons_f991(j, m, n, p): 5373 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)))) 5374 5375 cons991 = CustomConstraint(cons_f991) 5376 5377 def cons_f992(e, j, n): 5378 return Or(PositiveQ(e), IntegersQ(j, n)) 5379 5380 cons992 = CustomConstraint(cons_f992) 5381 5382 def cons_f993(j, m, n, p): 5383 return NonzeroQ(j*p + m - n + S(1)) 5384 5385 cons993 = CustomConstraint(cons_f993) 5386 5387 def cons_f994(j, m, n, p): 5388 return NonzeroQ(m + n + p*(j + n) + S(1)) 5389 5390 cons994 = CustomConstraint(cons_f994) 5391 5392 def cons_f995(j, n): 5393 return Not(And(ZeroQ(n + S(-1)), ZeroQ(j + S(-1)))) 5394 5395 cons995 = CustomConstraint(cons_f995) 5396 5397 def cons_f996(n): 5398 return Less(S(-1), n, S(1)) 5399 5400 cons996 = CustomConstraint(cons_f996) 5401 5402 def cons_f997(m): 5403 return Greater(m**S(2), S(1)) 5404 5405 cons997 = CustomConstraint(cons_f997) 5406 5407 def cons_f998(j, n): 5408 return PositiveIntegerQ(j, n, j/n) 5409 5410 cons998 = CustomConstraint(cons_f998) 5411 5412 def cons_f999(j, n): 5413 return PositiveIntegerQ(j, n) 5414 5415 cons999 = CustomConstraint(cons_f999) 5416 5417 def cons_f1000(j, n): 5418 return Less(j, n) 5419 5420 cons1000 = CustomConstraint(cons_f1000) 5421 5422 def cons_f1001(a, b, d): 5423 return ZeroQ(S(27)*a**S(2)*d + S(4)*b**S(3)) 5424 5425 cons1001 = CustomConstraint(cons_f1001) 5426 5427 def cons_f1002(a, b, d): 5428 return NonzeroQ(S(27)*a**S(2)*d + S(4)*b**S(3)) 5429 5430 cons1002 = CustomConstraint(cons_f1002) 5431 5432 def cons_f1003(a, c, d): 5433 return ZeroQ(S(27)*a*d**S(2) + S(4)*c**S(3)) 5434 5435 cons1003 = CustomConstraint(cons_f1003) 5436 5437 def cons_f1004(a, c, d): 5438 return NonzeroQ(S(27)*a*d**S(2) + S(4)*c**S(3)) 5439 5440 cons1004 = CustomConstraint(cons_f1004) 5441 5442 def cons_f1005(b, c, d): 5443 return ZeroQ(-S(3)*b*d + c**S(2)) 5444 5445 cons1005 = CustomConstraint(cons_f1005) 5446 5447 def cons_f1006(a, b, c): 5448 return ZeroQ(-S(3)*a*c + b**S(2)) 5449 5450 cons1006 = CustomConstraint(cons_f1006) 5451 5452 def cons_f1007(a, b, c): 5453 return NonzeroQ(-S(3)*a*c + b**S(2)) 5454 5455 cons1007 = CustomConstraint(cons_f1007) 5456 5457 def cons_f1008(b, c, d): 5458 return NonzeroQ(-S(3)*b*d + c**S(2)) 5459 5460 cons1008 = CustomConstraint(cons_f1008) 5461 5462 def cons_f1009(u, x): 5463 if isinstance(x, (int, Integer, float, Float)): 5464 return False 5465 return PolyQ(u, x, S(3)) 5466 5467 cons1009 = CustomConstraint(cons_f1009) 5468 5469 def cons_f1010(u, x): 5470 if isinstance(x, (int, Integer, float, Float)): 5471 return False 5472 return Not(CubicMatchQ(u, x)) 5473 5474 cons1010 = CustomConstraint(cons_f1010) 5475 5476 def cons_f1011(v, x): 5477 if isinstance(x, (int, Integer, float, Float)): 5478 return False 5479 return PolyQ(v, x, S(3)) 5480 5481 cons1011 = CustomConstraint(cons_f1011) 5482 5483 def cons_f1012(u, v, x): 5484 if isinstance(x, (int, Integer, float, Float)): 5485 return False 5486 return Not(And(LinearMatchQ(u, x), CubicMatchQ(v, x))) 5487 5488 cons1012 = CustomConstraint(cons_f1012) 5489 5490 def cons_f1013(f, g): 5491 return ZeroQ(f + g) 5492 5493 cons1013 = CustomConstraint(cons_f1013) 5494 5495 def cons_f1014(a, c): 5496 return PosQ(a**S(2)*(S(2)*a - c)) 5497 5498 cons1014 = CustomConstraint(cons_f1014) 5499 5500 def cons_f1015(a, c): 5501 return NegQ(a**S(2)*(S(2)*a - c)) 5502 5503 cons1015 = CustomConstraint(cons_f1015) 5504 5505 def cons_f1016(b, c, d, e): 5506 return ZeroQ(S(8)*b*e**S(2) - S(4)*c*d*e + d**S(3)) 5507 5508 cons1016 = CustomConstraint(cons_f1016) 5509 5510 def cons_f1017(p): 5511 return UnsameQ(p, S(2)) 5512 5513 cons1017 = CustomConstraint(cons_f1017) 5514 5515 def cons_f1018(p): 5516 return UnsameQ(p, S(3)) 5517 5518 cons1018 = CustomConstraint(cons_f1018) 5519 5520 def cons_f1019(v, x): 5521 if isinstance(x, (int, Integer, float, Float)): 5522 return False 5523 return PolynomialQ(v, x) 5524 5525 cons1019 = CustomConstraint(cons_f1019) 5526 5527 def cons_f1020(v, x): 5528 if isinstance(x, (int, Integer, float, Float)): 5529 return False 5530 return Equal(Exponent(v, x), S(4)) 5531 5532 cons1020 = CustomConstraint(cons_f1020) 5533 5534 def cons_f1021(a, b, c, d): 5535 return ZeroQ(S(8)*a**S(2)*d - S(4)*a*b*c + b**S(3)) 5536 5537 cons1021 = CustomConstraint(cons_f1021) 5538 5539 def cons_f1022(b, d): 5540 return ZeroQ(-b + d) 5541 5542 cons1022 = CustomConstraint(cons_f1022) 5543 5544 def cons_f1023(a, e): 5545 return ZeroQ(-a + e) 5546 5547 cons1023 = CustomConstraint(cons_f1023) 5548 5549 def cons_f1024(a, b, c, x): 5550 if isinstance(x, (int, Integer, float, Float)): 5551 return False 5552 return SumQ(Factor(a*x**S(4) + a + b*x**S(3) + b*x + c*x**S(2))) 5553 5554 cons1024 = CustomConstraint(cons_f1024) 5555 5556 def cons_f1025(D, x): 5557 return FreeQ(D, x) 5558 5559 cons1025 = CustomConstraint(cons_f1025) 5560 5561 def cons_f1026(A, B, C, b, c, d, e): 5562 return ZeroQ(B**S(2)*d - S(2)*B*(S(2)*A*e + C*c) + S(2)*C*(A*d + C*b)) 5563 5564 cons1026 = CustomConstraint(cons_f1026) 5565 5566 def cons_f1027(A, B, C, a, c, d, e): 5567 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) 5568 5569 cons1027 = CustomConstraint(cons_f1027) 5570 5571 def cons_f1028(A, B, C, c, d, e): 5572 return PosQ(C*(C*(-S(4)*c*e + d**S(2)) + S(2)*e*(-S(4)*A*e + B*d))) 5573 5574 cons1028 = CustomConstraint(cons_f1028) 5575 5576 def cons_f1029(A, C, b, d): 5577 return ZeroQ(A*d + C*b) 5578 5579 cons1029 = CustomConstraint(cons_f1029) 5580 5581 def cons_f1030(A, C, a, e): 5582 return ZeroQ(-A**S(2)*e + C**S(2)*a) 5583 5584 cons1030 = CustomConstraint(cons_f1030) 5585 5586 def cons_f1031(A, C, c, d, e): 5587 return PosQ(C*(-S(8)*A*e**S(2) + C*(-S(4)*c*e + d**S(2)))) 5588 5589 cons1031 = CustomConstraint(cons_f1031) 5590 5591 def cons_f1032(A, B, C, c, d, e): 5592 return NegQ(C*(C*(-S(4)*c*e + d**S(2)) + S(2)*e*(-S(4)*A*e + B*d))) 5593 5594 cons1032 = CustomConstraint(cons_f1032) 5595 5596 def cons_f1033(A, C, c, d, e): 5597 return NegQ(C*(-S(8)*A*e**S(2) + C*(-S(4)*c*e + d**S(2)))) 5598 5599 cons1033 = CustomConstraint(cons_f1033) 5600 5601 def cons_f1034(A, B, C, D, b, c, d, e): 5602 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)) 5603 5604 cons1034 = CustomConstraint(cons_f1034) 5605 5606 def cons_f1035(A, B, C, D, a, b, c, d, e): 5607 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))) 5608 5609 cons1035 = CustomConstraint(cons_f1035) 5610 5611 def cons_f1036(A, D, b, c, d, e): 5612 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)) 5613 5614 cons1036 = CustomConstraint(cons_f1036) 5615 5616 def cons_f1037(A, B, D, a, b, c, d, e): 5617 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))) 5618 5619 cons1037 = CustomConstraint(cons_f1037) 5620 5621 def cons_f1038(a, c, e, f): 5622 return ZeroQ(a*e**S(2) - c*f**S(2)) 5623 5624 cons1038 = CustomConstraint(cons_f1038) 5625 5626 def cons_f1039(b, d, e, f): 5627 return ZeroQ(b*e**S(2) - d*f**S(2)) 5628 5629 cons1039 = CustomConstraint(cons_f1039) 5630 5631 def cons_f1040(a, c, e, f): 5632 return NonzeroQ(a*e**S(2) - c*f**S(2)) 5633 5634 cons1040 = CustomConstraint(cons_f1040) 5635 5636 def cons_f1041(b, d, e, f): 5637 return NonzeroQ(b*e**S(2) - d*f**S(2)) 5638 5639 cons1041 = CustomConstraint(cons_f1041) 5640 5641 def cons_f1042(n, p): 5642 return ZeroQ(-S(2)*n + p) 5643 5644 cons1042 = CustomConstraint(cons_f1042) 5645 5646 def cons_f1043(b, c, d): 5647 return ZeroQ(b*c**S(2) - d**S(2)) 5648 5649 cons1043 = CustomConstraint(cons_f1043) 5650 5651 def cons_f1044(b, c, d): 5652 return NonzeroQ(b*c**S(2) - d**S(2)) 5653 5654 cons1044 = CustomConstraint(cons_f1044) 5655 5656 def cons_f1045(a, b, c, d, e, x): 5657 if isinstance(x, (int, Integer, float, Float)): 5658 return False 5659 return FreeQ(List(a, b, c, d, e), x) 5660 5661 cons1045 = CustomConstraint(cons_f1045) 5662 5663 def cons_f1046(a, b, c, d, e): 5664 return NonzeroQ(a*e**S(4) + b*d**S(2)*e**S(2) + c*d**S(4)) 5665 5666 cons1046 = CustomConstraint(cons_f1046) 5667 5668 def cons_f1047(b, c, d, e): 5669 return ZeroQ(b*d*e**S(2) + S(2)*c*d**S(3)) 5670 5671 cons1047 = CustomConstraint(cons_f1047) 5672 5673 def cons_f1048(b, c, d, e): 5674 return NonzeroQ(b*d*e**S(2) + S(2)*c*d**S(3)) 5675 5676 cons1048 = CustomConstraint(cons_f1048) 5677 5678 def cons_f1049(a, c, d, e): 5679 return NonzeroQ(a*e**S(4) + c*d**S(4)) 5680 5681 cons1049 = CustomConstraint(cons_f1049) 5682 5683 def cons_f1050(A, B, d, e): 5684 return ZeroQ(A*e + B*d) 5685 5686 cons1050 = CustomConstraint(cons_f1050) 5687 5688 def cons_f1051(A, B, a, c): 5689 return ZeroQ(A*c + B*a) 5690 5691 cons1051 = CustomConstraint(cons_f1051) 5692 5693 def cons_f1052(a, c, d, e): 5694 return ZeroQ(a*e + c*d) 5695 5696 cons1052 = CustomConstraint(cons_f1052) 5697 5698 def cons_f1053(a, b, c, d, e, f, g, h): 5699 return ZeroQ(-f**S(2)*(a*h**S(2) - b*g*h + c*g**S(2)) + (-d*h + e*g)**S(2)) 5700 5701 cons1053 = CustomConstraint(cons_f1053) 5702 5703 def cons_f1054(b, c, d, e, f, g, h): 5704 return ZeroQ(-S(2)*d*e*h + S(2)*e**S(2)*g - f**S(2)*(-b*h + S(2)*c*g)) 5705 5706 cons1054 = CustomConstraint(cons_f1054) 5707 5708 def cons_f1055(f, j, u, v, x): 5709 if isinstance(x, (int, Integer, float, Float)): 5710 return False 5711 return Not(And(LinearMatchQ(u, x), QuadraticMatchQ(v, x), Or(ZeroQ(j), ZeroQ(f + S(-1))))) 5712 5713 cons1055 = CustomConstraint(cons_f1055) 5714 5715 def cons_f1056(f, g, h, j, k, u, v, x): 5716 if isinstance(x, (int, Integer, float, Float)): 5717 return False 5718 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)) 5719 5720 cons1056 = CustomConstraint(cons_f1056) 5721 5722 def cons_f1057(c, e, f): 5723 return ZeroQ(-c*f**S(2) + e**S(2)) 5724 5725 cons1057 = CustomConstraint(cons_f1057) 5726 5727 def cons_f1058(f, u, v, x): 5728 if isinstance(x, (int, Integer, float, Float)): 5729 return False 5730 return ZeroQ(-f**S(2)*Coefficient(v, x, S(2)) + Coefficient(u, x, S(1))**S(2)) 5731 5732 cons1058 = CustomConstraint(cons_f1058) 5733 5734 def cons_f1059(a, c, g, i): 5735 return ZeroQ(-a*i + c*g) 5736 5737 cons1059 = CustomConstraint(cons_f1059) 5738 5739 def cons_f1060(m, p): 5740 return IntegersQ(p, S(2)*m) 5741 5742 cons1060 = CustomConstraint(cons_f1060) 5743 5744 def cons_f1061(c, i, m): 5745 return Or(IntegerQ(m), PositiveQ(i/c)) 5746 5747 cons1061 = CustomConstraint(cons_f1061) 5748 5749 def cons_f1062(b, c, h, i): 5750 return ZeroQ(-b*i + c*h) 5751 5752 cons1062 = CustomConstraint(cons_f1062) 5753 5754 def cons_f1063(c, i): 5755 return Not(PositiveQ(i/c)) 5756 5757 cons1063 = CustomConstraint(cons_f1063) 5758 5759 def cons_f1064(v, w, x): 5760 if isinstance(x, (int, Integer, float, Float)): 5761 return False 5762 return QuadraticQ(List(v, w), x) 5763 5764 cons1064 = CustomConstraint(cons_f1064) 5765 5766 def cons_f1065(f, j, u, v, w, x): 5767 if isinstance(x, (int, Integer, float, Float)): 5768 return False 5769 return Not(And(LinearMatchQ(u, x), QuadraticMatchQ(List(v, w), x), Or(ZeroQ(j), ZeroQ(f + S(-1))))) 5770 5771 cons1065 = CustomConstraint(cons_f1065) 5772 5773 def cons_f1066(f, k, u, v, x): 5774 if isinstance(x, (int, Integer, float, Float)): 5775 return False 5776 return ZeroQ(-f**S(2)*k**S(2)*Coefficient(v, x, S(2)) + Coefficient(u, x, S(1))**S(2)) 5777 5778 cons1066 = CustomConstraint(cons_f1066) 5779 5780 def cons_f1067(n, p): 5781 return ZeroQ(p - S(2)/n) 5782 5783 cons1067 = CustomConstraint(cons_f1067) 5784 5785 def cons_f1068(a, b, c): 5786 return ZeroQ(a**S(2) - b**S(2)*c) 5787 5788 cons1068 = CustomConstraint(cons_f1068) 5789 5790 def cons_f1069(a, b, d): 5791 return ZeroQ(a**S(2) - b**S(2)*d) 5792 5793 cons1069 = CustomConstraint(cons_f1069) 5794 5795 def cons_f1070(a, b, c): 5796 return ZeroQ(a + b**S(2)*c) 5797 5798 cons1070 = CustomConstraint(cons_f1070) 5799 5800 def cons_f1071(a, b, c, e): 5801 return ZeroQ(a + b**S(2)*c*e) 5802 5803 cons1071 = CustomConstraint(cons_f1071) 5804 5805 def cons_f1072(b, c, d): 5806 return ZeroQ(-b*d**S(2) + c**S(2)) 5807 5808 cons1072 = CustomConstraint(cons_f1072) 5809 5810 def cons_f1073(b, e): 5811 return ZeroQ(-b**S(2) + e) 5812 5813 cons1073 = CustomConstraint(cons_f1073) 5814 5815 def cons_f1074(a, b, c, d): 5816 return ZeroQ(-a*d + b*c, S(0)) 5817 5818 cons1074 = CustomConstraint(cons_f1074) 5819 5820 def cons_f1075(A, B, a, d, n): 5821 return ZeroQ(-A**S(2)*d*(n + S(-1))**S(2) + B**S(2)*a) 5822 5823 cons1075 = CustomConstraint(cons_f1075) 5824 5825 def cons_f1076(A, B, c, d, n): 5826 return ZeroQ(S(2)*A*d*(n + S(-1)) + B*c) 5827 5828 cons1076 = CustomConstraint(cons_f1076) 5829 5830 def cons_f1077(k, m): 5831 return ZeroQ(k - S(2)*m + S(-2)) 5832 5833 cons1077 = CustomConstraint(cons_f1077) 5834 5835 def cons_f1078(A, B, a, d, m, n): 5836 return ZeroQ(-A**S(2)*d*(m - n + S(1))**S(2) + B**S(2)*a*(m + S(1))**S(2)) 5837 5838 cons1078 = CustomConstraint(cons_f1078) 5839 5840 def cons_f1079(A, B, c, d, m, n): 5841 return ZeroQ(-S(2)*A*d*(m - n + S(1)) + B*c*(m + S(1))) 5842 5843 cons1079 = CustomConstraint(cons_f1079) 5844 5845 def cons_f1080(a, b, c, d, f, g): 5846 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))) 5847 5848 cons1080 = CustomConstraint(cons_f1080) 5849 5850 def cons_f1081(a, b, c, d, e, f, g): 5851 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)) 5852 5853 cons1081 = CustomConstraint(cons_f1081) 5854 5855 def cons_f1082(a, c, d, f): 5856 return NonzeroQ(-a*f + S(3)*c*d) 5857 5858 cons1082 = CustomConstraint(cons_f1082) 5859 5860 def cons_f1083(a, b, c, d, g): 5861 return NonzeroQ(-S(2)*a**S(2)*g + b*c*d) 5862 5863 cons1083 = CustomConstraint(cons_f1083) 5864 5865 def cons_f1084(a, b, c, d, f, g): 5866 return NonzeroQ(S(4)*a**S(2)*g - a*b*f + b*c*d) 5867 5868 cons1084 = CustomConstraint(cons_f1084) 5869 5870 def cons_f1085(a, b, c, d, f, g): 5871 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))) 5872 5873 cons1085 = CustomConstraint(cons_f1085) 5874 5875 def cons_f1086(a, c, d, f, g): 5876 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)) 5877 5878 cons1086 = CustomConstraint(cons_f1086) 5879 5880 def cons_f1087(a, c, d, e, f, g): 5881 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) 5882 5883 cons1087 = CustomConstraint(cons_f1087) 5884 5885 def cons_f1088(a, c, d, f, g): 5886 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))) 5887 5888 cons1088 = CustomConstraint(cons_f1088) 5889 5890 def cons_f1089(v): 5891 return SumQ(v) 5892 5893 cons1089 = CustomConstraint(cons_f1089) 5894 5895 def cons_f1090(u, v, x): 5896 if isinstance(x, (int, Integer, float, Float)): 5897 return False 5898 return Not(And(MonomialQ(u, x), BinomialQ(v, x))) 5899 5900 cons1090 = CustomConstraint(cons_f1090) 5901 5902 def cons_f1091(u, v, x): 5903 if isinstance(x, (int, Integer, float, Float)): 5904 return False 5905 return Not(And(ZeroQ(Coefficient(u, x, S(0))), ZeroQ(Coefficient(v, x, S(0))))) 5906 5907 cons1091 = CustomConstraint(cons_f1091) 5908 5909 def cons_f1092(u, x): 5910 if isinstance(x, (int, Integer, float, Float)): 5911 return False 5912 return PiecewiseLinearQ(u, x) 5913 5914 cons1092 = CustomConstraint(cons_f1092) 5915 5916 def cons_f1093(u, v, x): 5917 if isinstance(x, (int, Integer, float, Float)): 5918 return False 5919 return PiecewiseLinearQ(u, v, x) 5920 5921 cons1093 = CustomConstraint(cons_f1093) 5922 5923 def cons_f1094(n): 5924 return Unequal(n, S(1)) 5925 5926 cons1094 = CustomConstraint(cons_f1094) 5927 5928 def cons_f1095(m, n): 5929 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)))) 5930 5931 cons1095 = CustomConstraint(cons_f1095) 5932 5933 def cons_f1096(n): 5934 return Not(RationalQ(n)) 5935 5936 cons1096 = CustomConstraint(cons_f1096) 5937 5938 def cons_f1097(n): 5939 return SumSimplerQ(n, S(-1)) 5940 5941 cons1097 = CustomConstraint(cons_f1097) 5942 5943 def cons_f1098(m): 5944 return SumSimplerQ(m, S(1)) 5945 5946 cons1098 = CustomConstraint(cons_f1098) 5947 5948 def cons_f1099(u, x): 5949 if isinstance(x, (int, Integer, float, Float)): 5950 return False 5951 return Not(LinearQ(u, x)) 5952 5953 cons1099 = CustomConstraint(cons_f1099) 5954 5955 def cons_f1100(): 5956 return Not(SameQ(_UseGamma, True)) 5957 5958 cons1100 = CustomConstraint(cons_f1100) 5959 5960 def cons_f1101(F, x): 5961 return FreeQ(F, x) 5962 5963 cons1101 = CustomConstraint(cons_f1101) 5964 5965 def cons_f1102(F, b, c, d, e, f, g, m, n, x): 5966 if isinstance(x, (int, Integer, float, Float)): 5967 return False 5968 return FreeQ(List(F, b, c, d, e, f, g, m, n), x) 5969 5970 cons1102 = CustomConstraint(cons_f1102) 5971 5972 def cons_f1103(u, x): 5973 if isinstance(x, (int, Integer, float, Float)): 5974 return False 5975 return PowerOfLinearQ(u, x) 5976 5977 cons1103 = CustomConstraint(cons_f1103) 5978 5979 def cons_f1104(u, v, x): 5980 if isinstance(x, (int, Integer, float, Float)): 5981 return False 5982 return Not(And(LinearMatchQ(v, x), PowerOfLinearMatchQ(u, x))) 5983 5984 cons1104 = CustomConstraint(cons_f1104) 5985 5986 def cons_f1105(F, a, b, c, d, e, f, g, m, n, p, x): 5987 if isinstance(x, (int, Integer, float, Float)): 5988 return False 5989 return FreeQ(List(F, a, b, c, d, e, f, g, m, n, p), x) 5990 5991 cons1105 = CustomConstraint(cons_f1105) 5992 5993 def cons_f1106(F, G, f, g, i, j, n, q): 5994 return ZeroQ(f*g*n*log(F) - i*j*q*log(G)) 5995 5996 cons1106 = CustomConstraint(cons_f1106) 5997 5998 def cons_f1107(F, G, e, f, g, h, i, j, k, n, q, x): 5999 if isinstance(x, (int, Integer, float, Float)): 6000 return False 6001 return NonzeroQ((G**(j*(h + i*x))*k)**q - (F**(g*(e + f*x)))**n) 6002 6003 cons1107 = CustomConstraint(cons_f1107) 6004 6005 def cons_f1108(F, a, b, c, n, x): 6006 if isinstance(x, (int, Integer, float, Float)): 6007 return False 6008 return FreeQ(List(F, a, b, c, n), x) 6009 6010 cons1108 = CustomConstraint(cons_f1108) 6011 6012 def cons_f1109(): 6013 return SameQ(_UseGamma, True) 6014 6015 cons1109 = CustomConstraint(cons_f1109) 6016 6017 def cons_f1110(F, c, m, u, v, w, x): 6018 if isinstance(x, (int, Integer, float, Float)): 6019 return False 6020 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))) 6021 6022 cons1110 = CustomConstraint(cons_f1110) 6023 6024 def cons_f1111(w, x): 6025 if isinstance(x, (int, Integer, float, Float)): 6026 return False 6027 return PolynomialQ(w, x) 6028 6029 cons1111 = CustomConstraint(cons_f1111) 6030 6031 def cons_f1112(e, f, h, n): 6032 return ZeroQ(e - f*h*(n + S(1))) 6033 6034 cons1112 = CustomConstraint(cons_f1112) 6035 6036 def cons_f1113(F, b, c, e, g, h, n): 6037 return ZeroQ(-b*c*e*log(F) + g*h*(n + S(1))) 6038 6039 cons1113 = CustomConstraint(cons_f1113) 6040 6041 def cons_f1114(e, f, h, m, n): 6042 return ZeroQ(e*(m + S(1)) - f*h*(n + S(1))) 6043 6044 cons1114 = CustomConstraint(cons_f1114) 6045 6046 def cons_f1115(F, a, b, c, d, x): 6047 if isinstance(x, (int, Integer, float, Float)): 6048 return False 6049 return FreeQ(List(F, a, b, c, d), x) 6050 6051 cons1115 = CustomConstraint(cons_f1115) 6052 6053 def cons_f1116(n): 6054 return IntegerQ(S(2)/n) 6055 6056 cons1116 = CustomConstraint(cons_f1116) 6057 6058 def cons_f1117(n): 6059 return Not(IntegerQ(S(2)/n)) 6060 6061 cons1117 = CustomConstraint(cons_f1117) 6062 6063 def cons_f1118(c, d, e, f): 6064 return ZeroQ(-c*f + d*e) 6065 6066 cons1118 = CustomConstraint(cons_f1118) 6067 6068 def cons_f1119(m, n): 6069 return ZeroQ(-S(2)*m + n + S(-2)) 6070 6071 cons1119 = CustomConstraint(cons_f1119) 6072 6073 def cons_f1120(m, n): 6074 return IntegerQ(S(2)*(m + S(1))/n) 6075 6076 cons1120 = CustomConstraint(cons_f1120) 6077 6078 def cons_f1121(m, n): 6079 return Less(S(0), (m + S(1))/n, S(5)) 6080 6081 cons1121 = CustomConstraint(cons_f1121) 6082 6083 def cons_f1122(m, n): 6084 return Or(Less(S(0), n, m + S(1)), Less(m, n, S(0))) 6085 6086 cons1122 = CustomConstraint(cons_f1122) 6087 6088 def cons_f1123(m, n): 6089 return Less(S(-4), (m + S(1))/n, S(5)) 6090 6091 cons1123 = CustomConstraint(cons_f1123) 6092 6093 def cons_f1124(m, n): 6094 return Or(And(Greater(n, S(0)), Less(m, S(-1))), Inequality(S(0), Less, -n, LessEqual, m + S(1))) 6095 6096 cons1124 = CustomConstraint(cons_f1124) 6097 6098 def cons_f1125(d, f): 6099 return NonzeroQ(-d + f) 6100 6101 cons1125 = CustomConstraint(cons_f1125) 6102 6103 def cons_f1126(c, e): 6104 return NonzeroQ(c*e) 6105 6106 cons1126 = CustomConstraint(cons_f1126) 6107 6108 def cons_f1127(u, v, x): 6109 if isinstance(x, (int, Integer, float, Float)): 6110 return False 6111 return Not(And(LinearMatchQ(u, x), BinomialMatchQ(v, x))) 6112 6113 cons1127 = CustomConstraint(cons_f1127) 6114 6115 def cons_f1128(v, x): 6116 if isinstance(x, (int, Integer, float, Float)): 6117 return False 6118 return PowerOfLinearQ(v, x) 6119 6120 cons1128 = CustomConstraint(cons_f1128) 6121 6122 def cons_f1129(v, x): 6123 if isinstance(x, (int, Integer, float, Float)): 6124 return False 6125 return Not(PowerOfLinearMatchQ(v, x)) 6126 6127 cons1129 = CustomConstraint(cons_f1129) 6128 6129 def cons_f1130(c, d, g, h): 6130 return ZeroQ(-c*h + d*g) 6131 6132 cons1130 = CustomConstraint(cons_f1130) 6133 6134 def cons_f1131(c, d, g, h): 6135 return NonzeroQ(-c*h + d*g) 6136 6137 cons1131 = CustomConstraint(cons_f1131) 6138 6139 def cons_f1132(F, a, b, c, x): 6140 if isinstance(x, (int, Integer, float, Float)): 6141 return False 6142 return FreeQ(List(F, a, b, c), x) 6143 6144 cons1132 = CustomConstraint(cons_f1132) 6145 6146 def cons_f1133(v, x): 6147 if isinstance(x, (int, Integer, float, Float)): 6148 return False 6149 return Not(QuadraticMatchQ(v, x)) 6150 6151 cons1133 = CustomConstraint(cons_f1133) 6152 6153 def cons_f1134(b, c, d, e): 6154 return ZeroQ(b*e - S(2)*c*d) 6155 6156 cons1134 = CustomConstraint(cons_f1134) 6157 6158 def cons_f1135(b, c, d, e): 6159 return NonzeroQ(b*e - S(2)*c*d) 6160 6161 cons1135 = CustomConstraint(cons_f1135) 6162 6163 def cons_f1136(F, a, b, c, d, e, m, x): 6164 if isinstance(x, (int, Integer, float, Float)): 6165 return False 6166 return FreeQ(List(F, a, b, c, d, e, m), x) 6167 6168 cons1136 = CustomConstraint(cons_f1136) 6169 6170 def cons_f1137(c, d, e, v, x): 6171 if isinstance(x, (int, Integer, float, Float)): 6172 return False 6173 return ZeroQ(S(2)*e*(c + d*x) - v) 6174 6175 cons1137 = CustomConstraint(cons_f1137) 6176 6177 def cons_f1138(F, G, a, b, c, d, e, f, g, h, n, x): 6178 if isinstance(x, (int, Integer, float, Float)): 6179 return False 6180 return FreeQ(List(F, G, a, b, c, d, e, f, g, h, n), x) 6181 6182 cons1138 = CustomConstraint(cons_f1138) 6183 6184 def cons_f1139(G, x): 6185 return FreeQ(G, x) 6186 6187 cons1139 = CustomConstraint(cons_f1139) 6188 6189 def cons_f1140(F, G, d, e, g, h): 6190 return Not(RationalQ(FullSimplify(g*h*log(G)/(d*e*log(F))))) 6191 6192 cons1140 = CustomConstraint(cons_f1140) 6193 6194 def cons_f1141(F, G, H, a, b, c, d, e, f, g, h, n, r, s, t, x): 6195 if isinstance(x, (int, Integer, float, Float)): 6196 return False 6197 return FreeQ(List(F, G, H, a, b, c, d, e, f, g, h, r, s, t, n), x) 6198 6199 cons1141 = CustomConstraint(cons_f1141) 6200 6201 def cons_f1142(H, x): 6202 return FreeQ(H, x) 6203 6204 cons1142 = CustomConstraint(cons_f1142) 6205 6206 def cons_f1143(t, x): 6207 return FreeQ(t, x) 6208 6209 cons1143 = CustomConstraint(cons_f1143) 6210 6211 def cons_f1144(F, G, d, e, g, h, n): 6212 return ZeroQ(d*e*n*log(F) + g*h*log(G)) 6213 6214 cons1144 = CustomConstraint(cons_f1144) 6215 6216 def cons_f1145(F, G, H, d, e, g, h, s, t): 6217 return Not(RationalQ(FullSimplify((g*h*log(G) + s*t*log(H))/(d*e*log(F))))) 6218 6219 cons1145 = CustomConstraint(cons_f1145) 6220 6221 def cons_f1146(u, v): 6222 return ZeroQ(-S(2)*u + v) 6223 6224 cons1146 = CustomConstraint(cons_f1146) 6225 6226 def cons_f1147(c, d, v, x): 6227 if isinstance(x, (int, Integer, float, Float)): 6228 return False 6229 return ZeroQ(c + d*x + v) 6230 6231 cons1147 = CustomConstraint(cons_f1147) 6232 6233 def cons_f1148(w, x): 6234 if isinstance(x, (int, Integer, float, Float)): 6235 return False 6236 return LinearQ(w, x) 6237 6238 cons1148 = CustomConstraint(cons_f1148) 6239 6240 def cons_f1149(v, w): 6241 return ZeroQ(v + w) 6242 6243 cons1149 = CustomConstraint(cons_f1149) 6244 6245 def cons_f1150(v, w, x): 6246 if isinstance(x, (int, Integer, float, Float)): 6247 return False 6248 return If(RationalQ(Coefficient(v, x, S(1))), Greater(Coefficient(v, x, S(1)), S(0)), Less(LeafCount(v), LeafCount(w))) 6249 6250 cons1150 = CustomConstraint(cons_f1150) 6251 6252 def cons_f1151(F, a, b, c, d, e, g, n, x): 6253 if isinstance(x, (int, Integer, float, Float)): 6254 return False 6255 return FreeQ(List(F, a, b, c, d, e, g, n), x) 6256 6257 cons1151 = CustomConstraint(cons_f1151) 6258 6259 def cons_f1152(F, a, c, d, e, g, n, x): 6260 if isinstance(x, (int, Integer, float, Float)): 6261 return False 6262 return FreeQ(List(F, a, c, d, e, g, n), x) 6263 6264 cons1152 = CustomConstraint(cons_f1152) 6265 6266 def cons_f1153(F, a, b, x): 6267 if isinstance(x, (int, Integer, float, Float)): 6268 return False 6269 return FreeQ(List(F, a, b), x) 6270 6271 cons1153 = CustomConstraint(cons_f1153) 6272 6273 def cons_f1154(n): 6274 return Unequal(n, S(-1)) 6275 6276 cons1154 = CustomConstraint(cons_f1154) 6277 6278 def cons_f1155(u, x): 6279 if isinstance(x, (int, Integer, float, Float)): 6280 return False 6281 return FunctionOfExponentialQ(u, x) 6282 6283 cons1155 = CustomConstraint(cons_f1155) 6284 6285 def cons_f1156(v, w, x): 6286 if isinstance(x, (int, Integer, float, Float)): 6287 return False 6288 return LinearQ(List(v, w), x) 6289 6290 cons1156 = CustomConstraint(cons_f1156) 6291 6292 def cons_f1157(v, w, x): 6293 if isinstance(x, (int, Integer, float, Float)): 6294 return False 6295 return Or(BinomialQ(v + w, x), And(PolynomialQ(v + w, x), LessEqual(Exponent(v + w, x), S(2)))) 6296 6297 cons1157 = CustomConstraint(cons_f1157) 6298 6299 def cons_f1158(c, d, e, f, p, q, x): 6300 if isinstance(x, (int, Integer, float, Float)): 6301 return False 6302 return FreeQ(List(c, d, e, f, p, q), x) 6303 6304 cons1158 = CustomConstraint(cons_f1158) 6305 6306 def cons_f1159(d, e, f, x): 6307 if isinstance(x, (int, Integer, float, Float)): 6308 return False 6309 return FreeQ(List(d, e, f), x) 6310 6311 cons1159 = CustomConstraint(cons_f1159) 6312 6313 def cons_f1160(b, p, q): 6314 return PosQ(b*p*q) 6315 6316 cons1160 = CustomConstraint(cons_f1160) 6317 6318 def cons_f1161(b, p, q): 6319 return NegQ(b*p*q) 6320 6321 cons1161 = CustomConstraint(cons_f1161) 6322 6323 def cons_f1162(e, f, g, h): 6324 return ZeroQ(-e*h + f*g) 6325 6326 cons1162 = CustomConstraint(cons_f1162) 6327 6328 def cons_f1163(m, p): 6329 return ZeroQ(m - p + S(1)) 6330 6331 cons1163 = CustomConstraint(cons_f1163) 6332 6333 def cons_f1164(f, h, p): 6334 return Or(IntegerQ(p), PositiveQ(h/f)) 6335 6336 cons1164 = CustomConstraint(cons_f1164) 6337 6338 def cons_f1165(f, h, p): 6339 return Not(Or(IntegerQ(p), PositiveQ(h/f))) 6340 6341 cons1165 = CustomConstraint(cons_f1165) 6342 6343 def cons_f1166(b, m, p, q): 6344 return PosQ((m + S(1))/(b*p*q)) 6345 6346 cons1166 = CustomConstraint(cons_f1166) 6347 6348 def cons_f1167(b, m, p, q): 6349 return NegQ((m + S(1))/(b*p*q)) 6350 6351 cons1167 = CustomConstraint(cons_f1167) 6352 6353 def cons_f1168(c, e, f, g, h): 6354 return ZeroQ(c*(-e*h + f*g) + h) 6355 6356 cons1168 = CustomConstraint(cons_f1168) 6357 6358 def cons_f1169(c, e, f, g, h): 6359 return NonzeroQ(c*(-e*h + f*g) + h) 6360 6361 cons1169 = CustomConstraint(cons_f1169) 6362 6363 def cons_f1170(c, e, f, g, h): 6364 return PositiveQ(c*(e - f*g/h)) 6365 6366 cons1170 = CustomConstraint(cons_f1170) 6367 6368 def cons_f1171(e, f, g, h): 6369 return NonzeroQ(-e*h + f*g) 6370 6371 cons1171 = CustomConstraint(cons_f1171) 6372 6373 def cons_f1172(m, n): 6374 return IntegersQ(S(2)*m, S(2)*n) 6375 6376 cons1172 = CustomConstraint(cons_f1172) 6377 6378 def cons_f1173(m, n): 6379 return Or(Equal(n, S(1)), Not(PositiveIntegerQ(m)), And(Equal(n, S(2)), NonzeroQ(m + S(-1)))) 6380 6381 cons1173 = CustomConstraint(cons_f1173) 6382 6383 def cons_f1174(c, e, f, i, j): 6384 return ZeroQ(f*i + j*(c - e)) 6385 6386 cons1174 = CustomConstraint(cons_f1174) 6387 6388 def cons_f1175(m, n): 6389 return Or(IntegerQ(n), Greater(m, S(0))) 6390 6391 cons1175 = CustomConstraint(cons_f1175) 6392 6393 def cons_f1176(a, b, c, d, e, f, g, h, i, j, m, n, p, q, x): 6394 if isinstance(x, (int, Integer, float, Float)): 6395 return False 6396 return FreeQ(List(a, b, c, d, e, f, g, h, i, j, m, n, p, q), x) 6397 6398 cons1176 = CustomConstraint(cons_f1176) 6399 6400 def cons_f1177(e, f, g, h): 6401 return ZeroQ(e**S(2)*h + f**S(2)*g) 6402 6403 cons1177 = CustomConstraint(cons_f1177) 6404 6405 def cons_f1178(c, e): 6406 return ZeroQ(c - S(2)*e) 6407 6408 cons1178 = CustomConstraint(cons_f1178) 6409 6410 def cons_f1179(c, e): 6411 return PositiveQ(c/(S(2)*e)) 6412 6413 cons1179 = CustomConstraint(cons_f1179) 6414 6415 def cons_f1180(a, c, e): 6416 return Or(NonzeroQ(c - S(2)*e), NonzeroQ(a)) 6417 6418 cons1180 = CustomConstraint(cons_f1180) 6419 6420 def cons_f1181(e, f, g, h, i): 6421 return ZeroQ(e**S(2)*i - e*f*h + f**S(2)*g) 6422 6423 cons1181 = CustomConstraint(cons_f1181) 6424 6425 def cons_f1182(e, f, g, i): 6426 return ZeroQ(e**S(2)*i + f**S(2)*g) 6427 6428 cons1182 = CustomConstraint(cons_f1182) 6429 6430 def cons_f1183(g): 6431 return PositiveQ(g) 6432 6433 cons1183 = CustomConstraint(cons_f1183) 6434 6435 def cons_f1184(g1, g2, h1, h2): 6436 return ZeroQ(g1*h2 + g2*h1) 6437 6438 cons1184 = CustomConstraint(cons_f1184) 6439 6440 def cons_f1185(g1): 6441 return PositiveQ(g1) 6442 6443 cons1185 = CustomConstraint(cons_f1185) 6444 6445 def cons_f1186(g2): 6446 return PositiveQ(g2) 6447 6448 cons1186 = CustomConstraint(cons_f1186) 6449 6450 def cons_f1187(g1, x): 6451 return FreeQ(g1, x) 6452 6453 cons1187 = CustomConstraint(cons_f1187) 6454 6455 def cons_f1188(h1, x): 6456 return FreeQ(h1, x) 6457 6458 cons1188 = CustomConstraint(cons_f1188) 6459 6460 def cons_f1189(g2, x): 6461 return FreeQ(g2, x) 6462 6463 cons1189 = CustomConstraint(cons_f1189) 6464 6465 def cons_f1190(h2, x): 6466 return FreeQ(h2, x) 6467 6468 cons1190 = CustomConstraint(cons_f1190) 6469 6470 def cons_f1191(g): 6471 return Not(PositiveQ(g)) 6472 6473 cons1191 = CustomConstraint(cons_f1191) 6474 6475 def cons_f1192(g, h, i, j, k): 6476 return ZeroQ(h - i*(-g*k + h*j)) 6477 6478 cons1192 = CustomConstraint(cons_f1192) 6479 6480 def cons_f1193(g, h, j, k): 6481 return ZeroQ(-g*k + h*j) 6482 6483 cons1193 = CustomConstraint(cons_f1193) 6484 6485 def cons_f1194(F): 6486 return MemberQ(List(Log, ArcSin, ArcCos, ArcTan, ArcCot, ArcSinh, ArcCosh, ArcTanh, ArcCoth), F) 6487 6488 cons1194 = CustomConstraint(cons_f1194) 6489 6490 def cons_f1195(m, r): 6491 return ZeroQ(m + r) 6492 6493 cons1195 = CustomConstraint(cons_f1195) 6494 6495 def cons_f1196(r, r1): 6496 return ZeroQ(-r + r1 + S(1)) 6497 6498 cons1196 = CustomConstraint(cons_f1196) 6499 6500 def cons_f1197(a, b, c, d, e, n, x): 6501 if isinstance(x, (int, Integer, float, Float)): 6502 return False 6503 return FreeQ(List(a, b, c, d, e, n), x) 6504 6505 cons1197 = CustomConstraint(cons_f1197) 6506 6507 def cons_f1198(mn, n): 6508 return ZeroQ(mn + n) 6509 6510 cons1198 = CustomConstraint(cons_f1198) 6511 6512 def cons_f1199(a, b, c, d, e): 6513 return ZeroQ(-a*c*d + b*c*e + d) 6514 6515 cons1199 = CustomConstraint(cons_f1199) 6516 6517 def cons_f1200(RFx, x): 6518 if isinstance(x, (int, Integer, float, Float)): 6519 return False 6520 return RationalFunctionQ(RFx, x) 6521 6522 cons1200 = CustomConstraint(cons_f1200) 6523 6524 def cons_f1201(e, f, g): 6525 return ZeroQ(-S(4)*e*g + f**S(2)) 6526 6527 cons1201 = CustomConstraint(cons_f1201) 6528 6529 def cons_f1202(c, d, p, q, v, x): 6530 if isinstance(x, (int, Integer, float, Float)): 6531 return False 6532 def _cons_f_1201(cc, dd, e, f, pp, qq): 6533 return FreeQ(List(cc, dd, e, f, pp, qq), x) 6534 _cons_1201 = CustomConstraint(_cons_f_1201) 6535 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) 6536 result_matchq = is_match(UtilityOperator(c*(d*v**p)**q, x), pat) 6537 return Not(result_matchq) 6538 6539 cons1202 = CustomConstraint(cons_f1202) 6540 6541 def cons_f1203(a, b, c, n, p, q, r, x): 6542 if isinstance(x, (int, Integer, float, Float)): 6543 return False 6544 return FreeQ(List(a, b, c, n, p, q, r), x) 6545 6546 cons1203 = CustomConstraint(cons_f1203) 6547 6548 def cons_f1204(a, b, c, n, p, q, x): 6549 if isinstance(x, (int, Integer, float, Float)): 6550 return False 6551 return Not(SameQ(x**(n*p*q), a*(b*(c*x**n)**p)**q)) 6552 6553 cons1204 = CustomConstraint(cons_f1204) 6554 6555 def cons_f1205(n1, n2): 6556 return ZeroQ(n1 + n2) 6557 6558 cons1205 = CustomConstraint(cons_f1205) 6559 6560 def cons_f1206(n1, x): 6561 return FreeQ(n1, x) 6562 6563 cons1206 = CustomConstraint(cons_f1206) 6564 6565 def cons_f1207(c, d, f, g): 6566 return ZeroQ(-c*g + d*f) 6567 6568 cons1207 = CustomConstraint(cons_f1207) 6569 6570 def cons_f1208(b, d, e): 6571 return ZeroQ(-b*e + d) 6572 6573 cons1208 = CustomConstraint(cons_f1208) 6574 6575 def cons_f1209(a, b, f, g): 6576 return ZeroQ(-a*g + b*f) 6577 6578 cons1209 = CustomConstraint(cons_f1209) 6579 6580 def cons_f1210(c, d, f, g): 6581 return NonzeroQ(-c*g + d*f) 6582 6583 cons1210 = CustomConstraint(cons_f1210) 6584 6585 def cons_f1211(a, b, f, g): 6586 return NonzeroQ(-a*g + b*f) 6587 6588 cons1211 = CustomConstraint(cons_f1211) 6589 6590 def cons_f1212(m, m2): 6591 return ZeroQ(m + m2 + S(2)) 6592 6593 cons1212 = CustomConstraint(cons_f1212) 6594 6595 def cons_f1213(a, b, c, d, u, x): 6596 return FreeQ(simplify(Mul(u, Add(c, Mul(d, x)), Pow(Add(a, Mul(b, x)), S(-1)))), x) 6597 6598 cons1213 = CustomConstraint(cons_f1213) 6599 6600 def cons_f1214(a, b, c, d, e, f, g): 6601 return ZeroQ(-c*g + d*f - e*(-a*g + b*f)) 6602 6603 cons1214 = CustomConstraint(cons_f1214) 6604 6605 def cons_f1215(c, d, f, g): 6606 return ZeroQ(c**S(2)*g + d**S(2)*f) 6607 6608 cons1215 = CustomConstraint(cons_f1215) 6609 6610 def cons_f1216(a, b, c, d, e): 6611 return ZeroQ(-a*d*e - b*c*e + S(2)*c*d) 6612 6613 cons1216 = CustomConstraint(cons_f1216) 6614 6615 def cons_f1217(c, d, f, g, h): 6616 return ZeroQ(c**S(2)*h - c*d*g + d**S(2)*f) 6617 6618 cons1217 = CustomConstraint(cons_f1217) 6619 6620 def cons_f1218(c, d, f, h): 6621 return ZeroQ(c**S(2)*h + d**S(2)*f) 6622 6623 cons1218 = CustomConstraint(cons_f1218) 6624 6625 def cons_f1219(u, v): 6626 return FreeQ(simplify(Mul(u, Pow(Add(S(1), Mul(S(-1), v)), S(-1)))), x) 6627 6628 cons1219 = CustomConstraint(cons_f1219) 6629 6630 def cons_f1220(u, v): 6631 return FreeQ(simplify(Mul(u, Add(S(1), Mul(S(-1), v)))), x) 6632 6633 cons1220 = CustomConstraint(cons_f1220) 6634 6635 def cons_f1221(u, v): 6636 return FreeQ(simplify(Mul(u, Pow(v, S(-1)))), x) 6637 6638 cons1221 = CustomConstraint(cons_f1221) 6639 6640 def cons_f1222(u, v): 6641 return FreeQ(simplify(Mul(u, v)), x) 6642 6643 cons1222 = CustomConstraint(cons_f1222) 6644 6645 def cons_f1223(a, b, c, d, f, h): 6646 return ZeroQ(-a*c*h + b*d*f) 6647 6648 cons1223 = CustomConstraint(cons_f1223) 6649 6650 def cons_f1224(a, b, c, d, g, h): 6651 return ZeroQ(-a*d*h - b*c*h + b*d*g) 6652 6653 cons1224 = CustomConstraint(cons_f1224) 6654 6655 def cons_f1225(v, x): 6656 if isinstance(x, (int, Integer, float, Float)): 6657 return False 6658 return QuotientOfLinearsQ(v, x) 6659 6660 cons1225 = CustomConstraint(cons_f1225) 6661 6662 def cons_f1226(v, x): 6663 if isinstance(x, (int, Integer, float, Float)): 6664 return False 6665 return Not(QuotientOfLinearsMatchQ(v, x)) 6666 6667 cons1226 = CustomConstraint(cons_f1226) 6668 6669 def cons_f1227(v, x): 6670 if isinstance(x, (int, Integer, float, Float)): 6671 return False 6672 return Not(BinomialMatchQ(v, x)) 6673 6674 cons1227 = CustomConstraint(cons_f1227) 6675 6676 def cons_f1228(a, b, c, d, e, f, g, n, p, x): 6677 if isinstance(x, (int, Integer, float, Float)): 6678 return False 6679 return FreeQ(List(a, b, c, d, e, f, g, n, p), x) 6680 6681 cons1228 = CustomConstraint(cons_f1228) 6682 6683 def cons_f1229(a, b, c, d, e, f, g, p, x): 6684 if isinstance(x, (int, Integer, float, Float)): 6685 return False 6686 return FreeQ(List(a, b, c, d, e, f, g, p), x) 6687 6688 cons1229 = CustomConstraint(cons_f1229) 6689 6690 def cons_f1230(m): 6691 return IntegerQ(m/S(2) + S(-1)/2) 6692 6693 cons1230 = CustomConstraint(cons_f1230) 6694 6695 def cons_f1231(m): 6696 return Not(IntegerQ(m/S(2) + S(-1)/2)) 6697 6698 cons1231 = CustomConstraint(cons_f1231) 6699 6700 def cons_f1232(u, x): 6701 if isinstance(x, (int, Integer, float, Float)): 6702 return False 6703 return InverseFunctionFreeQ(u, x) 6704 6705 cons1232 = CustomConstraint(cons_f1232) 6706 6707 def cons_f1233(n): 6708 return Not(And(RationalQ(n), Less(n, S(0)))) 6709 6710 cons1233 = CustomConstraint(cons_f1233) 6711 6712 def cons_f1234(m, n): 6713 return Or(Equal(n, S(1)), IntegerQ(m)) 6714 6715 cons1234 = CustomConstraint(cons_f1234) 6716 6717 def cons_f1235(RFx, x): 6718 if isinstance(x, (int, Integer, float, Float)): 6719 return False 6720 return Not(PolynomialQ(RFx, x)) 6721 6722 cons1235 = CustomConstraint(cons_f1235) 6723 6724 def cons_f1236(Px, Qx, x): 6725 if isinstance(x, (int, Integer, float, Float)): 6726 return False 6727 return QuadraticQ(List(Qx, Px), x) 6728 6729 cons1236 = CustomConstraint(cons_f1236) 6730 6731 def cons_f1237(Px, Qx, x): 6732 if isinstance(x, (int, Integer, float, Float)): 6733 return False 6734 return ZeroQ(D(Px/Qx, x)) 6735 6736 cons1237 = CustomConstraint(cons_f1237) 6737 6738 def cons_f1238(RGx, x): 6739 if isinstance(x, (int, Integer, float, Float)): 6740 return False 6741 return RationalFunctionQ(RGx, x) 6742 6743 cons1238 = CustomConstraint(cons_f1238) 6744 6745 def cons_f1239(d): 6746 return NonzeroQ(d + S(-1)) 6747 6748 cons1239 = CustomConstraint(cons_f1239) 6749 6750 def cons_f1240(v, x): 6751 if isinstance(x, (int, Integer, float, Float)): 6752 return False 6753 def _cons_f_1239(g, m): 6754 return FreeQ(List(g, m), x) 6755 _cons_1239 = CustomConstraint(_cons_f_1239) 6756 pat = Pattern(UtilityOperator((x*WC('g', S(1)))**WC('m', S(1)), x), _cons_1239) 6757 result_matchq = is_match(UtilityOperator(v, x), pat) 6758 return Or(ZeroQ(v + S(-1)), result_matchq) 6759 6760 cons1240 = CustomConstraint(cons_f1240) 6761 6762 def cons_f1241(u, x): 6763 if isinstance(x, (int, Integer, float, Float)): 6764 return False 6765 return RationalFunctionQ(D(u, x)/u, x) 6766 6767 cons1241 = CustomConstraint(cons_f1241) 6768 6769 def cons_f1242(a, u, x): 6770 if isinstance(x, (int, Integer, float, Float)): 6771 return False 6772 try: 6773 return Or(NonzeroQ(a), Not(And(BinomialQ(u, x), ZeroQ(BinomialDegree(u, x)**S(2) + S(-1))))) 6774 except (TypeError, AttributeError): 6775 return False 6776 6777 cons1242 = CustomConstraint(cons_f1242) 6778 6779 def cons_f1243(Qx, x): 6780 if isinstance(x, (int, Integer, float, Float)): 6781 return False 6782 return QuadraticQ(Qx, x) 6783 6784 cons1243 = CustomConstraint(cons_f1243) 6785 6786 def cons_f1244(v, x): 6787 if isinstance(x, (int, Integer, float, Float)): 6788 return False 6789 return InverseFunctionFreeQ(v, x) 6790 6791 cons1244 = CustomConstraint(cons_f1244) 6792 6793 def cons_f1245(w, x): 6794 if isinstance(x, (int, Integer, float, Float)): 6795 return False 6796 return InverseFunctionFreeQ(w, x) 6797 6798 cons1245 = CustomConstraint(cons_f1245) 6799 6800 def cons_f1246(a, b, n, p, x): 6801 if isinstance(x, (int, Integer, float, Float)): 6802 return False 6803 return FreeQ(List(a, b, n, p), x) 6804 6805 cons1246 = CustomConstraint(cons_f1246) 6806 6807 def cons_f1247(A, B, a, b): 6808 return NonzeroQ(A*b - B*a) 6809 6810 cons1247 = CustomConstraint(cons_f1247) 6811 6812 def cons_f1248(a, f, x): 6813 if isinstance(x, (int, Integer, float, Float)): 6814 return False 6815 return FreeQ(List(a, f), x) 6816 6817 cons1248 = CustomConstraint(cons_f1248) 6818 6819 def cons_f1249(u): 6820 return NonsumQ(u) 6821 6822 cons1249 = CustomConstraint(cons_f1249) 6823 6824 def cons_f1250(u, x): 6825 if isinstance(x, (int, Integer, float, Float)): 6826 return False 6827 return AlgebraicFunctionQ(u, x) 6828 6829 cons1250 = CustomConstraint(cons_f1250) 6830 6831 def cons_f1251(u, x): 6832 if isinstance(x, (int, Integer, float, Float)): 6833 return False 6834 return FunctionOfTrigOfLinearQ(u, x) 6835 6836 cons1251 = CustomConstraint(cons_f1251) 6837 6838 def cons_f1252(n): 6839 return IntegerQ(n/S(2) + S(-1)/2) 6840 6841 cons1252 = CustomConstraint(cons_f1252) 6842 6843 def cons_f1253(m, n): 6844 return Not(And(IntegerQ(m/S(2) + S(-1)/2), Less(S(0), m, n))) 6845 6846 cons1253 = CustomConstraint(cons_f1253) 6847 6848 def cons_f1254(m, n): 6849 return Not(And(IntegerQ(m/S(2) + S(-1)/2), Inequality(S(0), Less, m, LessEqual, n))) 6850 6851 cons1254 = CustomConstraint(cons_f1254) 6852 6853 def cons_f1255(m, n): 6854 return Or(IntegersQ(S(2)*m, S(2)*n), ZeroQ(m + n)) 6855 6856 cons1255 = CustomConstraint(cons_f1255) 6857 6858 def cons_f1256(a, b, e, f, x): 6859 if isinstance(x, (int, Integer, float, Float)): 6860 return False 6861 return FreeQ(List(a, b, e, f), x) 6862 6863 cons1256 = CustomConstraint(cons_f1256) 6864 6865 def cons_f1257(m, n): 6866 return ZeroQ(m + n) 6867 6868 cons1257 = CustomConstraint(cons_f1257) 6869 6870 def cons_f1258(m): 6871 return Less(S(0), m, S(1)) 6872 6873 cons1258 = CustomConstraint(cons_f1258) 6874 6875 def cons_f1259(a, b, m, n): 6876 return Or(RationalQ(n), And(Not(RationalQ(m)), Or(ZeroQ(b + S(-1)), NonzeroQ(a + S(-1))))) 6877 6878 cons1259 = CustomConstraint(cons_f1259) 6879 6880 def cons_f1260(a, b, e, f, m, n, x): 6881 if isinstance(x, (int, Integer, float, Float)): 6882 return False 6883 return FreeQ(List(a, b, e, f, m, n), x) 6884 6885 cons1260 = CustomConstraint(cons_f1260) 6886 6887 def cons_f1261(m, n): 6888 return ZeroQ(m - n + S(2)) 6889 6890 cons1261 = CustomConstraint(cons_f1261) 6891 6892 def cons_f1262(m, n): 6893 return NonzeroQ(m - n) 6894 6895 cons1262 = CustomConstraint(cons_f1262) 6896 6897 def cons_f1263(c, d, x): 6898 if isinstance(x, (int, Integer, float, Float)): 6899 return False 6900 return FreeQ(List(c, d), x) 6901 6902 cons1263 = CustomConstraint(cons_f1263) 6903 6904 def cons_f1264(c, x): 6905 if isinstance(x, (int, Integer, float, Float)): 6906 return False 6907 return FreeQ(List(c, c), x) 6908 6909 cons1264 = CustomConstraint(cons_f1264) 6910 6911 def cons_f1265(b, c, d, x): 6912 if isinstance(x, (int, Integer, float, Float)): 6913 return False 6914 return FreeQ(List(b, c, d), x) 6915 6916 cons1265 = CustomConstraint(cons_f1265) 6917 6918 def cons_f1266(a, b, c, d, x): 6919 if isinstance(x, (int, Integer, float, Float)): 6920 return False 6921 return FreeQ(List(a, b, c, d), x) 6922 6923 cons1266 = CustomConstraint(cons_f1266) 6924 6925 def cons_f1267(a, b): 6926 return ZeroQ(a**S(2) - b**S(2)) 6927 6928 cons1267 = CustomConstraint(cons_f1267) 6929 6930 def cons_f1268(n): 6931 return PositiveIntegerQ(n + S(-1)/2) 6932 6933 cons1268 = CustomConstraint(cons_f1268) 6934 6935 def cons_f1269(a, b): 6936 return NonzeroQ(a**S(2) - b**S(2)) 6937 6938 cons1269 = CustomConstraint(cons_f1269) 6939 6940 def cons_f1270(a, b): 6941 return PositiveQ(a + b) 6942 6943 cons1270 = CustomConstraint(cons_f1270) 6944 6945 def cons_f1271(a, b): 6946 return PositiveQ(a - b) 6947 6948 cons1271 = CustomConstraint(cons_f1271) 6949 6950 def cons_f1272(a, b): 6951 return Not(PositiveQ(a + b)) 6952 6953 cons1272 = CustomConstraint(cons_f1272) 6954 6955 def cons_f1273(a, b): 6956 return PositiveQ(a**S(2) - b**S(2)) 6957 6958 cons1273 = CustomConstraint(cons_f1273) 6959 6960 def cons_f1274(c): 6961 return SimplerQ(-Pi/S(2) + c, c) 6962 6963 cons1274 = CustomConstraint(cons_f1274) 6964 6965 def cons_f1275(a, b, c, d, n, x): 6966 if isinstance(x, (int, Integer, float, Float)): 6967 return False 6968 return FreeQ(List(a, b, c, d, n), x) 6969 6970 cons1275 = CustomConstraint(cons_f1275) 6971 6972 def cons_f1276(p): 6973 return IntegerQ(p/S(2) + S(-1)/2) 6974 6975 cons1276 = CustomConstraint(cons_f1276) 6976 6977 def cons_f1277(a, b, m, p): 6978 return Or(GreaterEqual(p, S(-1)), Not(And(IntegerQ(m + S(1)/2), ZeroQ(a**S(2) - b**S(2))))) 6979 6980 cons1277 = CustomConstraint(cons_f1277) 6981 6982 def cons_f1278(a, b, p): 6983 return Or(IntegerQ(S(2)*p), NonzeroQ(a**S(2) - b**S(2))) 6984 6985 cons1278 = CustomConstraint(cons_f1278) 6986 6987 def cons_f1279(m, p): 6988 return GreaterEqual(S(2)*m + p, S(0)) 6989 6990 cons1279 = CustomConstraint(cons_f1279) 6991 6992 def cons_f1280(m, p): 6993 return ZeroQ(m + p + S(1)) 6994 6995 cons1280 = CustomConstraint(cons_f1280) 6996 6997 def cons_f1281(p): 6998 return Not(NegativeIntegerQ(p)) 6999 7000 cons1281 = CustomConstraint(cons_f1281) 7001 7002 def cons_f1282(m, p): 7003 return NegativeIntegerQ(m + p + S(1)) 7004 7005 cons1282 = CustomConstraint(cons_f1282) 7006 7007 def cons_f1283(m, p): 7008 return NonzeroQ(S(2)*m + p + S(1)) 7009 7010 cons1283 = CustomConstraint(cons_f1283) 7011 7012 def cons_f1284(m, p): 7013 return ZeroQ(S(2)*m + p + S(-1)) 7014 7015 cons1284 = CustomConstraint(cons_f1284) 7016 7017 def cons_f1285(m): 7018 return NonzeroQ(m + S(-1)) 7019 7020 cons1285 = CustomConstraint(cons_f1285) 7021 7022 def cons_f1286(m, p): 7023 return PositiveIntegerQ(m + p/S(2) + S(-1)/2) 7024 7025 cons1286 = CustomConstraint(cons_f1286) 7026 7027 def cons_f1287(m, p): 7028 return NonzeroQ(m + p) 7029 7030 cons1287 = CustomConstraint(cons_f1287) 7031 7032 def cons_f1288(m, p): 7033 return LessEqual(p, -S(2)*m) 7034 7035 cons1288 = CustomConstraint(cons_f1288) 7036 7037 def cons_f1289(m, p): 7038 return IntegersQ(m + S(1)/2, S(2)*p) 7039 7040 cons1289 = CustomConstraint(cons_f1289) 7041 7042 def cons_f1290(m, p): 7043 return IntegersQ(S(2)*m, S(2)*p) 7044 7045 cons1290 = CustomConstraint(cons_f1290) 7046 7047 def cons_f1291(m, p): 7048 return Or(Greater(m, S(-2)), ZeroQ(S(2)*m + p + S(1)), And(Equal(m, S(-2)), IntegerQ(p))) 7049 7050 cons1291 = CustomConstraint(cons_f1291) 7051 7052 def cons_f1292(m): 7053 return LessEqual(m, S(-2)) 7054 7055 cons1292 = CustomConstraint(cons_f1292) 7056 7057 def cons_f1293(m, p): 7058 return Not(NegativeIntegerQ(m + p + S(1))) 7059 7060 cons1293 = CustomConstraint(cons_f1293) 7061 7062 def cons_f1294(p): 7063 return Not(And(RationalQ(p), GreaterEqual(p, S(1)))) 7064 7065 cons1294 = CustomConstraint(cons_f1294) 7066 7067 def cons_f1295(p): 7068 return Greater(p, S(2)) 7069 7070 cons1295 = CustomConstraint(cons_f1295) 7071 7072 def cons_f1296(m, p): 7073 return Or(IntegersQ(S(2)*m, S(2)*p), IntegerQ(m)) 7074 7075 cons1296 = CustomConstraint(cons_f1296) 7076 7077 def cons_f1297(m, p): 7078 return ZeroQ(m + p + S(2)) 7079 7080 cons1297 = CustomConstraint(cons_f1297) 7081 7082 def cons_f1298(m, p): 7083 return NegativeIntegerQ(m + p + S(2)) 7084 7085 cons1298 = CustomConstraint(cons_f1298) 7086 7087 def cons_f1299(m, p): 7088 return Not(PositiveIntegerQ(m + p + S(1))) 7089 7090 cons1299 = CustomConstraint(cons_f1299) 7091 7092 def cons_f1300(p): 7093 return IntegerQ(p/S(2) + S(1)/2) 7094 7095 cons1300 = CustomConstraint(cons_f1300) 7096 7097 def cons_f1301(m, p): 7098 return IntegersQ(m, p) 7099 7100 cons1301 = CustomConstraint(cons_f1301) 7101 7102 def cons_f1302(m, p): 7103 return Equal(p, S(2)*m) 7104 7105 cons1302 = CustomConstraint(cons_f1302) 7106 7107 def cons_f1303(m, p): 7108 return IntegersQ(m, p/S(2)) 7109 7110 cons1303 = CustomConstraint(cons_f1303) 7111 7112 def cons_f1304(m, p): 7113 return Or(Less(p, S(0)), Greater(m - p/S(2), S(0))) 7114 7115 cons1304 = CustomConstraint(cons_f1304) 7116 7117 def cons_f1305(m): 7118 return Not(And(RationalQ(m), Less(m, S(0)))) 7119 7120 cons1305 = CustomConstraint(cons_f1305) 7121 7122 def cons_f1306(m): 7123 return IntegerQ(m + S(-1)/2) 7124 7125 cons1306 = CustomConstraint(cons_f1306) 7126 7127 def cons_f1307(m): 7128 return Not(Less(m, S(-1))) 7129 7130 cons1307 = CustomConstraint(cons_f1307) 7131 7132 def cons_f1308(p): 7133 return IntegerQ(p/S(2)) 7134 7135 cons1308 = CustomConstraint(cons_f1308) 7136 7137 def cons_f1309(p): 7138 return IntegersQ(S(2)*p) 7139 7140 cons1309 = CustomConstraint(cons_f1309) 7141 7142 def cons_f1310(a, b, e, f, g, m, p, x): 7143 if isinstance(x, (int, Integer, float, Float)): 7144 return False 7145 return FreeQ(List(a, b, e, f, g, m, p), x) 7146 7147 cons1310 = CustomConstraint(cons_f1310) 7148 7149 def cons_f1311(m, n): 7150 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))))) 7151 7152 cons1311 = CustomConstraint(cons_f1311) 7153 7154 def cons_f1312(n): 7155 return NonzeroQ(n + S(1)/2) 7156 7157 cons1312 = CustomConstraint(cons_f1312) 7158 7159 def cons_f1313(m): 7160 return PositiveIntegerQ(m + S(-1)/2) 7161 7162 cons1313 = CustomConstraint(cons_f1313) 7163 7164 def cons_f1314(m, n): 7165 return Not(And(NegativeIntegerQ(m + n), Greater(S(2)*m + n + S(1), S(0)))) 7166 7167 cons1314 = CustomConstraint(cons_f1314) 7168 7169 def cons_f1315(m, n): 7170 return Not(And(PositiveIntegerQ(n + S(-1)/2), Less(n, m))) 7171 7172 cons1315 = CustomConstraint(cons_f1315) 7173 7174 def cons_f1316(m): 7175 return NonzeroQ(m + S(1)/2) 7176 7177 cons1316 = CustomConstraint(cons_f1316) 7178 7179 def cons_f1317(m, n): 7180 return NegativeIntegerQ(m + n + S(1)) 7181 7182 cons1317 = CustomConstraint(cons_f1317) 7183 7184 def cons_f1318(m, n): 7185 return Not(And(RationalQ(n), Less(m, n, S(-1)))) 7186 7187 cons1318 = CustomConstraint(cons_f1318) 7188 7189 def cons_f1319(m, n): 7190 return Or(FractionQ(m), Not(FractionQ(n))) 7191 7192 cons1319 = CustomConstraint(cons_f1319) 7193 7194 def cons_f1320(b, c, d, e, f, m, x): 7195 if isinstance(x, (int, Integer, float, Float)): 7196 return False 7197 return FreeQ(List(b, c, d, e, f, m), x) 7198 7199 cons1320 = CustomConstraint(cons_f1320) 7200 7201 def cons_f1321(a, b, c, d, m): 7202 return ZeroQ(a*d*m + b*c*(m + S(1))) 7203 7204 cons1321 = CustomConstraint(cons_f1321) 7205 7206 def cons_f1322(m): 7207 return Less(m, S(-1)/2) 7208 7209 cons1322 = CustomConstraint(cons_f1322) 7210 7211 def cons_f1323(m): 7212 return Not(And(RationalQ(m), Less(m, S(-1)/2))) 7213 7214 cons1323 = CustomConstraint(cons_f1323) 7215 7216 def cons_f1324(c, d): 7217 return ZeroQ(c**S(2) - d**S(2)) 7218 7219 cons1324 = CustomConstraint(cons_f1324) 7220 7221 def cons_f1325(c, d): 7222 return NonzeroQ(c**S(2) - d**S(2)) 7223 7224 cons1325 = CustomConstraint(cons_f1325) 7225 7226 def cons_f1326(c, m, n): 7227 return Or(IntegersQ(S(2)*m, S(2)*n), IntegerQ(m + S(1)/2), And(IntegerQ(m), ZeroQ(c))) 7228 7229 cons1326 = CustomConstraint(cons_f1326) 7230 7231 def cons_f1327(n): 7232 return Less(S(0), n, S(1)) 7233 7234 cons1327 = CustomConstraint(cons_f1327) 7235 7236 def cons_f1328(c, m, n): 7237 return Or(IntegersQ(S(2)*m, S(2)*n), And(IntegerQ(m), ZeroQ(c))) 7238 7239 cons1328 = CustomConstraint(cons_f1328) 7240 7241 def cons_f1329(n): 7242 return Not(And(RationalQ(n), Greater(n, S(0)))) 7243 7244 cons1329 = CustomConstraint(cons_f1329) 7245 7246 def cons_f1330(c, n): 7247 return Or(IntegerQ(S(2)*n), ZeroQ(c)) 7248 7249 cons1330 = CustomConstraint(cons_f1330) 7250 7251 def cons_f1331(n): 7252 return NonzeroQ(S(2)*n + S(3)) 7253 7254 cons1331 = CustomConstraint(cons_f1331) 7255 7256 def cons_f1332(a, b, d): 7257 return ZeroQ(-a/b + d) 7258 7259 cons1332 = CustomConstraint(cons_f1332) 7260 7261 def cons_f1333(b, d): 7262 return PositiveQ(d/b) 7263 7264 cons1333 = CustomConstraint(cons_f1333) 7265 7266 def cons_f1334(b, d): 7267 return Not(PositiveQ(d/b)) 7268 7269 cons1334 = CustomConstraint(cons_f1334) 7270 7271 def cons_f1335(m): 7272 return Greater(m, S(2)) 7273 7274 cons1335 = CustomConstraint(cons_f1335) 7275 7276 def cons_f1336(m, n): 7277 return Or(IntegerQ(m), IntegersQ(S(2)*m, S(2)*n)) 7278 7279 cons1336 = CustomConstraint(cons_f1336) 7280 7281 def cons_f1337(a, c, m, n): 7282 return Not(And(IntegerQ(n), Greater(n, S(2)), Or(Not(IntegerQ(m)), And(ZeroQ(a), NonzeroQ(c))))) 7283 7284 cons1337 = CustomConstraint(cons_f1337) 7285 7286 def cons_f1338(n): 7287 return Less(S(1), n, S(2)) 7288 7289 cons1338 = CustomConstraint(cons_f1338) 7290 7291 def cons_f1339(a, m, n): 7292 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))))) 7293 7294 cons1339 = CustomConstraint(cons_f1339) 7295 7296 def cons_f1340(c, d): 7297 return PositiveQ(c + d) 7298 7299 cons1340 = CustomConstraint(cons_f1340) 7300 7301 def cons_f1341(c, d): 7302 return PositiveQ(c - d) 7303 7304 cons1341 = CustomConstraint(cons_f1341) 7305 7306 def cons_f1342(c, d): 7307 return Not(PositiveQ(c + d)) 7308 7309 cons1342 = CustomConstraint(cons_f1342) 7310 7311 def cons_f1343(c, d): 7312 return PositiveQ(c**S(2) - d**S(2)) 7313 7314 cons1343 = CustomConstraint(cons_f1343) 7315 7316 def cons_f1344(b, c, d): 7317 return PosQ((c + d)/b) 7318 7319 cons1344 = CustomConstraint(cons_f1344) 7320 7321 def cons_f1345(c): 7322 return PositiveQ(c**S(2)) 7323 7324 cons1345 = CustomConstraint(cons_f1345) 7325 7326 def cons_f1346(b, c, d): 7327 return NegQ((c + d)/b) 7328 7329 cons1346 = CustomConstraint(cons_f1346) 7330 7331 def cons_f1347(a, b, c, d): 7332 return PosQ((a + b)/(c + d)) 7333 7334 cons1347 = CustomConstraint(cons_f1347) 7335 7336 def cons_f1348(a, b, c, d): 7337 return NegQ((a + b)/(c + d)) 7338 7339 cons1348 = CustomConstraint(cons_f1348) 7340 7341 def cons_f1349(a, b): 7342 return NegativeQ(a**S(2) - b**S(2)) 7343 7344 cons1349 = CustomConstraint(cons_f1349) 7345 7346 def cons_f1350(d): 7347 return ZeroQ(d**S(2) + S(-1)) 7348 7349 cons1350 = CustomConstraint(cons_f1350) 7350 7351 def cons_f1351(b, d): 7352 return PositiveQ(b*d) 7353 7354 cons1351 = CustomConstraint(cons_f1351) 7355 7356 def cons_f1352(b): 7357 return PositiveQ(b**S(2)) 7358 7359 cons1352 = CustomConstraint(cons_f1352) 7360 7361 def cons_f1353(b, d): 7362 return Not(And(ZeroQ(d**S(2) + S(-1)), PositiveQ(b*d))) 7363 7364 cons1353 = CustomConstraint(cons_f1353) 7365 7366 def cons_f1354(a, b, d): 7367 return PosQ((a + b)/d) 7368 7369 cons1354 = CustomConstraint(cons_f1354) 7370 7371 def cons_f1355(a): 7372 return PositiveQ(a**S(2)) 7373 7374 cons1355 = CustomConstraint(cons_f1355) 7375 7376 def cons_f1356(a, b, d): 7377 return NegQ((a + b)/d) 7378 7379 cons1356 = CustomConstraint(cons_f1356) 7380 7381 def cons_f1357(a, b, c, d): 7382 return PosQ((c + d)/(a + b)) 7383 7384 cons1357 = CustomConstraint(cons_f1357) 7385 7386 def cons_f1358(a, b, c, d): 7387 return NegQ((c + d)/(a + b)) 7388 7389 cons1358 = CustomConstraint(cons_f1358) 7390 7391 def cons_f1359(m): 7392 return Less(S(0), m, S(2)) 7393 7394 cons1359 = CustomConstraint(cons_f1359) 7395 7396 def cons_f1360(n): 7397 return Less(S(-1), n, S(2)) 7398 7399 cons1360 = CustomConstraint(cons_f1360) 7400 7401 def cons_f1361(m, n): 7402 return NonzeroQ(m + n) 7403 7404 cons1361 = CustomConstraint(cons_f1361) 7405 7406 def cons_f1362(a, b, c, d, e, f, m, n, x): 7407 if isinstance(x, (int, Integer, float, Float)): 7408 return False 7409 return FreeQ(List(a, b, c, d, e, f, m, n), x) 7410 7411 cons1362 = CustomConstraint(cons_f1362) 7412 7413 def cons_f1363(a, b, n, p): 7414 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))) 7415 7416 cons1363 = CustomConstraint(cons_f1363) 7417 7418 def cons_f1364(n, p): 7419 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)) 7420 7421 cons1364 = CustomConstraint(cons_f1364) 7422 7423 def cons_f1365(a, b, d, e, f, g, n, p, x): 7424 if isinstance(x, (int, Integer, float, Float)): 7425 return False 7426 return FreeQ(List(a, b, d, e, f, g, n, p), x) 7427 7428 cons1365 = CustomConstraint(cons_f1365) 7429 7430 def cons_f1366(m, n): 7431 return Not(And(IntegerQ(n), Less(n**S(2), m**S(2)))) 7432 7433 cons1366 = CustomConstraint(cons_f1366) 7434 7435 def cons_f1367(n, p): 7436 return NonzeroQ(S(2)*n + p + S(1)) 7437 7438 cons1367 = CustomConstraint(cons_f1367) 7439 7440 def cons_f1368(m, n, p): 7441 return Not(And(NegativeIntegerQ(m + n + p), Greater(S(2)*m + n + S(3)*p/S(2) + S(1), S(0)))) 7442 7443 cons1368 = CustomConstraint(cons_f1368) 7444 7445 def cons_f1369(m, n, p): 7446 return Not(And(PositiveIntegerQ(n + p/S(2) + S(-1)/2), Greater(m - n, S(0)))) 7447 7448 cons1369 = CustomConstraint(cons_f1369) 7449 7450 def cons_f1370(m, p): 7451 return ZeroQ(S(2)*m + p + S(1)) 7452 7453 cons1370 = CustomConstraint(cons_f1370) 7454 7455 def cons_f1371(m, n, p): 7456 return ZeroQ(m + n + p + S(1)) 7457 7458 cons1371 = CustomConstraint(cons_f1371) 7459 7460 def cons_f1372(m, n, p): 7461 return NegativeIntegerQ(m + n + p + S(1)) 7462 7463 cons1372 = CustomConstraint(cons_f1372) 7464 7465 def cons_f1373(m, n, p): 7466 return NonzeroQ(m + n + p) 7467 7468 cons1373 = CustomConstraint(cons_f1373) 7469 7470 def cons_f1374(m, n): 7471 return Not(And(RationalQ(n), Less(S(0), n, m))) 7472 7473 cons1374 = CustomConstraint(cons_f1374) 7474 7475 def cons_f1375(a, b, c, d, m, p): 7476 return ZeroQ(a*d*m + b*c*(m + p + S(1))) 7477 7478 cons1375 = CustomConstraint(cons_f1375) 7479 7480 def cons_f1376(m): 7481 return Greater(m, S(-1)) 7482 7483 cons1376 = CustomConstraint(cons_f1376) 7484 7485 def cons_f1377(m, p): 7486 return PositiveIntegerQ(m + p/S(2) + S(1)/2) 7487 7488 cons1377 = CustomConstraint(cons_f1377) 7489 7490 def cons_f1378(m): 7491 return Less(m, S(-3)/2) 7492 7493 cons1378 = CustomConstraint(cons_f1378) 7494 7495 def cons_f1379(m): 7496 return Inequality(S(-3)/2, LessEqual, m, Less, S(0)) 7497 7498 cons1379 = CustomConstraint(cons_f1379) 7499 7500 def cons_f1380(m, p): 7501 return Or(And(RationalQ(m), Less(m, S(-1))), NegativeIntegerQ(m + p)) 7502 7503 cons1380 = CustomConstraint(cons_f1380) 7504 7505 def cons_f1381(p): 7506 return Not(And(RationalQ(p), Less(p, S(-1)))) 7507 7508 cons1381 = CustomConstraint(cons_f1381) 7509 7510 def cons_f1382(m, p): 7511 return Equal(S(2)*m + p, S(0)) 7512 7513 cons1382 = CustomConstraint(cons_f1382) 7514 7515 def cons_f1383(m, n, p): 7516 return IntegersQ(m, n, p/S(2)) 7517 7518 cons1383 = CustomConstraint(cons_f1383) 7519 7520 def cons_f1384(m, n, p): 7521 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)))) 7522 7523 cons1384 = CustomConstraint(cons_f1384) 7524 7525 def cons_f1385(m, n): 7526 return Or(NegativeIntegerQ(m), Not(PositiveIntegerQ(n))) 7527 7528 cons1385 = CustomConstraint(cons_f1385) 7529 7530 def cons_f1386(m, p): 7531 return Or(Equal(S(2)*m + p, S(0)), And(Greater(S(2)*m + p, S(0)), Less(p, S(-1)))) 7532 7533 cons1386 = CustomConstraint(cons_f1386) 7534 7535 def cons_f1387(m): 7536 return LessEqual(m, S(-1)/2) 7537 7538 cons1387 = CustomConstraint(cons_f1387) 7539 7540 def cons_f1388(m, p): 7541 return NonzeroQ(m + p + S(2)) 7542 7543 cons1388 = CustomConstraint(cons_f1388) 7544 7545 def cons_f1389(n, p): 7546 return Or(IntegerQ(p), PositiveIntegerQ(n)) 7547 7548 cons1389 = CustomConstraint(cons_f1389) 7549 7550 def cons_f1390(m, p): 7551 return ZeroQ(m + p + S(1)/2) 7552 7553 cons1390 = CustomConstraint(cons_f1390) 7554 7555 def cons_f1391(m, p): 7556 return ZeroQ(m + p + S(3)/2) 7557 7558 cons1391 = CustomConstraint(cons_f1391) 7559 7560 def cons_f1392(m, n): 7561 return Or(PositiveIntegerQ(m), IntegersQ(S(2)*m, S(2)*n)) 7562 7563 cons1392 = CustomConstraint(cons_f1392) 7564 7565 def cons_f1393(n): 7566 return Not(Less(n, S(-1))) 7567 7568 cons1393 = CustomConstraint(cons_f1393) 7569 7570 def cons_f1394(m, n): 7571 return Or(Less(m, S(-2)), ZeroQ(m + n + S(4))) 7572 7573 cons1394 = CustomConstraint(cons_f1394) 7574 7575 def cons_f1395(m, n): 7576 return NonzeroQ(m + n + S(4)) 7577 7578 cons1395 = CustomConstraint(cons_f1395) 7579 7580 def cons_f1396(m, n): 7581 return Or(Less(n, S(-2)), ZeroQ(m + n + S(4))) 7582 7583 cons1396 = CustomConstraint(cons_f1396) 7584 7585 def cons_f1397(n): 7586 return NonzeroQ(n + S(2)) 7587 7588 cons1397 = CustomConstraint(cons_f1397) 7589 7590 def cons_f1398(m, n): 7591 return NonzeroQ(m + n + S(5)) 7592 7593 cons1398 = CustomConstraint(cons_f1398) 7594 7595 def cons_f1399(m, n): 7596 return NonzeroQ(m + n + S(6)) 7597 7598 cons1399 = CustomConstraint(cons_f1399) 7599 7600 def cons_f1400(m, n, p): 7601 return IntegersQ(m, S(2)*n, p/S(2)) 7602 7603 cons1400 = CustomConstraint(cons_f1400) 7604 7605 def cons_f1401(m, p): 7606 return Or(Less(m, S(-1)), And(Equal(m, S(-1)), Greater(p, S(0)))) 7607 7608 cons1401 = CustomConstraint(cons_f1401) 7609 7610 def cons_f1402(n, p): 7611 return Or(Less(n, S(0)), PositiveIntegerQ(p + S(1)/2)) 7612 7613 cons1402 = CustomConstraint(cons_f1402) 7614 7615 def cons_f1403(n, p): 7616 return IntegersQ(S(2)*n, S(2)*p) 7617 7618 cons1403 = CustomConstraint(cons_f1403) 7619 7620 def cons_f1404(n, p): 7621 return Or(LessEqual(n, S(-2)), And(Equal(n, S(-3)/2), Equal(p, S(3)/2))) 7622 7623 cons1404 = CustomConstraint(cons_f1404) 7624 7625 def cons_f1405(n, p): 7626 return Or(Less(n, S(-1)), And(Equal(p, S(3)/2), Equal(n, S(-1)/2))) 7627 7628 cons1405 = CustomConstraint(cons_f1405) 7629 7630 def cons_f1406(p): 7631 return Less(S(-1), p, S(1)) 7632 7633 cons1406 = CustomConstraint(cons_f1406) 7634 7635 def cons_f1407(m, n): 7636 return Or(Greater(m, S(0)), IntegerQ(n)) 7637 7638 cons1407 = CustomConstraint(cons_f1407) 7639 7640 def cons_f1408(m, n, p): 7641 return IntegersQ(m, S(2)*n, S(2)*p) 7642 7643 cons1408 = CustomConstraint(cons_f1408) 7644 7645 def cons_f1409(m, n, p): 7646 return Or(LessEqual(n, S(-2)), And(Equal(m, S(-1)), Equal(n, S(-3)/2), Equal(p, S(3)/2))) 7647 7648 cons1409 = CustomConstraint(cons_f1409) 7649 7650 def cons_f1410(p): 7651 return PositiveIntegerQ(p/S(2)) 7652 7653 cons1410 = CustomConstraint(cons_f1410) 7654 7655 def cons_f1411(a, b, c, d): 7656 return Or(ZeroQ(a**S(2) - b**S(2)), ZeroQ(c**S(2) - d**S(2))) 7657 7658 cons1411 = CustomConstraint(cons_f1411) 7659 7660 def cons_f1412(c, d): 7661 return ZeroQ(-c + d) 7662 7663 cons1412 = CustomConstraint(cons_f1412) 7664 7665 def cons_f1413(a, b): 7666 return PositiveQ(-a**S(2) + b**S(2)) 7667 7668 cons1413 = CustomConstraint(cons_f1413) 7669 7670 def cons_f1414(a, b, c, d): 7671 return NonzeroQ(a*d + b*c) 7672 7673 cons1414 = CustomConstraint(cons_f1414) 7674 7675 def cons_f1415(a, b, c, d): 7676 return Or(NonzeroQ(a**S(2) - b**S(2)), NonzeroQ(c**S(2) - d**S(2))) 7677 7678 cons1415 = CustomConstraint(cons_f1415) 7679 7680 def cons_f1416(n, p): 7681 return ZeroQ(S(2)*n + p) 7682 7683 cons1416 = CustomConstraint(cons_f1416) 7684 7685 def cons_f1417(m, n, p): 7686 return Or(IntegersQ(m, n), IntegersQ(m, p), IntegersQ(n, p)) 7687 7688 cons1417 = CustomConstraint(cons_f1417) 7689 7690 def cons_f1418(p): 7691 return NonzeroQ(p + S(-2)) 7692 7693 cons1418 = CustomConstraint(cons_f1418) 7694 7695 def cons_f1419(m, n): 7696 return Not(And(IntegerQ(m), IntegerQ(n))) 7697 7698 cons1419 = CustomConstraint(cons_f1419) 7699 7700 def cons_f1420(A, B, a, b): 7701 return ZeroQ(A*b + B*a) 7702 7703 cons1420 = CustomConstraint(cons_f1420) 7704 7705 def cons_f1421(A, B, a, b, m, n): 7706 return ZeroQ(A*b*(m + n + S(1)) + B*a*(m - n)) 7707 7708 cons1421 = CustomConstraint(cons_f1421) 7709 7710 def cons_f1422(m, n): 7711 return Or(And(RationalQ(m), Less(m, S(-1)/2)), And(NegativeIntegerQ(m + n), Not(SumSimplerQ(n, S(1))))) 7712 7713 cons1422 = CustomConstraint(cons_f1422) 7714 7715 def cons_f1423(m): 7716 return NonzeroQ(S(2)*m + S(1)) 7717 7718 cons1423 = CustomConstraint(cons_f1423) 7719 7720 def cons_f1424(A, B, a, b, c, d, m, n): 7721 return ZeroQ(A*(a*d*m + b*c*(n + S(1))) - B*(a*c*m + b*d*(n + S(1)))) 7722 7723 cons1424 = CustomConstraint(cons_f1424) 7724 7725 def cons_f1425(m): 7726 return Greater(m, S(1)/2) 7727 7728 cons1425 = CustomConstraint(cons_f1425) 7729 7730 def cons_f1426(A, B, a, b, c, d, n): 7731 return ZeroQ(A*b*d*(S(2)*n + S(3)) - B*(-S(2)*a*d*(n + S(1)) + b*c)) 7732 7733 cons1426 = CustomConstraint(cons_f1426) 7734 7735 def cons_f1427(m, n): 7736 return Or(IntegerQ(n), ZeroQ(m + S(1)/2)) 7737 7738 cons1427 = CustomConstraint(cons_f1427) 7739 7740 def cons_f1428(A, B, a, b): 7741 return NonzeroQ(A*b + B*a) 7742 7743 cons1428 = CustomConstraint(cons_f1428) 7744 7745 def cons_f1429(a, c, m, n): 7746 return Not(And(IntegerQ(n), Greater(n, S(1)), Or(Not(IntegerQ(m)), And(ZeroQ(a), NonzeroQ(c))))) 7747 7748 cons1429 = CustomConstraint(cons_f1429) 7749 7750 def cons_f1430(A, B): 7751 return ZeroQ(A - B) 7752 7753 cons1430 = CustomConstraint(cons_f1430) 7754 7755 def cons_f1431(A, B): 7756 return NonzeroQ(A - B) 7757 7758 cons1431 = CustomConstraint(cons_f1431) 7759 7760 def cons_f1432(n): 7761 return Equal(n**S(2), S(1)/4) 7762 7763 cons1432 = CustomConstraint(cons_f1432) 7764 7765 def cons_f1433(B, C, b, e, f, m, x): 7766 if isinstance(x, (int, Integer, float, Float)): 7767 return False 7768 return FreeQ(List(b, e, f, B, C, m), x) 7769 7770 cons1433 = CustomConstraint(cons_f1433) 7771 7772 def cons_f1434(A, C, m): 7773 return ZeroQ(A*(m + S(2)) + C*(m + S(1))) 7774 7775 cons1434 = CustomConstraint(cons_f1434) 7776 7777 def cons_f1435(A, C, a, b): 7778 return ZeroQ(A*b**S(2) + C*a**S(2)) 7779 7780 cons1435 = CustomConstraint(cons_f1435) 7781 7782 def cons_f1436(A, B, C): 7783 return ZeroQ(A - B + C) 7784 7785 cons1436 = CustomConstraint(cons_f1436) 7786 7787 def cons_f1437(A, C): 7788 return ZeroQ(A + C) 7789 7790 cons1437 = CustomConstraint(cons_f1437) 7791 7792 def cons_f1438(m, n): 7793 return Or(And(RationalQ(m), Less(m, S(-1)/2)), And(ZeroQ(m + n + S(2)), NonzeroQ(S(2)*m + S(1)))) 7794 7795 cons1438 = CustomConstraint(cons_f1438) 7796 7797 def cons_f1439(m, n): 7798 return Or(And(RationalQ(n), Less(n, S(-1))), ZeroQ(m + n + S(2))) 7799 7800 cons1439 = CustomConstraint(cons_f1439) 7801 7802 def cons_f1440(a, c, m, n): 7803 return Not(And(IntegerQ(n), Greater(n, S(0)), Or(Not(IntegerQ(m)), And(ZeroQ(a), NonzeroQ(c))))) 7804 7805 cons1440 = CustomConstraint(cons_f1440) 7806 7807 def cons_f1441(a, b): 7808 return ZeroQ(a**S(2) + b**S(2)) 7809 7810 cons1441 = CustomConstraint(cons_f1441) 7811 7812 def cons_f1442(a, b): 7813 return NonzeroQ(a**S(2) + b**S(2)) 7814 7815 cons1442 = CustomConstraint(cons_f1442) 7816 7817 def cons_f1443(n): 7818 return Not(OddQ(n)) 7819 7820 cons1443 = CustomConstraint(cons_f1443) 7821 7822 def cons_f1444(n): 7823 return Unequal(n, S(-2)) 7824 7825 cons1444 = CustomConstraint(cons_f1444) 7826 7827 def cons_f1445(n): 7828 return Not(And(RationalQ(n), Or(GreaterEqual(n, S(1)), LessEqual(n, S(-1))))) 7829 7830 cons1445 = CustomConstraint(cons_f1445) 7831 7832 def cons_f1446(a, b): 7833 return PositiveQ(a**S(2) + b**S(2)) 7834 7835 cons1446 = CustomConstraint(cons_f1446) 7836 7837 def cons_f1447(a, b): 7838 return Not(Or(PositiveQ(a**S(2) + b**S(2)), ZeroQ(a**S(2) + b**S(2)))) 7839 7840 cons1447 = CustomConstraint(cons_f1447) 7841 7842 def cons_f1448(m, n): 7843 return IntegerQ(m/S(2) + n/S(2)) 7844 7845 cons1448 = CustomConstraint(cons_f1448) 7846 7847 def cons_f1449(m, n): 7848 return Not(And(Greater(n, S(0)), Greater(m, S(1)))) 7849 7850 cons1449 = CustomConstraint(cons_f1449) 7851 7852 def cons_f1450(a, b, c): 7853 return ZeroQ(a**S(2) - b**S(2) - c**S(2)) 7854 7855 cons1450 = CustomConstraint(cons_f1450) 7856 7857 def cons_f1451(b, c): 7858 return ZeroQ(b**S(2) + c**S(2)) 7859 7860 cons1451 = CustomConstraint(cons_f1451) 7861 7862 def cons_f1452(b, c): 7863 return NonzeroQ(b**S(2) + c**S(2)) 7864 7865 cons1452 = CustomConstraint(cons_f1452) 7866 7867 def cons_f1453(a, b, c): 7868 return PositiveQ(a + sqrt(b**S(2) + c**S(2))) 7869 7870 cons1453 = CustomConstraint(cons_f1453) 7871 7872 def cons_f1454(a, b, c): 7873 return NonzeroQ(a**S(2) - b**S(2) - c**S(2)) 7874 7875 cons1454 = CustomConstraint(cons_f1454) 7876 7877 def cons_f1455(a, b, c): 7878 return Not(PositiveQ(a + sqrt(b**S(2) + c**S(2)))) 7879 7880 cons1455 = CustomConstraint(cons_f1455) 7881 7882 def cons_f1456(a, b): 7883 return ZeroQ(a + b) 7884 7885 cons1456 = CustomConstraint(cons_f1456) 7886 7887 def cons_f1457(a, c): 7888 return ZeroQ(a - c) 7889 7890 cons1457 = CustomConstraint(cons_f1457) 7891 7892 def cons_f1458(a, b): 7893 return NonzeroQ(a - b) 7894 7895 cons1458 = CustomConstraint(cons_f1458) 7896 7897 def cons_f1459(n): 7898 return Unequal(n, S(-3)/2) 7899 7900 cons1459 = CustomConstraint(cons_f1459) 7901 7902 def cons_f1460(A, B, C, a, b, c): 7903 return ZeroQ(A*(b**S(2) + c**S(2)) - a*(B*b + C*c)) 7904 7905 cons1460 = CustomConstraint(cons_f1460) 7906 7907 def cons_f1461(A, C, a, b, c): 7908 return ZeroQ(A*(b**S(2) + c**S(2)) - C*a*c) 7909 7910 cons1461 = CustomConstraint(cons_f1461) 7911 7912 def cons_f1462(A, B, a, b, c): 7913 return ZeroQ(A*(b**S(2) + c**S(2)) - B*a*b) 7914 7915 cons1462 = CustomConstraint(cons_f1462) 7916 7917 def cons_f1463(A, B, C, a, b, c): 7918 return NonzeroQ(A*(b**S(2) + c**S(2)) - a*(B*b + C*c)) 7919 7920 cons1463 = CustomConstraint(cons_f1463) 7921 7922 def cons_f1464(A, C, a, b, c): 7923 return NonzeroQ(A*(b**S(2) + c**S(2)) - C*a*c) 7924 7925 cons1464 = CustomConstraint(cons_f1464) 7926 7927 def cons_f1465(A, B, a, b, c): 7928 return NonzeroQ(A*(b**S(2) + c**S(2)) - B*a*b) 7929 7930 cons1465 = CustomConstraint(cons_f1465) 7931 7932 def cons_f1466(A, B, C, a, b, c, n): 7933 return ZeroQ(A*a*(n + S(1)) + n*(B*b + C*c)) 7934 7935 cons1466 = CustomConstraint(cons_f1466) 7936 7937 def cons_f1467(A, C, a, c, n): 7938 return ZeroQ(A*a*(n + S(1)) + C*c*n) 7939 7940 cons1467 = CustomConstraint(cons_f1467) 7941 7942 def cons_f1468(A, B, a, b, n): 7943 return ZeroQ(A*a*(n + S(1)) + B*b*n) 7944 7945 cons1468 = CustomConstraint(cons_f1468) 7946 7947 def cons_f1469(A, B, C, a, b, c, n): 7948 return NonzeroQ(A*a*(n + S(1)) + n*(B*b + C*c)) 7949 7950 cons1469 = CustomConstraint(cons_f1469) 7951 7952 def cons_f1470(A, C, a, c, n): 7953 return NonzeroQ(A*a*(n + S(1)) + C*c*n) 7954 7955 cons1470 = CustomConstraint(cons_f1470) 7956 7957 def cons_f1471(A, B, a, b, n): 7958 return NonzeroQ(A*a*(n + S(1)) + B*b*n) 7959 7960 cons1471 = CustomConstraint(cons_f1471) 7961 7962 def cons_f1472(B, C, b, c): 7963 return ZeroQ(B*b + C*c) 7964 7965 cons1472 = CustomConstraint(cons_f1472) 7966 7967 def cons_f1473(B, C, b, c): 7968 return ZeroQ(B*c - C*b) 7969 7970 cons1473 = CustomConstraint(cons_f1473) 7971 7972 def cons_f1474(A, B, C, a, b, c): 7973 return ZeroQ(A*a - B*b - C*c) 7974 7975 cons1474 = CustomConstraint(cons_f1474) 7976 7977 def cons_f1475(A, C, a, c): 7978 return ZeroQ(A*a - C*c) 7979 7980 cons1475 = CustomConstraint(cons_f1475) 7981 7982 def cons_f1476(A, B, a, b): 7983 return ZeroQ(A*a - B*b) 7984 7985 cons1476 = CustomConstraint(cons_f1476) 7986 7987 def cons_f1477(A, B, C, a, b, c): 7988 return NonzeroQ(A*a - B*b - C*c) 7989 7990 cons1477 = CustomConstraint(cons_f1477) 7991 7992 def cons_f1478(A, C, a, c): 7993 return NonzeroQ(A*a - C*c) 7994 7995 cons1478 = CustomConstraint(cons_f1478) 7996 7997 def cons_f1479(A, B, a, b): 7998 return NonzeroQ(A*a - B*b) 7999 8000 cons1479 = CustomConstraint(cons_f1479) 8001 8002 def cons_f1480(a, b): 8003 return NonzeroQ(a + b) 8004 8005 cons1480 = CustomConstraint(cons_f1480) 8006 8007 def cons_f1481(n): 8008 return EvenQ(n) 8009 8010 cons1481 = CustomConstraint(cons_f1481) 8011 8012 def cons_f1482(m): 8013 return EvenQ(m) 8014 8015 cons1482 = CustomConstraint(cons_f1482) 8016 8017 def cons_f1483(m): 8018 return OddQ(m) 8019 8020 cons1483 = CustomConstraint(cons_f1483) 8021 8022 def cons_f1484(n): 8023 return OddQ(n) 8024 8025 cons1484 = CustomConstraint(cons_f1484) 8026 8027 def cons_f1485(m): 8028 return Not(OddQ(m)) 8029 8030 cons1485 = CustomConstraint(cons_f1485) 8031 8032 def cons_f1486(p): 8033 return EvenQ(p) 8034 8035 cons1486 = CustomConstraint(cons_f1486) 8036 8037 def cons_f1487(q): 8038 return EvenQ(q) 8039 8040 cons1487 = CustomConstraint(cons_f1487) 8041 8042 def cons_f1488(p, q): 8043 return Inequality(S(0), Less, p, LessEqual, q) 8044 8045 cons1488 = CustomConstraint(cons_f1488) 8046 8047 def cons_f1489(p, q): 8048 return Less(S(0), q, p) 8049 8050 cons1489 = CustomConstraint(cons_f1489) 8051 8052 def cons_f1490(c, d, e, f, m, x): 8053 if isinstance(x, (int, Integer, float, Float)): 8054 return False 8055 return FreeQ(List(c, d, e, f, m), x) 8056 8057 cons1490 = CustomConstraint(cons_f1490) 8058 8059 def cons_f1491(m): 8060 return Or(Not(RationalQ(m)), Inequality(S(-1), LessEqual, m, Less, S(1))) 8061 8062 cons1491 = CustomConstraint(cons_f1491) 8063 8064 def cons_f1492(a, b, m, n): 8065 return Or(Equal(n, S(1)), PositiveIntegerQ(m), NonzeroQ(a**S(2) - b**S(2))) 8066 8067 cons1492 = CustomConstraint(cons_f1492) 8068 8069 def cons_f1493(m, n): 8070 return Or(Greater(n, S(0)), PositiveIntegerQ(m)) 8071 8072 cons1493 = CustomConstraint(cons_f1493) 8073 8074 def cons_f1494(a, b): 8075 return ZeroQ(a - b) 8076 8077 cons1494 = CustomConstraint(cons_f1494) 8078 8079 def cons_f1495(n): 8080 return NegativeIntegerQ(n + S(2)) 8081 8082 cons1495 = CustomConstraint(cons_f1495) 8083 8084 def cons_f1496(n, p): 8085 return Or(Equal(n, S(2)), Equal(p, S(-1))) 8086 8087 cons1496 = CustomConstraint(cons_f1496) 8088 8089 def cons_f1497(a, b, c, d, n, p, x): 8090 if isinstance(x, (int, Integer, float, Float)): 8091 return False 8092 return FreeQ(List(a, b, c, d, n, p), x) 8093 8094 cons1497 = CustomConstraint(cons_f1497) 8095 8096 def cons_f1498(m, n): 8097 return Or(Greater(m - n + S(1), S(0)), Greater(n, S(2))) 8098 8099 cons1498 = CustomConstraint(cons_f1498) 8100 8101 def cons_f1499(a, b, c, d, e, m, n, p, x): 8102 if isinstance(x, (int, Integer, float, Float)): 8103 return False 8104 return FreeQ(List(a, b, c, d, e, m, n, p), x) 8105 8106 cons1499 = CustomConstraint(cons_f1499) 8107 8108 def cons_f1500(c, d, n, x): 8109 if isinstance(x, (int, Integer, float, Float)): 8110 return False 8111 return FreeQ(List(c, d, n), x) 8112 8113 cons1500 = CustomConstraint(cons_f1500) 8114 8115 def cons_f1501(d, n, x): 8116 if isinstance(x, (int, Integer, float, Float)): 8117 return False 8118 return FreeQ(List(d, n), x) 8119 8120 cons1501 = CustomConstraint(cons_f1501) 8121 8122 def cons_f1502(m, n): 8123 return ZeroQ(m - n/S(2) + S(1)) 8124 8125 cons1502 = CustomConstraint(cons_f1502) 8126 8127 def cons_f1503(m, n): 8128 return Less(S(0), n, m + S(1)) 8129 8130 cons1503 = CustomConstraint(cons_f1503) 8131 8132 def cons_f1504(n): 8133 return NonzeroQ(n + S(-1)) 8134 8135 cons1504 = CustomConstraint(cons_f1504) 8136 8137 def cons_f1505(m, n): 8138 return Less(S(0), S(2)*n, m + S(1)) 8139 8140 cons1505 = CustomConstraint(cons_f1505) 8141 8142 def cons_f1506(m, n): 8143 return Less(S(0), S(2)*n, S(1) - m) 8144 8145 cons1506 = CustomConstraint(cons_f1506) 8146 8147 def cons_f1507(p): 8148 return Unequal(p, S(-2)) 8149 8150 cons1507 = CustomConstraint(cons_f1507) 8151 8152 def cons_f1508(c, d, e, m, n, x): 8153 if isinstance(x, (int, Integer, float, Float)): 8154 return False 8155 return FreeQ(List(c, d, e, m, n), x) 8156 8157 cons1508 = CustomConstraint(cons_f1508) 8158 8159 def cons_f1509(a, b, c, d, e, m, x): 8160 if isinstance(x, (int, Integer, float, Float)): 8161 return False 8162 return FreeQ(List(a, b, c, d, e, m), x) 8163 8164 cons1509 = CustomConstraint(cons_f1509) 8165 8166 def cons_f1510(m, n): 8167 return ZeroQ(m + n + S(-1)) 8168 8169 cons1510 = CustomConstraint(cons_f1510) 8170 8171 def cons_f1511(m, n): 8172 return IntegersQ(m, n, m/S(2) + n/S(2) + S(-1)/2) 8173 8174 cons1511 = CustomConstraint(cons_f1511) 8175 8176 def cons_f1512(m): 8177 return Unequal(m, S(-2)) 8178 8179 cons1512 = CustomConstraint(cons_f1512) 8180 8181 def cons_f1513(m): 8182 return Not(And(RationalQ(m), Greater(m, S(1)), Not(IntegerQ(m/S(2) + S(-1)/2)))) 8183 8184 cons1513 = CustomConstraint(cons_f1513) 8185 8186 def cons_f1514(n): 8187 return IntegerQ(n/S(2) + S(1)/2) 8188 8189 cons1514 = CustomConstraint(cons_f1514) 8190 8191 def cons_f1515(m, n): 8192 return Not(IntegersQ(S(2)*m, S(2)*n)) 8193 8194 cons1515 = CustomConstraint(cons_f1515) 8195 8196 def cons_f1516(m, n): 8197 return Not(And(IntegerQ(m/S(2)), Less(S(0), m, n + S(1)))) 8198 8199 cons1516 = CustomConstraint(cons_f1516) 8200 8201 def cons_f1517(m): 8202 return IntegerQ(m/S(2)) 8203 8204 cons1517 = CustomConstraint(cons_f1517) 8205 8206 def cons_f1518(m, n): 8207 return Not(And(IntegerQ(n/S(2) + S(-1)/2), Less(S(0), n, m + S(-1)))) 8208 8209 cons1518 = CustomConstraint(cons_f1518) 8210 8211 def cons_f1519(m, n): 8212 return Or(Greater(m, S(1)), And(Equal(m, S(1)), Equal(n, S(-3)/2))) 8213 8214 cons1519 = CustomConstraint(cons_f1519) 8215 8216 def cons_f1520(m, n): 8217 return Or(Less(m, S(-1)), And(Equal(m, S(-1)), Equal(n, S(3)/2))) 8218 8219 cons1520 = CustomConstraint(cons_f1520) 8220 8221 def cons_f1521(m, n): 8222 return NonzeroQ(m + n + S(-1)) 8223 8224 cons1521 = CustomConstraint(cons_f1521) 8225 8226 def cons_f1522(m, n): 8227 return Or(Less(m, S(-1)), And(Equal(m, S(-1)), RationalQ(n), Equal(n, S(-1)/2))) 8228 8229 cons1522 = CustomConstraint(cons_f1522) 8230 8231 def cons_f1523(m, n): 8232 return Or(Greater(m, S(1)), And(Equal(m, S(1)), RationalQ(n), Equal(n, S(1)/2))) 8233 8234 cons1523 = CustomConstraint(cons_f1523) 8235 8236 def cons_f1524(b, e, f, x): 8237 if isinstance(x, (int, Integer, float, Float)): 8238 return False 8239 return FreeQ(List(b, e, f), x) 8240 8241 cons1524 = CustomConstraint(cons_f1524) 8242 8243 def cons_f1525(n): 8244 return Not(IntegerQ(n/S(2) + S(-1)/2)) 8245 8246 cons1525 = CustomConstraint(cons_f1525) 8247 8248 def cons_f1526(m): 8249 return Not(IntegerQ(m/S(2))) 8250 8251 cons1526 = CustomConstraint(cons_f1526) 8252 8253 def cons_f1527(m, n, p): 8254 return NonzeroQ(m*p + n + S(-1)) 8255 8256 cons1527 = CustomConstraint(cons_f1527) 8257 8258 def cons_f1528(m, n, p): 8259 return IntegersQ(S(2)*m*p, S(2)*n) 8260 8261 cons1528 = CustomConstraint(cons_f1528) 8262 8263 def cons_f1529(m, n, p): 8264 return NonzeroQ(m*p + n + S(1)) 8265 8266 cons1529 = CustomConstraint(cons_f1529) 8267 8268 def cons_f1530(a, b, m): 8269 return Or(IntegerQ(S(2)*m), NonzeroQ(a**S(2) + b**S(2))) 8270 8271 cons1530 = CustomConstraint(cons_f1530) 8272 8273 def cons_f1531(m, n): 8274 return ZeroQ(m/S(2) + n) 8275 8276 cons1531 = CustomConstraint(cons_f1531) 8277 8278 def cons_f1532(m, n): 8279 return ZeroQ(m/S(2) + n + S(-1)) 8280 8281 cons1532 = CustomConstraint(cons_f1532) 8282 8283 def cons_f1533(m, n): 8284 return PositiveIntegerQ(m/S(2) + n + S(-1)) 8285 8286 cons1533 = CustomConstraint(cons_f1533) 8287 8288 def cons_f1534(m, n): 8289 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))) 8290 8291 cons1534 = CustomConstraint(cons_f1534) 8292 8293 def cons_f1535(m, n): 8294 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))) 8295 8296 cons1535 = CustomConstraint(cons_f1535) 8297 8298 def cons_f1536(m, n): 8299 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)))) 8300 8301 cons1536 = CustomConstraint(cons_f1536) 8302 8303 def cons_f1537(m, n): 8304 return Not(NegativeIntegerQ(m + n)) 8305 8306 cons1537 = CustomConstraint(cons_f1537) 8307 8308 def cons_f1538(m, n): 8309 return NonzeroQ(m + S(2)*n) 8310 8311 cons1538 = CustomConstraint(cons_f1538) 8312 8313 def cons_f1539(m, n): 8314 return PositiveIntegerQ(m + n + S(-1)) 8315 8316 cons1539 = CustomConstraint(cons_f1539) 8317 8318 def cons_f1540(m, n): 8319 return NegativeIntegerQ(m + n) 8320 8321 cons1540 = CustomConstraint(cons_f1540) 8322 8323 def cons_f1541(m): 8324 return PositiveIntegerQ(m + S(-1)) 8325 8326 cons1541 = CustomConstraint(cons_f1541) 8327 8328 def cons_f1542(m, n): 8329 return Or(And(Less(m, S(5)), Greater(n, S(-4))), And(Equal(m, S(5)), Equal(n, S(-1)))) 8330 8331 cons1542 = CustomConstraint(cons_f1542) 8332 8333 def cons_f1543(m, n): 8334 return Not(And(IntegerQ(n), Greater(n, S(0)), Or(Less(m, S(0)), Less(n, m)))) 8335 8336 cons1543 = CustomConstraint(cons_f1543) 8337 8338 def cons_f1544(a, b, c, d): 8339 return ZeroQ(a*c + b*d) 8340 8341 cons1544 = CustomConstraint(cons_f1544) 8342 8343 def cons_f1545(a, b, c, d): 8344 return NonzeroQ(a*c + b*d) 8345 8346 cons1545 = CustomConstraint(cons_f1545) 8347 8348 def cons_f1546(c, d): 8349 return ZeroQ(c**S(2) + d**S(2)) 8350 8351 cons1546 = CustomConstraint(cons_f1546) 8352 8353 def cons_f1547(c, d): 8354 return NonzeroQ(c**S(2) + d**S(2)) 8355 8356 cons1547 = CustomConstraint(cons_f1547) 8357 8358 def cons_f1548(a, b, c, d): 8359 return ZeroQ(S(2)*a*c*d - b*(c**S(2) - d**S(2))) 8360 8361 cons1548 = CustomConstraint(cons_f1548) 8362 8363 def cons_f1549(a, b, c, d): 8364 return NonzeroQ(S(2)*a*c*d - b*(c**S(2) - d**S(2))) 8365 8366 cons1549 = CustomConstraint(cons_f1549) 8367 8368 def cons_f1550(a, b, c, d): 8369 return Or(PerfectSquareQ(a**S(2) + b**S(2)), RationalQ(a, b, c, d)) 8370 8371 cons1550 = CustomConstraint(cons_f1550) 8372 8373 def cons_f1551(m): 8374 return Not(And(RationalQ(m), LessEqual(m, S(-1)))) 8375 8376 cons1551 = CustomConstraint(cons_f1551) 8377 8378 def cons_f1552(a, m): 8379 return Not(And(ZeroQ(m + S(-2)), ZeroQ(a))) 8380 8381 cons1552 = CustomConstraint(cons_f1552) 8382 8383 def cons_f1553(m, n): 8384 return Equal(m + n, S(0)) 8385 8386 cons1553 = CustomConstraint(cons_f1553) 8387 8388 def cons_f1554(m): 8389 return IntegersQ(S(2)*m) 8390 8391 cons1554 = CustomConstraint(cons_f1554) 8392 8393 def cons_f1555(m, n): 8394 return Or(IntegerQ(n), IntegersQ(S(2)*m, S(2)*n)) 8395 8396 cons1555 = CustomConstraint(cons_f1555) 8397 8398 def cons_f1556(m, n): 8399 return Or(And(RationalQ(n), GreaterEqual(n, S(-1))), IntegerQ(m)) 8400 8401 cons1556 = CustomConstraint(cons_f1556) 8402 8403 def cons_f1557(a, c, m, n): 8404 return Not(And(IntegerQ(n), Greater(n, S(2)), Or(Not(IntegerQ(m)), And(ZeroQ(c), NonzeroQ(a))))) 8405 8406 cons1557 = CustomConstraint(cons_f1557) 8407 8408 def cons_f1558(m, n): 8409 return Or(And(RationalQ(n), Less(n, S(0))), IntegerQ(m)) 8410 8411 cons1558 = CustomConstraint(cons_f1558) 8412 8413 def cons_f1559(a, c, m, n): 8414 return Not(And(IntegerQ(n), Less(n, S(-1)), Or(Not(IntegerQ(m)), And(ZeroQ(c), NonzeroQ(a))))) 8415 8416 cons1559 = CustomConstraint(cons_f1559) 8417 8418 def cons_f1560(A, B): 8419 return ZeroQ(A**S(2) + B**S(2)) 8420 8421 cons1560 = CustomConstraint(cons_f1560) 8422 8423 def cons_f1561(A, B): 8424 return NonzeroQ(A**S(2) + B**S(2)) 8425 8426 cons1561 = CustomConstraint(cons_f1561) 8427 8428 def cons_f1562(a, c, m, n): 8429 return Not(And(IntegerQ(n), Greater(n, S(1)), Or(Not(IntegerQ(m)), And(ZeroQ(c), NonzeroQ(a))))) 8430 8431 cons1562 = CustomConstraint(cons_f1562) 8432 8433 def cons_f1563(A, C): 8434 return ZeroQ(A - C) 8435 8436 cons1563 = CustomConstraint(cons_f1563) 8437 8438 def cons_f1564(A, B, C, a, b): 8439 return NonzeroQ(A*b**S(2) - B*a*b + C*a**S(2)) 8440 8441 cons1564 = CustomConstraint(cons_f1564) 8442 8443 def cons_f1565(A, C, a, b): 8444 return NonzeroQ(A*b**S(2) + C*a**S(2)) 8445 8446 cons1565 = CustomConstraint(cons_f1565) 8447 8448 def cons_f1566(A, B, C, a, b): 8449 return ZeroQ(A*b - B*a - C*b) 8450 8451 cons1566 = CustomConstraint(cons_f1566) 8452 8453 def cons_f1567(A, C): 8454 return NonzeroQ(A - C) 8455 8456 cons1567 = CustomConstraint(cons_f1567) 8457 8458 def cons_f1568(A, B, C, a, b): 8459 return NonzeroQ(A*b - B*a - C*b) 8460 8461 cons1568 = CustomConstraint(cons_f1568) 8462 8463 def cons_f1569(m, n): 8464 return Or(And(RationalQ(m), Less(m, S(0))), ZeroQ(m + n + S(1))) 8465 8466 cons1569 = CustomConstraint(cons_f1569) 8467 8468 def cons_f1570(a, c, m, n): 8469 return Not(And(IntegerQ(n), Greater(n, S(0)), Or(Not(IntegerQ(m)), And(ZeroQ(c), NonzeroQ(a))))) 8470 8471 cons1570 = CustomConstraint(cons_f1570) 8472 8473 def cons_f1571(n): 8474 return Not(And(RationalQ(n), LessEqual(n, S(-1)))) 8475 8476 cons1571 = CustomConstraint(cons_f1571) 8477 8478 def cons_f1572(a, b, c, d, e, n, p, x): 8479 if isinstance(x, (int, Integer, float, Float)): 8480 return False 8481 return FreeQ(List(a, b, c, d, e, n, p), x) 8482 8483 cons1572 = CustomConstraint(cons_f1572) 8484 8485 def cons_f1573(m, n): 8486 return NegativeIntegerQ(m, n) 8487 8488 cons1573 = CustomConstraint(cons_f1573) 8489 8490 def cons_f1574(n): 8491 return NegativeIntegerQ(n + S(1)) 8492 8493 cons1574 = CustomConstraint(cons_f1574) 8494 8495 def cons_f1575(n): 8496 return PositiveIntegerQ(S(1)/n) 8497 8498 cons1575 = CustomConstraint(cons_f1575) 8499 8500 def cons_f1576(m, n): 8501 return PositiveIntegerQ((m + S(1))/n) 8502 8503 cons1576 = CustomConstraint(cons_f1576) 8504 8505 def cons_f1577(c, d, m, n, x): 8506 if isinstance(x, (int, Integer, float, Float)): 8507 return False 8508 return FreeQ(List(c, d, m, n), x) 8509 8510 cons1577 = CustomConstraint(cons_f1577) 8511 8512 def cons_f1578(a, b, c, d, m, n, p, x): 8513 if isinstance(x, (int, Integer, float, Float)): 8514 return False 8515 return FreeQ(List(a, b, c, d, m, n, p), x) 8516 8517 cons1578 = CustomConstraint(cons_f1578) 8518 8519 def cons_f1579(m, n): 8520 return GreaterEqual(m - n, S(0)) 8521 8522 cons1579 = CustomConstraint(cons_f1579) 8523 8524 def cons_f1580(q): 8525 return SameQ(q, S(1)) 8526 8527 cons1580 = CustomConstraint(cons_f1580) 8528 8529 def cons_f1581(a, b, c, n, x): 8530 if isinstance(x, (int, Integer, float, Float)): 8531 return False 8532 return FreeQ(List(a, b, c, n), x) 8533 8534 cons1581 = CustomConstraint(cons_f1581) 8535 8536 def cons_f1582(a, b, c, d, e, m, n, x): 8537 if isinstance(x, (int, Integer, float, Float)): 8538 return False 8539 return FreeQ(List(a, b, c, d, e, m, n), x) 8540 8541 cons1582 = CustomConstraint(cons_f1582) 8542 8543 def cons_f1583(m, n): 8544 return ZeroQ(m + n + S(-2)) 8545 8546 cons1583 = CustomConstraint(cons_f1583) 8547 8548 def cons_f1584(m, n): 8549 return IntegersQ(m, n, m/S(2) + n/S(2)) 8550 8551 cons1584 = CustomConstraint(cons_f1584) 8552 8553 def cons_f1585(m, n): 8554 return Not(And(IntegerQ(m/S(2) + S(1)/2), Less(S(0), m, n))) 8555 8556 cons1585 = CustomConstraint(cons_f1585) 8557 8558 def cons_f1586(m, n): 8559 return Not(PositiveIntegerQ(m/S(2), n/S(2) + S(-1)/2)) 8560 8561 cons1586 = CustomConstraint(cons_f1586) 8562 8563 def cons_f1587(n): 8564 return ZeroQ(n**S(2) + S(-1)/4) 8565 8566 cons1587 = CustomConstraint(cons_f1587) 8567 8568 def cons_f1588(n): 8569 return LessEqual(n, S(-1)) 8570 8571 cons1588 = CustomConstraint(cons_f1588) 8572 8573 def cons_f1589(a, b, d, e, f, n, x): 8574 if isinstance(x, (int, Integer, float, Float)): 8575 return False 8576 return FreeQ(List(a, b, d, e, f, n), x) 8577 8578 cons1589 = CustomConstraint(cons_f1589) 8579 8580 def cons_f1590(a, b, d): 8581 return PositiveQ(a*d/b) 8582 8583 cons1590 = CustomConstraint(cons_f1590) 8584 8585 def cons_f1591(a, b, d): 8586 return Not(PositiveQ(a*d/b)) 8587 8588 cons1591 = CustomConstraint(cons_f1591) 8589 8590 def cons_f1592(n): 8591 return Less(n, S(-1)/2) 8592 8593 cons1592 = CustomConstraint(cons_f1592) 8594 8595 def cons_f1593(m, n): 8596 return Or(Less(n, S(-1)), And(Equal(m, S(3)/2), Equal(n, S(-1)/2))) 8597 8598 cons1593 = CustomConstraint(cons_f1593) 8599 8600 def cons_f1594(m, n): 8601 return Or(IntegersQ(S(2)*m, S(2)*n), IntegerQ(m)) 8602 8603 cons1594 = CustomConstraint(cons_f1594) 8604 8605 def cons_f1595(a, b, d): 8606 return NegativeQ(a*d/b) 8607 8608 cons1595 = CustomConstraint(cons_f1595) 8609 8610 def cons_f1596(m, n): 8611 return Or(And(IntegerQ(m), Less(n, S(-1))), And(IntegersQ(m + S(1)/2, S(2)*n), LessEqual(n, S(-1)))) 8612 8613 cons1596 = CustomConstraint(cons_f1596) 8614 8615 def cons_f1597(m, n): 8616 return Not(And(IntegerQ(n), Greater(n, S(2)), Not(IntegerQ(m)))) 8617 8618 cons1597 = CustomConstraint(cons_f1597) 8619 8620 def cons_f1598(m, n): 8621 return Or(And(IntegerQ(n), Greater(n, S(3))), And(IntegersQ(n + S(1)/2, S(2)*m), Greater(n, S(2)))) 8622 8623 cons1598 = CustomConstraint(cons_f1598) 8624 8625 def cons_f1599(m, n): 8626 return NegativeIntegerQ(m + S(1)/2, n) 8627 8628 cons1599 = CustomConstraint(cons_f1599) 8629 8630 def cons_f1600(n): 8631 return Greater(n, S(3)) 8632 8633 cons1600 = CustomConstraint(cons_f1600) 8634 8635 def cons_f1601(n): 8636 return IntegersQ(S(2)*n) 8637 8638 cons1601 = CustomConstraint(cons_f1601) 8639 8640 def cons_f1602(m): 8641 return Not(And(IntegerQ(m), Greater(m, S(2)))) 8642 8643 cons1602 = CustomConstraint(cons_f1602) 8644 8645 def cons_f1603(n): 8646 return Less(S(0), n, S(3)) 8647 8648 cons1603 = CustomConstraint(cons_f1603) 8649 8650 def cons_f1604(m): 8651 return Less(S(-1), m, S(2)) 8652 8653 cons1604 = CustomConstraint(cons_f1604) 8654 8655 def cons_f1605(n): 8656 return Less(S(1), n, S(3)) 8657 8658 cons1605 = CustomConstraint(cons_f1605) 8659 8660 def cons_f1606(a, b, d, e, f, m, n, x): 8661 if isinstance(x, (int, Integer, float, Float)): 8662 return False 8663 return FreeQ(List(a, b, d, e, f, m, n), x) 8664 8665 cons1606 = CustomConstraint(cons_f1606) 8666 8667 def cons_f1607(a, b, e, f, m, x): 8668 if isinstance(x, (int, Integer, float, Float)): 8669 return False 8670 return FreeQ(List(a, b, e, f, m), x) 8671 8672 cons1607 = CustomConstraint(cons_f1607) 8673 8674 def cons_f1608(a, b, m, p): 8675 return Or(ZeroQ(a**S(2) - b**S(2)), IntegersQ(S(2)*m, p)) 8676 8677 cons1608 = CustomConstraint(cons_f1608) 8678 8679 def cons_f1609(n): 8680 return IntegerQ(n + S(-1)/2) 8681 8682 cons1609 = CustomConstraint(cons_f1609) 8683 8684 def cons_f1610(m): 8685 return NegativeIntegerQ(m + S(1)/2) 8686 8687 cons1610 = CustomConstraint(cons_f1610) 8688 8689 def cons_f1611(m): 8690 return Or(IntegerQ(m/S(2)), LessEqual(m, S(1))) 8691 8692 cons1611 = CustomConstraint(cons_f1611) 8693 8694 def cons_f1612(m, n): 8695 return Less(m + n, S(2)) 8696 8697 cons1612 = CustomConstraint(cons_f1612) 8698 8699 def cons_f1613(m, n): 8700 return Not(And(IntegerQ(n), Greater(m - n, S(0)))) 8701 8702 cons1613 = CustomConstraint(cons_f1613) 8703 8704 def cons_f1614(n): 8705 return Greater(n, S(1)/2) 8706 8707 cons1614 = CustomConstraint(cons_f1614) 8708 8709 def cons_f1615(n): 8710 return Not(And(RationalQ(n), LessEqual(n, S(-1)/2))) 8711 8712 cons1615 = CustomConstraint(cons_f1615) 8713 8714 def cons_f1616(m, n): 8715 return MemberQ(List(S(0), S(-1), S(-2)), m + n) 8716 8717 cons1616 = CustomConstraint(cons_f1616) 8718 8719 def cons_f1617(m, n): 8720 return Not(And(PositiveIntegerQ(n + S(1)/2), Less(n + S(1)/2, -m - n))) 8721 8722 cons1617 = CustomConstraint(cons_f1617) 8723 8724 def cons_f1618(m, n): 8725 return Not(And(PositiveIntegerQ(m + S(-1)/2), Less(m, n))) 8726 8727 cons1618 = CustomConstraint(cons_f1618) 8728 8729 def cons_f1619(m, n): 8730 return GreaterEqual(-m + n, S(0)) 8731 8732 cons1619 = CustomConstraint(cons_f1619) 8733 8734 def cons_f1620(m, n): 8735 return Greater(m*n, S(0)) 8736 8737 cons1620 = CustomConstraint(cons_f1620) 8738 8739 def cons_f1621(m, n): 8740 return Or(NegativeIntegerQ(m, n + S(-1)/2), And(NegativeIntegerQ(m + S(-1)/2, n + S(-1)/2), Less(m, n))) 8741 8742 cons1621 = CustomConstraint(cons_f1621) 8743 8744 def cons_f1622(m, p): 8745 return Or(ZeroQ(p + S(-1)), IntegerQ(m + S(-1)/2)) 8746 8747 cons1622 = CustomConstraint(cons_f1622) 8748 8749 def cons_f1623(m, n, p): 8750 return ZeroQ(m + n + p) 8751 8752 cons1623 = CustomConstraint(cons_f1623) 8753 8754 def cons_f1624(m, n, p): 8755 return MemberQ(List(S(-1), S(-2)), m + n + p) 8756 8757 cons1624 = CustomConstraint(cons_f1624) 8758 8759 def cons_f1625(A, B, a, b, m): 8760 return ZeroQ(A*b*(m + S(1)) + B*a*m) 8761 8762 cons1625 = CustomConstraint(cons_f1625) 8763 8764 def cons_f1626(A, B, a, b, m): 8765 return NonzeroQ(A*b*(m + S(1)) + B*a*m) 8766 8767 cons1626 = CustomConstraint(cons_f1626) 8768 8769 def cons_f1627(A, B): 8770 return ZeroQ(A**S(2) - B**S(2)) 8771 8772 cons1627 = CustomConstraint(cons_f1627) 8773 8774 def cons_f1628(A, B): 8775 return NonzeroQ(A**S(2) - B**S(2)) 8776 8777 cons1628 = CustomConstraint(cons_f1628) 8778 8779 def cons_f1629(A, B, a, b, m, n): 8780 return ZeroQ(A*a*m - B*b*n) 8781 8782 cons1629 = CustomConstraint(cons_f1629) 8783 8784 def cons_f1630(A, B, a, b, n): 8785 return ZeroQ(A*b*(S(2)*n + S(1)) + S(2)*B*a*n) 8786 8787 cons1630 = CustomConstraint(cons_f1630) 8788 8789 def cons_f1631(A, B, a, b, n): 8790 return NonzeroQ(A*b*(S(2)*n + S(1)) + S(2)*B*a*n) 8791 8792 cons1631 = CustomConstraint(cons_f1631) 8793 8794 def cons_f1632(m, n): 8795 return Not(And(IntegerQ(n), Greater(n, S(1)), Not(IntegerQ(m)))) 8796 8797 cons1632 = CustomConstraint(cons_f1632) 8798 8799 def cons_f1633(m, n): 8800 return Not(NegativeIntegerQ(m + S(1)/2, n)) 8801 8802 cons1633 = CustomConstraint(cons_f1633) 8803 8804 def cons_f1634(m): 8805 return Not(And(IntegerQ(m), Greater(m, S(1)))) 8806 8807 cons1634 = CustomConstraint(cons_f1634) 8808 8809 def cons_f1635(A, C, m): 8810 return ZeroQ(A*(m + S(1)) + C*m) 8811 8812 cons1635 = CustomConstraint(cons_f1635) 8813 8814 def cons_f1636(A, C, m): 8815 return NonzeroQ(A*(m + S(1)) + C*m) 8816 8817 cons1636 = CustomConstraint(cons_f1636) 8818 8819 def cons_f1637(A, B, C, b, e, f, m, x): 8820 if isinstance(x, (int, Integer, float, Float)): 8821 return False 8822 return FreeQ(List(b, e, f, A, B, C, m), x) 8823 8824 cons1637 = CustomConstraint(cons_f1637) 8825 8826 def cons_f1638(A, B, C, a, b, e, f, x): 8827 if isinstance(x, (int, Integer, float, Float)): 8828 return False 8829 return FreeQ(List(a, b, e, f, A, B, C), x) 8830 8831 cons1638 = CustomConstraint(cons_f1638) 8832 8833 def cons_f1639(A, C, a, b, e, f, x): 8834 if isinstance(x, (int, Integer, float, Float)): 8835 return False 8836 return FreeQ(List(a, b, e, f, A, C), x) 8837 8838 cons1639 = CustomConstraint(cons_f1639) 8839 8840 def cons_f1640(m): 8841 return PositiveIntegerQ(S(2)*m) 8842 8843 cons1640 = CustomConstraint(cons_f1640) 8844 8845 def cons_f1641(m, n): 8846 return Or(And(RationalQ(n), Less(n, S(-1)/2)), ZeroQ(m + n + S(1))) 8847 8848 cons1641 = CustomConstraint(cons_f1641) 8849 8850 def cons_f1642(n): 8851 return Not(And(RationalQ(n), Less(n, S(-1)/2))) 8852 8853 cons1642 = CustomConstraint(cons_f1642) 8854 8855 def cons_f1643(A, B, C, a, b, d, e, f, m, n, x): 8856 if isinstance(x, (int, Integer, float, Float)): 8857 return False 8858 return FreeQ(List(a, b, d, e, f, A, B, C, m, n), x) 8859 8860 cons1643 = CustomConstraint(cons_f1643) 8861 8862 def cons_f1644(A, C, a, b, d, e, f, m, n, x): 8863 if isinstance(x, (int, Integer, float, Float)): 8864 return False 8865 return FreeQ(List(a, b, d, e, f, A, C, m, n), x) 8866 8867 cons1644 = CustomConstraint(cons_f1644) 8868 8869 def cons_f1645(b, c, d, n, x): 8870 if isinstance(x, (int, Integer, float, Float)): 8871 return False 8872 return FreeQ(List(b, c, d, n), x) 8873 8874 cons1645 = CustomConstraint(cons_f1645) 8875 8876 def cons_f1646(n): 8877 return Unequal(n, S(2)) 8878 8879 cons1646 = CustomConstraint(cons_f1646) 8880 8881 def cons_f1647(p): 8882 return NonzeroQ(p + S(-1)) 8883 8884 cons1647 = CustomConstraint(cons_f1647) 8885 8886 def cons_f1648(u, x): 8887 if isinstance(x, (int, Integer, float, Float)): 8888 return False 8889 return KnownSineIntegrandQ(u, x) 8890 8891 cons1648 = CustomConstraint(cons_f1648) 8892 8893 def cons_f1649(A, B, C, a, b, x): 8894 if isinstance(x, (int, Integer, float, Float)): 8895 return False 8896 return FreeQ(List(a, b, A, B, C), x) 8897 8898 cons1649 = CustomConstraint(cons_f1649) 8899 8900 def cons_f1650(n, n1): 8901 return ZeroQ(-n + n1 + S(-1)) 8902 8903 cons1650 = CustomConstraint(cons_f1650) 8904 8905 def cons_f1651(n, n2): 8906 return ZeroQ(-n + n2 + S(-2)) 8907 8908 cons1651 = CustomConstraint(cons_f1651) 8909 8910 def cons_f1652(u, x): 8911 if isinstance(x, (int, Integer, float, Float)): 8912 return False 8913 return KnownTangentIntegrandQ(u, x) 8914 8915 cons1652 = CustomConstraint(cons_f1652) 8916 8917 def cons_f1653(u, x): 8918 if isinstance(x, (int, Integer, float, Float)): 8919 return False 8920 return KnownCotangentIntegrandQ(u, x) 8921 8922 cons1653 = CustomConstraint(cons_f1653) 8923 8924 def cons_f1654(u, x): 8925 if isinstance(x, (int, Integer, float, Float)): 8926 return False 8927 return KnownSecantIntegrandQ(u, x) 8928 8929 cons1654 = CustomConstraint(cons_f1654) 8930 8931 def cons_f1655(b, d): 8932 return NonzeroQ(b**S(2) - d**S(2)) 8933 8934 cons1655 = CustomConstraint(cons_f1655) 8935 8936 def cons_f1656(b, d): 8937 return ZeroQ(S(-2) + d/b) 8938 8939 cons1656 = CustomConstraint(cons_f1656) 8940 8941 def cons_f1657(m, p): 8942 return Or(Greater(m, S(3)), Equal(p, S(-3)/2)) 8943 8944 cons1657 = CustomConstraint(cons_f1657) 8945 8946 def cons_f1658(m, p): 8947 return Or(Less(p, S(-2)), Equal(m, S(2))) 8948 8949 cons1658 = CustomConstraint(cons_f1658) 8950 8951 def cons_f1659(m, n, p): 8952 return ZeroQ(m + n + S(2)*p + S(2)) 8953 8954 cons1659 = CustomConstraint(cons_f1659) 8955 8956 def cons_f1660(m): 8957 return Greater(m, S(3)) 8958 8959 cons1660 = CustomConstraint(cons_f1660) 8960 8961 def cons_f1661(n, p): 8962 return NonzeroQ(n + p + S(1)) 8963 8964 cons1661 = CustomConstraint(cons_f1661) 8965 8966 def cons_f1662(m, n, p): 8967 return NonzeroQ(m + n + S(2)*p + S(2)) 8968 8969 cons1662 = CustomConstraint(cons_f1662) 8970 8971 def cons_f1663(m, p): 8972 return Or(Less(p, S(-2)), Equal(m, S(2)), Equal(m, S(3))) 8973 8974 cons1663 = CustomConstraint(cons_f1663) 8975 8976 def cons_f1664(m, n, p): 8977 return NonzeroQ(m + n + S(2)*p) 8978 8979 cons1664 = CustomConstraint(cons_f1664) 8980 8981 def cons_f1665(b, d, m): 8982 return ZeroQ(-Abs(m + S(2)) + d/b) 8983 8984 cons1665 = CustomConstraint(cons_f1665) 8985 8986 def cons_f1666(F): 8987 return InertTrigQ(F) 8988 8989 cons1666 = CustomConstraint(cons_f1666) 8990 8991 def cons_f1667(F, G): 8992 return InertTrigQ(F, G) 8993 8994 cons1667 = CustomConstraint(cons_f1667) 8995 8996 def cons_f1668(F): 8997 return Or(SameQ(F, Cos), SameQ(F, cos)) 8998 8999 cons1668 = CustomConstraint(cons_f1668) 9000 9001 def cons_f1669(F): 9002 return Or(SameQ(F, Sin), SameQ(F, sin)) 9003 9004 cons1669 = CustomConstraint(cons_f1669) 9005 9006 def cons_f1670(F): 9007 return Or(SameQ(F, Cot), SameQ(F, cot)) 9008 9009 cons1670 = CustomConstraint(cons_f1670) 9010 9011 def cons_f1671(F): 9012 return Or(SameQ(F, Tan), SameQ(F, tan)) 9013 9014 cons1671 = CustomConstraint(cons_f1671) 9015 9016 def cons_f1672(F): 9017 return Or(SameQ(F, Sec), SameQ(F, sec)) 9018 9019 cons1672 = CustomConstraint(cons_f1672) 9020 9021 def cons_f1673(F): 9022 return Or(SameQ(F, Csc), SameQ(F, csc)) 9023 9024 cons1673 = CustomConstraint(cons_f1673) 9025 9026 def cons_f1674(F): 9027 return Or(SameQ(F, sin), SameQ(F, cos)) 9028 9029 cons1674 = CustomConstraint(cons_f1674) 9030 9031 def cons_f1675(G): 9032 return Or(SameQ(G, sin), SameQ(G, cos)) 9033 9034 cons1675 = CustomConstraint(cons_f1675) 9035 9036 def cons_f1676(H): 9037 return Or(SameQ(H, sin), SameQ(H, cos)) 9038 9039 cons1676 = CustomConstraint(cons_f1676) 9040 9041 def cons_f1677(b, c): 9042 return ZeroQ(b - c) 9043 9044 cons1677 = CustomConstraint(cons_f1677) 9045 9046 def cons_f1678(b, c): 9047 return ZeroQ(b + c) 9048 9049 cons1678 = CustomConstraint(cons_f1678) 9050 9051 def cons_f1679(u): 9052 return Not(InertTrigFreeQ(u)) 9053 9054 cons1679 = CustomConstraint(cons_f1679) 9055 9056 def cons_f1680(p): 9057 return NegQ(p) 9058 9059 cons1680 = CustomConstraint(cons_f1680) 9060 9061 def cons_f1681(u): 9062 return TrigSimplifyQ(u) 9063 9064 cons1681 = CustomConstraint(cons_f1681) 9065 9066 def cons_f1682(v): 9067 return Not(InertTrigFreeQ(v)) 9068 9069 cons1682 = CustomConstraint(cons_f1682) 9070 9071 def cons_f1683(v, w): 9072 return Or(Not(InertTrigFreeQ(v)), Not(InertTrigFreeQ(w))) 9073 9074 cons1683 = CustomConstraint(cons_f1683) 9075 9076 def cons_f1684(u, x): 9077 if isinstance(x, (int, Integer, float, Float)): 9078 return False 9079 try: 9080 return Not(FalseQ(FunctionOfTrig(u, x))) 9081 except (TypeError, AttributeError): 9082 return False 9083 9084 cons1684 = CustomConstraint(cons_f1684) 9085 9086 def cons_f1685(p): 9087 return SameQ(p, S(1)) 9088 9089 cons1685 = CustomConstraint(cons_f1685) 9090 9091 def cons_f1686(n, p): 9092 return Or(EvenQ(n), OddQ(p)) 9093 9094 cons1686 = CustomConstraint(cons_f1686) 9095 9096 def cons_f1687(n, p): 9097 return Unequal(n, p) 9098 9099 cons1687 = CustomConstraint(cons_f1687) 9100 9101 def cons_f1688(F): 9102 return TrigQ(F) 9103 9104 cons1688 = CustomConstraint(cons_f1688) 9105 9106 def cons_f1689(G): 9107 return TrigQ(G) 9108 9109 cons1689 = CustomConstraint(cons_f1689) 9110 9111 def cons_f1690(v, w): 9112 return ZeroQ(v - w) 9113 9114 cons1690 = CustomConstraint(cons_f1690) 9115 9116 def cons_f1691(F): 9117 return MemberQ(List(Sin, Cos), F) 9118 9119 cons1691 = CustomConstraint(cons_f1691) 9120 9121 def cons_f1692(G): 9122 return MemberQ(List(Sec, Csc), G) 9123 9124 cons1692 = CustomConstraint(cons_f1692) 9125 9126 def cons_f1693(b, d): 9127 return PositiveIntegerQ(b/d + S(-1)) 9128 9129 cons1693 = CustomConstraint(cons_f1693) 9130 9131 def cons_f1694(F, b, c, e): 9132 return NonzeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)) 9133 9134 cons1694 = CustomConstraint(cons_f1694) 9135 9136 def cons_f1695(F, b, c, e, n): 9137 return NonzeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*n**S(2)) 9138 9139 cons1695 = CustomConstraint(cons_f1695) 9140 9141 def cons_f1696(F, b, c, e, m): 9142 return NonzeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*m**S(2)) 9143 9144 cons1696 = CustomConstraint(cons_f1696) 9145 9146 def cons_f1697(F, b, c, e, n): 9147 return ZeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(2))**S(2)) 9148 9149 cons1697 = CustomConstraint(cons_f1697) 9150 9151 def cons_f1698(F, b, c, e, n): 9152 return NonzeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(2))**S(2)) 9153 9154 cons1698 = CustomConstraint(cons_f1698) 9155 9156 def cons_f1699(F, b, c, e, n): 9157 return ZeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(-2))**S(2)) 9158 9159 cons1699 = CustomConstraint(cons_f1699) 9160 9161 def cons_f1700(F, b, c, e, n): 9162 return NonzeroQ(b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(-2))**S(2)) 9163 9164 cons1700 = CustomConstraint(cons_f1700) 9165 9166 def cons_f1701(f, g): 9167 return ZeroQ(f**S(2) - g**S(2)) 9168 9169 cons1701 = CustomConstraint(cons_f1701) 9170 9171 def cons_f1702(f, g): 9172 return ZeroQ(f - g) 9173 9174 cons1702 = CustomConstraint(cons_f1702) 9175 9176 def cons_f1703(h, i): 9177 return ZeroQ(h**S(2) - i**S(2)) 9178 9179 cons1703 = CustomConstraint(cons_f1703) 9180 9181 def cons_f1704(f, g, h, i): 9182 return ZeroQ(-f*i + g*h) 9183 9184 cons1704 = CustomConstraint(cons_f1704) 9185 9186 def cons_f1705(f, g, h, i): 9187 return ZeroQ(f*i + g*h) 9188 9189 cons1705 = CustomConstraint(cons_f1705) 9190 9191 def cons_f1706(m, n, p): 9192 return PositiveIntegerQ(m, n, p) 9193 9194 cons1706 = CustomConstraint(cons_f1706) 9195 9196 def cons_f1707(H): 9197 return TrigQ(H) 9198 9199 cons1707 = CustomConstraint(cons_f1707) 9200 9201 def cons_f1708(u, x): 9202 if isinstance(x, (int, Integer, float, Float)): 9203 return False 9204 return Or(LinearQ(u, x), PolyQ(u, x, S(2))) 9205 9206 cons1708 = CustomConstraint(cons_f1708) 9207 9208 def cons_f1709(v, x): 9209 if isinstance(x, (int, Integer, float, Float)): 9210 return False 9211 return Or(LinearQ(v, x), PolyQ(v, x, S(2))) 9212 9213 cons1709 = CustomConstraint(cons_f1709) 9214 9215 def cons_f1710(b, n, p): 9216 return ZeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + S(1)) 9217 9218 cons1710 = CustomConstraint(cons_f1710) 9219 9220 def cons_f1711(b, n, p): 9221 return ZeroQ(b**S(2)*n**S(2)*p**S(2) + S(1)) 9222 9223 cons1711 = CustomConstraint(cons_f1711) 9224 9225 def cons_f1712(b, n): 9226 return NonzeroQ(b**S(2)*n**S(2) + S(1)) 9227 9228 cons1712 = CustomConstraint(cons_f1712) 9229 9230 def cons_f1713(b, n, p): 9231 return NonzeroQ(b**S(2)*n**S(2)*p**S(2) + S(1)) 9232 9233 cons1713 = CustomConstraint(cons_f1713) 9234 9235 def cons_f1714(b, n, p): 9236 return NonzeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + S(1)) 9237 9238 cons1714 = CustomConstraint(cons_f1714) 9239 9240 def cons_f1715(b, m, n, p): 9241 return ZeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + (m + S(1))**S(2)) 9242 9243 cons1715 = CustomConstraint(cons_f1715) 9244 9245 def cons_f1716(b, m, n, p): 9246 return ZeroQ(b**S(2)*n**S(2)*p**S(2) + (m + S(1))**S(2)) 9247 9248 cons1716 = CustomConstraint(cons_f1716) 9249 9250 def cons_f1717(b, m, n): 9251 return NonzeroQ(b**S(2)*n**S(2) + (m + S(1))**S(2)) 9252 9253 cons1717 = CustomConstraint(cons_f1717) 9254 9255 def cons_f1718(b, m, n, p): 9256 return NonzeroQ(b**S(2)*n**S(2)*p**S(2) + (m + S(1))**S(2)) 9257 9258 cons1718 = CustomConstraint(cons_f1718) 9259 9260 def cons_f1719(b, m, n, p): 9261 return NonzeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + (m + S(1))**S(2)) 9262 9263 cons1719 = CustomConstraint(cons_f1719) 9264 9265 def cons_f1720(b, n): 9266 return ZeroQ(b**S(2)*n**S(2) + S(1)) 9267 9268 cons1720 = CustomConstraint(cons_f1720) 9269 9270 def cons_f1721(b, n, p): 9271 return ZeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + S(1)) 9272 9273 cons1721 = CustomConstraint(cons_f1721) 9274 9275 def cons_f1722(p): 9276 return Unequal(p, S(2)) 9277 9278 cons1722 = CustomConstraint(cons_f1722) 9279 9280 def cons_f1723(b, n, p): 9281 return NonzeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + S(1)) 9282 9283 cons1723 = CustomConstraint(cons_f1723) 9284 9285 def cons_f1724(b, m, n): 9286 return ZeroQ(b**S(2)*n**S(2) + (m + S(1))**S(2)) 9287 9288 cons1724 = CustomConstraint(cons_f1724) 9289 9290 def cons_f1725(b, m, n, p): 9291 return ZeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + (m + S(1))**S(2)) 9292 9293 cons1725 = CustomConstraint(cons_f1725) 9294 9295 def cons_f1726(b, m, n, p): 9296 return NonzeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + (m + S(1))**S(2)) 9297 9298 cons1726 = CustomConstraint(cons_f1726) 9299 9300 def cons_f1727(u, x): 9301 if isinstance(x, (int, Integer, float, Float)): 9302 return False 9303 return QuotientOfLinearsQ(u, x) 9304 9305 cons1727 = CustomConstraint(cons_f1727) 9306 9307 def cons_f1728(v, w, x): 9308 if isinstance(x, (int, Integer, float, Float)): 9309 return False 9310 return Or(And(PolynomialQ(v, x), PolynomialQ(w, x)), And(BinomialQ(List(v, w), x), IndependentQ(v/w, x))) 9311 9312 cons1728 = CustomConstraint(cons_f1728) 9313 9314 def cons_f1729(m, p, q): 9315 return PositiveIntegerQ(m, p, q) 9316 9317 cons1729 = CustomConstraint(cons_f1729) 9318 9319 def cons_f1730(v, w): 9320 return NonzeroQ(v - w) 9321 9322 cons1730 = CustomConstraint(cons_f1730) 9323 9324 def cons_f1731(m, n): 9325 return Or(Equal(n, S(-1)), And(Equal(m, S(1)), Equal(n, S(-2)))) 9326 9327 cons1731 = CustomConstraint(cons_f1731) 9328 9329 def cons_f1732(a, c): 9330 return NonzeroQ(a + c) 9331 9332 cons1732 = CustomConstraint(cons_f1732) 9333 9334 def cons_f1733(a, b): 9335 return PosQ(a**S(2) - b**S(2)) 9336 9337 cons1733 = CustomConstraint(cons_f1733) 9338 9339 def cons_f1734(a, b): 9340 return NegQ(a**S(2) - b**S(2)) 9341 9342 cons1734 = CustomConstraint(cons_f1734) 9343 9344 def cons_f1735(b, d): 9345 return ZeroQ(b**S(2) - d**S(2)) 9346 9347 cons1735 = CustomConstraint(cons_f1735) 9348 9349 def cons_f1736(n): 9350 return Inequality(S(-2), LessEqual, n, Less, S(-1)) 9351 9352 cons1736 = CustomConstraint(cons_f1736) 9353 9354 def cons_f1737(n): 9355 return Less(n, S(-2)) 9356 9357 cons1737 = CustomConstraint(cons_f1737) 9358 9359 def cons_f1738(a, b, c, d, m, n, x): 9360 if isinstance(x, (int, Integer, float, Float)): 9361 return False 9362 return FreeQ(List(a, b, c, d, m, n), x) 9363 9364 cons1738 = CustomConstraint(cons_f1738) 9365 9366 def cons_f1739(c, d, e): 9367 return ZeroQ(c**S(2)*d + e) 9368 9369 cons1739 = CustomConstraint(cons_f1739) 9370 9371 def cons_f1740(d): 9372 return Not(PositiveQ(d)) 9373 9374 cons1740 = CustomConstraint(cons_f1740) 9375 9376 def cons_f1741(p): 9377 return PositiveIntegerQ(S(2)*p) 9378 9379 cons1741 = CustomConstraint(cons_f1741) 9380 9381 def cons_f1742(d, p): 9382 return Or(IntegerQ(p), PositiveQ(d)) 9383 9384 cons1742 = CustomConstraint(cons_f1742) 9385 9386 def cons_f1743(d, p): 9387 return Not(Or(IntegerQ(p), PositiveQ(d))) 9388 9389 cons1743 = CustomConstraint(cons_f1743) 9390 9391 def cons_f1744(c, d, e): 9392 return NonzeroQ(c**S(2)*d + e) 9393 9394 cons1744 = CustomConstraint(cons_f1744) 9395 9396 def cons_f1745(p): 9397 return Or(PositiveIntegerQ(p), NegativeIntegerQ(p + S(1)/2)) 9398 9399 cons1745 = CustomConstraint(cons_f1745) 9400 9401 def cons_f1746(n, p): 9402 return Or(Greater(p, S(0)), PositiveIntegerQ(n)) 9403 9404 cons1746 = CustomConstraint(cons_f1746) 9405 9406 def cons_f1747(c, f, g): 9407 return ZeroQ(c**S(2)*f**S(2) - g**S(2)) 9408 9409 cons1747 = CustomConstraint(cons_f1747) 9410 9411 def cons_f1748(m): 9412 return NegativeIntegerQ(m/S(2) + S(1)/2) 9413 9414 cons1748 = CustomConstraint(cons_f1748) 9415 9416 def cons_f1749(m, p): 9417 return Or(PositiveIntegerQ(m/S(2) + S(1)/2), NegativeIntegerQ(m/S(2) + p + S(3)/2)) 9418 9419 cons1749 = CustomConstraint(cons_f1749) 9420 9421 def cons_f1750(m, n): 9422 return Or(RationalQ(m), ZeroQ(n + S(-1))) 9423 9424 cons1750 = CustomConstraint(cons_f1750) 9425 9426 def cons_f1751(m, n, p): 9427 return Or(IntegerQ(m), IntegerQ(p), Equal(n, S(1))) 9428 9429 cons1751 = CustomConstraint(cons_f1751) 9430 9431 def cons_f1752(m, n): 9432 return Or(IntegerQ(m), Equal(n, S(1))) 9433 9434 cons1752 = CustomConstraint(cons_f1752) 9435 9436 def cons_f1753(m): 9437 return Greater(m, S(-3)) 9438 9439 cons1753 = CustomConstraint(cons_f1753) 9440 9441 def cons_f1754(p): 9442 return Greater(p, S(-1)) 9443 9444 cons1754 = CustomConstraint(cons_f1754) 9445 9446 def cons_f1755(m): 9447 return Not(PositiveIntegerQ(m/S(2) + S(1)/2)) 9448 9449 cons1755 = CustomConstraint(cons_f1755) 9450 9451 def cons_f1756(m): 9452 return Less(S(-3), m, S(0)) 9453 9454 cons1756 = CustomConstraint(cons_f1756) 9455 9456 def cons_f1757(m, p): 9457 return Or(Greater(p, S(0)), And(PositiveIntegerQ(m/S(2) + S(-1)/2), LessEqual(m + p, S(0)))) 9458 9459 cons1757 = CustomConstraint(cons_f1757) 9460 9461 def cons_f1758(a, b, c, d, e, f, m, n, p, x): 9462 if isinstance(x, (int, Integer, float, Float)): 9463 return False 9464 return FreeQ(List(a, b, c, d, e, f, m, n, p), x) 9465 9466 cons1758 = CustomConstraint(cons_f1758) 9467 9468 def cons_f1759(m, p): 9469 return Less(m + p + S(1), S(0)) 9470 9471 cons1759 = CustomConstraint(cons_f1759) 9472 9473 def cons_f1760(d, e, g, h): 9474 return ZeroQ(-S(2)*d*h + e*g) 9475 9476 cons1760 = CustomConstraint(cons_f1760) 9477 9478 def cons_f1761(m, p): 9479 return Or(Less(m, -S(2)*p + S(-1)), Greater(m, S(3))) 9480 9481 cons1761 = CustomConstraint(cons_f1761) 9482 9483 def cons_f1762(m, n, p): 9484 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)))) 9485 9486 cons1762 = CustomConstraint(cons_f1762) 9487 9488 def cons_f1763(m, n): 9489 return Or(Greater(m, S(0)), PositiveIntegerQ(n)) 9490 9491 cons1763 = CustomConstraint(cons_f1763) 9492 9493 def cons_f1764(A, B, c, d): 9494 return ZeroQ(S(2)*A*c*d + B*(S(1) - c**S(2))) 9495 9496 cons1764 = CustomConstraint(cons_f1764) 9497 9498 def cons_f1765(B, C, c, d): 9499 return ZeroQ(-B*d + S(2)*C*c) 9500 9501 cons1765 = CustomConstraint(cons_f1765) 9502 9503 def cons_f1766(c): 9504 return ZeroQ(c**S(2) + S(-1)) 9505 9506 cons1766 = CustomConstraint(cons_f1766) 9507 9508 def cons_f1767(a, b, d, x): 9509 if isinstance(x, (int, Integer, float, Float)): 9510 return False 9511 return FreeQ(List(a, b, d), x) 9512 9513 cons1767 = CustomConstraint(cons_f1767) 9514 9515 def cons_f1768(a, b, c, m, n, x): 9516 if isinstance(x, (int, Integer, float, Float)): 9517 return False 9518 return FreeQ(List(a, b, c, n, m), x) 9519 9520 cons1768 = CustomConstraint(cons_f1768) 9521 9522 def cons_f1769(b, n, x): 9523 if isinstance(x, (int, Integer, float, Float)): 9524 return False 9525 return FreeQ(List(b, n), x) 9526 9527 cons1769 = CustomConstraint(cons_f1769) 9528 9529 def cons_f1770(b, c): 9530 return EqQ(b**S(2)*c, S(1)) 9531 9532 cons1770 = CustomConstraint(cons_f1770) 9533 9534 def cons_f1771(u, x): 9535 if isinstance(x, (int, Integer, float, Float)): 9536 return False 9537 return Not(FunctionOfExponentialQ(u, x)) 9538 9539 cons1771 = CustomConstraint(cons_f1771) 9540 9541 def cons_f1772(c, d, m, u, x): 9542 if isinstance(x, (int, Integer, float, Float)): 9543 return False 9544 return Not(FunctionOfQ((c + d*x)**(m + S(1)), u, x)) 9545 9546 cons1772 = CustomConstraint(cons_f1772) 9547 9548 def cons_f1773(v, x): 9549 if isinstance(x, (int, Integer, float, Float)): 9550 return False 9551 def _cons_f_1772(c, d, m): 9552 return FreeQ(List(c, d, m), x) 9553 _cons_1772 = CustomConstraint(_cons_f_1772) 9554 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1772) 9555 result_matchq = is_match(UtilityOperator(v, x), pat) 9556 return Not(result_matchq) 9557 9558 cons1773 = CustomConstraint(cons_f1773) 9559 9560 def cons_f1774(v, x): 9561 if isinstance(x, (int, Integer, float, Float)): 9562 return False 9563 def _cons_f_1773(c, d, m): 9564 return FreeQ(List(c, d, m), x) 9565 _cons_1773 = CustomConstraint(_cons_f_1773) 9566 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1773) 9567 result_matchq = is_match(UtilityOperator(v, x), pat) 9568 return Not(result_matchq) 9569 9570 cons1774 = CustomConstraint(cons_f1774) 9571 9572 def cons_f1775(c, d, e): 9573 return ZeroQ(c**S(2)*d**S(2) + e**S(2)) 9574 9575 cons1775 = CustomConstraint(cons_f1775) 9576 9577 def cons_f1776(c, d, e): 9578 return PositiveQ(I*c*d/e + S(1)) 9579 9580 cons1776 = CustomConstraint(cons_f1776) 9581 9582 def cons_f1777(c, d, e): 9583 return NegativeQ(I*c*d/e + S(-1)) 9584 9585 cons1777 = CustomConstraint(cons_f1777) 9586 9587 def cons_f1778(c, d, e, x): 9588 if isinstance(x, (int, Integer, float, Float)): 9589 return False 9590 return FreeQ(List(c, d, e), x) 9591 9592 cons1778 = CustomConstraint(cons_f1778) 9593 9594 def cons_f1779(a, m, p): 9595 return Or(Greater(p, S(0)), NonzeroQ(a), IntegerQ(m)) 9596 9597 cons1779 = CustomConstraint(cons_f1779) 9598 9599 def cons_f1780(c, d, e): 9600 return ZeroQ(-c**S(2)*d + e) 9601 9602 cons1780 = CustomConstraint(cons_f1780) 9603 9604 def cons_f1781(p): 9605 return NegativeIntegerQ(S(2)*p + S(2)) 9606 9607 cons1781 = CustomConstraint(cons_f1781) 9608 9609 def cons_f1782(p): 9610 return Or(IntegerQ(p), NegativeIntegerQ(p + S(1)/2)) 9611 9612 cons1782 = CustomConstraint(cons_f1782) 9613 9614 def cons_f1783(a, m): 9615 return Not(And(Equal(m, S(1)), NonzeroQ(a))) 9616 9617 cons1783 = CustomConstraint(cons_f1783) 9618 9619 def cons_f1784(p): 9620 return Unequal(p, S(-5)/2) 9621 9622 cons1784 = CustomConstraint(cons_f1784) 9623 9624 def cons_f1785(m, n, p): 9625 return Or(RationalQ(m), And(EqQ(n, S(1)), IntegerQ(p))) 9626 9627 cons1785 = CustomConstraint(cons_f1785) 9628 9629 def cons_f1786(m, n, p): 9630 return IntegersQ(m, n, S(2)*p) 9631 9632 cons1786 = CustomConstraint(cons_f1786) 9633 9634 def cons_f1787(m, p): 9635 return NegativeIntegerQ(m + S(2)*p + S(1)) 9636 9637 cons1787 = CustomConstraint(cons_f1787) 9638 9639 def cons_f1788(m, p): 9640 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)))) 9641 9642 cons1788 = CustomConstraint(cons_f1788) 9643 9644 def cons_f1789(m, p): 9645 return Or(Greater(p, S(0)), And(Less(p, S(-1)), IntegerQ(m), Unequal(m, S(1)))) 9646 9647 cons1789 = CustomConstraint(cons_f1789) 9648 9649 def cons_f1790(a, b, c, d, e, m, p, x): 9650 if isinstance(x, (int, Integer, float, Float)): 9651 return False 9652 return FreeQ(List(a, b, c, d, e, m, p), x) 9653 9654 cons1790 = CustomConstraint(cons_f1790) 9655 9656 def cons_f1791(c, u, x): 9657 if isinstance(x, (int, Integer, float, Float)): 9658 return False 9659 return ZeroQ(u**S(2) - (S(1) - S(2)*I/(c*x + I))**S(2)) 9660 9661 cons1791 = CustomConstraint(cons_f1791) 9662 9663 def cons_f1792(c, u, x): 9664 if isinstance(x, (int, Integer, float, Float)): 9665 return False 9666 return ZeroQ(u**S(2) - (S(1) - S(2)*I/(-c*x + I))**S(2)) 9667 9668 cons1792 = CustomConstraint(cons_f1792) 9669 9670 def cons_f1793(c, u, x): 9671 if isinstance(x, (int, Integer, float, Float)): 9672 return False 9673 return ZeroQ((S(1) - u)**S(2) - (S(1) - S(2)*I/(c*x + I))**S(2)) 9674 9675 cons1793 = CustomConstraint(cons_f1793) 9676 9677 def cons_f1794(c, u, x): 9678 if isinstance(x, (int, Integer, float, Float)): 9679 return False 9680 return ZeroQ((S(1) - u)**S(2) - (S(1) - S(2)*I/(-c*x + I))**S(2)) 9681 9682 cons1794 = CustomConstraint(cons_f1794) 9683 9684 def cons_f1795(m, n): 9685 return Inequality(S(0), Less, n, LessEqual, m) 9686 9687 cons1795 = CustomConstraint(cons_f1795) 9688 9689 def cons_f1796(m, n): 9690 return Less(S(0), n, m) 9691 9692 cons1796 = CustomConstraint(cons_f1796) 9693 9694 def cons_f1797(a, c, d, n): 9695 return Not(And(Equal(n, S(2)), ZeroQ(-a**S(2)*c + d))) 9696 9697 cons1797 = CustomConstraint(cons_f1797) 9698 9699 def cons_f1798(a, b, c, d, e, f, g, x): 9700 if isinstance(x, (int, Integer, float, Float)): 9701 return False 9702 return FreeQ(List(a, b, c, d, e, f, g), x) 9703 9704 cons1798 = CustomConstraint(cons_f1798) 9705 9706 def cons_f1799(m): 9707 return PositiveIntegerQ(m/S(2) + S(1)/2) 9708 9709 cons1799 = CustomConstraint(cons_f1799) 9710 9711 def cons_f1800(c, f, g): 9712 return ZeroQ(-c**S(2)*f + g) 9713 9714 cons1800 = CustomConstraint(cons_f1800) 9715 9716 def cons_f1801(n): 9717 return OddQ(I*n) 9718 9719 cons1801 = CustomConstraint(cons_f1801) 9720 9721 def cons_f1802(n): 9722 return Not(OddQ(I*n)) 9723 9724 cons1802 = CustomConstraint(cons_f1802) 9725 9726 def cons_f1803(a, c, d): 9727 return ZeroQ(a**S(2)*c**S(2) + d**S(2)) 9728 9729 cons1803 = CustomConstraint(cons_f1803) 9730 9731 def cons_f1804(c, p): 9732 return Or(IntegerQ(p), PositiveQ(c)) 9733 9734 cons1804 = CustomConstraint(cons_f1804) 9735 9736 def cons_f1805(c, p): 9737 return Not(Or(IntegerQ(p), PositiveQ(c))) 9738 9739 cons1805 = CustomConstraint(cons_f1805) 9740 9741 def cons_f1806(a, c, d): 9742 return ZeroQ(a**S(2)*d**S(2) + c**S(2)) 9743 9744 cons1806 = CustomConstraint(cons_f1806) 9745 9746 def cons_f1807(n): 9747 return IntegerQ(I*n/S(2)) 9748 9749 cons1807 = CustomConstraint(cons_f1807) 9750 9751 def cons_f1808(a, c, d): 9752 return ZeroQ(-a**S(2)*c + d) 9753 9754 cons1808 = CustomConstraint(cons_f1808) 9755 9756 def cons_f1809(n): 9757 return Not(IntegerQ(I*n)) 9758 9759 cons1809 = CustomConstraint(cons_f1809) 9760 9761 def cons_f1810(n, p): 9762 return NonzeroQ(n**S(2) + S(4)*(p + S(1))**S(2)) 9763 9764 cons1810 = CustomConstraint(cons_f1810) 9765 9766 def cons_f1811(n): 9767 return IntegerQ(I*n/S(2) + S(1)/2) 9768 9769 cons1811 = CustomConstraint(cons_f1811) 9770 9771 def cons_f1812(n, p): 9772 return Not(IntegerQ(-I*n/S(2) + p)) 9773 9774 cons1812 = CustomConstraint(cons_f1812) 9775 9776 def cons_f1813(n): 9777 return PositiveIntegerQ(I*n/S(2)) 9778 9779 cons1813 = CustomConstraint(cons_f1813) 9780 9781 def cons_f1814(n): 9782 return NegativeIntegerQ(I*n/S(2)) 9783 9784 cons1814 = CustomConstraint(cons_f1814) 9785 9786 def cons_f1815(n, p): 9787 return ZeroQ(n**S(2) - S(2)*p + S(-2)) 9788 9789 cons1815 = CustomConstraint(cons_f1815) 9790 9791 def cons_f1816(n): 9792 return Not(IntegerQ(I*n/S(2))) 9793 9794 cons1816 = CustomConstraint(cons_f1816) 9795 9796 def cons_f1817(a, c, d): 9797 return ZeroQ(-a**S(2)*d + c) 9798 9799 cons1817 = CustomConstraint(cons_f1817) 9800 9801 def cons_f1818(n): 9802 return RationalQ(I*n) 9803 9804 cons1818 = CustomConstraint(cons_f1818) 9805 9806 def cons_f1819(n): 9807 return Less(S(-1), I*n, S(1)) 9808 9809 cons1819 = CustomConstraint(cons_f1819) 9810 9811 def cons_f1820(a, b, d, e): 9812 return ZeroQ(-S(2)*a*e + b*d) 9813 9814 cons1820 = CustomConstraint(cons_f1820) 9815 9816 def cons_f1821(a, b, c, e): 9817 return ZeroQ(b**S(2)*c - e*(a**S(2) + S(1))) 9818 9819 cons1821 = CustomConstraint(cons_f1821) 9820 9821 def cons_f1822(a, c, p): 9822 return Or(IntegerQ(p), PositiveQ(c/(a**S(2) + S(1)))) 9823 9824 cons1822 = CustomConstraint(cons_f1822) 9825 9826 def cons_f1823(a, c, p): 9827 return Not(Or(IntegerQ(p), PositiveQ(c/(a**S(2) + S(1))))) 9828 9829 cons1823 = CustomConstraint(cons_f1823) 9830 9831 def cons_f1824(n, p): 9832 return Not(And(IntegerQ(p), EvenQ(I*n))) 9833 9834 cons1824 = CustomConstraint(cons_f1824) 9835 9836 def cons_f1825(n, p): 9837 return Not(And(Not(IntegerQ(p)), OddQ(I*n))) 9838 9839 cons1825 = CustomConstraint(cons_f1825) 9840 9841 def cons_f1826(p): 9842 return LessEqual(p, S(-1)) 9843 9844 cons1826 = CustomConstraint(cons_f1826) 9845 9846 def cons_f1827(n): 9847 return NonzeroQ(n**S(2) + S(1)) 9848 9849 cons1827 = CustomConstraint(cons_f1827) 9850 9851 def cons_f1828(n, p): 9852 return NonzeroQ(n**S(2) - S(2)*p + S(-2)) 9853 9854 cons1828 = CustomConstraint(cons_f1828) 9855 9856 def cons_f1829(m, p): 9857 return LessEqual(S(3), m, -S(2)*p + S(-2)) 9858 9859 cons1829 = CustomConstraint(cons_f1829) 9860 9861 def cons_f1830(n, p): 9862 return IntegersQ(S(2)*p, I*n/S(2) + p) 9863 9864 cons1830 = CustomConstraint(cons_f1830) 9865 9866 def cons_f1831(n, p): 9867 return Not(IntegersQ(S(2)*p, I*n/S(2) + p)) 9868 9869 cons1831 = CustomConstraint(cons_f1831) 9870 9871 def cons_f1832(A, B, c, d): 9872 return ZeroQ(-S(2)*A*c*d + B*(c**S(2) + S(1))) 9873 9874 cons1832 = CustomConstraint(cons_f1832) 9875 9876 def cons_f1833(a, b, n, x): 9877 if isinstance(x, (int, Integer, float, Float)): 9878 return False 9879 return FreeQ(List(a, b, n), x) 9880 9881 cons1833 = CustomConstraint(cons_f1833) 9882 9883 def cons_f1834(m): 9884 return Unequal(m + S(1), S(0)) 9885 9886 cons1834 = CustomConstraint(cons_f1834) 9887 9888 def cons_f1835(m, n): 9889 return Unequal(m + S(1), n) 9890 9891 cons1835 = CustomConstraint(cons_f1835) 9892 9893 def cons_f1836(a, b, c, d, f, x): 9894 if isinstance(x, (int, Integer, float, Float)): 9895 return False 9896 return FreeQ(List(a, b, c, d, f), x) 9897 9898 cons1836 = CustomConstraint(cons_f1836) 9899 9900 def cons_f1837(b, c): 9901 return ZeroQ(b + c**S(2)) 9902 9903 cons1837 = CustomConstraint(cons_f1837) 9904 9905 def cons_f1838(s): 9906 return ZeroQ(s**S(2) + S(-1)) 9907 9908 cons1838 = CustomConstraint(cons_f1838) 9909 9910 def cons_f1839(v, w): 9911 return ZeroQ(-v**S(2) + w + S(-1)) 9912 9913 cons1839 = CustomConstraint(cons_f1839) 9914 9915 def cons_f1840(v, x): 9916 if isinstance(x, (int, Integer, float, Float)): 9917 return False 9918 return NegQ(Discriminant(v, x)) 9919 9920 cons1840 = CustomConstraint(cons_f1840) 9921 9922 def cons_f1841(u, x): 9923 if isinstance(x, (int, Integer, float, Float)): 9924 return False 9925 def _cons_f_1840(f, r, w): 9926 return FreeQ(f, x) 9927 _cons_1840 = CustomConstraint(_cons_f_1840) 9928 pat = Pattern(UtilityOperator(f_**w_*WC('r', S(1)), x), _cons_1840) 9929 result_matchq = is_match(UtilityOperator(u, x), pat) 9930 return result_matchq 9931 9932 cons1841 = CustomConstraint(cons_f1841) 9933 9934 def cons_f1842(u, x): 9935 if isinstance(x, (int, Integer, float, Float)): 9936 return False 9937 def _cons_f_1841(f, r, w): 9938 return FreeQ(f, x) 9939 _cons_1841 = CustomConstraint(_cons_f_1841) 9940 pat = Pattern(UtilityOperator(f_**w_*WC('r', S(1)), x), _cons_1841) 9941 result_matchq = is_match(UtilityOperator(u, x), pat) 9942 return result_matchq 9943 9944 cons1842 = CustomConstraint(cons_f1842) 9945 9946 def cons_f1843(c, d): 9947 return ZeroQ((c + I*d)**S(2) + S(1)) 9948 9949 cons1843 = CustomConstraint(cons_f1843) 9950 9951 def cons_f1844(c, d): 9952 return ZeroQ((c - I*d)**S(2) + S(1)) 9953 9954 cons1844 = CustomConstraint(cons_f1844) 9955 9956 def cons_f1845(c, d): 9957 return NonzeroQ((c + I*d)**S(2) + S(1)) 9958 9959 cons1845 = CustomConstraint(cons_f1845) 9960 9961 def cons_f1846(c, d): 9962 return NonzeroQ((c - I*d)**S(2) + S(1)) 9963 9964 cons1846 = CustomConstraint(cons_f1846) 9965 9966 def cons_f1847(c, d): 9967 return ZeroQ((c - d)**S(2) + S(1)) 9968 9969 cons1847 = CustomConstraint(cons_f1847) 9970 9971 def cons_f1848(c, d): 9972 return NonzeroQ((c - d)**S(2) + S(1)) 9973 9974 cons1848 = CustomConstraint(cons_f1848) 9975 9976 def cons_f1849(m, u, x): 9977 if isinstance(x, (int, Integer, float, Float)): 9978 return False 9979 try: 9980 return FalseQ(PowerVariableExpn(u, m + S(1), x)) 9981 except (TypeError, AttributeError): 9982 return False 9983 9984 cons1849 = CustomConstraint(cons_f1849) 9985 9986 def cons_f1850(v, x): 9987 if isinstance(x, (int, Integer, float, Float)): 9988 return False 9989 def _cons_f_1849(c, d, m): 9990 return FreeQ(List(c, d, m), x) 9991 _cons_1849 = CustomConstraint(_cons_f_1849) 9992 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1849) 9993 result_matchq = is_match(UtilityOperator(v, x), pat) 9994 return Not(result_matchq) 9995 9996 cons1850 = CustomConstraint(cons_f1850) 9997 9998 def cons_f1851(a, b, u, v, x): 9999 if isinstance(x, (int, Integer, float, Float)): 10000 return False 10001 try: 10002 return FalseQ(FunctionOfLinear(v*(a + b*ArcTan(u)), x)) 10003 except (TypeError, AttributeError): 10004 return False 10005 10006 cons1851 = CustomConstraint(cons_f1851) 10007 10008 def cons_f1852(v, x): 10009 if isinstance(x, (int, Integer, float, Float)): 10010 return False 10011 def _cons_f_1851(c, d, m): 10012 return FreeQ(List(c, d, m), x) 10013 _cons_1851 = CustomConstraint(_cons_f_1851) 10014 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1851) 10015 result_matchq = is_match(UtilityOperator(v, x), pat) 10016 return Not(result_matchq) 10017 10018 cons1852 = CustomConstraint(cons_f1852) 10019 10020 def cons_f1853(a, b, u, v, x): 10021 if isinstance(x, (int, Integer, float, Float)): 10022 return False 10023 try: 10024 return FalseQ(FunctionOfLinear(v*(a + b*acot(u)), x)) 10025 except (TypeError, AttributeError): 10026 return False 10027 10028 cons1853 = CustomConstraint(cons_f1853) 10029 10030 def cons_f1854(a, b, v, x): 10031 if isinstance(x, (int, Integer, float, Float)): 10032 return False 10033 return ZeroQ(D(v/(a + b*x), x)) 10034 10035 cons1854 = CustomConstraint(cons_f1854) 10036 10037 def cons_f1855(a, b, w, x): 10038 if isinstance(x, (int, Integer, float, Float)): 10039 return False 10040 return ZeroQ(D(w/(a + b*x), x)) 10041 10042 cons1855 = CustomConstraint(cons_f1855) 10043 10044 def cons_f1856(a, b, c, m, n, x): 10045 if isinstance(x, (int, Integer, float, Float)): 10046 return False 10047 return FreeQ(List(a, b, c, m, n), x) 10048 10049 cons1856 = CustomConstraint(cons_f1856) 10050 10051 def cons_f1857(d): 10052 return Negative(d) 10053 10054 cons1857 = CustomConstraint(cons_f1857) 10055 10056 def cons_f1858(d, e): 10057 return Not(And(PositiveQ(e), Negative(d))) 10058 10059 cons1858 = CustomConstraint(cons_f1858) 10060 10061 def cons_f1859(v, x): 10062 if isinstance(x, (int, Integer, float, Float)): 10063 return False 10064 def _cons_f_1858(c, d, m): 10065 return FreeQ(List(c, d, m), x) 10066 _cons_1858 = CustomConstraint(_cons_f_1858) 10067 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1858) 10068 result_matchq = is_match(UtilityOperator(v, x), pat) 10069 return Not(result_matchq) 10070 10071 cons1859 = CustomConstraint(cons_f1859) 10072 10073 def cons_f1860(v, x): 10074 if isinstance(x, (int, Integer, float, Float)): 10075 return False 10076 def _cons_f_1859(c, d, m): 10077 return FreeQ(List(c, d, m), x) 10078 _cons_1859 = CustomConstraint(_cons_f_1859) 10079 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1859) 10080 result_matchq = is_match(UtilityOperator(v, x), pat) 10081 return Not(result_matchq) 10082 10083 cons1860 = CustomConstraint(cons_f1860) 10084 10085 def cons_f1861(a, b, m, n): 10086 return Or(Equal(n, S(1)), PositiveIntegerQ(m), NonzeroQ(a**S(2) + b**S(2))) 10087 10088 cons1861 = CustomConstraint(cons_f1861) 10089 10090 def cons_f1862(F): 10091 return HyperbolicQ(F) 10092 10093 cons1862 = CustomConstraint(cons_f1862) 10094 10095 def cons_f1863(G): 10096 return HyperbolicQ(G) 10097 10098 cons1863 = CustomConstraint(cons_f1863) 10099 10100 def cons_f1864(F): 10101 return MemberQ(List(Sinh, Cosh), F) 10102 10103 cons1864 = CustomConstraint(cons_f1864) 10104 10105 def cons_f1865(G): 10106 return MemberQ(List(Sech, Csch), G) 10107 10108 cons1865 = CustomConstraint(cons_f1865) 10109 10110 def cons_f1866(F, b, c, e): 10111 return NonzeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)) 10112 10113 cons1866 = CustomConstraint(cons_f1866) 10114 10115 def cons_f1867(F, b, c, e, n): 10116 return NonzeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*n**S(2)) 10117 10118 cons1867 = CustomConstraint(cons_f1867) 10119 10120 def cons_f1868(F, b, c, e, n): 10121 return ZeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(2))**S(2)) 10122 10123 cons1868 = CustomConstraint(cons_f1868) 10124 10125 def cons_f1869(F, b, c, e, n): 10126 return NonzeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(2))**S(2)) 10127 10128 cons1869 = CustomConstraint(cons_f1869) 10129 10130 def cons_f1870(F, b, c, e, n): 10131 return ZeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(-2))**S(2)) 10132 10133 cons1870 = CustomConstraint(cons_f1870) 10134 10135 def cons_f1871(F, b, c, e, n): 10136 return NonzeroQ(-b**S(2)*c**S(2)*log(F)**S(2) + e**S(2)*(n + S(-2))**S(2)) 10137 10138 cons1871 = CustomConstraint(cons_f1871) 10139 10140 def cons_f1872(f, g): 10141 return ZeroQ(f**S(2) + g**S(2)) 10142 10143 cons1872 = CustomConstraint(cons_f1872) 10144 10145 def cons_f1873(h, i): 10146 return ZeroQ(h**S(2) + i**S(2)) 10147 10148 cons1873 = CustomConstraint(cons_f1873) 10149 10150 def cons_f1874(H): 10151 return HyperbolicQ(H) 10152 10153 cons1874 = CustomConstraint(cons_f1874) 10154 10155 def cons_f1875(b, n, p): 10156 return RationalQ(b, n, p) 10157 10158 cons1875 = CustomConstraint(cons_f1875) 10159 10160 def cons_f1876(b, n, p): 10161 return ZeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + S(-1)) 10162 10163 cons1876 = CustomConstraint(cons_f1876) 10164 10165 def cons_f1877(b, n): 10166 return ZeroQ(b*n + S(-2)) 10167 10168 cons1877 = CustomConstraint(cons_f1877) 10169 10170 def cons_f1878(b, n, p): 10171 return ZeroQ(b**S(2)*n**S(2)*p**S(2) + S(-1)) 10172 10173 cons1878 = CustomConstraint(cons_f1878) 10174 10175 def cons_f1879(b, n): 10176 return NonzeroQ(b**S(2)*n**S(2) + S(-1)) 10177 10178 cons1879 = CustomConstraint(cons_f1879) 10179 10180 def cons_f1880(b, n, p): 10181 return NonzeroQ(b**S(2)*n**S(2)*p**S(2) + S(-1)) 10182 10183 cons1880 = CustomConstraint(cons_f1880) 10184 10185 def cons_f1881(b, n, p): 10186 return NonzeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) + S(-1)) 10187 10188 cons1881 = CustomConstraint(cons_f1881) 10189 10190 def cons_f1882(b, m, n, p): 10191 return ZeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) - (m + S(1))**S(2)) 10192 10193 cons1882 = CustomConstraint(cons_f1882) 10194 10195 def cons_f1883(b, m, n, p): 10196 return ZeroQ(b**S(2)*n**S(2)*p**S(2) - (m + S(1))**S(2)) 10197 10198 cons1883 = CustomConstraint(cons_f1883) 10199 10200 def cons_f1884(b, m, n): 10201 return NonzeroQ(b**S(2)*n**S(2) - (m + S(1))**S(2)) 10202 10203 cons1884 = CustomConstraint(cons_f1884) 10204 10205 def cons_f1885(b, m, n, p): 10206 return NonzeroQ(b**S(2)*n**S(2)*p**S(2) - (m + S(1))**S(2)) 10207 10208 cons1885 = CustomConstraint(cons_f1885) 10209 10210 def cons_f1886(b, m, n, p): 10211 return NonzeroQ(b**S(2)*n**S(2)*(p + S(2))**S(2) - (m + S(1))**S(2)) 10212 10213 cons1886 = CustomConstraint(cons_f1886) 10214 10215 def cons_f1887(b, n): 10216 return ZeroQ(b**S(2)*n**S(2) + S(-1)) 10217 10218 cons1887 = CustomConstraint(cons_f1887) 10219 10220 def cons_f1888(b, n, p): 10221 return ZeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + S(-1)) 10222 10223 cons1888 = CustomConstraint(cons_f1888) 10224 10225 def cons_f1889(b, n, p): 10226 return NonzeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) + S(-1)) 10227 10228 cons1889 = CustomConstraint(cons_f1889) 10229 10230 def cons_f1890(b, m, n, p): 10231 return RationalQ(b, m, n, p) 10232 10233 cons1890 = CustomConstraint(cons_f1890) 10234 10235 def cons_f1891(b, m, n): 10236 return ZeroQ(b**S(2)*n**S(2) - (m + S(1))**S(2)) 10237 10238 cons1891 = CustomConstraint(cons_f1891) 10239 10240 def cons_f1892(b, m, n, p): 10241 return NonzeroQ(b**S(2)*n**S(2)*(p + S(-2))**S(2) - (m + S(1))**S(2)) 10242 10243 cons1892 = CustomConstraint(cons_f1892) 10244 10245 def cons_f1893(A, B, a, b): 10246 return ZeroQ(A*a + B*b) 10247 10248 cons1893 = CustomConstraint(cons_f1893) 10249 10250 def cons_f1894(c, d1, e1): 10251 return ZeroQ(-c*d1 + e1) 10252 10253 cons1894 = CustomConstraint(cons_f1894) 10254 10255 def cons_f1895(c, d2, e2): 10256 return ZeroQ(c*d2 + e2) 10257 10258 cons1895 = CustomConstraint(cons_f1895) 10259 10260 def cons_f1896(d1): 10261 return PositiveQ(d1) 10262 10263 cons1896 = CustomConstraint(cons_f1896) 10264 10265 def cons_f1897(d2): 10266 return NegativeQ(d2) 10267 10268 cons1897 = CustomConstraint(cons_f1897) 10269 10270 def cons_f1898(d1, d2): 10271 return Not(And(PositiveQ(d1), NegativeQ(d2))) 10272 10273 cons1898 = CustomConstraint(cons_f1898) 10274 10275 def cons_f1899(d1, d2): 10276 return And(PositiveQ(d1), NegativeQ(d2)) 10277 10278 cons1899 = CustomConstraint(cons_f1899) 10279 10280 def cons_f1900(c, d, e): 10281 return NonzeroQ(-c**S(2)*d + e) 10282 10283 cons1900 = CustomConstraint(cons_f1900) 10284 10285 def cons_f1901(a, b, c, d1, d2, e1, e2, n, p, x): 10286 if isinstance(x, (int, Integer, float, Float)): 10287 return False 10288 return FreeQ(List(a, b, c, d1, e1, d2, e2, n, p), x) 10289 10290 cons1901 = CustomConstraint(cons_f1901) 10291 10292 def cons_f1902(c, f, g): 10293 return ZeroQ(c**S(2)*f**S(2) + g**S(2)) 10294 10295 cons1902 = CustomConstraint(cons_f1902) 10296 10297 def cons_f1903(d1, d2, p): 10298 return Not(Or(IntegerQ(p), And(PositiveQ(d1), NegativeQ(d2)))) 10299 10300 cons1903 = CustomConstraint(cons_f1903) 10301 10302 def cons_f1904(m): 10303 return NonzeroQ(m + S(3)) 10304 10305 cons1904 = CustomConstraint(cons_f1904) 10306 10307 def cons_f1905(a, b, c, d1, d2, e1, e2, f, m, n, p, x): 10308 if isinstance(x, (int, Integer, float, Float)): 10309 return False 10310 return FreeQ(List(a, b, c, d1, e1, d2, e2, f, m, n, p), x) 10311 10312 cons1905 = CustomConstraint(cons_f1905) 10313 10314 def cons_f1906(c): 10315 return ZeroQ(c**S(2) + S(1)) 10316 10317 cons1906 = CustomConstraint(cons_f1906) 10318 10319 def cons_f1907(v, x): 10320 if isinstance(x, (int, Integer, float, Float)): 10321 return False 10322 def _cons_f_1906(c, d, m): 10323 return FreeQ(List(c, d, m), x) 10324 _cons_1906 = CustomConstraint(_cons_f_1906) 10325 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1906) 10326 result_matchq = is_match(UtilityOperator(v, x), pat) 10327 return Not(result_matchq) 10328 10329 cons1907 = CustomConstraint(cons_f1907) 10330 10331 def cons_f1908(v, x): 10332 if isinstance(x, (int, Integer, float, Float)): 10333 return False 10334 def _cons_f_1907(c, d, m): 10335 return FreeQ(List(c, d, m), x) 10336 _cons_1907 = CustomConstraint(_cons_f_1907) 10337 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1907) 10338 result_matchq = is_match(UtilityOperator(v, x), pat) 10339 return Not(result_matchq) 10340 10341 cons1908 = CustomConstraint(cons_f1908) 10342 10343 def cons_f1909(c, d, e): 10344 return ZeroQ(c**S(2)*d**S(2) - e**S(2)) 10345 10346 cons1909 = CustomConstraint(cons_f1909) 10347 10348 def cons_f1910(c, d, e): 10349 return PositiveQ(c*d/e + S(1)) 10350 10351 cons1910 = CustomConstraint(cons_f1910) 10352 10353 def cons_f1911(c, d, e): 10354 return NegativeQ(c*d/e + S(-1)) 10355 10356 cons1911 = CustomConstraint(cons_f1911) 10357 10358 def cons_f1912(c, u, x): 10359 if isinstance(x, (int, Integer, float, Float)): 10360 return False 10361 return ZeroQ(u**S(2) - (S(1) - S(2)/(c*x + S(1)))**S(2)) 10362 10363 cons1912 = CustomConstraint(cons_f1912) 10364 10365 def cons_f1913(c, u, x): 10366 if isinstance(x, (int, Integer, float, Float)): 10367 return False 10368 return ZeroQ(u**S(2) - (S(1) - S(2)/(-c*x + S(1)))**S(2)) 10369 10370 cons1913 = CustomConstraint(cons_f1913) 10371 10372 def cons_f1914(c, u, x): 10373 if isinstance(x, (int, Integer, float, Float)): 10374 return False 10375 return ZeroQ((S(1) - u)**S(2) - (S(1) - S(2)/(c*x + S(1)))**S(2)) 10376 10377 cons1914 = CustomConstraint(cons_f1914) 10378 10379 def cons_f1915(c, u, x): 10380 if isinstance(x, (int, Integer, float, Float)): 10381 return False 10382 return ZeroQ((S(1) - u)**S(2) - (S(1) - S(2)/(-c*x + S(1)))**S(2)) 10383 10384 cons1915 = CustomConstraint(cons_f1915) 10385 10386 def cons_f1916(a, c, d, n): 10387 return Not(And(Equal(n, S(2)), ZeroQ(a**S(2)*c + d))) 10388 10389 cons1916 = CustomConstraint(cons_f1916) 10390 10391 def cons_f1917(c, f, g): 10392 return ZeroQ(c**S(2)*f + g) 10393 10394 cons1917 = CustomConstraint(cons_f1917) 10395 10396 def cons_f1918(a, c, d): 10397 return ZeroQ(a*c + d) 10398 10399 cons1918 = CustomConstraint(cons_f1918) 10400 10401 def cons_f1919(n, p): 10402 return Or(IntegerQ(p), ZeroQ(-n/S(2) + p), ZeroQ(-n/S(2) + p + S(-1))) 10403 10404 cons1919 = CustomConstraint(cons_f1919) 10405 10406 def cons_f1920(a, c, d): 10407 return ZeroQ(a**S(2)*c**S(2) - d**S(2)) 10408 10409 cons1920 = CustomConstraint(cons_f1920) 10410 10411 def cons_f1921(a, c, d): 10412 return ZeroQ(-a**S(2)*d**S(2) + c**S(2)) 10413 10414 cons1921 = CustomConstraint(cons_f1921) 10415 10416 def cons_f1922(a, c, d): 10417 return ZeroQ(a**S(2)*c + d) 10418 10419 cons1922 = CustomConstraint(cons_f1922) 10420 10421 def cons_f1923(n, p): 10422 return NonzeroQ(n**S(2) - S(4)*(p + S(1))**S(2)) 10423 10424 cons1923 = CustomConstraint(cons_f1923) 10425 10426 def cons_f1924(n): 10427 return Not(IntegerQ(n/S(2))) 10428 10429 cons1924 = CustomConstraint(cons_f1924) 10430 10431 def cons_f1925(n): 10432 return PositiveIntegerQ(n/S(2) + S(1)/2) 10433 10434 cons1925 = CustomConstraint(cons_f1925) 10435 10436 def cons_f1926(n, p): 10437 return Not(IntegerQ(-n/S(2) + p)) 10438 10439 cons1926 = CustomConstraint(cons_f1926) 10440 10441 def cons_f1927(n): 10442 return NegativeIntegerQ(n/S(2) + S(-1)/2) 10443 10444 cons1927 = CustomConstraint(cons_f1927) 10445 10446 def cons_f1928(n): 10447 return NegativeIntegerQ(n/S(2)) 10448 10449 cons1928 = CustomConstraint(cons_f1928) 10450 10451 def cons_f1929(n, p): 10452 return ZeroQ(n**S(2) + S(2)*p + S(2)) 10453 10454 cons1929 = CustomConstraint(cons_f1929) 10455 10456 def cons_f1930(a, c, d): 10457 return ZeroQ(a**S(2)*d + c) 10458 10459 cons1930 = CustomConstraint(cons_f1930) 10460 10461 def cons_f1931(a, b, c, e): 10462 return ZeroQ(b**S(2)*c + e*(S(1) - a**S(2))) 10463 10464 cons1931 = CustomConstraint(cons_f1931) 10465 10466 def cons_f1932(a, c, p): 10467 return Or(IntegerQ(p), PositiveQ(c/(S(1) - a**S(2)))) 10468 10469 cons1932 = CustomConstraint(cons_f1932) 10470 10471 def cons_f1933(a, c, p): 10472 return Not(Or(IntegerQ(p), PositiveQ(c/(S(1) - a**S(2))))) 10473 10474 cons1933 = CustomConstraint(cons_f1933) 10475 10476 def cons_f1934(n, p): 10477 return ZeroQ(-n/S(2) + p) 10478 10479 cons1934 = CustomConstraint(cons_f1934) 10480 10481 def cons_f1935(a, c, d): 10482 return ZeroQ(a*d + c) 10483 10484 cons1935 = CustomConstraint(cons_f1935) 10485 10486 def cons_f1936(m, n, p): 10487 return Or(IntegerQ(p), ZeroQ(-n/S(2) + p), ZeroQ(-n/S(2) + p + S(-1)), Less(S(-5), m, S(-1))) 10488 10489 cons1936 = CustomConstraint(cons_f1936) 10490 10491 def cons_f1937(n, p): 10492 return Or(IntegerQ(p), Not(IntegerQ(n))) 10493 10494 cons1937 = CustomConstraint(cons_f1937) 10495 10496 def cons_f1938(n, p): 10497 return NonzeroQ(n**S(2) + S(2)*p + S(2)) 10498 10499 cons1938 = CustomConstraint(cons_f1938) 10500 10501 def cons_f1939(n, p): 10502 return IntegersQ(S(2)*p, n/S(2) + p) 10503 10504 cons1939 = CustomConstraint(cons_f1939) 10505 10506 def cons_f1940(n, p): 10507 return Not(IntegersQ(S(2)*p, n/S(2) + p)) 10508 10509 cons1940 = CustomConstraint(cons_f1940) 10510 10511 def cons_f1941(b, c): 10512 return ZeroQ(b - c**S(2)) 10513 10514 cons1941 = CustomConstraint(cons_f1941) 10515 10516 def cons_f1942(v, x): 10517 if isinstance(x, (int, Integer, float, Float)): 10518 return False 10519 return PosQ(Discriminant(v, x)) 10520 10521 cons1942 = CustomConstraint(cons_f1942) 10522 10523 def cons_f1943(u, x): 10524 if isinstance(x, (int, Integer, float, Float)): 10525 return False 10526 def _cons_f_1942(f, r, w): 10527 return FreeQ(f, x) 10528 _cons_1942 = CustomConstraint(_cons_f_1942) 10529 pat = Pattern(UtilityOperator(f_**w_*WC('r', S(1)), x), _cons_1942) 10530 result_matchq = is_match(UtilityOperator(u, x), pat) 10531 return result_matchq 10532 10533 cons1943 = CustomConstraint(cons_f1943) 10534 10535 def cons_f1944(u, x): 10536 if isinstance(x, (int, Integer, float, Float)): 10537 return False 10538 def _cons_f_1943(f, r, w): 10539 return FreeQ(f, x) 10540 _cons_1943 = CustomConstraint(_cons_f_1943) 10541 pat = Pattern(UtilityOperator(f_**w_*WC('r', S(1)), x), _cons_1943) 10542 result_matchq = is_match(UtilityOperator(u, x), pat) 10543 return result_matchq 10544 10545 cons1944 = CustomConstraint(cons_f1944) 10546 10547 def cons_f1945(c, d): 10548 return ZeroQ((c - d)**S(2) + S(-1)) 10549 10550 cons1945 = CustomConstraint(cons_f1945) 10551 10552 def cons_f1946(c, d): 10553 return NonzeroQ((c - d)**S(2) + S(-1)) 10554 10555 cons1946 = CustomConstraint(cons_f1946) 10556 10557 def cons_f1947(c, d): 10558 return ZeroQ((c + I*d)**S(2) + S(-1)) 10559 10560 cons1947 = CustomConstraint(cons_f1947) 10561 10562 def cons_f1948(c, d): 10563 return ZeroQ((c - I*d)**S(2) + S(-1)) 10564 10565 cons1948 = CustomConstraint(cons_f1948) 10566 10567 def cons_f1949(c, d): 10568 return NonzeroQ((c + I*d)**S(2) + S(-1)) 10569 10570 cons1949 = CustomConstraint(cons_f1949) 10571 10572 def cons_f1950(c, d): 10573 return NonzeroQ((c - I*d)**S(2) + S(-1)) 10574 10575 cons1950 = CustomConstraint(cons_f1950) 10576 10577 def cons_f1951(v, x): 10578 if isinstance(x, (int, Integer, float, Float)): 10579 return False 10580 def _cons_f_1950(c, d, m): 10581 return FreeQ(List(c, d, m), x) 10582 _cons_1950 = CustomConstraint(_cons_f_1950) 10583 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1950) 10584 result_matchq = is_match(UtilityOperator(v, x), pat) 10585 return Not(result_matchq) 10586 10587 cons1951 = CustomConstraint(cons_f1951) 10588 10589 def cons_f1952(a, b, u, v, x): 10590 if isinstance(x, (int, Integer, float, Float)): 10591 return False 10592 try: 10593 return FalseQ(FunctionOfLinear(v*(a + b*atanh(u)), x)) 10594 except (TypeError, AttributeError): 10595 return False 10596 10597 cons1952 = CustomConstraint(cons_f1952) 10598 10599 def cons_f1953(v, x): 10600 if isinstance(x, (int, Integer, float, Float)): 10601 return False 10602 def _cons_f_1952(c, d, m): 10603 return FreeQ(List(c, d, m), x) 10604 _cons_1952 = CustomConstraint(_cons_f_1952) 10605 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1952) 10606 result_matchq = is_match(UtilityOperator(v, x), pat) 10607 return Not(result_matchq) 10608 10609 cons1953 = CustomConstraint(cons_f1953) 10610 10611 def cons_f1954(a, b, u, v, x): 10612 if isinstance(x, (int, Integer, float, Float)): 10613 return False 10614 try: 10615 return FalseQ(FunctionOfLinear(v*(a + b*acoth(u)), x)) 10616 except (TypeError, AttributeError): 10617 return False 10618 10619 cons1954 = CustomConstraint(cons_f1954) 10620 10621 def cons_f1955(a, p, x): 10622 if isinstance(x, (int, Integer, float, Float)): 10623 return False 10624 return FreeQ(List(a, p), x) 10625 10626 cons1955 = CustomConstraint(cons_f1955) 10627 10628 def cons_f1956(a, m, p, x): 10629 if isinstance(x, (int, Integer, float, Float)): 10630 return False 10631 return FreeQ(List(a, m, p), x) 10632 10633 cons1956 = CustomConstraint(cons_f1956) 10634 10635 def cons_f1957(v, x): 10636 if isinstance(x, (int, Integer, float, Float)): 10637 return False 10638 def _cons_f_1956(c, d, m): 10639 return FreeQ(List(c, d, m), x) 10640 _cons_1956 = CustomConstraint(_cons_f_1956) 10641 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1956) 10642 result_matchq = is_match(UtilityOperator(v, x), pat) 10643 return Not(result_matchq) 10644 10645 cons1957 = CustomConstraint(cons_f1957) 10646 10647 def cons_f1958(v, x): 10648 if isinstance(x, (int, Integer, float, Float)): 10649 return False 10650 def _cons_f_1957(c, d, m): 10651 return FreeQ(List(c, d, m), x) 10652 _cons_1957 = CustomConstraint(_cons_f_1957) 10653 pat = Pattern(UtilityOperator((x*WC('d', S(1)) + WC('c', S(0)))**WC('m', S(1)), x), _cons_1957) 10654 result_matchq = is_match(UtilityOperator(v, x), pat) 10655 return Not(result_matchq) 10656 10657 cons1958 = CustomConstraint(cons_f1958) 10658 10659 def cons_f1959(b, d): 10660 return ZeroQ(-b**S(2) + d) 10661 10662 cons1959 = CustomConstraint(cons_f1959) 10663 10664 def cons_f1960(b, d): 10665 return ZeroQ(b**S(2) + d) 10666 10667 cons1960 = CustomConstraint(cons_f1960) 10668 10669 def cons_f1961(m): 10670 return Or(Greater(m, S(0)), OddQ(m)) 10671 10672 cons1961 = CustomConstraint(cons_f1961) 10673 10674 def cons_f1962(m): 10675 return Or(And(Greater(m, S(0)), EvenQ(m)), Equal(Mod(m, S(4)), S(3))) 10676 10677 cons1962 = CustomConstraint(cons_f1962) 10678 10679 def cons_f1963(b, c): 10680 return ZeroQ(-Pi*b**S(2)/S(2) + c) 10681 10682 cons1963 = CustomConstraint(cons_f1963) 10683 10684 def cons_f1964(m): 10685 return Not(Equal(Mod(m, S(4)), S(2))) 10686 10687 cons1964 = CustomConstraint(cons_f1964) 10688 10689 def cons_f1965(m): 10690 return Equal(Mod(m, S(4)), S(0)) 10691 10692 cons1965 = CustomConstraint(cons_f1965) 10693 10694 def cons_f1966(m): 10695 return Not(Equal(Mod(m, S(4)), S(0))) 10696 10697 cons1966 = CustomConstraint(cons_f1966) 10698 10699 def cons_f1967(m): 10700 return Equal(Mod(m, S(4)), S(2)) 10701 10702 cons1967 = CustomConstraint(cons_f1967) 10703 10704 def cons_f1968(m, n): 10705 return Or(PositiveIntegerQ(m), NegativeIntegerQ(n), And(RationalQ(m, n), Greater(m, S(0)), Less(n, S(-1)))) 10706 10707 cons1968 = CustomConstraint(cons_f1968) 10708 10709 def cons_f1969(m, n): 10710 return Or(PositiveIntegerQ(n), And(RationalQ(m, n), Less(m, S(-1)), Greater(n, S(0)))) 10711 10712 cons1969 = CustomConstraint(cons_f1969) 10713 10714 def cons_f1970(n): 10715 return Not(And(IntegerQ(n), LessEqual(n, S(0)))) 10716 10717 cons1970 = CustomConstraint(cons_f1970) 10718 10719 def cons_f1971(m, n): 10720 return Or(PositiveIntegerQ(m), PositiveIntegerQ(n), IntegersQ(m, n)) 10721 10722 cons1971 = CustomConstraint(cons_f1971) 10723 10724 def cons_f1972(a, c): 10725 return ZeroQ(a - c + S(1)) 10726 10727 cons1972 = CustomConstraint(cons_f1972) 10728 10729 def cons_f1973(s): 10730 return NonzeroQ(s + S(-1)) 10731 10732 cons1973 = CustomConstraint(cons_f1973) 10733 10734 def cons_f1974(s): 10735 return NonzeroQ(s + S(-2)) 10736 10737 cons1974 = CustomConstraint(cons_f1974) 10738 10739 def cons_f1975(a, b, n, p, q, x): 10740 if isinstance(x, (int, Integer, float, Float)): 10741 return False 10742 return FreeQ(List(a, b, n, p, q), x) 10743 10744 cons1975 = CustomConstraint(cons_f1975) 10745 10746 def cons_f1976(r): 10747 return RationalQ(r) 10748 10749 cons1976 = CustomConstraint(cons_f1976) 10750 10751 def cons_f1977(r): 10752 return Greater(r, S(0)) 10753 10754 cons1977 = CustomConstraint(cons_f1977) 10755 10756 def cons_f1978(F, a, b, c, d, n, p, x): 10757 if isinstance(x, (int, Integer, float, Float)): 10758 return False 10759 return FreeQ(List(F, a, b, c, d, n, p), x) 10760 10761 cons1978 = CustomConstraint(cons_f1978) 10762 10763 def cons_f1979(n, p): 10764 return Or(ZeroQ(n*(p + S(-1)) + S(1)), And(IntegerQ(p + S(-1)/2), ZeroQ(n*(p + S(-1)/2) + S(1)))) 10765 10766 cons1979 = CustomConstraint(cons_f1979) 10767 10768 def cons_f1980(n, p): 10769 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)))) 10770 10771 cons1980 = CustomConstraint(cons_f1980) 10772 10773 def cons_f1981(m, n, p): 10774 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)))) 10775 10776 cons1981 = CustomConstraint(cons_f1981) 10777 10778 def cons_f1982(m, n, p): 10779 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)))) 10780 10781 cons1982 = CustomConstraint(cons_f1982) 10782 10783 def cons_f1983(a, c, m, x): 10784 if isinstance(x, (int, Integer, float, Float)): 10785 return False 10786 return FreeQ(List(a, c, m), x) 10787 10788 cons1983 = CustomConstraint(cons_f1983) 10789 10790 def cons_f1984(a, b, c, d, p, x): 10791 if isinstance(x, (int, Integer, float, Float)): 10792 return False 10793 return FreeQ(List(a, b, c, d, p), x) 10794 10795 cons1984 = CustomConstraint(cons_f1984) 10796 10797 def cons_f1985(n, p): 10798 return ZeroQ(n*(p + S(-1)) + S(1)) 10799 10800 cons1985 = CustomConstraint(cons_f1985) 10801 10802 def cons_f1986(n, p): 10803 return ZeroQ(p + S(1)/n) 10804 10805 cons1986 = CustomConstraint(cons_f1986) 10806 10807 def cons_f1987(n, p): 10808 return ZeroQ(p + S(-1)/2 + S(1)/n) 10809 10810 cons1987 = CustomConstraint(cons_f1987) 10811 10812 def cons_f1988(c, n): 10813 return PosQ(c*n) 10814 10815 cons1988 = CustomConstraint(cons_f1988) 10816 10817 def cons_f1989(c, n): 10818 return NegQ(c*n) 10819 10820 cons1989 = CustomConstraint(cons_f1989) 10821 10822 def cons_f1990(n, p): 10823 return Greater(n*(p + S(-1)) + S(1), S(0)) 10824 10825 cons1990 = CustomConstraint(cons_f1990) 10826 10827 def cons_f1991(n, p): 10828 return Less(n*p + S(1), S(0)) 10829 10830 cons1991 = CustomConstraint(cons_f1991) 10831 10832 def cons_f1992(a, d, x): 10833 if isinstance(x, (int, Integer, float, Float)): 10834 return False 10835 return FreeQ(List(a, d), x) 10836 10837 cons1992 = CustomConstraint(cons_f1992) 10838 10839 def cons_f1993(a, d, n, x): 10840 if isinstance(x, (int, Integer, float, Float)): 10841 return False 10842 return FreeQ(List(a, d, n), x) 10843 10844 cons1993 = CustomConstraint(cons_f1993) 10845 10846 def cons_f1994(a, c, d, n, p, x): 10847 if isinstance(x, (int, Integer, float, Float)): 10848 return False 10849 return FreeQ(List(a, c, d, n, p), x) 10850 10851 cons1994 = CustomConstraint(cons_f1994) 10852 10853 def cons_f1995(m, n, p): 10854 return ZeroQ(m + n*(p + S(-1)) + S(1)) 10855 10856 cons1995 = CustomConstraint(cons_f1995) 10857 10858 def cons_f1996(m, n, p): 10859 return ZeroQ(m + n*p + S(1)) 10860 10861 cons1996 = CustomConstraint(cons_f1996) 10862 10863 def cons_f1997(m, n, p): 10864 return ZeroQ(m + n*(p + S(-1)/2) + S(1)) 10865 10866 cons1997 = CustomConstraint(cons_f1997) 10867 10868 def cons_f1998(c, p): 10869 return PosQ(c/(p + S(-1)/2)) 10870 10871 cons1998 = CustomConstraint(cons_f1998) 10872 10873 def cons_f1999(c, p): 10874 return NegQ(c/(p + S(-1)/2)) 10875 10876 cons1999 = CustomConstraint(cons_f1999) 10877 10878 def cons_f2000(m, n, p): 10879 return RationalQ((m + n*p + S(1))/n) 10880 10881 cons2000 = CustomConstraint(cons_f2000) 10882 10883 def cons_f2001(m, n, p): 10884 return Greater((m + n*p + S(1))/n, S(1)) 10885 10886 cons2001 = CustomConstraint(cons_f2001) 10887 10888 def cons_f2002(m, n, p): 10889 return Less((m + n*p + S(1))/n, S(0)) 10890 10891 cons2002 = CustomConstraint(cons_f2002) 10892 10893 def cons_f2003(u, x): 10894 if isinstance(x, (int, Integer, float, Float)): 10895 return False 10896 return FunctionOfQ(ProductLog(x), u, x) 10897 10898 cons2003 = CustomConstraint(cons_f2003) 10899 10900 def cons_f2004(n, u, x): 10901 if isinstance(x, (int, Integer, float, Float)): 10902 return False 10903 def _cons_f_2003(n1, v): 10904 return ZeroQ(n - n1 - 1) 10905 _cons_2003 = CustomConstraint(_cons_f_2003) 10906 pat = Pattern(UtilityOperator(x**WC('n1', S(1))*WC('v', S(1)), x), _cons_2003) 10907 result_matchq = is_match(UtilityOperator(u, x), pat) 10908 return Not(result_matchq) 10909 10910 cons2004 = CustomConstraint(cons_f2004) 10911 10912 def cons_f2005(e, g): 10913 return ZeroQ(e + g) 10914 10915 cons2005 = CustomConstraint(cons_f2005) 10916 10917 def cons_f2006(d, f): 10918 return ZeroQ(d + f + S(-2)) 10919 10920 cons2006 = CustomConstraint(cons_f2006) 10921 10922 def cons_f2007(A, C, d, e, f): 10923 return ZeroQ(A*e**S(2) + C*d*f) 10924 10925 cons2007 = CustomConstraint(cons_f2007) 10926 10927 def cons_f2008(B, C, d, e): 10928 return ZeroQ(-B*e + S(2)*C*(d + S(-1))) 10929 10930 cons2008 = CustomConstraint(cons_f2008) 10931 10932 def cons_f2009(A, C, e): 10933 return ZeroQ(A*e**S(2) + C) 10934 10935 cons2009 = CustomConstraint(cons_f2009) 10936 10937 def cons_f2010(n): 10938 return Not(PositiveQ(n)) 10939 10940 cons2010 = CustomConstraint(cons_f2010) 10941 10942 def cons_f2011(v, y): 10943 return ZeroQ(-v + y) 10944 10945 cons2011 = CustomConstraint(cons_f2011) 10946 10947 def cons_f2012(w, y): 10948 return ZeroQ(-w + y) 10949 10950 cons2012 = CustomConstraint(cons_f2012) 10951 10952 def cons_f2013(y, z): 10953 return ZeroQ(y - z) 10954 10955 cons2013 = CustomConstraint(cons_f2013) 10956 10957 def cons_f2014(a, b, m, n, p, x): 10958 if isinstance(x, (int, Integer, float, Float)): 10959 return False 10960 return FreeQ(List(a, b, m, n, p), x) 10961 10962 cons2014 = CustomConstraint(cons_f2014) 10963 10964 def cons_f2015(v, w): 10965 return ZeroQ(-v + w) 10966 10967 cons2015 = CustomConstraint(cons_f2015) 10968 10969 def cons_f2016(p, q, r): 10970 return ZeroQ(p - q*(r + S(1))) 10971 10972 cons2016 = CustomConstraint(cons_f2016) 10973 10974 def cons_f2017(r): 10975 return NonzeroQ(r + S(1)) 10976 10977 cons2017 = CustomConstraint(cons_f2017) 10978 10979 def cons_f2018(p, r): 10980 return IntegerQ(p/(r + S(1))) 10981 10982 cons2018 = CustomConstraint(cons_f2018) 10983 10984 def cons_f2019(p, q, r, s): 10985 return ZeroQ(p*(s + S(1)) - q*(r + S(1))) 10986 10987 cons2019 = CustomConstraint(cons_f2019) 10988 10989 def cons_f2020(m, p, q): 10990 return ZeroQ(p + q*(m*p + S(1))) 10991 10992 cons2020 = CustomConstraint(cons_f2020) 10993 10994 def cons_f2021(m, p, q, r): 10995 return ZeroQ(p + q*(m*p + r + S(1))) 10996 10997 cons2021 = CustomConstraint(cons_f2021) 10998 10999 def cons_f2022(m, p, q, s): 11000 return ZeroQ(p*(s + S(1)) + q*(m*p + S(1))) 11001 11002 cons2022 = CustomConstraint(cons_f2022) 11003 11004 def cons_f2023(s): 11005 return NonzeroQ(s + S(1)) 11006 11007 cons2023 = CustomConstraint(cons_f2023) 11008 11009 def cons_f2024(q, s): 11010 return IntegerQ(q/(s + S(1))) 11011 11012 cons2024 = CustomConstraint(cons_f2024) 11013 11014 def cons_f2025(m, p, q, r, s): 11015 return ZeroQ(p*(s + S(1)) + q*(m*p + r + S(1))) 11016 11017 cons2025 = CustomConstraint(cons_f2025) 11018 11019 def cons_f2026(m, u, x): 11020 if isinstance(x, (int, Integer, float, Float)): 11021 return False 11022 return FunctionOfQ(x**(m + S(1)), u, x) 11023 11024 cons2026 = CustomConstraint(cons_f2026) 11025 11026 def cons_f2027(w, x): 11027 if isinstance(x, (int, Integer, float, Float)): 11028 return False 11029 return Not(FreeQ(w, x)) 11030 11031 cons2027 = CustomConstraint(cons_f2027) 11032 11033 def cons_f2028(x, z): 11034 if isinstance(x, (int, Integer, float, Float)): 11035 return False 11036 return Not(FreeQ(z, x)) 11037 11038 cons2028 = CustomConstraint(cons_f2028) 11039 11040 def cons_f2029(a, m): 11041 return Not(And(EqQ(a, S(1)), EqQ(m, S(1)))) 11042 11043 cons2029 = CustomConstraint(cons_f2029) 11044 11045 def cons_f2030(m, v, x): 11046 if isinstance(x, (int, Integer, float, Float)): 11047 return False 11048 return Not(And(EqQ(v, x), EqQ(m, S(1)))) 11049 11050 cons2030 = CustomConstraint(cons_f2030) 11051 11052 def cons_f2031(u, x): 11053 if isinstance(x, (int, Integer, float, Float)): 11054 return False 11055 return Not(RationalFunctionQ(u, x)) 11056 11057 cons2031 = CustomConstraint(cons_f2031) 11058 11059 def cons_f2032(v, x): 11060 if isinstance(x, (int, Integer, float, Float)): 11061 return False 11062 return Not(LinearQ(v, x)) 11063 11064 cons2032 = CustomConstraint(cons_f2032) 11065 11066 def cons_f2033(r, s): 11067 return PosQ(-r + s) 11068 11069 cons2033 = CustomConstraint(cons_f2033) 11070 11071 def cons_f2034(u, x): 11072 if isinstance(x, (int, Integer, float, Float)): 11073 return False 11074 return Not(AlgebraicFunctionQ(u, x)) 11075 11076 cons2034 = CustomConstraint(cons_f2034) 11077 11078 def cons_f2035(m, u, x): 11079 if isinstance(x, (int, Integer, float, Float)): 11080 return False 11081 return Or(Greater(m, S(0)), Not(AlgebraicFunctionQ(u, x))) 11082 11083 cons2035 = CustomConstraint(cons_f2035) 11084 11085 def cons_f2036(u, x): 11086 if isinstance(x, (int, Integer, float, Float)): 11087 return False 11088 return EulerIntegrandQ(u, x) 11089 11090 cons2036 = CustomConstraint(cons_f2036) 11091 11092 def cons_f2037(u, v, x): 11093 if isinstance(x, (int, Integer, float, Float)): 11094 return False 11095 return PolynomialInQ(v, u, x) 11096 11097 cons2037 = CustomConstraint(cons_f2037) 11098 11099 def cons_f2038(a, d): 11100 return ZeroQ(a + d) 11101 11102 cons2038 = CustomConstraint(cons_f2038) 11103 11104 def cons_f2039(p, q): 11105 return ZeroQ(p + q) 11106 11107 cons2039 = CustomConstraint(cons_f2039) 11108