src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
GitMetadataEtl extends EtlJob { public void extract() throws Exception { logger.info("git extract"); String gitHost = this.prop.getProperty(Constant.GIT_HOST_KEY); String[] projects = (this.prop.getProperty(Constant.GIT_PROJECT_WHITELIST_KEY)).trim().split("\\s*,\\s*"); String localDir = this.prop.getProperty(Constant.WH_APP_FOLDER_KEY) + "/" + this.prop.getProperty(Constant.APP_ID_KEY); File dir = new File(localDir); if (!dir.exists()) { if (!dir.mkdirs()) { throw new Exception("can not create metadata directory"); } } FileWriter fw = new FileWriter(localDir + "/" + COMMIT_OUTPUT_FILE); for (String project : projects) { Map<String, String> repos = GitUtil.getRepoListFromProject(GitUtil.getHttpsUrl(gitHost, project)); for (String repo : repos.keySet()) { String repoUri = repos.get(repo); String repoDir = localDir + "/" + repo; GitUtil.clone(repoUri, repoDir); List<GitUtil.CommitMetadata> commitMetadataList = GitUtil.getRepoMetadata(repoDir); for (GitUtil.CommitMetadata m : commitMetadataList) { fw.append(new GitCommitRecord(m, repoUri)); } } } fw.close(); } GitMetadataEtl(int appId, long whExecId); GitMetadataEtl(int appId, long whExecId, Properties prop); void extract(); @Override void transform(); @Override void load(); public ClassLoader classLoader; static final String COMMIT_OUTPUT_FILE; } | @Test public void testExtract() throws Exception { git.extract(); } |
DatasetTreeBuildETL extends EtlJob { @Override public void load() throws Exception { logger.info("In DatasetTreeBuildETL java launch load jython scripts"); InputStream inputStream = classLoader.getResourceAsStream("jython/DatasetTreeBuilder.py"); interpreter.execfile(inputStream); inputStream.close(); logger.info("In DatasetTreeBuildETL java load jython scripts finished"); } DatasetTreeBuildETL(int appId, long whExecId); DatasetTreeBuildETL(int appId, long whExecId, Properties properties); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testLoad() throws Exception { datasetTreeBuildETL.load(); } |
GitMetadataEtl extends EtlJob { @Override public void transform() throws Exception { logger.info("git transform"); InputStream inputStream = classLoader.getResourceAsStream("jython/GitTransform.py"); interpreter.execfile(inputStream); inputStream.close(); } GitMetadataEtl(int appId, long whExecId); GitMetadataEtl(int appId, long whExecId, Properties prop); void extract(); @Override void transform(); @Override void load(); public ClassLoader classLoader; static final String COMMIT_OUTPUT_FILE; } | @Test public void testTransform() throws Exception { git.transform(); } |
GitMetadataEtl extends EtlJob { @Override public void load() throws Exception { logger.info("git load"); InputStream inputStream = classLoader.getResourceAsStream("jython/GitLoad.py"); interpreter.execfile(inputStream); inputStream.close(); } GitMetadataEtl(int appId, long whExecId); GitMetadataEtl(int appId, long whExecId, Properties prop); void extract(); @Override void transform(); @Override void load(); public ClassLoader classLoader; static final String COMMIT_OUTPUT_FILE; } | @Test public void testLoad() throws Exception { git.load(); } |
DatasetOwnerEtl extends EtlJob { @Override public void extract() throws Exception { logger.info("Begin hdfs dataset ownership extract!"); JSch jsch = new JSch(); Session session = null; try { session = jsch.getSession(this.prop.getProperty(Constant.HDFS_REMOTE_USER_KEY), this.prop.getProperty(Constant.HDFS_REMOTE_MACHINE_KEY)); session.setConfig("PreferredAuthentications", "publickey"); jsch.addIdentity(this.prop.getProperty(Constant.HDFS_PRIVATE_KEY_LOCATION_KEY)); Properties config = new Properties(); config.put("StrictHostKeyChecking", "no"); session.setConfig(config); session.connect(); String remoteDir = prop.getProperty(Constant.HDFS_REMOTE_WORKING_DIR); String localDir = prop.getProperty(Constant.WH_APP_FOLDER_KEY) + "/" + prop.getProperty(Constant.DB_ID_KEY); File dir = new File(localDir); if (!dir.exists()) { if (!dir.mkdirs()) { throw new Exception("can not create metadata directory"); } } ChannelSftp channelSftp = (ChannelSftp) session.openChannel("sftp"); channelSftp.connect(); InputStream localFileStream = classLoader.getResourceAsStream("java/" + JAVA_FILE_NAME + JAVA_EXT); channelSftp.put(localFileStream, remoteDir + "/" + JAVA_FILE_NAME + JAVA_EXT, ChannelSftp.OVERWRITE); localFileStream.close(); String hiveQuery = prop.getProperty(Constant.HDFS_OWNER_HIVE_QUERY_KEY); localFileStream = new ByteArrayInputStream(hiveQuery.getBytes()); channelSftp.put(localFileStream, remoteDir + "/" + HIVE_SCRIPT_FILE, ChannelSftp.OVERWRITE); localFileStream.close(); StringBuilder execCmd = new StringBuilder(""); execCmd.append("cd " + remoteDir + ";"); execCmd.append("javac " + JAVA_FILE_NAME + JAVA_EXT + ";"); execCmd.append("java -cp " + CLASSPATH + " " + JAVA_FILE_NAME + " " + HIVE_SCRIPT_FILE + " " + OUTPUT_FILE_NAME + ";"); logger.info("execute remote command : " + execCmd); Channel execChannel = session.openChannel("exec"); ((ChannelExec) execChannel).setCommand(execCmd.toString()); execChannel.setInputStream(System.in); execChannel.setOutputStream(System.out); ((ChannelExec) execChannel).setErrStream(System.err); execChannel.connect(); logger.debug("Debug : execChannel exit-status: " + execChannel.getExitStatus()); while (execChannel.getExitStatus() == -1) { try { Thread.sleep(1000); } catch (Exception e) { System.out.println(e); } } logger.debug("execute finished!"); execChannel.disconnect(); String remoteOutputFile = remoteDir + "/" + OUTPUT_FILE_NAME; String localOutputFile = localDir + "/" + OUTPUT_FILE_NAME; channelSftp.get(remoteOutputFile, localOutputFile); logger.info("extract ownership finished"); channelSftp.exit(); } catch (Exception e) { logger.error("hdfs ownership collection error!"); StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); e.printStackTrace(pw); logger.error(sw.toString()); throw e; } finally { if (session != null) { session.disconnect(); } } } @Deprecated DatasetOwnerEtl(int dbId, long whExecId); DatasetOwnerEtl(int dbId, long whExecId, Properties prop); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testExtract() throws Exception { doe.extract(); } |
DatasetOwnerEtl extends EtlJob { @Override public void transform() throws Exception { logger.info("hdfs ownership transform"); InputStream inputStream = classLoader.getResourceAsStream("jython/OwnerTransform.py"); interpreter.execfile(inputStream); inputStream.close(); } @Deprecated DatasetOwnerEtl(int dbId, long whExecId); DatasetOwnerEtl(int dbId, long whExecId, Properties prop); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testTransform() throws Exception { doe.transform(); } |
DatasetOwnerEtl extends EtlJob { @Override public void load() throws Exception { logger.info("hdfs ownership load"); InputStream inputStream = classLoader.getResourceAsStream("jython/OwnerLoad.py"); interpreter.execfile(inputStream); inputStream.close(); logger.info("hdfs ownership load finished"); } @Deprecated DatasetOwnerEtl(int dbId, long whExecId); DatasetOwnerEtl(int dbId, long whExecId, Properties prop); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testLoad() throws Exception { doe.load(); } |
OozieExecEtl extends EtlJob { @Override public void extract() throws Exception { logger.info("In OozieExecEtl java launch extract jython scripts"); InputStream inputStream = classLoader.getResourceAsStream("jython/OozieExtract.py"); interpreter.execfile(inputStream); inputStream.close(); } OozieExecEtl(int appId, long whExecId); OozieExecEtl(int appId, long whExecId, Properties properties); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testExtract() throws Exception { oz.extract(); } |
OozieExecEtl extends EtlJob { @Override public void transform() throws Exception { logger.info("In OozieExecEtl java launch transform jython scripts"); InputStream inputStream = classLoader.getResourceAsStream("jython/OozieTransform.py"); interpreter.execfile(inputStream); inputStream.close(); } OozieExecEtl(int appId, long whExecId); OozieExecEtl(int appId, long whExecId, Properties properties); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testTransform() throws Exception { oz.transform(); } |
OozieExecEtl extends EtlJob { @Override public void load() throws Exception { logger.info("In OozieExecEtl java launch load jython scripts"); InputStream inputStream = classLoader.getResourceAsStream("jython/OozieLoad.py"); interpreter.execfile(inputStream); inputStream.close(); logger.info("In OozieExecEtl java load jython scripts finished"); } OozieExecEtl(int appId, long whExecId); OozieExecEtl(int appId, long whExecId, Properties properties); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testLoad() throws Exception { oz.load(); } |
AzkabanExecEtl extends EtlJob { @Override public void extract() throws Exception { logger.info("In AzkabanExecEtl java launch extract jython scripts"); InputStream inputStream = classLoader.getResourceAsStream("jython/AzkabanExtract.py"); interpreter.execfile(inputStream); inputStream.close(); } AzkabanExecEtl(int appId, long whExecId); AzkabanExecEtl(int appId, long whExecId, Properties properties); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testExtract() throws Exception { az.extract(); } |
AzkabanExecEtl extends EtlJob { @Override public void transform() throws Exception { logger.info("In AzkabanExecEtl java launch transform jython scripts"); InputStream inputStream = classLoader.getResourceAsStream("jython/AzkabanTransform.py"); interpreter.execfile(inputStream); inputStream.close(); } AzkabanExecEtl(int appId, long whExecId); AzkabanExecEtl(int appId, long whExecId, Properties properties); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testTransform() throws Exception { az.transform(); } |
LdapEtl extends EtlJob { public void extract() throws Exception { logger.info("ldap db extract"); InputStream inputStream = classLoader.getResourceAsStream("jython/LdapExtract.py"); interpreter.execfile(inputStream); inputStream.close(); } LdapEtl(int appId, long whExecId); LdapEtl(int appId, long whExecId, Properties prop); void extract(); @Override void transform(); @Override void load(); public ClassLoader classLoader; } | @Test(groups = {"needConfig"}) public void testExtract() throws Exception { ldapEtl.extract(); } |
AzkabanExecEtl extends EtlJob { @Override public void load() throws Exception { logger.info("In AzkabanExecEtl java launch load jython scripts"); InputStream inputStream = classLoader.getResourceAsStream("jython/AzkabanLoad.py"); interpreter.execfile(inputStream); inputStream.close(); logger.info("In AzkabanExecEtl java load jython scripts finished"); } AzkabanExecEtl(int appId, long whExecId); AzkabanExecEtl(int appId, long whExecId, Properties properties); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testLoad() throws Exception { az.load(); } |
GitUtil { public static void clone(String remoteUri, String localDir) throws IOException, GitAPIException { File localGitRepo = new File(localDir); if (localGitRepo.exists()) { if (localGitRepo.isDirectory()) { FileUtils.cleanDirectory(localGitRepo); } else { throw new IOException("File exists: " + localDir); } } else { localGitRepo.mkdirs(); } Git g = Git.cloneRepository().setURI(remoteUri).setDirectory(localGitRepo).call(); g.close(); } static void clone(String remoteUri, String localDir); static Map<String, String> getRepoListFromProject(String projectUrl); static List<CommitMetadata> getRepoMetadata(String repoDir); static String getHttpsUrl(String host, String path); static String getGitUrl(String host, String path); static String getSshUrl(String host, String path); static final String HTTPS_PROTOCAL; static final String GIT_PROTOCAL; static final String GIT_SUBFIX; } | @Test public void testClone() throws Exception { } |
GitUtil { public static Map<String, String> getRepoListFromProject(String projectUrl) throws IOException { Map<String, String> repoList = new HashMap<>(); Document doc = Jsoup.connect(projectUrl).data("format", "xml").get(); Elements repos = doc.getElementsByTag("repositories"); Elements mainlines = repos.first().getElementsByTag("mainlines"); Elements repo = mainlines.first().getElementsByTag("repository"); for (Element e : repo) { String repoName = e.getElementsByTag("name").first().text(); String repoUrl = e.getElementsByTag("clone_url").first().text(); repoList.put(repoName.trim(), repoUrl.trim()); } return repoList; } static void clone(String remoteUri, String localDir); static Map<String, String> getRepoListFromProject(String projectUrl); static List<CommitMetadata> getRepoMetadata(String repoDir); static String getHttpsUrl(String host, String path); static String getGitUrl(String host, String path); static String getSshUrl(String host, String path); static final String HTTPS_PROTOCAL; static final String GIT_PROTOCAL; static final String GIT_SUBFIX; } | @Test public void testGetRepoListFromProject() throws Exception { } |
GitUtil { public static List<CommitMetadata> getRepoMetadata(String repoDir) throws IOException, GitAPIException { List<CommitMetadata> metadataList = new ArrayList<>(); FileRepositoryBuilder builder = new FileRepositoryBuilder(); Repository repository = builder.setGitDir(new File(repoDir, ".git")).readEnvironment().findGitDir().build(); String currentBranch = repository.getBranch(); Ref head = repository.getRef("refs/heads/" + currentBranch); if (head == null) { return metadataList; } Git git = new Git(repository); RevWalk walk = new RevWalk(repository); RevCommit commit = walk.parseCommit(head.getObjectId()); TreeWalk treeWalk = new TreeWalk(repository); treeWalk.addTree(commit.getTree()); treeWalk.setRecursive(true); while (treeWalk.next()) { String filePath = treeWalk.getPathString(); Iterable<RevCommit> commitLog = git.log().add(repository.resolve(Constants.HEAD)).addPath(filePath).call(); for (RevCommit r : commitLog) { CommitMetadata metadata = new CommitMetadata(r.getName()); metadata.setFilePath(filePath); metadata.setFileName(FilenameUtils.getName(filePath)); metadata.setMessage(r.getShortMessage().trim()); PersonIdent committer = r.getCommitterIdent(); PersonIdent author = r.getAuthorIdent(); metadata.setAuthor(author.getName()); metadata.setAuthorEmail(author.getEmailAddress()); metadata.setCommitter(committer.getName()); metadata.setCommitterEmail(committer.getEmailAddress()); metadata.setCommitTime(committer.getWhen()); metadataList.add(metadata); } } git.close(); return metadataList; } static void clone(String remoteUri, String localDir); static Map<String, String> getRepoListFromProject(String projectUrl); static List<CommitMetadata> getRepoMetadata(String repoDir); static String getHttpsUrl(String host, String path); static String getGitUrl(String host, String path); static String getSshUrl(String host, String path); static final String HTTPS_PROTOCAL; static final String GIT_PROTOCAL; static final String GIT_SUBFIX; } | @Test public void testGetRepoMetadata() throws Exception { } |
LdapEtl extends EtlJob { @Override public void transform() throws Exception { logger.info("ldap db transform"); InputStream inputStream = classLoader.getResourceAsStream("jython/LdapTransform.py"); interpreter.execfile(inputStream); inputStream.close(); } LdapEtl(int appId, long whExecId); LdapEtl(int appId, long whExecId, Properties prop); void extract(); @Override void transform(); @Override void load(); public ClassLoader classLoader; } | @Test(groups = {"needConfig"}) public void testTransform() throws Exception { ldapEtl.transform(); } |
LdapEtl extends EtlJob { @Override public void load() throws Exception { logger.info("ldap db load"); InputStream inputStream = classLoader.getResourceAsStream("jython/LdapLoad.py"); interpreter.execfile(inputStream); inputStream.close(); } LdapEtl(int appId, long whExecId); LdapEtl(int appId, long whExecId, Properties prop); void extract(); @Override void transform(); @Override void load(); public ClassLoader classLoader; } | @Test(groups = {"needConfig"}) public void testLoad() throws Exception { ldapEtl.load(); } |
ElasticSearchBuildIndexETL extends EtlJob { @Override public void extract() throws Exception { logger.info("In ElasticSearchBuildIndexETL java launch extract jython scripts"); } ElasticSearchBuildIndexETL(int appId, long whExecId); ElasticSearchBuildIndexETL(int appId, long whExecId, Properties properties); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testExtract() throws Exception { esbi.extract(); } |
ElasticSearchBuildIndexETL extends EtlJob { @Override public void transform() throws Exception { logger.info("In ElasticSearchBuildIndexETL java launch transform jython scripts"); } ElasticSearchBuildIndexETL(int appId, long whExecId); ElasticSearchBuildIndexETL(int appId, long whExecId, Properties properties); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testTransform() throws Exception { esbi.transform(); } |
ElasticSearchBuildIndexETL extends EtlJob { @Override public void load() throws Exception { logger.info("In ElasticSearchBuildIndexETL java launch load jython scripts"); InputStream inputStream = classLoader.getResourceAsStream("jython/ElasticSearchIndex.py"); interpreter.execfile(inputStream); inputStream.close(); logger.info("In ElasticSearchBuildIndexETL java load jython scripts finished"); } ElasticSearchBuildIndexETL(int appId, long whExecId); ElasticSearchBuildIndexETL(int appId, long whExecId, Properties properties); @Override void extract(); @Override void transform(); @Override void load(); } | @Test(groups = {"needConfig"}) public void testLoad() throws Exception { esbi.load(); } |
Rationals implements Ring<Rational<E>> { @Override public Rational<E> randomElement(RandomGenerator rnd) { long den; E eden; do {den = rnd.nextInt();} while (ring.isZero(eden = ring.valueOf(den))); return new Rational<>(ring, ring.valueOf(rnd.nextInt()), eden); } Rationals(Ring<E> ring); Rational<E> mkNumerator(E num); Rational<E> mkNumerator(long num); Rational<E> mkDenominator(E den); Rational<E> mkDenominator(long den); Rational<E> mk(E num, E den); Rational<E> mk(long num, long den); @Override boolean isField(); @Override boolean isEuclideanRing(); @Override BigInteger cardinality(); @Override BigInteger characteristic(); @Override boolean isPerfectPower(); @Override BigInteger perfectPowerBase(); @Override BigInteger perfectPowerExponent(); @Override Rational<E> add(Rational<E> a, Rational<E> b); @Override Rational<E> subtract(Rational<E> a, Rational<E> b); @Override Rational<E> multiply(Rational<E> a, Rational<E> b); @Override Rational<E> negate(Rational<E> element); @Override int signum(Rational<E> element); @Override @SuppressWarnings("unchecked") Rational<E>[] divideAndRemainder(Rational<E> dividend, Rational<E> divider); @Override Rational<E> reciprocal(Rational<E> element); @Override Rational<E> gcd(Rational<E> a, Rational<E> b); @Override FactorDecomposition<Rational<E>> factorSquareFree(Rational<E> element); @Override FactorDecomposition<Rational<E>> factor(Rational<E> element); @Override Rational<E> getZero(); @Override Rational<E> getOne(); @Override boolean isZero(Rational<E> element); @Override boolean isOne(Rational<E> element); @Override boolean isUnit(Rational<E> element); @Override Rational<E> valueOf(long val); @Override Rational<E> valueOfBigInteger(BigInteger val); @Override Rational<E> copy(Rational<E> element); @Override Rational<E> valueOf(Rational<E> val); @Override @SuppressWarnings("unchecked") Rational<E>[][] createArray2d(int length); @Override @SuppressWarnings("unchecked") Rational<E>[][] createArray2d(int m, int n); @Override int compare(Rational<E> o1, Rational<E> o2); @Override Rational<E> getNegativeOne(); @Override @SuppressWarnings("unchecked") Rational<E>[] createArray(int length); @Override Rational<E> randomElement(RandomGenerator rnd); @Override Rational<E> randomElementTree(RandomGenerator rnd); @Override Iterator<Rational<E>> iterator(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(IStringifier<Rational<E>> stringifier); @Override String toString(); final Ring<E> ring; } | @Test public void test1() throws Exception { for (int i = 19; i < 1000; i++) Assert.assertNotNull(Frac(UnivariateRingZp64(17)).randomElement()); } |
UnivariateGCD { @SuppressWarnings("ConstantConditions") public static UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a, UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b) { UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> simpleGCD = TrivialGCDInNumberField(a, b); if (simpleGCD != null) return simpleGCD; AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> numberField = (AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>>) a.ring; UnivariatePolynomial<Rational<BigInteger>> minimalPoly = numberField.getMinimalPolynomial(); assert numberField.isField(); a = a.clone(); b = b.clone(); if (minimalPoly.stream().allMatch(Rational::isIntegral)) { UnivariatePolynomial<BigInteger> minimalPolyZ = minimalPoly.mapCoefficients(Z, Rational::numerator); AlgebraicNumberField<UnivariatePolynomial<BigInteger>> numberFieldZ = new AlgebraicNumberField<>(minimalPolyZ); removeDenominators(a); removeDenominators(b); assert a.stream().allMatch(p -> p.stream().allMatch(Rational::isIntegral)); assert b.stream().allMatch(p -> p.stream().allMatch(Rational::isIntegral)); UnivariatePolynomial<UnivariatePolynomial<BigInteger>> gcdZ = gcdAssociateInNumberField( a.mapCoefficients(numberFieldZ, cf -> cf.mapCoefficients(Z, Rational::numerator)), b.mapCoefficients(numberFieldZ, cf -> cf.mapCoefficients(Z, Rational::numerator))); return gcdZ .mapCoefficients(numberField, p -> p.mapCoefficients(Q, cf -> new Rational<>(Z, cf))) .monic(); } else { BigInteger minPolyLeadCoeff = commonDenominator(minimalPoly); Rational<BigInteger> scale = new Rational<>(Z, Z.getOne(), minPolyLeadCoeff), scaleReciprocal = scale.reciprocal(); AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> scaledNumberField = new AlgebraicNumberField<>(minimalPoly.scale(scale).monic()); return PolynomialGCDInNumberField( a.mapCoefficients(scaledNumberField, cf -> cf.scale(scale)), b.mapCoefficients(scaledNumberField, cf -> cf.scale(scale))) .mapCoefficients(numberField, cf -> cf.scale(scaleReciprocal)); } } private UnivariateGCD(); @SuppressWarnings("unchecked") static T PolynomialGCD(T a, T b); @SuppressWarnings("unchecked") static T[] PolynomialExtendedGCD(T a, T b); static T[] PolynomialFirstBezoutCoefficient(T a, T b); static T PolynomialGCD(T... polynomials); static T PolynomialGCD(Iterable<T> polynomials); static T EuclidGCD(final T a, final T b); @SuppressWarnings("unchecked") static T[] ExtendedEuclidGCD(final T a, final T b); static T[] EuclidFirstBezoutCoefficient(final T a, final T b); static T HalfGCD(T a, T b); static T[] ExtendedHalfGCD(T a, T b); static UnivariatePolynomialZ64 ModularGCD(UnivariatePolynomialZ64 a, UnivariatePolynomialZ64 b); @SuppressWarnings("ConstantConditions") static UnivariatePolynomial<BigInteger> ModularGCD(UnivariatePolynomial<BigInteger> a,
UnivariatePolynomial<BigInteger> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static UnivariatePolynomial<Rational<BigInteger>>[] ModularExtendedRationalGCD(
UnivariatePolynomial<Rational<BigInteger>> a,
UnivariatePolynomial<Rational<BigInteger>> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static UnivariatePolynomial<Rational<BigInteger>>[] ModularExtendedResultantGCDInQ(UnivariatePolynomial<Rational<BigInteger>> a,
UnivariatePolynomial<Rational<BigInteger>> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static UnivariatePolynomial<BigInteger>[] ModularExtendedResultantGCDInZ(UnivariatePolynomial<BigInteger> a,
UnivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("ConstantConditions") static UnivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDInRingOfIntegersOfNumberField(UnivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
UnivariatePolynomial<UnivariatePolynomial<BigInteger>> b); static boolean updateCRT(ChineseRemaindersMagic<BigInteger> magic,
UnivariatePolynomial<BigInteger> accumulated,
UnivariatePolynomialZp64 update); } | @Test @Benchmark public void test44_algext_performance() { UnivariatePolynomial<Rational<BigInteger>> minimalPoly = UnivariatePolynomial.create(31229703, 31584466, 9500649, 9480702, 23265262, 5568454, 3392530, 30401154, 15298203, 25411939, 30401154, 15298203, 25411939, 31584466, 9500649, 9480702, 30401154, 15298203, 25411939, 30401154, 15298203, 25411939, 1).mapCoefficients(Q, Q::valueOfBigInteger); AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = AlgebraicNumberField(minimalPoly); Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> cfCoder = Coder.mkUnivariateCoder(field, "s"); UnivariateRing<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> uRing = UnivariateRing(field); Coder<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>, ?, ?> coder = Coder.mkUnivariateCoder(uRing, cfCoder, "x"); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a = coder.parse("-2629984078 - 2747848492*s - 826556509*s^2 - 824821066*s^3 - 2024077758*s^4 - 484455432*s^5 - 295150100*s^6 - 2644900377*s^7 - 1330943630*s^8 - 2210838750*s^9 + (-2539295050 - 2653095078*s - 798054533*s^2 - 796378949*s^3 - 1954282008*s^4 - 467750096*s^5 - 284972456*s^6 - 2553696896*s^7 - 1285048960*s^8 - 2134602853*s^9)*x + (2750903023 + 2874186377*s + 864559081*s^2 + 862743871*s^3 + 2117138752*s^4 + 506729319*s^5 + 308720296*s^6 + 2766505047*s^7 + 1392136388*s^8 + 2312486542*s^9)*x^2 + (-2902051419 - 3032108714*s - 912062266*s^2 - 910147339*s^3 - 2233465130*s^4 - 534571658*s^5 - 325682847*s^6 - 2918510751*s^7 - 1468627461*s^8 - 2439546109*s^9)*x^3 + (-2025390071 - 2116159152*s - 636543408*s^2 - 635207023*s^3 - 1558772527*s^4 - 373086362*s^5 - 227299470*s^6 - 2036877303*s^7 - 1024979692*s^8 - 1702599819*s^9)*x^4 + (-2962510945 - 3095277661*s - 931063590*s^2 - 929108773*s^3 - 2279995709*s^4 - 545708558*s^5 - 332467948*s^6 - 2979313000*s^7 - 1499223872*s^8 - 2490370012*s^9)*x^5 + (-1934700903 - 2021405804*s - 608041537*s^2 - 606764926*s^3 - 1488976751*s^4 - 356381007*s^5 - 217121886*s^6 - 1945673813*s^7 - 979084946*s^8 - 1626364082*s^9)*x^6 + (-997580106 - 1042287350*s - 313521458*s^2 - 312863069*s^3 - 767753632*s^4 - 183758950*s^5 - 111953411*s^6 - 1003238154*s^7 - 504840626*s^8 - 838594076*s^9)*x^7 + (-1178958351 - 1231794140*s - 370525402*s^2 - 369747315*s^3 - 907345216*s^4 - 217169661*s^5 - 132308571*s^6 - 1185645024*s^7 - 596629988*s^8 - 991065545*s^9)*x^8 + (-2025390077 - 2116159255*s - 636543412*s^2 - 635207025*s^3 - 1558772532*s^4 - 373086332*s^5 - 227299454*s^6 - 2036877243*s^7 - 1024979650*s^8 - 1702599890*s^9)*x^9 + (1118499087 + 1168625309*s + 351524046*s^2 + 350785991*s^3 + 860814787*s^4 + 206032829*s^5 + 125523644*s^6 + 1124842769*s^7 + 566033562*s^8 + 940241738*s^9)*x^10 + (-2267227821 - 2368834898*s - 712548607*s^2 - 711052633*s^3 - 1744894553*s^4 - 417633996*s^5 - 254439748*s^6 - 2280086614*s^7 - 1147365191*s^8 - 1905895490*s^9)*x^11 + (1239417854 + 1294963126*s + 389526531*s^2 + 388708754*s^3 + 953875698*s^4 + 228306652*s^5 + 139093768*s^6 + 1246447343*s^7 + 627226377*s^8 + 1041889549*s^9)*x^12 + (-906891056 - 947533928*s - 285019558*s^2 - 284421059*s^3 - 697957802*s^4 - 167053574*s^5 - 101775989*s^6 - 912034527*s^7 - 458946168*s^8 - 762358095*s^9)*x^13 + (-1844011957 - 1926652508*s - 579539643*s^2 - 578322774*s^3 - 1419181047*s^4 - 339675694*s^5 - 206944325*s^6 - 1854470337*s^7 - 933190317*s^8 - 1550128270*s^9)*x^14 + (1602174351 + 1673976642*s + 503534338*s^2 + 502477269*s^3 + 1233058976*s^4 + 295128130*s^5 + 179804110*s^6 + 1611261193*s^7 + 810804831*s^8 + 1346832799*s^9)*x^15 + (-453445531 - 473766944*s - 142509715*s^2 - 142210541*s^3 - 348978962*s^4 - 83526711*s^5 - 50887854*s^6 - 456017293*s^7 - 229473009*s^8 - 381179039*s^9)*x^16 + (-2509065293 - 2621510610*s - 788553921*s^2 - 786898292*s^3 - 1931016741*s^4 - 462181736*s^5 - 281579982*s^6 - 2523295772*s^7 - 1269750839*s^8 - 2109190927*s^9)*x^17 + (-1964930601 - 2052990286*s - 617542158*s^2 - 616245716*s^3 - 1512241977*s^4 - 361949565*s^5 - 220514529*s^6 - 1976074947*s^7 - 994383246*s^8 - 1651775975*s^9)*x^18 + (2327687048 + 2432003909*s + 731549963*s^2 + 730014071*s^3 + 1791425258*s^4 + 428771016*s^5 + 261224799*s^6 + 2340888912*s^7 + 1177961640*s^8 + 1956719266*s^9)*x^19"); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b = coder.parse("-2297457369 - 2400419408*s - 722049354*s^2 - 720533283*s^3 - 1768159825*s^4 - 423202465*s^5 - 257832326*s^6 - 2310487767*s^7 - 1162663504*s^8 - 1931307309*s^9 + (-1118498918 - 1168625170*s - 351523998*s^2 - 350785953*s^3 - 860814620*s^4 - 206032844*s^5 - 125523543*s^6 - 1124842734*s^7 - 566033484*s^8 - 940241840*s^9)*x + (-634823841 - 663273730*s - 199513585*s^2 - 199094740*s^3 - 488570500*s^4 - 116937491*s^5 - 71243056*s^6 - 638424217*s^7 - 321262269*s^8 - 533650647*s^9)*x^2 + (-120918804 - 126337886*s - 38002569*s^2 - 37922791*s^3 - 93061011*s^4 - 22273824*s^5 - 13570040*s^6 - 121604571*s^7 - 61192741*s^8 - 101647722*s^9)*x^3 + (-2629984238 - 2747848535*s - 826556405*s^2 - 824821002*s^3 - 2024077765*s^4 - 484455463*s^5 - 295150103*s^6 - 2644900316*s^7 - 1330943621*s^8 - 2210838616*s^9)*x^4 + (60459502 + 63168844*s + 19001371*s^2 + 18961478*s^3 + 46530559*s^4 + 11136967*s^5 + 6785128*s^6 + 60802294*s^7 + 30596476*s^8 + 50823949*s^9)*x^5 + (-2599754450 - 2716264170*s - 817055796*s^2 - 815340331*s^3 - 2000812621*s^4 - 478886953*s^5 - 291757547*s^6 - 2614499288*s^7 - 1315645534*s^8 - 2185426692*s^9)*x^6 + (-1964930626 - 2052990342*s - 617542144*s^2 - 616245697*s^3 - 1512242053*s^4 - 361949415*s^5 - 220514397*s^6 - 1976074963*s^7 - 994383244*s^8 - 1651775954*s^9)*x^7 + (-1571944495 - 1642392288*s - 494033670*s^2 - 492996488*s^3 - 1209793576*s^4 - 289559689*s^5 - 176411479*s^6 - 1580860073*s^7 - 795506501*s^8 - 1321420729*s^9)*x^8 + (2811362414 + 2937355383*s + 883560380*s^2 + 881705200*s^3 + 2163669280*s^4 + 517866158*s^5 + 315505366*s^6 + 2827307413*s^7 + 1422732958*s^8 + 2363310334*s^9)*x^9 + (2116079261 + 2210912639*s + 665045462*s^2 + 663649187*s^3 + 1628568308*s^4 + 389791803*s^5 + 237477108*s^6 + 2128080876*s^7 + 1070874245*s^8 + 1778835730*s^9)*x^10 + (-2236998012 - 2337250400*s - 703047951*s^2 - 701571937*s^3 - 1721629439*s^4 - 412065534*s^5 - 251047253*s^6 - 2249685310*s^7 - 1132067031*s^8 - 1880483482*s^9)*x^11 + (-2629984108 - 2747848541*s - 826556482*s^2 - 824821041*s^3 - 2024077781*s^4 - 484455457*s^5 - 295150030*s^6 - 2644900382*s^7 - 1330943563*s^8 - 2210838627*s^9)*x^12"); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> g = coder.parse("-2811362312 - 2937355319*s - 883560337*s^2 - 881705356*s^3 - 2163669316*s^4 - 517866198*s^5 - 315505348*s^6 - 2827307397*s^7 - 1422732833*s^8 - 2363310305*s^9 + (-1027809863 - 1073871832*s - 323021979*s^2 - 322343852*s^3 - 791018874*s^4 - 189327442*s^5 - 115345990*s^6 - 1033639203*s^7 - 520138994*s^8 - 864005935*s^9)*x + (755742670 + 789611730*s + 237516324*s^2 + 237017568*s^3 + 581631609*s^4 + 139211399*s^5 + 84813301*s^6 + 760028909*s^7 + 382455125*s^8 + 635298486*s^9)*x^2 + (-2569524725 - 2684679604*s - 807555125*s^2 - 805859617*s^3 - 1977547175*s^4 - 473318570*s^5 - 288364973*s^6 - 2584098178*s^7 - 1300347246*s^8 - 2160014731*s^9)*x^3 + (-90689044 - 94753334*s - 28502018*s^2 - 28442203*s^3 - 69795734*s^4 - 16705297*s^5 - 10177621*s^6 - 91203421*s^7 - 45894548*s^8 - 76235851*s^9)*x^4 + (-60459337 - 63168954*s - 19001279*s^2 - 18961469*s^3 - 46530495*s^4 - 11136820*s^5 - 6785055*s^6 - 60802219*s^7 - 30596432*s^8 - 50823814*s^9)*x^5 + (-2206768278 - 2305665984*s - 693547285*s^2 - 692091191*s^3 - 1698364119*s^4 - 406497048*s^5 - 247654596*s^6 - 2219284280*s^7 - 1116768829*s^8 - 1855071634*s^9)*x^6 + (-2992740680 - 3126862134*s - 940564345*s^2 - 938589464*s^3 - 2303260921*s^4 - 551276902*s^5 - 335860390*s^6 - 3009714187*s^7 - 1514522192*s^8 - 2515781892*s^9)*x^7 + (-937120739 - 979118398*s - 294520061*s^2 - 293901791*s^3 - 721223167*s^4 - 172622016*s^5 - 105168421*s^6 - 942435722*s^7 - 474244292*s^8 - 787770068*s^9)*x^8 + (-2569524839 - 2684679579*s - 807555086*s^2 - 805859625*s^3 - 1977547366*s^4 - 473318589*s^5 - 288365123*s^6 - 2584098088*s^7 - 1300347180*s^8 - 2160014805*s^9)*x^9 + (-302297052 - 315844685*s - 95006420*s^2 - 94806952*s^3 - 232652706*s^4 - 55684503*s^5 - 33925202*s^6 - 304011605*s^7 - 152982033*s^8 - 254119332*s^9)*x^10 + (362756428 + 379013624*s + 114007873*s^2 + 113768522*s^3 + 279183228*s^4 + 66821400*s^5 + 40710454*s^6 + 364813756*s^7 + 183578437*s^8 + 304943317*s^9)*x^11 + (-2327687116 - 2432003792*s - 731549932*s^2 - 730014098*s^3 - 1791425234*s^4 - 428770976*s^5 - 261224810*s^6 - 2340888824*s^7 - 1177961606*s^8 - 1956719264*s^9)*x^12 + (-2962510886 - 3095277709*s - 931063515*s^2 - 929108855*s^3 - 2279995592*s^4 - 545708444*s^5 - 332467892*s^6 - 2979313007*s^7 - 1499223814*s^8 - 2490369949*s^9)*x^13 + (1904471341 + 1989821396*s + 598540924*s^2 + 597284317*s^3 + 1465711520*s^4 + 350812607*s^5 + 213729418*s^6 + 1915272618*s^7 + 963786874*s^8 + 1600952190*s^9)*x^14 + (1420796032 + 1484469924*s + 446530582*s^2 + 445593084*s^3 + 1093467219*s^4 + 261717435*s^5 + 159448870*s^6 + 1428854284*s^7 + 719015466*s^8 + 1194361180*s^9)*x^15 + (-2327687165 - 2432003807*s - 731549938*s^2 - 730013976*s^3 - 1791425083*s^4 - 428770908*s^5 - 261224823*s^6 - 2340888813*s^7 - 1177961603*s^8 - 1956719254*s^9)*x^16 + (1390566435 + 1452885413*s + 437029859*s^2 + 436112351*s^3 + 1070202123*s^4 + 256148955*s^5 + 156056436*s^6 + 1398453101*s^7 + 703717376*s^8 + 1168949284*s^9)*x^17 + (-272067241 - 284260115*s - 85505836*s^2 - 85326368*s^3 - 209387338*s^4 - 50116022*s^5 - 30532678*s^6 - 273610327*s^7 - 137683742*s^8 - 228707356*s^9)*x^18 + (-1027809875 - 1073871903*s - 323021967*s^2 - 322343855*s^3 - 791018854*s^4 - 189327350*s^5 - 115345977*s^6 - 1033639175*s^7 - 520138874*s^8 - 864005908*s^9)*x^19 + (-2055619749 - 2147743611*s - 646044049*s^2 - 644687698*s^3 - 1582037829*s^4 - 378654787*s^5 - 230691998*s^6 - 2067278570*s^7 - 1040277772*s^8 - 1728011857*s^9)*x^20 + (-1783552468 - 1863483492*s - 560538209*s^2 - 559361408*s^3 - 1372650543*s^4 - 328538714*s^5 - 200159198*s^6 - 1793668083*s^7 - 902593935*s^8 - 1499304498*s^9)*x^21 + (-876661420 - 915949489*s - 275518819*s^2 - 274940409*s^3 - 674692521*s^4 - 161485158*s^5 - 98383273*s^6 - 881633387*s^7 - 443647831*s^8 - 736946230*s^9)*x^22 + (-2116079189 - 2210912556*s - 665045429*s^2 - 663649110*s^3 - 1628568244*s^4 - 389791730*s^5 - 237477099*s^6 - 2128080829*s^7 - 1070874203*s^8 - 1778835671*s^9)*x^23 + (-1239417745 - 1294963053*s - 389526527*s^2 - 388708825*s^3 - 953875650*s^4 - 228306522*s^5 - 139093680*s^6 - 1246447329*s^7 - 627226263*s^8 - 1041889490*s^9)*x^24 + (-2509065417 - 2621510653*s - 788553920*s^2 - 786898228*s^3 - 1931016745*s^4 - 462181615*s^5 - 281579891*s^6 - 2523295782*s^7 - 1269750822*s^8 - 2109190863*s^9)*x^25"); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ag = a.clone().multiply(g).multiply(a.clone().decrement()), bg = b.clone().multiply(g).multiply(b.clone().decrement()); for (int i = 0; i < 2; ++i) { long start; start = System.nanoTime(); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> mod = UnivariateGCD.PolynomialGCDInNumberField(ag, bg); System.out.println("Modular: " + nanosecondsToString(System.nanoTime() - start)); assertTrue(remainder(mod, g, true).isZero()); } }
@Test public void test41algext() { UnivariatePolynomial<Rational<BigInteger>> minimalPoly = UnivariatePolynomial.create(2, 0, 0, 0, 0, 0, 5).mapCoefficients(Q, Q::valueOfBigInteger); AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = AlgebraicNumberField(minimalPoly); Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> cfCoder = Coder.mkUnivariateCoder(field, "s"); UnivariateRing<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> uRing = UnivariateRing(field); Coder<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>, ?, ?> coder = Coder.mkUnivariateCoder(uRing, cfCoder, "x"); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a = coder.parse("(1 - s + (1 - 3*s^5) * x^5) * ( 3 + s*x^2 + 12*s^6*x^5)"); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b = coder.parse("(1 - s + (1 - 3*s^5) * x^5) * ( 14 - s*x + 2*s*x^17)^2"); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> gcd = UnivariateGCD.PolynomialGCDInNumberField(a, b); assertGCD(a, b, gcd); }
@Test public void test43_algext_random() throws Exception { RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = getRandomData(); for (int i = 0; i < its(30, 100); i++) { UnivariatePolynomial<Rational<BigInteger>> minimalPoly = IrreduciblePolynomials.randomIrreduciblePolynomialOverZ(rndd.nextInt(1, 5), rnd) .mapCoefficients(Q, Q::valueOfBigInteger); AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = new AlgebraicNumberField<>(minimalPoly); for (int j = 0; j < 3; ++j) { UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a = randomPolyOverAlgExt(field, 10, 30, rndd), b = randomPolyOverAlgExt(field, 10, 30, rndd), gcd = randomPolyOverAlgExt(field, 10, 30, rndd); a = a.multiply(gcd); b = b.multiply(gcd); long start = System.nanoTime(); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> mgcd = PolynomialGCDInNumberField(a, b); System.out.print(i + ": " + nanosecondsToString(System.nanoTime() - start) + " "); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>[] qr = UnivariateDivision.divideAndRemainder(mgcd, gcd, true); assertNotNull(qr); assertTrue(qr[1].isZero()); assertGCD(a, b, mgcd); } System.out.println(); } } |
UnivariatePolynomialArithmetic { public static <T extends IUnivariatePolynomial<T>> T polyMultiplyMod(T m1, T m2, T polyModulus, boolean copy) { return polyMod((copy ? m1.clone() : m1).multiply(m2), polyModulus, false); } private UnivariatePolynomialArithmetic(); static T polyMod(T dividend, T polyModulus, boolean copy); static T polyMod(T dividend, T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod, boolean copy); static T polyMultiplyMod(T m1, T m2, T polyModulus, boolean copy); static T polyMultiplyMod(T m1, T m2,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyAddMod(T m1, T m2,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyAddMod(T m1, T m2, T polyModulus, boolean copy); static T polySubtractMod(T m1, T m2,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polySubtractMod(T m1, T m2, T polyModulus, boolean copy); static T polyNegateMod(T m1,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyNegateMod(T m1, T polyModulus, boolean copy); static T polyPow(final T base, long exponent, boolean copy); static T polyPowMod(final T base, long exponent,
T polyModulus,
boolean copy); static T polyPowMod(final T base, long exponent,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyPowMod(final T base, BigInteger exponent,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyPowMod(final T base, BigInteger exponent,
T polyModulus,
boolean copy); static T createMonomialMod(long exponent,
T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod); static T createMonomialMod(BigInteger exponent,
T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod); } | @Test public void test1() throws Exception { long modulus = 5; UnivariatePolynomialZp64 a = UnivariatePolynomialZ64.create(1, 4).modulus(modulus); UnivariatePolynomialZp64 b = UnivariatePolynomialZ64.create(0, 2, 3).modulus(modulus); UnivariatePolynomialZp64 polyModulus = UnivariatePolynomialZ64.create(0, 4, 0, 1).modulus(modulus); Assert.assertEquals(UnivariatePolynomialZ64.create(0, 4, 1).modulus(modulus), UnivariatePolynomialArithmetic.polyMultiplyMod(a, b, polyModulus, true)); Assert.assertEquals(UnivariatePolynomialZ64.create(0, 4, 1).modulus(modulus), UnivariatePolynomialArithmetic.polyMultiplyMod(a.clone(), b, polyModulus, false)); } |
UnivariatePolynomialArithmetic { public static <T extends IUnivariatePolynomial<T>> T polyPow(final T base, long exponent, boolean copy) { if (exponent < 0) throw new IllegalArgumentException(); T result = base.createOne(); T k2p = copy ? base.clone() : base; for (; ; ) { if ((exponent & 1) != 0) result = result.multiply(k2p); exponent = exponent >> 1; if (exponent == 0) return result; k2p = k2p.multiply(k2p); } } private UnivariatePolynomialArithmetic(); static T polyMod(T dividend, T polyModulus, boolean copy); static T polyMod(T dividend, T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod, boolean copy); static T polyMultiplyMod(T m1, T m2, T polyModulus, boolean copy); static T polyMultiplyMod(T m1, T m2,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyAddMod(T m1, T m2,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyAddMod(T m1, T m2, T polyModulus, boolean copy); static T polySubtractMod(T m1, T m2,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polySubtractMod(T m1, T m2, T polyModulus, boolean copy); static T polyNegateMod(T m1,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyNegateMod(T m1, T polyModulus, boolean copy); static T polyPow(final T base, long exponent, boolean copy); static T polyPowMod(final T base, long exponent,
T polyModulus,
boolean copy); static T polyPowMod(final T base, long exponent,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyPowMod(final T base, BigInteger exponent,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyPowMod(final T base, BigInteger exponent,
T polyModulus,
boolean copy); static T createMonomialMod(long exponent,
T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod); static T createMonomialMod(BigInteger exponent,
T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod); } | @Test public void test3() throws Exception { Assert.assertEquals(UnivariatePolynomialZ64.create(1, 2, 1), UnivariatePolynomialArithmetic.polyPow(UnivariatePolynomialZ64.create(1, 1), 2, true)); Assert.assertEquals(UnivariatePolynomialZ64.create(1, 2, 1), UnivariatePolynomialArithmetic.polyPow(UnivariatePolynomialZ64.create(1, 1), 2, false)); }
@Test public void test4() throws Exception { UnivariatePolynomialZ64 a = UnivariatePolynomialZ64.create(1, 0, 1, 0, 1); UnivariatePolynomialZ64 b = UnivariatePolynomialZ64.create(1, 1, 1); UnivariatePolynomialArithmetic.polyPow(b.modulus(2), 2, true); } |
UnivariatePolynomialArithmetic { public static <T extends IUnivariatePolynomial<T>> T polyPowMod(final T base, long exponent, T polyModulus, boolean copy) { return polyPowMod(base, exponent, polyModulus, UnivariateDivision.fastDivisionPreConditioning(polyModulus), copy); } private UnivariatePolynomialArithmetic(); static T polyMod(T dividend, T polyModulus, boolean copy); static T polyMod(T dividend, T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod, boolean copy); static T polyMultiplyMod(T m1, T m2, T polyModulus, boolean copy); static T polyMultiplyMod(T m1, T m2,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyAddMod(T m1, T m2,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyAddMod(T m1, T m2, T polyModulus, boolean copy); static T polySubtractMod(T m1, T m2,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polySubtractMod(T m1, T m2, T polyModulus, boolean copy); static T polyNegateMod(T m1,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyNegateMod(T m1, T polyModulus, boolean copy); static T polyPow(final T base, long exponent, boolean copy); static T polyPowMod(final T base, long exponent,
T polyModulus,
boolean copy); static T polyPowMod(final T base, long exponent,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyPowMod(final T base, BigInteger exponent,
T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod,
boolean copy); static T polyPowMod(final T base, BigInteger exponent,
T polyModulus,
boolean copy); static T createMonomialMod(long exponent,
T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod); static T createMonomialMod(BigInteger exponent,
T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod); } | @Test public void test5() throws Exception { long modulus = 3; UnivariatePolynomialZp64 a = UnivariatePolynomialZ64.create(0, 0, 0, 1).modulus(modulus); UnivariatePolynomialZp64 polyModulus = UnivariatePolynomialZ64.create(0, -1, -1, -1, 0, 1, -1, 1, 1).modulus(modulus); Assert.assertEquals(UnivariatePolynomialZ64.create(0, -1, 0, 0, 1, 1, 1, -1).modulus(modulus), UnivariatePolynomialArithmetic.polyPowMod(a, modulus, polyModulus, true)); Assert.assertEquals(UnivariatePolynomialZ64.create(0, -1, 0, 0, 1, 1, 1, -1).modulus(modulus), UnivariatePolynomialArithmetic.polyPowMod(a, modulus, polyModulus, false)); } |
UnivariateFactorization { public static <Poly extends IUnivariatePolynomial<Poly>> PolynomialFactorDecomposition<Poly> FactorInGF(Poly poly) { Util.ensureOverFiniteField(poly); if (canConvertToZp64(poly)) return FactorInGF(asOverZp64(poly)).mapTo(Conversions64bit::convert); PolynomialFactorDecomposition<Poly> result = earlyFactorizationChecks(poly); if (result != null) return result; result = PolynomialFactorDecomposition.empty(poly); FactorInGF(poly, result); return result.setUnit(poly.lcAsPoly()); } private UnivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(Poly poly); static PolynomialFactorDecomposition<UnivariatePolynomial<Rational<E>>> FactorInQ(UnivariatePolynomial<Rational<E>> poly); static PolynomialFactorDecomposition<Poly> FactorInGF(Poly poly); static PolynomialFactorDecomposition<T> FactorSquareFreeInGF(T poly); static PolynomialFactorDecomposition<PolyZ> FactorSquareFreeInZ(PolyZ poly); static PolynomialFactorDecomposition<Poly> FactorInZ(Poly poly); static PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly); static PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorSquareFreeInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly); } | @Test public void test1() throws Exception { assertTrue(UnivariateFactorization.FactorInGF(UnivariatePolynomialZ64.create(3, 7).modulus(19)).get(0).isMonic()); }
@Test public void test2() throws Exception { BigInteger modulus = BigInteger.LONG_MAX_VALUE; modulus = modulus.multiply(modulus).increment().nextProbablePrime(); UnivariatePolynomial<BigInteger> poly = UnivariatePolynomial.create(new IntegersZp(modulus), BigInteger.valueOf(Long.MAX_VALUE), BigInteger.valueOf(Long.MAX_VALUE - 1), BigInteger.valueOf(Long.MAX_VALUE - 2)); for (int i = 0; i < 5; i++) poly = poly.square().add(poly.derivative()).increment(); PolynomialFactorDecomposition<UnivariatePolynomial<BigInteger>> fct = UnivariateFactorization.FactorInGF(poly); Assert.assertEquals(7, fct.size()); FactorDecompositionTest.assertFactorization(poly, fct); }
@Test public void test3() throws Exception { long modulus = 13; UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(5, 8, 1, 5, 7, 0, 0, 1, 5, 7, 0, 9, 3, 2).modulus(modulus); FactorDecompositionTest.assertFactorization(poly, UnivariateFactorization.FactorInGF(poly)); }
@Test public void test4a() throws Exception { long modulus = 59; UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(46, 16, 1, 54, 16, 57, 22, 15, 31, 21).modulus(modulus); PolynomialFactorDecomposition<UnivariatePolynomialZp64> fct = UnivariateFactorization.FactorInGF(poly); FactorDecompositionTest.assertFactorization(poly, fct); assertEquals(5, fct.size()); assertEquals(6, fct.sumExponents()); }
@Test public void test4b() throws Exception { for (int i = 0; i < 100; i++) { PrivateRandom.getRandom().setSeed(i); long modulus = 3; UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.parse("2*x^2+2*x^3+2*x^5+x^7+2*x^9+2*x^10+x^11+2*x^12+x^13+2*x^14+x^16+x^18+x^19+2*x^20+2*x^21").modulus(modulus); PolynomialFactorDecomposition<UnivariatePolynomialZp64> fct = UnivariateFactorization.FactorInGF(poly); FactorDecompositionTest.assertFactorization(poly, fct); assertEquals(6, fct.size()); assertEquals(15, fct.sumExponents()); } }
@Test public void test4c() throws Exception { PrivateRandom.getRandom().setSeed(76); long modulus = 3; UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.parse("2*x^2+2*x^3+2*x^5+x^7+2*x^9+2*x^10+x^11+2*x^12+x^13+2*x^14+x^16+x^18+x^19+2*x^20+2*x^21").modulus(modulus); PolynomialFactorDecomposition<UnivariatePolynomialZp64> fct = UnivariateFactorization.FactorInGF(poly); FactorDecompositionTest.assertFactorization(poly, fct); assertEquals(6, fct.size()); assertEquals(15, fct.sumExponents()); }
@Test public void test4e() throws Exception { PrivateRandom.getRandom().setSeed(4178); long modulus = 29; UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.parse("10+25*x+23*x^2+7*x^3+21*x^4+9*x^5+9*x^6+16*x^7+10*x^8+24*x^9+3*x^10+24*x^11+8*x^12").modulus(modulus); PolynomialFactorDecomposition<UnivariatePolynomialZp64> fct = UnivariateFactorization.FactorInGF(poly); FactorDecompositionTest.assertFactorization(poly, fct); assertEquals(8, fct.size()); assertEquals(9, fct.sumExponents()); }
@Test public void testFiniteField1() throws Exception { UnivariatePolynomialZp64 irreducible = IrreduciblePolynomials.randomIrreduciblePolynomial(2, 10, getRandom()); FiniteField<UnivariatePolynomialZp64> domain = new FiniteField<>(irreducible); UnivariatePolynomialZp64 c0 = domain.valueOf(UnivariatePolynomialZ64.create(1, 2, 3, 4, 5).modulus(irreducible.ring)), c1 = domain.valueOf(UnivariatePolynomialZ64.create(1, -2, 3, -4, -5).modulus(irreducible.ring)), c2 = domain.valueOf(UnivariatePolynomialZ64.create(11, 12, 13, 14, 15).modulus(irreducible.ring)), c3 = domain.add(c0, c1), c4 = domain.subtract(c1, c2), c5 = domain.multiply(c0, c1); UnivariatePolynomial<UnivariatePolynomialZp64> poly1 = UnivariatePolynomial.create(domain, c0, c1, c2, c3, c4, c5), poly2 = UnivariatePolynomial.create(domain, c5, c4, c3, c2, c1, c0), poly = poly1.clone().multiply(poly2).multiply(poly1.clone().add(poly2)); PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomialZp64>> factors = UnivariateFactorization.FactorInGF(poly); FactorDecompositionTest.assertFactorization(poly, factors); }
@Test public void testFiniteField2() throws Exception { UnivariatePolynomialZp64 irreducible = UnivariatePolynomialZ64.create(1, 1, 0, 1).modulus(2); FiniteField<UnivariatePolynomialZp64> domain = new FiniteField<>(irreducible); UnivariatePolynomial<UnivariatePolynomialZp64> poly = UnivariatePolynomial.create(domain, UnivariatePolynomialZ64.create(0, 0, 1).modulus(2), UnivariatePolynomialZ64.create(0, 1, 1).modulus(2), UnivariatePolynomialZ64.create(0, 0, 1).modulus(2), UnivariatePolynomialZ64.create(1).modulus(2), UnivariatePolynomialZ64.create(0, 0, 1).modulus(2), UnivariatePolynomialZ64.create(0).modulus(2), UnivariatePolynomialZ64.create(1, 0, 1).modulus(2), UnivariatePolynomialZ64.create(0, 0, 1).modulus(2)); PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomialZp64>> factors = UnivariateFactorization.FactorInGF(poly); FactorDecompositionTest.assertFactorization(poly, factors); } |
ArraysUtil { public static <T> int[] bijection(T[] from, T[] to, Comparator<? super T> comparator) { if (from.length != to.length) return null; int length = from.length; int[] bijection = new int[length]; Arrays.fill(bijection, -1); int i, j; OUT: for (i = 0; i < length; ++i) { for (j = 0; j < length; ++j) if (bijection[j] == -1 && comparator.compare(from[i], to[j]) == 0) { bijection[j] = i; continue OUT; } return null; } return bijection; } private ArraysUtil(); static int[] flatten(int[][] array); static int[] arrayOf(int val, int len); static long[] arrayOf(long val, int len); static char[] arrayOf(char val, int len); static T[] arrayOf(T val, int len); static int[] negate(int[] arr); static long[] negate(long[] arr); static BigInteger[] negate(BigInteger[] arr); static String toString(long[] a, int from, int to); static String toString(T[] a, int from, int to); static String toString(T[] a, int from, int to, Function<T, String> stringer); static void shuffle(int[] array, RandomGenerator rnd); static int[] getSortedDistinct(int[] values); static BigInteger[] getSortedDistinct(BigInteger[] values); static long[] getSortedDistinct(long[] values); static int[] intSetDifference(int[] main, int[] delete); static int[] intSetUnion(int[] a, int[] b); static int[] insert(int[] array, int position, int value); static int[] insert(int[] array, int position, int value, int length); static long[] insert(long[] array, int position, long value); @SuppressWarnings("unchecked") static T[] insert(T[] array, int position, T value); static void reverse(int[] array, int from, int to); static void reverse(long[] array, int from, int to); static void reverse(T[] array, int from, int to); static void reverse(T[] array); static void reverse(int[] array); static void reverse(long[] array); static int[] short2int(final short[] a); static short[] int2short(final int[] a); static int[] byte2int(final byte[] a); static short[] byte2short(final byte[] a); static byte[] int2byte(final int[] a); static int max(int[] array); static long max(long[] array); static int max(int[] array, int from, int to); static int[] max(int[] a, int[] b); static int min(int[] array); static long min(long[] array); static int min(int[] array, int from, int to); static int[] min(int[] a, int[] b); static int firstIndexOf(int element, int[] array); static int firstIndexOf(Object element, Object[] array); static int indexOfMax(int[] array); static int[] sequence(int size); static int[] sequence(int from, int to); static int[][] deepClone(int[][] input); static Object[][] deepClone(Object[][] input); static int sum(final int[] array); static int[] sum(final int[] a, final int[] b); static int[] multiply(final int[] a, final int[] b); static int[] subtract(final int[] a, final int[] b); static int sum(final int[] array, int from); static int sum(final int[] array, int from, int to); static int multiply(final int[] array, int from, int to); static double multiplyToDouble(final int[] array, int from, int to); static double multiplyToDouble(final int[] array); static double sumToDouble(final int[] array, int from, int to); static double sumToDouble(final int[] array); static int or(final long[] array); static int or(final long[] array, int from); static int or(final long[] array, int from, int to); static int[] bijection(T[] from, T[] to, Comparator<? super T> comparator); static int[] bijection(T[] from, T[] to); static int[] addAll(int[] array1, int... array2); static long[] addAll(long[] array1, long... array2); static int[] addAll(int[]... arrays); static int[] remove(int[] array, int i); static long[] remove(long[] array, int i); static T[] remove(T[] array, int i); @SafeVarargs static T[] addAll(T[] array1, T... array2); static T[] remove(T[] array, int[] positions); static int[] remove(int[] array, int[] positions); static long[] remove(long[] array, int[] positions); static T[] select(T[] array, int[] positions); static int[] select(int[] array, int[] positions); static int[] toArray(Set<Integer> set); static int binarySearch1(int[] a, int key); static int binarySearch1(int[] a, int fromIndex, int toIndex,
int key); static int commutativeHashCode(final T[] data); static int commutativeHashCode(T[] data, int from, int to); static int commutativeHashCode(final int[] data); static int commutativeHashCode(int[] data, int from, int to); static void insertionSort(int[] target, int[] coSort); static void insertionSort(int[] target, int fromIndex, int toIndex, int[] coSort); static void insertionSort(int[] target, long[] coSort); static void insertionSort(int[] target, int fromIndex, int toIndex, long[] coSort); static void insertionSort(T[] target, Object[] coSort); static void insertionSort(T[] target, int fromIndex, int toIndex, Object[] coSort); static void insertionSort(T[] target, int[] coSort); static void insertionSort(T[] target, int fromIndex, int toIndex, int[] coSort); static void timSort(int target[], int[] coSort); static void stableSort(int target[], int[] cosort); static int[] quickSortP(int[] target); static void quickSort(int[] target, int[] coSort); static void quickSort(int[] target, int fromIndex, int toIndex, int[] coSort); static void quickSort1(int target[], int fromIndex, int length, int[] coSort); static void swap(int x[], int a, int b); static void quickSort(long[] target, long[] coSort); static void quickSort(long[] target, int fromIndex, int toIndex, long[] coSort); static void quickSort1(long target[], int fromIndex, int length, long[] coSort); static void quickSort(int[] target, long[] coSort); static void quickSort(int[] target, int fromIndex, int toIndex, long[] coSort); static void quickSort1(int target[], int fromIndex, int length, long[] coSort); static void swap(long x[], int a, int b); static void quickSort(T[] target, Object[] coSort); static void quickSort(T[] target, int fromIndex, int toIndex, Object[] coSort); static void quickSort1(T[] target, int fromIndex, int length, Object[] coSort); static void quickSort(T[] target, int[] coSort); static void quickSort(T[] target, int fromIndex, int toIndex, int[] coSort); static void quickSort1(T[] target, int fromIndex, int length, int[] coSort); static void swap(Object[] x, int a, int b); static void quickSort(int[] target, Object[] coSort); static void quickSort(int[] target, int fromIndex, int toIndex, Object[] coSort); static void quickSort1(int target[], int fromIndex, int length, Object[] coSort); static int[] quickSortP(short[] target); static void quickSort(short[] target, int fromIndex, int toIndex, int[] coSort); static void quickSort1(short target[], int fromIndex, int length, int[] coSort); static void quickSort(short[] target, int[] coSort); static void quickSort(int[] target, IntComparator comparator); static void quickSort(int[] target, int fromIndex, int toIndex, IntComparator comparator); static void quickSort1(int target[], int fromIndex, int length, IntComparator comparator); static void quickSort(int[] target, int[] cosort, IntComparator comparator); static void quickSort(int[] target, int fromIndex, int toIndex, int[] cosort, IntComparator comparator); static final Comparator<Object> HASH_COMPARATOR; static final Comparator<int[]> COMPARATOR; static final Comparator<long[]> COMPARATOR_LONG; static final Comparator<Comparable[]> COMPARATOR_GENERIC; } | @Test public void testBijection2() { Integer[] from = {1, 3, 1}; Integer[] to = {3, 1, 1}; int[] bijection = {1, 0, 2}; Assert.assertArrayEquals(bijection, ArraysUtil.bijection(from, to)); }
@Test public void testBijection1() { Integer[] from = {1, 3, 1}; Integer[] to = {1, 3, 1}; int[] bijection = {0, 1, 2}; Assert.assertArrayEquals(bijection, ArraysUtil.bijection(from, to)); } |
UnivariateFactorization { public static <Poly extends IUnivariatePolynomial<Poly>> PolynomialFactorDecomposition<Poly> FactorInZ(Poly poly) { ensureIntegersDomain(poly); if (poly.degree() <= 1 || poly.isMonomial()) if (poly.isMonic()) return PolynomialFactorDecomposition.of(poly); else { Poly c = poly.contentAsPoly(); return PolynomialFactorDecomposition.of(c, poly.clone().divideByLC(c)); } PolynomialFactorDecomposition<Poly> result = PolynomialFactorDecomposition.empty(poly); Poly content = poly.contentAsPoly(); if (poly.signumOfLC() < 0) content = content.negate(); FactorInZ(poly.clone().divideByLC(content), result); return result.setUnit(content); } private UnivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(Poly poly); static PolynomialFactorDecomposition<UnivariatePolynomial<Rational<E>>> FactorInQ(UnivariatePolynomial<Rational<E>> poly); static PolynomialFactorDecomposition<Poly> FactorInGF(Poly poly); static PolynomialFactorDecomposition<T> FactorSquareFreeInGF(T poly); static PolynomialFactorDecomposition<PolyZ> FactorSquareFreeInZ(PolyZ poly); static PolynomialFactorDecomposition<Poly> FactorInZ(Poly poly); static PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly); static PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorSquareFreeInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly); } | @Test public void test5_randomZ() throws Exception { RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = getRandomData(); int nIterations = (int) its(100, 1000); int maxDegree = 30; for (int n = 0; n < nIterations; n++) { UnivariatePolynomial<BigInteger> poly = UnivariatePolynomial.create(1); int expectedNFactors = 0; while (true) { UnivariatePolynomial<BigInteger> m = RandomUnivariatePolynomials.randomPoly(rndd.nextInt(1, 15), BigInteger.LONG_MAX_VALUE, rnd); if (m.isZero()) continue; if (!m.isConstant()) ++expectedNFactors; poly = poly.multiply(m); if (poly.degree() >= maxDegree) break; } PolynomialFactorDecomposition<UnivariatePolynomial<BigInteger>> lFactors = UnivariateFactorization.FactorInZ(poly); assertTrue(lFactors.size() >= expectedNFactors); FactorDecompositionTest.assertFactorization(poly, lFactors); } }
@Test @Benchmark(runAnyway = true) public void test7_referenceZb() throws Exception { UnivariatePolynomial<BigInteger> a = UnivariatePolynomial.create(1, 2, 3, 5, 3, 2, 1), b = UnivariatePolynomial.create(1, 2, -12443241213L, 412312, 3, 2, 123423554351L), c = UnivariatePolynomial.create(-1, -2, -12443241213L, 412312, 3, 2, 123423554351L), d = UnivariatePolynomial.create(-1, -2, -12441213L, 412312, 3, 2, 1234235543L), e = UnivariatePolynomial.create(-11111111, -2, -12441213L, 412312, 3, 2, 1234235543L), f = UnivariatePolynomial.create(-11, -2222121, -12441213L, 412312, 3, 2, 1234235543L), g = UnivariatePolynomial.create(-33, -2, -12441213L, 412312, 3, 2, 1234235543L, -12441213L, 412312, 3, 2, 1234235543L, -1, -2, -12441213L, 412312, 3, 2, 1234235543L, -12441213L, 412312, 3, 2, 1234235543L); UnivariatePolynomial<BigInteger> poly = a.clone().multiply(b, c, d, e, f, g, g.clone().increment(), f.clone().increment()); DescriptiveStatistics timing = new DescriptiveStatistics(); int nIterations = its(100, 100); for (int i = 0; i < nIterations; i++) { if (i == 1000) timing.clear(); long start = System.nanoTime(); PolynomialFactorDecomposition<UnivariatePolynomial<BigInteger>> factors = UnivariateFactorization.FactorInZ(poly); long time = System.nanoTime() - start; timing.addValue(time); assertEquals(9, factors.size()); FactorDecompositionTest.assertFactorization(poly, factors); } System.out.println(TimeUnits.statisticsNanotimeFull(timing)); } |
UnivariateFactorization { @SuppressWarnings("unchecked") public static <Poly extends IUnivariatePolynomial<Poly>> PolynomialFactorDecomposition<Poly> Factor(Poly poly) { if (poly.isOverFiniteField()) return FactorInGF(poly); else if (poly.isOverZ()) return FactorInZ(poly); else if (Util.isOverRationals(poly)) return FactorInQ((UnivariatePolynomial) poly); else if (Util.isOverSimpleNumberField(poly)) return (PolynomialFactorDecomposition<Poly>) FactorInNumberField((UnivariatePolynomial) poly); else if (Util.isOverMultipleFieldExtension(poly)) return (PolynomialFactorDecomposition<Poly>) FactorInMultipleFieldExtension((UnivariatePolynomial) poly); else if (isOverMultivariate(poly)) return (PolynomialFactorDecomposition<Poly>) FactorOverMultivariate((UnivariatePolynomial) poly, MultivariateFactorization::Factor); else if (isOverUnivariate(poly)) return (PolynomialFactorDecomposition<Poly>) FactorOverUnivariate((UnivariatePolynomial) poly, MultivariateFactorization::Factor); else throw new RuntimeException("ring is not supported: " + poly.coefficientRingToString()); } private UnivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(Poly poly); static PolynomialFactorDecomposition<UnivariatePolynomial<Rational<E>>> FactorInQ(UnivariatePolynomial<Rational<E>> poly); static PolynomialFactorDecomposition<Poly> FactorInGF(Poly poly); static PolynomialFactorDecomposition<T> FactorSquareFreeInGF(T poly); static PolynomialFactorDecomposition<PolyZ> FactorSquareFreeInZ(PolyZ poly); static PolynomialFactorDecomposition<Poly> FactorInZ(Poly poly); static PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly); static PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorSquareFreeInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly); } | @Test public void test8() throws Exception { UnivariatePolynomial<BigInteger> poly = UnivariatePolynomial.create(0, -13284, -15390, -33552, -55998, 2151, 381296, 1573628, 1135112, 688800, 358176, 1119300); Assert.assertEquals(2, UnivariateFactorization.Factor(poly).size()); poly = UnivariatePolynomial.create(0, -13284, -15390, -33552, -55998, 2151, 381296, 1573628, 1135112, -688800, 358176, 1119300); Assert.assertEquals(4, UnivariateFactorization.Factor(poly).size()); }
@Test public void testFiniteField3a() throws Exception { UnivariatePolynomialZp64 irreducible = UnivariatePolynomialZ64.create(1, 1, 1, 1, 1).modulus(2); FiniteField<UnivariatePolynomialZp64> domain = new FiniteField<>(irreducible); Coder<UnivariatePolynomialZp64, ?, ?> ffParser = Coder.mkPolynomialCoder(domain, "t"); Coder<UnivariatePolynomial<UnivariatePolynomialZp64>, ?, ?> parser = Coder.mkUnivariateCoder(Rings.UnivariateRing(domain), ffParser, "x"); UnivariatePolynomial<UnivariatePolynomialZp64> input = parser.parse("(1+t+t^2)+(1+t+t^2)*x+(1+t+t^3)*x^4+x^6"); PrivateRandom.getRandom().setSeed(1); PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomialZp64>> factors = UnivariateFactorization.Factor(input); assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(input, factors); }
@Test public void testFiniteField3b() throws Exception { UnivariatePolynomialZp64 irreducible = UnivariatePolynomialZ64.create(1, 1, 1, 1, 1).modulus(2); FiniteField<UnivariatePolynomialZp64> domain = new FiniteField<>(irreducible); Coder<UnivariatePolynomialZp64, ?, ?> ffParser = Coder.mkPolynomialCoder(domain, "t"); Coder<UnivariatePolynomial<UnivariatePolynomialZp64>, ?, ?> parser = Coder.mkUnivariateCoder(Rings.UnivariateRing(domain), ffParser, "x"); UnivariatePolynomial<UnivariatePolynomialZp64> input = parser.parse("(1+t+t^2)+(1+t+t^2)*x+(1+t+t^3)*x^4+x^6"); PrivateRandom.getRandom().setSeed(43); PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomialZp64>> factors = UnivariateFactorization.Factor(input); assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(input, factors); }
@Test public void testFiniteField3() throws Exception { UnivariatePolynomialZp64 irreducible = UnivariatePolynomialZ64.create(1, 1, 1, 1, 1).modulus(2); FiniteField<UnivariatePolynomialZp64> domain = new FiniteField<>(irreducible); Coder<UnivariatePolynomialZp64, ?, ?> ffParser = Coder.mkPolynomialCoder(domain, "t"); Coder<UnivariatePolynomial<UnivariatePolynomialZp64>, ?, ?> parser = Coder.mkUnivariateCoder(Rings.UnivariateRing(domain), ffParser, "x"); UnivariatePolynomial<UnivariatePolynomialZp64> input = parser.parse("(1+t+t^2)+(1+t+t^2)*x+(1+t+t^3)*x^4+x^6"); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomialZp64>> factors = UnivariateFactorization.Factor(input); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(input, factors); } }
@Test public void testRationals() throws Exception { UnivariatePolynomial<Rational<BigInteger>> f1 = UnivariatePolynomial.parse("(1/2) + x^6 + (1/33)*x^5", Rings.Q), f2 = UnivariatePolynomial.parse("(1/2) - (3/4)*x^6 + (2/5)*x^11", Rings.Q), f3 = UnivariatePolynomial.parse("1 - x^2 + x^3", Rings.Q), poly = f1.createOne().multiply(f1, f2, f3); PolynomialFactorDecomposition<UnivariatePolynomial<Rational<BigInteger>>> fct = UnivariateFactorization.Factor(poly); Assert.assertEquals(3, fct.size()); Assert.assertEquals(poly, fct.multiply()); }
@Test(timeout = 100_000) public void test7() { UnivariatePolynomial<BigInteger> poly = UnivariatePolynomial.parse("x^259 - 1", Z, "x"); assertEquals(4, Factor(poly).size()); } |
ArraysUtil { public static void quickSort(int[] target, int[] coSort) { quickSort(target, 0, target.length, coSort); } private ArraysUtil(); static int[] flatten(int[][] array); static int[] arrayOf(int val, int len); static long[] arrayOf(long val, int len); static char[] arrayOf(char val, int len); static T[] arrayOf(T val, int len); static int[] negate(int[] arr); static long[] negate(long[] arr); static BigInteger[] negate(BigInteger[] arr); static String toString(long[] a, int from, int to); static String toString(T[] a, int from, int to); static String toString(T[] a, int from, int to, Function<T, String> stringer); static void shuffle(int[] array, RandomGenerator rnd); static int[] getSortedDistinct(int[] values); static BigInteger[] getSortedDistinct(BigInteger[] values); static long[] getSortedDistinct(long[] values); static int[] intSetDifference(int[] main, int[] delete); static int[] intSetUnion(int[] a, int[] b); static int[] insert(int[] array, int position, int value); static int[] insert(int[] array, int position, int value, int length); static long[] insert(long[] array, int position, long value); @SuppressWarnings("unchecked") static T[] insert(T[] array, int position, T value); static void reverse(int[] array, int from, int to); static void reverse(long[] array, int from, int to); static void reverse(T[] array, int from, int to); static void reverse(T[] array); static void reverse(int[] array); static void reverse(long[] array); static int[] short2int(final short[] a); static short[] int2short(final int[] a); static int[] byte2int(final byte[] a); static short[] byte2short(final byte[] a); static byte[] int2byte(final int[] a); static int max(int[] array); static long max(long[] array); static int max(int[] array, int from, int to); static int[] max(int[] a, int[] b); static int min(int[] array); static long min(long[] array); static int min(int[] array, int from, int to); static int[] min(int[] a, int[] b); static int firstIndexOf(int element, int[] array); static int firstIndexOf(Object element, Object[] array); static int indexOfMax(int[] array); static int[] sequence(int size); static int[] sequence(int from, int to); static int[][] deepClone(int[][] input); static Object[][] deepClone(Object[][] input); static int sum(final int[] array); static int[] sum(final int[] a, final int[] b); static int[] multiply(final int[] a, final int[] b); static int[] subtract(final int[] a, final int[] b); static int sum(final int[] array, int from); static int sum(final int[] array, int from, int to); static int multiply(final int[] array, int from, int to); static double multiplyToDouble(final int[] array, int from, int to); static double multiplyToDouble(final int[] array); static double sumToDouble(final int[] array, int from, int to); static double sumToDouble(final int[] array); static int or(final long[] array); static int or(final long[] array, int from); static int or(final long[] array, int from, int to); static int[] bijection(T[] from, T[] to, Comparator<? super T> comparator); static int[] bijection(T[] from, T[] to); static int[] addAll(int[] array1, int... array2); static long[] addAll(long[] array1, long... array2); static int[] addAll(int[]... arrays); static int[] remove(int[] array, int i); static long[] remove(long[] array, int i); static T[] remove(T[] array, int i); @SafeVarargs static T[] addAll(T[] array1, T... array2); static T[] remove(T[] array, int[] positions); static int[] remove(int[] array, int[] positions); static long[] remove(long[] array, int[] positions); static T[] select(T[] array, int[] positions); static int[] select(int[] array, int[] positions); static int[] toArray(Set<Integer> set); static int binarySearch1(int[] a, int key); static int binarySearch1(int[] a, int fromIndex, int toIndex,
int key); static int commutativeHashCode(final T[] data); static int commutativeHashCode(T[] data, int from, int to); static int commutativeHashCode(final int[] data); static int commutativeHashCode(int[] data, int from, int to); static void insertionSort(int[] target, int[] coSort); static void insertionSort(int[] target, int fromIndex, int toIndex, int[] coSort); static void insertionSort(int[] target, long[] coSort); static void insertionSort(int[] target, int fromIndex, int toIndex, long[] coSort); static void insertionSort(T[] target, Object[] coSort); static void insertionSort(T[] target, int fromIndex, int toIndex, Object[] coSort); static void insertionSort(T[] target, int[] coSort); static void insertionSort(T[] target, int fromIndex, int toIndex, int[] coSort); static void timSort(int target[], int[] coSort); static void stableSort(int target[], int[] cosort); static int[] quickSortP(int[] target); static void quickSort(int[] target, int[] coSort); static void quickSort(int[] target, int fromIndex, int toIndex, int[] coSort); static void quickSort1(int target[], int fromIndex, int length, int[] coSort); static void swap(int x[], int a, int b); static void quickSort(long[] target, long[] coSort); static void quickSort(long[] target, int fromIndex, int toIndex, long[] coSort); static void quickSort1(long target[], int fromIndex, int length, long[] coSort); static void quickSort(int[] target, long[] coSort); static void quickSort(int[] target, int fromIndex, int toIndex, long[] coSort); static void quickSort1(int target[], int fromIndex, int length, long[] coSort); static void swap(long x[], int a, int b); static void quickSort(T[] target, Object[] coSort); static void quickSort(T[] target, int fromIndex, int toIndex, Object[] coSort); static void quickSort1(T[] target, int fromIndex, int length, Object[] coSort); static void quickSort(T[] target, int[] coSort); static void quickSort(T[] target, int fromIndex, int toIndex, int[] coSort); static void quickSort1(T[] target, int fromIndex, int length, int[] coSort); static void swap(Object[] x, int a, int b); static void quickSort(int[] target, Object[] coSort); static void quickSort(int[] target, int fromIndex, int toIndex, Object[] coSort); static void quickSort1(int target[], int fromIndex, int length, Object[] coSort); static int[] quickSortP(short[] target); static void quickSort(short[] target, int fromIndex, int toIndex, int[] coSort); static void quickSort1(short target[], int fromIndex, int length, int[] coSort); static void quickSort(short[] target, int[] coSort); static void quickSort(int[] target, IntComparator comparator); static void quickSort(int[] target, int fromIndex, int toIndex, IntComparator comparator); static void quickSort1(int target[], int fromIndex, int length, IntComparator comparator); static void quickSort(int[] target, int[] cosort, IntComparator comparator); static void quickSort(int[] target, int fromIndex, int toIndex, int[] cosort, IntComparator comparator); static final Comparator<Object> HASH_COMPARATOR; static final Comparator<int[]> COMPARATOR; static final Comparator<long[]> COMPARATOR_LONG; static final Comparator<Comparable[]> COMPARATOR_GENERIC; } | @Test public void testQuickSortComparator1() { IntComparator comparator = new IntComparator() { @Override public int compare(int a, int b) { return Integer.compare(b, a); } }; RandomGenerator rnd = new Well1024a(); int[] array = new int[1000]; for (int t = 0; t < 100; ++t) { for (int i = 0; i < array.length; ++i) array[i] = rnd.nextInt(10000); ArraysUtil.quickSort(array, comparator); for (int i = 1; i < array.length; ++i) assertTrue(array[i - 1] >= array[i]); } } |
UnivariateFactorization { public static PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly) { if (poly.degree() <= 1 || poly.isMonomial()) return PolynomialFactorDecomposition.of(poly); PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> result = PolynomialFactorDecomposition.empty(poly); FactorInNumberField(poly, result); if (result.isTrivial()) return PolynomialFactorDecomposition.of(poly); AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> numberField = (AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>>) poly.ring; UnivariatePolynomial<Rational<BigInteger>> unit = result.unit.lc(); for (int i = 0; i < result.size(); i++) unit = numberField.multiply(unit, numberField.pow(result.get(i).lc(), result.getExponent(i))); unit = numberField.divideExact(poly.lc(), unit); result.addUnit(UnivariatePolynomial.constant(numberField, unit)); return result; } private UnivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(Poly poly); static PolynomialFactorDecomposition<UnivariatePolynomial<Rational<E>>> FactorInQ(UnivariatePolynomial<Rational<E>> poly); static PolynomialFactorDecomposition<Poly> FactorInGF(Poly poly); static PolynomialFactorDecomposition<T> FactorSquareFreeInGF(T poly); static PolynomialFactorDecomposition<PolyZ> FactorSquareFreeInZ(PolyZ poly); static PolynomialFactorDecomposition<Poly> FactorInZ(Poly poly); static PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly); static PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorSquareFreeInNumberField(UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly); } | @Test public void testNumberField1() { Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> pCoder = Coder.mkUnivariateCoder(UnivariateRing(Q), "x"); AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = new AlgebraicNumberField<>(pCoder.parse("1 + x^2")); Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> cfCoder = Coder.mkUnivariateCoder(field, "s"); Coder<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>, ?, ?> coder = Coder.mkUnivariateCoder(UnivariateRing(field), cfCoder, "x"); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly = coder.parse("1 + x^2"); PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> factors = FactorInNumberField(poly); assertTrue(factors.size() == 2); FactorDecompositionTest.assertFactorization(poly, factors); }
@Test public void testNumberField2() { Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> pCoder = Coder.mkUnivariateCoder(UnivariateRing(Q), "x"); AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = new AlgebraicNumberField<>(pCoder.parse("5/2+7/2*x+5/2*x^2+x^4")); Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> cfCoder = Coder.mkUnivariateCoder(field, "s"); Coder<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>, ?, ?> coder = Coder.mkUnivariateCoder(UnivariateRing(field), cfCoder, "x"); UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a = coder.parse("3/4+3*s+s^3+(3+s+1/2*s^2+2*s^3)*x+(2+3*s+s^2+4/3*s^3)*x^2"), b = coder.parse("3/2+1/2*s+3/5*s^3+(3/2+s+4/3*s^2+1/2*s^3)*x+(2/3+4*s+4/5*s^2+s^3)*x^2+(4/5+1/3*s+3/4*s^2+1/4*s^3)*x^3+(s+s^2+s^3)*x^4+(3+1/3*s+s^3)*x^5+(2+s+1/5*s^3)*x^6+(2/3+2/5*s+1/5*s^2+2/5*s^3)*x^7+(1+1/5*s^2+2*s^3)*x^8"), c = coder.parse("2+1/5*s+s^2+1/3*s^3+(1/2+3/2*s+s^2+4*s^3)*x+(1+4/3*s+3/5*s^3)*x^2"), poly = a.clone().multiply(b, c); for (int i = 0; i < 2; ++i) { long start = System.nanoTime(); PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> factors = FactorInNumberField(poly); assertTrue(factors.size() == 3); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); FactorDecompositionTest.assertFactorization(poly, factors); } }
@Test public void testNumberField3_random() { RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = getRandomData(); for (int i = 0; i < 10; ++i) { UnivariatePolynomial<Rational<BigInteger>> minimalPoly = RandomUnivariatePolynomials .randomPoly(rndd.nextInt(2, 5), rnd) .toBigPoly() .mapCoefficients(Q, cf -> Q.mkNumerator(cf.mod(10))); minimalPoly.setLC(Q.mkNumerator(rndd.nextInt(1, 10))); if (minimalPoly.isMonomial() || !IrreduciblePolynomials.irreducibleQ(minimalPoly)) { --i; continue; } AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = new AlgebraicNumberField<>(minimalPoly); Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> cfCoder = Coder.mkUnivariateCoder(field, "s"); Coder<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>, ?, ?> coder = Coder.mkUnivariateCoder(UnivariateRing(field), cfCoder, "x"); System.out.println("Field : " + field); Supplier<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> rndPoly = () -> RandomUnivariatePolynomials.randomPoly( rndd.nextInt(2, 8), field, __ -> RandomUnivariatePolynomials.randomPoly(minimalPoly.degree - 1, Q, ___ -> Q.mk(rnd.nextInt(5), 1 + rnd.nextInt(5)), rnd), rnd); for (int j = 0; j < 5; ++j) { UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a = rndPoly.get(), b = rndPoly.get(), c = rndPoly.get(), poly = a.clone().multiply(b, c); long start, elapsed; start = System.nanoTime(); PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> factors = FactorInNumberField(poly); elapsed = System.nanoTime() - start; FactorDecompositionTest.assertFactorization(poly, factors); System.out.println("Elapsed : " + TimeUnits.nanosecondsToString(elapsed)); } } } |
HenselLifting { public static List<UnivariatePolynomialZp64> liftFactorization(long modulus, long desiredBound, UnivariatePolynomialZ64 poly, List<UnivariatePolynomialZp64> modularFactors, boolean quadratic) { long[] im = nIterations(modulus, desiredBound, quadratic); return liftFactorization(modulus, im[1], (int) im[0], poly, modularFactors, quadratic); } private HenselLifting(); static lQuadraticLift createQuadraticLift(long modulus,
UnivariatePolynomialZ64 poly,
UnivariatePolynomialZp64 aFactor,
UnivariatePolynomialZp64 bFactor); static bQuadraticLift createQuadraticLift(BigInteger modulus,
UnivariatePolynomial<BigInteger> poly,
UnivariatePolynomial<BigInteger> aFactor,
UnivariatePolynomial<BigInteger> bFactor); static bQuadraticLift createQuadraticLift(BigInteger modulus,
UnivariatePolynomial<BigInteger> poly,
UnivariatePolynomialZp64 aFactor,
UnivariatePolynomialZp64 bFactor); static lLinearLift createLinearLift(BigInteger modulus,
UnivariatePolynomialZ64 poly,
UnivariatePolynomialZp64 aFactor,
UnivariatePolynomialZp64 bFactor); static bLinearLift createLinearLift(BigInteger modulus,
UnivariatePolynomial<BigInteger> poly,
UnivariatePolynomialZp64 aFactor,
UnivariatePolynomialZp64 bFactor); static lLinearLift createLinearLift(long modulus,
UnivariatePolynomialZ64 poly,
UnivariatePolynomialZp64 aFactor,
UnivariatePolynomialZp64 bFactor); static bLinearLift createLinearLift(long modulus,
UnivariatePolynomial<BigInteger> poly,
UnivariatePolynomialZp64 aFactor,
UnivariatePolynomialZp64 bFactor); static List<UnivariatePolynomialZp64> liftFactorization(long modulus,
long desiredBound,
UnivariatePolynomialZ64 poly,
List<UnivariatePolynomialZp64> modularFactors,
boolean quadratic); static List<UnivariatePolynomialZp64> liftFactorization(long modulus,
long finalModulus,
int nIterations,
UnivariatePolynomialZ64 poly,
List<UnivariatePolynomialZp64> modularFactors,
boolean quadratic); static List<UnivariatePolynomial<BigInteger>> liftFactorization(BigInteger modulus,
BigInteger desiredBound,
UnivariatePolynomial<BigInteger> poly,
List<UnivariatePolynomialZp64> modularFactors,
boolean quadratic); static List<UnivariatePolynomial<BigInteger>> liftFactorizationQuadratic(BigInteger modulus,
BigInteger desiredBound,
UnivariatePolynomial<BigInteger> poly,
List<UnivariatePolynomial<BigInteger>> modularFactors); static List<UnivariatePolynomial<BigInteger>> liftFactorization(BigInteger modulus,
BigInteger desiredBound,
UnivariatePolynomial<BigInteger> poly,
List<UnivariatePolynomialZp64> modularFactors); } | @Test @Benchmark(runAnyway = true) public void testHensel9_random() throws Exception { RandomGenerator rnd = AbstractTest.getRandom(); RandomDataGenerator rndd = AbstractTest.getRandomData(); DescriptiveStatistics linear = new DescriptiveStatistics(), quadratic = new DescriptiveStatistics(), adaptive = new DescriptiveStatistics(); int nFactors = 6; int nIterations = (int) AbstractTest.its(30, 150); for (int n = 0; n < nIterations; n++) { if (nIterations / 10 == n) { linear.clear(); quadratic.clear(); adaptive.clear(); } if (n % 10 == 0) System.out.println(n); UnivariatePolynomial<BigInteger> poly = UnivariatePolynomial.create(1); for (int i = 0; i < nFactors; i++) poly = poly.multiply(RandomUnivariatePolynomials.randomPoly(rndd.nextInt(5, 15), BigInteger.valueOf(1000), rnd)); poly = UnivariateSquareFreeFactorization.SquareFreePart(poly); UnivariatePolynomial<BigInteger> polyMod; long modulus; IntegersZp domain; do { modulus = getModulusRandom(rndd.nextInt(5, 28)); domain = new IntegersZp(modulus); polyMod = poly.setRing(domain); } while (!UnivariateSquareFreeFactorization.isSquareFree(poly.setRing(domain)) || polyMod.degree() != poly.degree()); BigInteger desiredBound = UnivariatePolynomial.mignotteBound(poly).shiftLeft(1).multiply(poly.lc()); PolynomialFactorDecomposition<UnivariatePolynomialZp64> modularFactors = UnivariateFactorization.FactorInGF(UnivariatePolynomial.asOverZp64(polyMod)); BigInteger bModulus = BigInteger.valueOf(modulus); long start; try { start = System.nanoTime(); List<UnivariatePolynomial<BigInteger>> factorsQuad = HenselLifting.liftFactorization(bModulus, desiredBound, poly, modularFactors.factors, true); quadratic.addValue(System.nanoTime() - start); FactorizationTestUtil.assertFactorization(poly.setRing(factorsQuad.get(0).ring), poly.lc(), factorsQuad); start = System.nanoTime(); List<UnivariatePolynomial<BigInteger>> factorsLin = HenselLifting.liftFactorization(bModulus, desiredBound, poly, modularFactors.factors, false); linear.addValue(System.nanoTime() - start); FactorizationTestUtil.assertFactorization(poly.setRing(factorsLin.get(0).ring), poly.lc(), factorsLin); start = System.nanoTime(); List<UnivariatePolynomial<BigInteger>> factorsAdp = HenselLifting.liftFactorization(bModulus, desiredBound, poly, modularFactors.factors); adaptive.addValue(System.nanoTime() - start); FactorizationTestUtil.assertFactorization(poly.setRing(factorsAdp.get(0).ring), poly.lc(), factorsAdp); } catch (Throwable e) { System.out.println("===="); System.out.println(modulus); System.out.println(poly); System.out.println(modularFactors); System.out.println(poly.toStringForCopy()); System.out.println("===="); throw e; } } System.out.println("Quadratic lifting : " + TimeUnits.statisticsNanotime(quadratic, true)); System.out.println("Linear lifting : " + TimeUnits.statisticsNanotime(linear, true)); System.out.println("Adaptive lifting : " + TimeUnits.statisticsNanotime(adaptive, true)); } |
Util { public static <E> Tuple2<UnivariatePolynomial<E>, E> toCommonDenominator(UnivariatePolynomial<Rational<E>> poly) { Ring<Rational<E>> field = poly.ring; Ring<E> integralRing = field.getOne().ring; E denominator = integralRing.getOne(); for (int i = 0; i <= poly.degree(); i++) if (!poly.isZeroAt(i)) denominator = integralRing.lcm(denominator, poly.get(i).denominator()); E[] data = integralRing.createArray(poly.degree() + 1); for (int i = 0; i <= poly.degree(); i++) { Rational<E> cf = poly.get(i).multiply(denominator); assert cf.isIntegral(); data[i] = cf.numerator(); } return new Tuple2<>(UnivariatePolynomial.createUnsafe(integralRing, data), denominator); } private Util(); static void ensureOverFiniteField(IPolynomial... polys); static void ensureOverField(IPolynomial... polys); static void ensureOverZ(IPolynomial... polys); static boolean canConvertToZp64(IPolynomial poly); static boolean isOverRationals(T poly); @SuppressWarnings("unchecked") static boolean isOverSimpleFieldExtension(T poly); @SuppressWarnings("unchecked") static boolean isOverMultipleFieldExtension(T poly); @SuppressWarnings("unchecked") static boolean isOverSimpleNumberField(T poly); @SuppressWarnings("unchecked") static boolean isOverRingOfIntegersOfSimpleNumberField(T poly); static boolean isOverQ(T poly); static boolean isOverZ(T poly); static Tuple2<UnivariatePolynomial<E>, E> toCommonDenominator(UnivariatePolynomial<Rational<E>> poly); static E commonDenominator(UnivariatePolynomial<Rational<E>> poly); static E commonDenominator(MultivariatePolynomial<Rational<E>> poly); static Tuple2<MultivariatePolynomial<E>, E> toCommonDenominator(MultivariatePolynomial<Rational<E>> poly); static UnivariatePolynomial<Rational<E>> asOverRationals(Ring<Rational<E>> field, UnivariatePolynomial<E> poly); static MultivariatePolynomial<Rational<E>> asOverRationals(Ring<Rational<E>> field, MultivariatePolynomial<E> poly); static UnivariatePolynomial<Rational<E>> divideOverRationals(Ring<Rational<E>> field, UnivariatePolynomial<E> poly, E denominator); static MultivariatePolynomial<Rational<E>> divideOverRationals(Ring<Rational<E>> field, MultivariatePolynomial<E> poly, E denominator); } | @Test public void test1() throws Exception { UnivariatePolynomial<Rational<BigInteger>> poly = UnivariatePolynomial.parse("(1/2) + (1/3)*x + (1/4)*x^2 + (1/5)*x^3 + (1/6)*x^7", Rings.Q); System.out.println(Util.toCommonDenominator(poly)); MultivariatePolynomial<Rational<BigInteger>> mpoly = MultivariatePolynomial.parse("(1/2) + (1/3)*x + (1/4)*x^2 + (1/5)*x^3111 + 1/5*x^66", Rings.Q); System.out.println(Util.toCommonDenominator(mpoly)); } |
MultivariatePolynomial extends AMultivariatePolynomial<Monomial<E>, MultivariatePolynomial<E>> { public final MultivariatePolynomial<E> createLinear(int variable, E cc, E lc) { MonomialSet<Monomial<E>> data = new MonomialSet<>(ordering); if (!ring.isZero(cc)) data.add(new Monomial<>(nVariables, cc)); if (!ring.isZero(lc)) { int[] lcDegreeVector = new int[nVariables]; lcDegreeVector[variable] = 1; data.add(new Monomial<>(lcDegreeVector, 1, lc)); } return new MultivariatePolynomial<>(nVariables, ring, ordering, data); } MultivariatePolynomial(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, MonomialSet<Monomial<E>> terms); static MultivariatePolynomial<E> create(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, Iterable<Monomial<E>> terms); static MultivariatePolynomial<E> create(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, Monomial<E>... terms); static MultivariatePolynomial<E> zero(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> one(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering); static MultivariatePolynomial<BigInteger> parse(String string, String... variables); @Deprecated static MultivariatePolynomial<BigInteger> parse(String string); static MultivariatePolynomial<E> parse(String string, Ring<E> ring, String... variables); @Deprecated static MultivariatePolynomial<E> parse(String string, Ring<E> ring); static MultivariatePolynomial<BigInteger> parse(String string, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomial<BigInteger> parse(String string, Comparator<DegreeVector> ordering); static MultivariatePolynomial<E> parse(String string, Ring<E> ring, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomial<E> parse(String string, Ring<E> ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asOverZp64(MultivariatePolynomial<BigInteger> poly); static MultivariatePolynomialZp64 asOverZp64(MultivariatePolynomial<BigInteger> poly, IntegersZp64 ring); static MultivariatePolynomial<E> asMultivariate(UnivariatePolynomial<E> poly, int nVariables, int variable, Comparator<DegreeVector> ordering); @Override @SuppressWarnings("unchecked") UnivariatePolynomial<E> asUnivariate(); @Override MultivariatePolynomial<UnivariatePolynomial<E>> asOverUnivariate(int variable); @Override MultivariatePolynomial<UnivariatePolynomial<E>> asOverUnivariateEliminate(int variable); @Override MultivariatePolynomial<MultivariatePolynomial<E>> asOverMultivariate(int... variables); @Override MultivariatePolynomial<MultivariatePolynomial<E>> asOverMultivariateEliminate(int[] variables, Comparator<DegreeVector> ordering); static MultivariatePolynomial<E> asNormalMultivariate(MultivariatePolynomial<UnivariatePolynomial<E>> poly, int variable); static MultivariatePolynomial<E> asNormalMultivariate(MultivariatePolynomial<MultivariatePolynomial<E>> poly); static MultivariatePolynomial<E> asNormalMultivariate(
MultivariatePolynomial<MultivariatePolynomial<E>> poly,
int[] coefficientVariables, int[] mainVariables); static MultivariatePolynomial<BigInteger> asPolyZ(MultivariatePolynomial<BigInteger> poly, boolean copy); static MultivariatePolynomial<BigInteger> asPolyZSymmetric(MultivariatePolynomial<BigInteger> poly); @Override MultivariatePolynomial<E> contentAsPoly(); @Override MultivariatePolynomial<E> lcAsPoly(); @Override MultivariatePolynomial<E> lcAsPoly(Comparator<DegreeVector> ordering); @Override MultivariatePolynomial<E> ccAsPoly(); @Override boolean isOverField(); @Override boolean isOverFiniteField(); @Override boolean isOverZ(); @Override BigInteger coefficientRingCardinality(); @Override BigInteger coefficientRingCharacteristic(); @Override boolean isOverPerfectPower(); @Override BigInteger coefficientRingPerfectPowerBase(); @Override BigInteger coefficientRingPerfectPowerExponent(); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[] createArray(int length); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[][] createArray2d(int length); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[][] createArray2d(int length1, int length2); @Override boolean sameCoefficientRingWith(MultivariatePolynomial<E> oth); @Override MultivariatePolynomial<E> setCoefficientRingFrom(MultivariatePolynomial<E> poly); MultivariatePolynomial<E> setRing(Ring<E> newRing); MultivariatePolynomial<E> setRingUnsafe(Ring<E> newRing); MultivariatePolynomial<E> createConstant(E val); @Override MultivariatePolynomial<E> createConstantFromTerm(Monomial<E> monomial); @Override MultivariatePolynomial<E> createZero(); @Override MultivariatePolynomial<E> createOne(); final MultivariatePolynomial<E> createLinear(int variable, E cc, E lc); @Override boolean isMonic(); @Override int signumOfLC(); @Override boolean isOne(); @Override boolean isUnitCC(); @Override boolean isConstant(); E maxAbsCoefficient(); E lc(); E lc(Comparator<DegreeVector> ordering); MultivariatePolynomial<E> setLC(E val); E cc(); E content(); Iterable<E> coefficients(); E[] coefficientsArray(); @Override MultivariatePolynomial<E> primitivePart(int variable); @Override UnivariatePolynomial<E> contentUnivariate(int variable); @Override MultivariatePolynomial<E> primitivePart(); @Override MultivariatePolynomial<E> primitivePartSameSign(); @Override MultivariatePolynomial<E> divideByLC(MultivariatePolynomial<E> other); MultivariatePolynomial<E> divideOrNull(E factor); MultivariatePolynomial<E> divideExact(E factor); @Override MultivariatePolynomial<E> divideOrNull(Monomial<E> monomial); @Override MultivariatePolynomial<E> monic(); @Override MultivariatePolynomial<E> monic(Comparator<DegreeVector> ordering); MultivariatePolynomial<E> monic(E factor); MultivariatePolynomial<E> monic(Comparator<DegreeVector> ordering, E factor); @Override MultivariatePolynomial<E> monicWithLC(MultivariatePolynomial<E> other); @Override MultivariatePolynomial<E> monicWithLC(Comparator<DegreeVector> ordering, MultivariatePolynomial<E> other); UnivariatePolynomial toDenseRecursiveForm(); static MultivariatePolynomial<E> fromDenseRecursiveForm(UnivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static E evaluateDenseRecursiveForm(UnivariatePolynomial recForm, int nVariables, E[] values); AMultivariatePolynomial toSparseRecursiveForm(); static MultivariatePolynomial<E> fromSparseRecursiveForm(AMultivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static E evaluateSparseRecursiveForm(AMultivariatePolynomial recForm, int nVariables, E[] values); @SuppressWarnings("unchecked") HornerForm getHornerForm(int[] evaluationVariables); MultivariatePolynomial<E> evaluate(int variable, E value); @SuppressWarnings("unchecked") E evaluate(E... values); @SuppressWarnings("unchecked") MultivariatePolynomial<E> evaluate(int[] variables, E[] values); @SuppressWarnings("unchecked") MultivariatePolynomial<E>[] evaluate(int variable, E... values); MultivariatePolynomial<E> evaluate(int variable, long value); MultivariatePolynomial<E> eliminate(int variable, E value); MultivariatePolynomial<E> eliminate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomial<E> eliminate(int[] variables, E[] values); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(int variable, E value); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(int[] variables, E[] values); @SuppressWarnings("unchecked") static PrecomputedPowersHolder<E> mkPrecomputedPowers(int nVariables, Ring<E> ring, int[] variables, E[] values); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(E[] values); MultivariatePolynomial<E> substitute(int variable, MultivariatePolynomial<E> poly); MultivariatePolynomial<E> shift(int variable, long shift); @SuppressWarnings("unchecked") MultivariatePolynomial<E> shift(int variable, E shift); @SuppressWarnings("unchecked") MultivariatePolynomial<E> shift(int[] variables, E[] shifts); MultivariatePolynomial<E> add(E oth); MultivariatePolynomial<E> subtract(E oth); @Override MultivariatePolynomial<E> increment(); @Override MultivariatePolynomial<E> decrement(); MultivariatePolynomial<E> multiply(E factor); @Override MultivariatePolynomial<E> multiplyByLC(MultivariatePolynomial<E> other); @Override MultivariatePolynomial<E> multiply(Monomial<E> monomial); @Override MultivariatePolynomial<E> multiply(long factor); @Override MultivariatePolynomial<E> multiplyByBigInteger(BigInteger factor); @Override MultivariatePolynomial<E> multiply(MultivariatePolynomial<E> oth); @Override MultivariatePolynomial<E> square(); @Override MultivariatePolynomial<E> evaluateAtRandom(int variable, RandomGenerator rnd); @Override MultivariatePolynomial<E> evaluateAtRandomPreservingSkeleton(int variable, RandomGenerator rnd); @Override MultivariatePolynomial<E> derivative(int variable, int order); @Override MultivariatePolynomial<E> seriesCoefficient(int variable, int order); Stream<E> stream(); MultivariatePolynomial<T> mapTerms(Ring<T> newRing, Function<Monomial<E>, Monomial<T>> mapper); MultivariatePolynomial<T> mapCoefficients(Ring<T> newRing, Function<E, T> mapper); MultivariatePolynomialZp64 mapCoefficients(IntegersZp64 newDomain, ToLongFunction<E> mapper); @Override MultivariatePolynomial<T> mapCoefficientsAsPolys(Ring<T> ring, Function<MultivariatePolynomial<E>, T> mapper); @Override int compareTo(MultivariatePolynomial<E> oth); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E> clone(); @Override @Deprecated MultivariatePolynomial<E> parsePoly(String string); @Override String toString(IStringifier<MultivariatePolynomial<E>> stringifier); @Override String coefficientRingToString(IStringifier<MultivariatePolynomial<E>> stringifier); final Ring<E> ring; } | @Test public void testCreateLinear() throws Exception { MultivariatePolynomial<BigInteger> p0 = MultivariatePolynomial.zero(3, Rings.Z, LEX); String[] vars = {"a", "b", "c"}; assertEquals(parse("-1+2*a", vars), p0.createLinear(0, NEGATIVE_ONE, TWO)); assertEquals(parse("-1+2*b", vars), p0.createLinear(1, NEGATIVE_ONE, TWO)); assertEquals(parse("-1+2*c", vars), p0.createLinear(2, NEGATIVE_ONE, TWO)); } |
MultivariatePolynomial extends AMultivariatePolynomial<Monomial<E>, MultivariatePolynomial<E>> { public static MultivariatePolynomial<BigInteger> parse(String string, String... variables) { return parse(string, Rings.Z, variables); } MultivariatePolynomial(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, MonomialSet<Monomial<E>> terms); static MultivariatePolynomial<E> create(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, Iterable<Monomial<E>> terms); static MultivariatePolynomial<E> create(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, Monomial<E>... terms); static MultivariatePolynomial<E> zero(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> one(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering); static MultivariatePolynomial<BigInteger> parse(String string, String... variables); @Deprecated static MultivariatePolynomial<BigInteger> parse(String string); static MultivariatePolynomial<E> parse(String string, Ring<E> ring, String... variables); @Deprecated static MultivariatePolynomial<E> parse(String string, Ring<E> ring); static MultivariatePolynomial<BigInteger> parse(String string, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomial<BigInteger> parse(String string, Comparator<DegreeVector> ordering); static MultivariatePolynomial<E> parse(String string, Ring<E> ring, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomial<E> parse(String string, Ring<E> ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asOverZp64(MultivariatePolynomial<BigInteger> poly); static MultivariatePolynomialZp64 asOverZp64(MultivariatePolynomial<BigInteger> poly, IntegersZp64 ring); static MultivariatePolynomial<E> asMultivariate(UnivariatePolynomial<E> poly, int nVariables, int variable, Comparator<DegreeVector> ordering); @Override @SuppressWarnings("unchecked") UnivariatePolynomial<E> asUnivariate(); @Override MultivariatePolynomial<UnivariatePolynomial<E>> asOverUnivariate(int variable); @Override MultivariatePolynomial<UnivariatePolynomial<E>> asOverUnivariateEliminate(int variable); @Override MultivariatePolynomial<MultivariatePolynomial<E>> asOverMultivariate(int... variables); @Override MultivariatePolynomial<MultivariatePolynomial<E>> asOverMultivariateEliminate(int[] variables, Comparator<DegreeVector> ordering); static MultivariatePolynomial<E> asNormalMultivariate(MultivariatePolynomial<UnivariatePolynomial<E>> poly, int variable); static MultivariatePolynomial<E> asNormalMultivariate(MultivariatePolynomial<MultivariatePolynomial<E>> poly); static MultivariatePolynomial<E> asNormalMultivariate(
MultivariatePolynomial<MultivariatePolynomial<E>> poly,
int[] coefficientVariables, int[] mainVariables); static MultivariatePolynomial<BigInteger> asPolyZ(MultivariatePolynomial<BigInteger> poly, boolean copy); static MultivariatePolynomial<BigInteger> asPolyZSymmetric(MultivariatePolynomial<BigInteger> poly); @Override MultivariatePolynomial<E> contentAsPoly(); @Override MultivariatePolynomial<E> lcAsPoly(); @Override MultivariatePolynomial<E> lcAsPoly(Comparator<DegreeVector> ordering); @Override MultivariatePolynomial<E> ccAsPoly(); @Override boolean isOverField(); @Override boolean isOverFiniteField(); @Override boolean isOverZ(); @Override BigInteger coefficientRingCardinality(); @Override BigInteger coefficientRingCharacteristic(); @Override boolean isOverPerfectPower(); @Override BigInteger coefficientRingPerfectPowerBase(); @Override BigInteger coefficientRingPerfectPowerExponent(); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[] createArray(int length); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[][] createArray2d(int length); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[][] createArray2d(int length1, int length2); @Override boolean sameCoefficientRingWith(MultivariatePolynomial<E> oth); @Override MultivariatePolynomial<E> setCoefficientRingFrom(MultivariatePolynomial<E> poly); MultivariatePolynomial<E> setRing(Ring<E> newRing); MultivariatePolynomial<E> setRingUnsafe(Ring<E> newRing); MultivariatePolynomial<E> createConstant(E val); @Override MultivariatePolynomial<E> createConstantFromTerm(Monomial<E> monomial); @Override MultivariatePolynomial<E> createZero(); @Override MultivariatePolynomial<E> createOne(); final MultivariatePolynomial<E> createLinear(int variable, E cc, E lc); @Override boolean isMonic(); @Override int signumOfLC(); @Override boolean isOne(); @Override boolean isUnitCC(); @Override boolean isConstant(); E maxAbsCoefficient(); E lc(); E lc(Comparator<DegreeVector> ordering); MultivariatePolynomial<E> setLC(E val); E cc(); E content(); Iterable<E> coefficients(); E[] coefficientsArray(); @Override MultivariatePolynomial<E> primitivePart(int variable); @Override UnivariatePolynomial<E> contentUnivariate(int variable); @Override MultivariatePolynomial<E> primitivePart(); @Override MultivariatePolynomial<E> primitivePartSameSign(); @Override MultivariatePolynomial<E> divideByLC(MultivariatePolynomial<E> other); MultivariatePolynomial<E> divideOrNull(E factor); MultivariatePolynomial<E> divideExact(E factor); @Override MultivariatePolynomial<E> divideOrNull(Monomial<E> monomial); @Override MultivariatePolynomial<E> monic(); @Override MultivariatePolynomial<E> monic(Comparator<DegreeVector> ordering); MultivariatePolynomial<E> monic(E factor); MultivariatePolynomial<E> monic(Comparator<DegreeVector> ordering, E factor); @Override MultivariatePolynomial<E> monicWithLC(MultivariatePolynomial<E> other); @Override MultivariatePolynomial<E> monicWithLC(Comparator<DegreeVector> ordering, MultivariatePolynomial<E> other); UnivariatePolynomial toDenseRecursiveForm(); static MultivariatePolynomial<E> fromDenseRecursiveForm(UnivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static E evaluateDenseRecursiveForm(UnivariatePolynomial recForm, int nVariables, E[] values); AMultivariatePolynomial toSparseRecursiveForm(); static MultivariatePolynomial<E> fromSparseRecursiveForm(AMultivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static E evaluateSparseRecursiveForm(AMultivariatePolynomial recForm, int nVariables, E[] values); @SuppressWarnings("unchecked") HornerForm getHornerForm(int[] evaluationVariables); MultivariatePolynomial<E> evaluate(int variable, E value); @SuppressWarnings("unchecked") E evaluate(E... values); @SuppressWarnings("unchecked") MultivariatePolynomial<E> evaluate(int[] variables, E[] values); @SuppressWarnings("unchecked") MultivariatePolynomial<E>[] evaluate(int variable, E... values); MultivariatePolynomial<E> evaluate(int variable, long value); MultivariatePolynomial<E> eliminate(int variable, E value); MultivariatePolynomial<E> eliminate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomial<E> eliminate(int[] variables, E[] values); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(int variable, E value); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(int[] variables, E[] values); @SuppressWarnings("unchecked") static PrecomputedPowersHolder<E> mkPrecomputedPowers(int nVariables, Ring<E> ring, int[] variables, E[] values); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(E[] values); MultivariatePolynomial<E> substitute(int variable, MultivariatePolynomial<E> poly); MultivariatePolynomial<E> shift(int variable, long shift); @SuppressWarnings("unchecked") MultivariatePolynomial<E> shift(int variable, E shift); @SuppressWarnings("unchecked") MultivariatePolynomial<E> shift(int[] variables, E[] shifts); MultivariatePolynomial<E> add(E oth); MultivariatePolynomial<E> subtract(E oth); @Override MultivariatePolynomial<E> increment(); @Override MultivariatePolynomial<E> decrement(); MultivariatePolynomial<E> multiply(E factor); @Override MultivariatePolynomial<E> multiplyByLC(MultivariatePolynomial<E> other); @Override MultivariatePolynomial<E> multiply(Monomial<E> monomial); @Override MultivariatePolynomial<E> multiply(long factor); @Override MultivariatePolynomial<E> multiplyByBigInteger(BigInteger factor); @Override MultivariatePolynomial<E> multiply(MultivariatePolynomial<E> oth); @Override MultivariatePolynomial<E> square(); @Override MultivariatePolynomial<E> evaluateAtRandom(int variable, RandomGenerator rnd); @Override MultivariatePolynomial<E> evaluateAtRandomPreservingSkeleton(int variable, RandomGenerator rnd); @Override MultivariatePolynomial<E> derivative(int variable, int order); @Override MultivariatePolynomial<E> seriesCoefficient(int variable, int order); Stream<E> stream(); MultivariatePolynomial<T> mapTerms(Ring<T> newRing, Function<Monomial<E>, Monomial<T>> mapper); MultivariatePolynomial<T> mapCoefficients(Ring<T> newRing, Function<E, T> mapper); MultivariatePolynomialZp64 mapCoefficients(IntegersZp64 newDomain, ToLongFunction<E> mapper); @Override MultivariatePolynomial<T> mapCoefficientsAsPolys(Ring<T> ring, Function<MultivariatePolynomial<E>, T> mapper); @Override int compareTo(MultivariatePolynomial<E> oth); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E> clone(); @Override @Deprecated MultivariatePolynomial<E> parsePoly(String string); @Override String toString(IStringifier<MultivariatePolynomial<E>> stringifier); @Override String coefficientRingToString(IStringifier<MultivariatePolynomial<E>> stringifier); final Ring<E> ring; } | @Test public void testRenameVariables1() throws Exception { String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomial<BigInteger> poly = parse("5+6*b*e+7*b^2+3*a^2+d+15*a^2*b^2+a^3+11*a^3*b*e^9+6*a^3*b^2+c*e^3", vars); for (int i = 1; i < poly.nVariables; i++) for (int j = 0; j < i; j++) assertEquals(poly, swapVariables(swapVariables(poly, i, j), i, j)); }
@Test public void testRenameVariables2() throws Exception { String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomial<BigInteger> poly = parse("1 + a^4 + b^6 + c^5 + d^3 + e^2", vars); int[] variables = ArraysUtil.sequence(poly.nVariables); int[] degrees = poly.degrees(); int lastVar = 2; ArraysUtil.quickSort(ArraysUtil.negate(degrees), variables); ArraysUtil.negate(degrees); assertEquals(0, variables[lastVar]); MultivariatePolynomial<BigInteger> renamed = renameVariables(poly, variables); assertDescending(renamed.degrees()); assertEquals(poly, renameVariables(renamed, inverse(variables))); }
@Test public void testComposition1() { String[] vars = {"x", "y", "z"}; MultivariatePolynomial<BigInteger> poly = MultivariatePolynomial.parse("x + 2*y + 3*z", vars), y = MultivariatePolynomial.parse("x^3", vars), z = MultivariatePolynomial.parse("x^5", vars); assertEquals(parse("x + 2*x^3 + 3*x^5", vars), poly.composition(new int[]{1, 2}, new MultivariatePolynomial[]{y, z})); assertEquals(parse("x^3 + 2*x^5 + 3*z", vars), poly.composition(new int[]{0, 1}, new MultivariatePolynomial[]{y, z})); assertEquals(parse("x^5 + 2*x^3 + 3*z", vars), poly.composition(new int[]{1, 0}, new MultivariatePolynomial[]{y, z})); assertEquals(parse("x + 2*x^5 + 3*x^3", vars), poly.composition(new int[]{2, 1}, new MultivariatePolynomial[]{y, z})); assertEquals(parse("x^5 + 2*y + 3*x^3", vars), poly.composition(new int[]{2, 0}, new MultivariatePolynomial[]{y, z})); }
@Test @SuppressWarnings("unchecked") public void testComposition2() { RandomGenerator rnd = getRandom(); String[] vars = {"d", "s34", "x", "y", "z", "du0", "du1"}; for (int n = 0; n < 10; ++n) { int l = rnd.nextInt(vars.length), m = rnd.nextInt(vars.length); ArraysUtil.swap(vars, l, m); MultivariatePolynomial<BigInteger> poly = parse("du0^4*du1^3*s34^2 + du0^3*du1^4*s34^2 - du0^3*du1^3*s34^3 - du0^3*du1^3*s34^2*x + du0^2*du1^3*s34^3*x - du0^4*du1^3*s34*y - du0^3*du1^4*s34*y - 3*du0^3*du1^2*s34^3*y - 3*du0^2*du1^3*s34^3*y + 3*du0^2*du1^2*s34^4*y + du0^3*du1^3*s34*x*y + du0^3*du1^2*s34^2*x*y - du0^2*du1^3*s34^2*x*y + du0^2*du1^2*s34^3*x*y - 2*du0*du1^2*s34^4*x*y + du0^3*du1^3*s34*y^2 + 3*du0^3*du1^2*s34^2*y^2 + 3*du0^2*du1^3*s34^2*y^2 + 3*du0^2*du1*s34^4*y^2 + 3*du0*du1^2*s34^4*y^2 - 3*du0*du1*s34^5*y^2 - du0^3*du1^2*s34*x*y^2 - du0^2*du1^2*s34^2*x*y^2 - 2*du0^2*du1*s34^3*x*y^2 + 2*du0*du1^2*s34^3*x*y^2 + du0*du1*s34^4*x*y^2 + du1*s34^5*x*y^2 - 3*du0^2*du1^2*s34^2*y^3 - 3*du0^2*du1*s34^3*y^3 - 3*du0*du1^2*s34^3*y^3 - du0*s34^5*y^3 - du1*s34^5*y^3 + s34^6*y^3 + 2*du0^2*du1*s34^2*x*y^3 - du0*du1*s34^3*x*y^3 + du0*s34^4*x*y^3 - du1*s34^4*x*y^3 - s34^5*x*y^3 + 3*du0*du1*s34^3*y^4 + du0*s34^4*y^4 + du1*s34^4*y^4 - du0*s34^3*x*y^4 + s34^4*x*y^4 - s34^4*y^5 - du0^4*du1^3*s34*z - du0^3*du1^4*s34*z + du0^3*du1^2*s34^3*z + du0^3*du1^3*s34*x*z - 3*du0^3*du1^2*s34^2*x*z - 4*du0^2*du1^3*s34^2*x*z + du0^2*du1^2*s34^3*x*z + 3*du0^2*du1^2*s34^2*x^2*z - 2*du0*du1^2*s34^3*x^2*z + du0^4*du1^3*y*z + du0^3*du1^4*y*z + du0^3*du1^3*s34*y*z + 2*du0^3*du1^2*s34^2*y*z + 4*du0^2*du1^3*s34^2*y*z - 2*du0^2*du1^2*s34^3*y*z - 2*du0^2*du1*s34^4*y*z - du0^3*du1^3*x*y*z + 2*du0^3*du1^2*s34*x*y*z + 4*du0^2*du1^3*s34*x*y*z - du0^2*du1^2*s34^2*x*y*z + 2*du0^2*du1*s34^3*x*y*z + 4*du0*du1^2*s34^3*x*y*z + 2*du0*du1*s34^4*x*y*z - 3*du0^2*du1^2*s34*x^2*y*z - 2*du0^2*du1*s34^2*x^2*y*z + 2*du0*du1^2*s34^2*x^2*y*z + 2*du0*du1*s34^3*x^2*y*z - 2*du1*s34^4*x^2*y*z - du0^3*du1^3*y^2*z - 3*du0^3*du1^2*s34*y^2*z - 4*du0^2*du1^3*s34*y^2*z - du0^2*du1^2*s34^2*y^2*z - du0^2*du1*s34^3*y^2*z - 5*du0*du1^2*s34^3*y^2*z + 4*du0*du1*s34^4*y^2*z + du0*s34^5*y^2*z + du0^3*du1^2*x*y^2*z - 4*du0*du1^2*s34^2*x*y^2*z - du0*du1*s34^3*x*y^2*z + du0*s34^4*x*y^2*z - 3*s34^5*x*y^2*z + 2*du0^2*du1*s34*x^2*y^2*z - 2*du0*du1*s34^2*x^2*y^2*z - 2*du0*s34^3*x^2*y^2*z + 2*du1*s34^3*x^2*y^2*z + 3*s34^4*x^2*y^2*z + 3*du0^2*du1^2*s34*y^3*z + 3*du0^2*du1*s34^2*y^3*z + 5*du0*du1^2*s34^2*y^3*z - du0*du1*s34^3*y^3*z + 2*du1*s34^4*y^3*z - 2*s34^5*y^3*z - 2*du0^2*du1*s34*x*y^3*z - du0*du1*s34^2*x*y^3*z - 2*du0*s34^3*x*y^3*z + s34^4*x*y^3*z + 2*du0*s34^2*x^2*y^3*z - 3*s34^3*x^2*y^3*z - 3*du0*du1*s34^2*y^4*z - du0*s34^3*y^4*z - 2*du1*s34^3*y^4*z + s34^4*y^4*z + du0*s34^2*x*y^4*z + 2*s34^3*x*y^4*z + s34^3*y^5*z + du0^3*du1^3*s34*z^2 - du0^3*du1^2*s34^2*z^2 + 3*du0^3*du1^2*s34*x*z^2 + 3*du0^2*du1^3*s34*x*z^2 + 2*du0^2*du1^2*s34^2*x*z^2 - 2*du0^2*du1*s34^3*x*z^2 - 3*du0^2*du1^2*s34*x^2*z^2 + 3*du0^2*du1*s34^2*x^2*z^2 + 5*du0*du1^2*s34^2*x^2*z^2 + du0*du1*s34^3*x^2*z^2 - 3*du0*du1*s34^2*x^3*z^2 + du1*s34^3*x^3*z^2 - du0^3*du1^3*y*z^2 + du0^3*du1^2*s34*y*z^2 - du0^2*du1^3*s34*y*z^2 - du0^2*du1^2*s34^2*y*z^2 + 2*du0^2*du1*s34^3*y*z^2 - 3*du0^3*du1^2*x*y*z^2 - 3*du0^2*du1^3*x*y*z^2 - 3*du0^2*du1^2*s34*x*y*z^2 - 4*du0*du1^2*s34^2*x*y*z^2 - 2*du0*s34^4*x*y*z^2 + 3*du0^2*du1^2*x^2*y*z^2 - du0^2*du1*s34*x^2*y*z^2 - 5*du0*du1^2*s34*x^2*y*z^2 - 2*du0*du1*s34^2*x^2*y*z^2 + du0*s34^3*x^2*y*z^2 + 3*du1*s34^3*x^2*y*z^2 + 3*s34^4*x^2*y*z^2 + 3*du0*du1*s34*x^3*y*z^2 + du0*s34^2*x^3*y*z^2 - du1*s34^2*x^3*y*z^2 - 3*s34^3*x^3*y*z^2 + du0^2*du1^3*y^2*z^2 + du0^2*du1^2*s34*y^2*z^2 - 2*du0^2*du1*s34^2*y^2*z^2 + 2*du0*du1^2*s34^2*y^2*z^2 - du0*du1*s34^3*y^2*z^2 - du0*s34^4*y^2*z^2 + du0^2*du1^2*x*y^2*z^2 + 2*du0^2*du1*s34*x*y^2*z^2 + 4*du0*du1^2*s34*x*y^2*z^2 - 2*du0*du1*s34^2*x*y^2*z^2 + du0*s34^3*x*y^2*z^2 - 3*du1*s34^3*x*y^2*z^2 + 6*s34^4*x*y^2*z^2 - 2*du0^2*du1*x^2*y^2*z^2 + du0*du1*s34*x^2*y^2*z^2 + du0*s34^2*x^2*y^2*z^2 - 3*du1*s34^2*x^2*y^2*z^2 - 3*s34^3*x^2*y^2*z^2 - du0*s34*x^3*y^2*z^2 + 3*s34^2*x^3*y^2*z^2 - 2*du0*du1^2*s34*y^3*z^2 + du0*du1*s34^2*y^3*z^2 + du0*s34^3*y^3*z^2 - du1*s34^3*y^3*z^2 + s34^4*y^3*z^2 + 2*du0*du1*s34*x*y^3*z^2 + du0*s34^2*x*y^3*z^2 + 3*du1*s34^2*x*y^3*z^2 - 3*s34^3*x*y^3*z^2 - 2*du0*s34*x^2*y^3*z^2 + du1*s34^2*y^4*z^2 - s34^3*y^4*z^2 - 3*s34^2*x*y^4*z^2 - 3*du0^2*du1^2*s34*x*z^3 + 2*du0^2*du1*s34^2*x*z^3 - 3*du0^2*du1*s34*x^2*z^3 - 3*du0*du1^2*s34*x^2*z^3 - 4*du0*du1*s34^2*x^2*z^3 + du0*s34^3*x^2*z^3 + 3*du0*du1*s34*x^3*z^3 - du0*s34^2*x^3*z^3 - 2*du1*s34^2*x^3*z^3 - s34^3*x^3*z^3 + s34^2*x^4*z^3 + 3*du0^2*du1^2*x*y*z^3 - 2*du0^2*du1*s34*x*y*z^3 + 2*du0*du1^2*s34*x*y*z^3 - 2*du0*du1*s34^2*x*y*z^3 + 2*du0*s34^3*x*y*z^3 + 3*du0^2*du1*x^2*y*z^3 + 3*du0*du1^2*x^2*y*z^3 + 3*du0*du1*s34*x^2*y*z^3 - 2*du0*s34^2*x^2*y*z^3 - 6*s34^3*x^2*y*z^3 - 3*du0*du1*x^3*y*z^3 + 2*du1*s34*x^3*y*z^3 + 3*s34^2*x^3*y*z^3 - s34*x^4*y*z^3 - 2*du0*du1^2*x*y^2*z^3 + 2*du0*du1*s34*x*y^2*z^3 - 2*du0*s34^2*x*y^2*z^3 + 2*du1*s34^2*x*y^2*z^3 - 3*s34^3*x*y^2*z^3 + du0*du1*x^2*y^2*z^3 + du0*s34*x^2*y^2*z^3 + 3*s34^2*x^2*y^2*z^3 + du0*x^3*y^2*z^3 - 2*s34*x^3*y^2*z^3 - 2*du1*s34*x*y^3*z^3 + 3*s34^2*x*y^3*z^3 + 3*s34*x^2*y^3*z^3 + 3*du0*du1*s34*x^2*z^4 - du0*s34^2*x^2*z^4 + du0*s34*x^3*z^4 + du1*s34*x^3*z^4 + 2*s34^2*x^3*z^4 - s34*x^4*z^4 - 3*du0*du1*x^2*y*z^4 + du0*s34*x^2*y*z^4 - du1*s34*x^2*y*z^4 + 3*s34^2*x^2*y*z^4 - du0*x^3*y*z^4 - du1*x^3*y*z^4 - s34*x^3*y*z^4 + x^4*y*z^4 + du1*x^2*y^2*z^4 - 3*s34*x^2*y^2*z^4 - x^3*y^2*z^4 - s34*x^3*z^5 + x^3*y*z^5", vars); int du0 = parse("du0", vars).univariateVariable(), du1 = parse("du1", vars).univariateVariable(), s34 = parse("s34", vars).univariateVariable(), d = parse("d", vars).univariateVariable(), x = parse("x", vars).univariateVariable(), y = parse("y", vars).univariateVariable(), z = parse("z", vars).univariateVariable(); int[] from = {s34, x, y, du0, du1}; MultivariatePolynomial<BigInteger>[] to = new MultivariatePolynomial[]{ parse("x", vars), parse("0", vars), parse("s34", vars), parse("y", vars), parse("0", vars) }; MultivariatePolynomial<BigInteger> expected = parse("-(s34^5*x^4) + s34^3*x^6 + s34^4*x^4*y - s34^3*x^5*y + s34^5*x^3*z + s34^4*x^4*z - 2*s34^3*x^5*z - s34^4*x^3*y*z + s34^2*x^5*y*z - s34^4*x^3*z^2 + s34^3*x^4*z^2 + s34^3*x^3*y*z^2 - s34^2*x^4*y*z^2", vars); assertEquals(expected, poly.composition(from, to)); for (int i = 0; i < 10; ++i) { l = rnd.nextInt(from.length); m = rnd.nextInt(from.length); if (l == m) continue; ArraysUtil.swap(from, l, m); ArraysUtil.swap(to, l, m); assertEquals(expected, poly.composition(from, to)); } } } |
ArraysUtil { public static int[] insert(int[] array, int position, int value) { int[] newArray = new int[array.length + 1]; System.arraycopy(array, 0, newArray, 0, position); System.arraycopy(array, position, newArray, position + 1, array.length - position); newArray[position] = value; return newArray; } private ArraysUtil(); static int[] flatten(int[][] array); static int[] arrayOf(int val, int len); static long[] arrayOf(long val, int len); static char[] arrayOf(char val, int len); static T[] arrayOf(T val, int len); static int[] negate(int[] arr); static long[] negate(long[] arr); static BigInteger[] negate(BigInteger[] arr); static String toString(long[] a, int from, int to); static String toString(T[] a, int from, int to); static String toString(T[] a, int from, int to, Function<T, String> stringer); static void shuffle(int[] array, RandomGenerator rnd); static int[] getSortedDistinct(int[] values); static BigInteger[] getSortedDistinct(BigInteger[] values); static long[] getSortedDistinct(long[] values); static int[] intSetDifference(int[] main, int[] delete); static int[] intSetUnion(int[] a, int[] b); static int[] insert(int[] array, int position, int value); static int[] insert(int[] array, int position, int value, int length); static long[] insert(long[] array, int position, long value); @SuppressWarnings("unchecked") static T[] insert(T[] array, int position, T value); static void reverse(int[] array, int from, int to); static void reverse(long[] array, int from, int to); static void reverse(T[] array, int from, int to); static void reverse(T[] array); static void reverse(int[] array); static void reverse(long[] array); static int[] short2int(final short[] a); static short[] int2short(final int[] a); static int[] byte2int(final byte[] a); static short[] byte2short(final byte[] a); static byte[] int2byte(final int[] a); static int max(int[] array); static long max(long[] array); static int max(int[] array, int from, int to); static int[] max(int[] a, int[] b); static int min(int[] array); static long min(long[] array); static int min(int[] array, int from, int to); static int[] min(int[] a, int[] b); static int firstIndexOf(int element, int[] array); static int firstIndexOf(Object element, Object[] array); static int indexOfMax(int[] array); static int[] sequence(int size); static int[] sequence(int from, int to); static int[][] deepClone(int[][] input); static Object[][] deepClone(Object[][] input); static int sum(final int[] array); static int[] sum(final int[] a, final int[] b); static int[] multiply(final int[] a, final int[] b); static int[] subtract(final int[] a, final int[] b); static int sum(final int[] array, int from); static int sum(final int[] array, int from, int to); static int multiply(final int[] array, int from, int to); static double multiplyToDouble(final int[] array, int from, int to); static double multiplyToDouble(final int[] array); static double sumToDouble(final int[] array, int from, int to); static double sumToDouble(final int[] array); static int or(final long[] array); static int or(final long[] array, int from); static int or(final long[] array, int from, int to); static int[] bijection(T[] from, T[] to, Comparator<? super T> comparator); static int[] bijection(T[] from, T[] to); static int[] addAll(int[] array1, int... array2); static long[] addAll(long[] array1, long... array2); static int[] addAll(int[]... arrays); static int[] remove(int[] array, int i); static long[] remove(long[] array, int i); static T[] remove(T[] array, int i); @SafeVarargs static T[] addAll(T[] array1, T... array2); static T[] remove(T[] array, int[] positions); static int[] remove(int[] array, int[] positions); static long[] remove(long[] array, int[] positions); static T[] select(T[] array, int[] positions); static int[] select(int[] array, int[] positions); static int[] toArray(Set<Integer> set); static int binarySearch1(int[] a, int key); static int binarySearch1(int[] a, int fromIndex, int toIndex,
int key); static int commutativeHashCode(final T[] data); static int commutativeHashCode(T[] data, int from, int to); static int commutativeHashCode(final int[] data); static int commutativeHashCode(int[] data, int from, int to); static void insertionSort(int[] target, int[] coSort); static void insertionSort(int[] target, int fromIndex, int toIndex, int[] coSort); static void insertionSort(int[] target, long[] coSort); static void insertionSort(int[] target, int fromIndex, int toIndex, long[] coSort); static void insertionSort(T[] target, Object[] coSort); static void insertionSort(T[] target, int fromIndex, int toIndex, Object[] coSort); static void insertionSort(T[] target, int[] coSort); static void insertionSort(T[] target, int fromIndex, int toIndex, int[] coSort); static void timSort(int target[], int[] coSort); static void stableSort(int target[], int[] cosort); static int[] quickSortP(int[] target); static void quickSort(int[] target, int[] coSort); static void quickSort(int[] target, int fromIndex, int toIndex, int[] coSort); static void quickSort1(int target[], int fromIndex, int length, int[] coSort); static void swap(int x[], int a, int b); static void quickSort(long[] target, long[] coSort); static void quickSort(long[] target, int fromIndex, int toIndex, long[] coSort); static void quickSort1(long target[], int fromIndex, int length, long[] coSort); static void quickSort(int[] target, long[] coSort); static void quickSort(int[] target, int fromIndex, int toIndex, long[] coSort); static void quickSort1(int target[], int fromIndex, int length, long[] coSort); static void swap(long x[], int a, int b); static void quickSort(T[] target, Object[] coSort); static void quickSort(T[] target, int fromIndex, int toIndex, Object[] coSort); static void quickSort1(T[] target, int fromIndex, int length, Object[] coSort); static void quickSort(T[] target, int[] coSort); static void quickSort(T[] target, int fromIndex, int toIndex, int[] coSort); static void quickSort1(T[] target, int fromIndex, int length, int[] coSort); static void swap(Object[] x, int a, int b); static void quickSort(int[] target, Object[] coSort); static void quickSort(int[] target, int fromIndex, int toIndex, Object[] coSort); static void quickSort1(int target[], int fromIndex, int length, Object[] coSort); static int[] quickSortP(short[] target); static void quickSort(short[] target, int fromIndex, int toIndex, int[] coSort); static void quickSort1(short target[], int fromIndex, int length, int[] coSort); static void quickSort(short[] target, int[] coSort); static void quickSort(int[] target, IntComparator comparator); static void quickSort(int[] target, int fromIndex, int toIndex, IntComparator comparator); static void quickSort1(int target[], int fromIndex, int length, IntComparator comparator); static void quickSort(int[] target, int[] cosort, IntComparator comparator); static void quickSort(int[] target, int fromIndex, int toIndex, int[] cosort, IntComparator comparator); static final Comparator<Object> HASH_COMPARATOR; static final Comparator<int[]> COMPARATOR; static final Comparator<long[]> COMPARATOR_LONG; static final Comparator<Comparable[]> COMPARATOR_GENERIC; } | @Test public void testInsert() throws Exception { int[] arr = {0, 1, 2, 3}; assertArrayEquals(new int[]{99, 0, 1, 2, 3}, ArraysUtil.insert(arr, 0, 99)); assertArrayEquals(new int[]{0, 99, 1, 2, 3}, ArraysUtil.insert(arr, 1, 99)); assertArrayEquals(new int[]{0, 1, 2, 3, 99}, ArraysUtil.insert(arr, 4, 99)); } |
MultivariatePolynomial extends AMultivariatePolynomial<Monomial<E>, MultivariatePolynomial<E>> { @Override public String toString(IStringifier<MultivariatePolynomial<E>> stringifier) { IStringifier<E> cfStringifier = stringifier.substringifier(ring); if (isConstant()) return cfStringifier.stringify(cc()); String[] varStrings = new String[nVariables]; for (int i = 0; i < nVariables; ++i) varStrings[i] = stringifier.getBindings().getOrDefault(createMonomial(i, 1), IStringifier.defaultVar(i, nVariables)); StringBuilder sb = new StringBuilder(); for (Monomial<E> term : terms) { E cf = term.coefficient; String cfString; if (ring.isMinusOne(cf) && term.totalDegree != 0) cfString = "-"; else if (!ring.isOne(cf) || term.totalDegree == 0) cfString = cfStringifier.stringify(cf); else cfString = ""; if (term.totalDegree != 0 && IStringifier.needParenthesisInSum(cfString)) cfString = "(" + cfString + ")"; if (sb.length() != 0 && !cfString.startsWith("-")) sb.append("+"); StringBuilder cfBuilder = new StringBuilder(); cfBuilder.append(cfString); boolean appended = false; for (int i = 0; i < nVariables; ++i) { if (term.exponents[i] == 0) continue; if (!(cfString.equals("-") && !appended) && cfBuilder.length() != 0) cfBuilder.append("*"); cfBuilder.append(varStrings[i]); if (term.exponents[i] > 1) cfBuilder.append("^").append(term.exponents[i]); appended = true; } sb.append(cfBuilder); } return sb.toString(); } MultivariatePolynomial(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, MonomialSet<Monomial<E>> terms); static MultivariatePolynomial<E> create(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, Iterable<Monomial<E>> terms); static MultivariatePolynomial<E> create(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, Monomial<E>... terms); static MultivariatePolynomial<E> zero(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> one(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering); static MultivariatePolynomial<BigInteger> parse(String string, String... variables); @Deprecated static MultivariatePolynomial<BigInteger> parse(String string); static MultivariatePolynomial<E> parse(String string, Ring<E> ring, String... variables); @Deprecated static MultivariatePolynomial<E> parse(String string, Ring<E> ring); static MultivariatePolynomial<BigInteger> parse(String string, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomial<BigInteger> parse(String string, Comparator<DegreeVector> ordering); static MultivariatePolynomial<E> parse(String string, Ring<E> ring, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomial<E> parse(String string, Ring<E> ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asOverZp64(MultivariatePolynomial<BigInteger> poly); static MultivariatePolynomialZp64 asOverZp64(MultivariatePolynomial<BigInteger> poly, IntegersZp64 ring); static MultivariatePolynomial<E> asMultivariate(UnivariatePolynomial<E> poly, int nVariables, int variable, Comparator<DegreeVector> ordering); @Override @SuppressWarnings("unchecked") UnivariatePolynomial<E> asUnivariate(); @Override MultivariatePolynomial<UnivariatePolynomial<E>> asOverUnivariate(int variable); @Override MultivariatePolynomial<UnivariatePolynomial<E>> asOverUnivariateEliminate(int variable); @Override MultivariatePolynomial<MultivariatePolynomial<E>> asOverMultivariate(int... variables); @Override MultivariatePolynomial<MultivariatePolynomial<E>> asOverMultivariateEliminate(int[] variables, Comparator<DegreeVector> ordering); static MultivariatePolynomial<E> asNormalMultivariate(MultivariatePolynomial<UnivariatePolynomial<E>> poly, int variable); static MultivariatePolynomial<E> asNormalMultivariate(MultivariatePolynomial<MultivariatePolynomial<E>> poly); static MultivariatePolynomial<E> asNormalMultivariate(
MultivariatePolynomial<MultivariatePolynomial<E>> poly,
int[] coefficientVariables, int[] mainVariables); static MultivariatePolynomial<BigInteger> asPolyZ(MultivariatePolynomial<BigInteger> poly, boolean copy); static MultivariatePolynomial<BigInteger> asPolyZSymmetric(MultivariatePolynomial<BigInteger> poly); @Override MultivariatePolynomial<E> contentAsPoly(); @Override MultivariatePolynomial<E> lcAsPoly(); @Override MultivariatePolynomial<E> lcAsPoly(Comparator<DegreeVector> ordering); @Override MultivariatePolynomial<E> ccAsPoly(); @Override boolean isOverField(); @Override boolean isOverFiniteField(); @Override boolean isOverZ(); @Override BigInteger coefficientRingCardinality(); @Override BigInteger coefficientRingCharacteristic(); @Override boolean isOverPerfectPower(); @Override BigInteger coefficientRingPerfectPowerBase(); @Override BigInteger coefficientRingPerfectPowerExponent(); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[] createArray(int length); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[][] createArray2d(int length); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[][] createArray2d(int length1, int length2); @Override boolean sameCoefficientRingWith(MultivariatePolynomial<E> oth); @Override MultivariatePolynomial<E> setCoefficientRingFrom(MultivariatePolynomial<E> poly); MultivariatePolynomial<E> setRing(Ring<E> newRing); MultivariatePolynomial<E> setRingUnsafe(Ring<E> newRing); MultivariatePolynomial<E> createConstant(E val); @Override MultivariatePolynomial<E> createConstantFromTerm(Monomial<E> monomial); @Override MultivariatePolynomial<E> createZero(); @Override MultivariatePolynomial<E> createOne(); final MultivariatePolynomial<E> createLinear(int variable, E cc, E lc); @Override boolean isMonic(); @Override int signumOfLC(); @Override boolean isOne(); @Override boolean isUnitCC(); @Override boolean isConstant(); E maxAbsCoefficient(); E lc(); E lc(Comparator<DegreeVector> ordering); MultivariatePolynomial<E> setLC(E val); E cc(); E content(); Iterable<E> coefficients(); E[] coefficientsArray(); @Override MultivariatePolynomial<E> primitivePart(int variable); @Override UnivariatePolynomial<E> contentUnivariate(int variable); @Override MultivariatePolynomial<E> primitivePart(); @Override MultivariatePolynomial<E> primitivePartSameSign(); @Override MultivariatePolynomial<E> divideByLC(MultivariatePolynomial<E> other); MultivariatePolynomial<E> divideOrNull(E factor); MultivariatePolynomial<E> divideExact(E factor); @Override MultivariatePolynomial<E> divideOrNull(Monomial<E> monomial); @Override MultivariatePolynomial<E> monic(); @Override MultivariatePolynomial<E> monic(Comparator<DegreeVector> ordering); MultivariatePolynomial<E> monic(E factor); MultivariatePolynomial<E> monic(Comparator<DegreeVector> ordering, E factor); @Override MultivariatePolynomial<E> monicWithLC(MultivariatePolynomial<E> other); @Override MultivariatePolynomial<E> monicWithLC(Comparator<DegreeVector> ordering, MultivariatePolynomial<E> other); UnivariatePolynomial toDenseRecursiveForm(); static MultivariatePolynomial<E> fromDenseRecursiveForm(UnivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static E evaluateDenseRecursiveForm(UnivariatePolynomial recForm, int nVariables, E[] values); AMultivariatePolynomial toSparseRecursiveForm(); static MultivariatePolynomial<E> fromSparseRecursiveForm(AMultivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static E evaluateSparseRecursiveForm(AMultivariatePolynomial recForm, int nVariables, E[] values); @SuppressWarnings("unchecked") HornerForm getHornerForm(int[] evaluationVariables); MultivariatePolynomial<E> evaluate(int variable, E value); @SuppressWarnings("unchecked") E evaluate(E... values); @SuppressWarnings("unchecked") MultivariatePolynomial<E> evaluate(int[] variables, E[] values); @SuppressWarnings("unchecked") MultivariatePolynomial<E>[] evaluate(int variable, E... values); MultivariatePolynomial<E> evaluate(int variable, long value); MultivariatePolynomial<E> eliminate(int variable, E value); MultivariatePolynomial<E> eliminate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomial<E> eliminate(int[] variables, E[] values); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(int variable, E value); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(int[] variables, E[] values); @SuppressWarnings("unchecked") static PrecomputedPowersHolder<E> mkPrecomputedPowers(int nVariables, Ring<E> ring, int[] variables, E[] values); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(E[] values); MultivariatePolynomial<E> substitute(int variable, MultivariatePolynomial<E> poly); MultivariatePolynomial<E> shift(int variable, long shift); @SuppressWarnings("unchecked") MultivariatePolynomial<E> shift(int variable, E shift); @SuppressWarnings("unchecked") MultivariatePolynomial<E> shift(int[] variables, E[] shifts); MultivariatePolynomial<E> add(E oth); MultivariatePolynomial<E> subtract(E oth); @Override MultivariatePolynomial<E> increment(); @Override MultivariatePolynomial<E> decrement(); MultivariatePolynomial<E> multiply(E factor); @Override MultivariatePolynomial<E> multiplyByLC(MultivariatePolynomial<E> other); @Override MultivariatePolynomial<E> multiply(Monomial<E> monomial); @Override MultivariatePolynomial<E> multiply(long factor); @Override MultivariatePolynomial<E> multiplyByBigInteger(BigInteger factor); @Override MultivariatePolynomial<E> multiply(MultivariatePolynomial<E> oth); @Override MultivariatePolynomial<E> square(); @Override MultivariatePolynomial<E> evaluateAtRandom(int variable, RandomGenerator rnd); @Override MultivariatePolynomial<E> evaluateAtRandomPreservingSkeleton(int variable, RandomGenerator rnd); @Override MultivariatePolynomial<E> derivative(int variable, int order); @Override MultivariatePolynomial<E> seriesCoefficient(int variable, int order); Stream<E> stream(); MultivariatePolynomial<T> mapTerms(Ring<T> newRing, Function<Monomial<E>, Monomial<T>> mapper); MultivariatePolynomial<T> mapCoefficients(Ring<T> newRing, Function<E, T> mapper); MultivariatePolynomialZp64 mapCoefficients(IntegersZp64 newDomain, ToLongFunction<E> mapper); @Override MultivariatePolynomial<T> mapCoefficientsAsPolys(Ring<T> ring, Function<MultivariatePolynomial<E>, T> mapper); @Override int compareTo(MultivariatePolynomial<E> oth); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E> clone(); @Override @Deprecated MultivariatePolynomial<E> parsePoly(String string); @Override String toString(IStringifier<MultivariatePolynomial<E>> stringifier); @Override String coefficientRingToString(IStringifier<MultivariatePolynomial<E>> stringifier); final Ring<E> ring; } | @Test public void testToString() { String str = MultivariatePolynomial.parse("- x - y", "x", "y").toString(); assertTrue(str.equals("-x-y") || str.equals("-y-x")); str = MultivariatePolynomial.parse("- 2*x - y*z", "x", "y", "z").toString(); assertTrue(str.equals("-2*x-y*z") || str.equals("-y*z-2*x")); } |
MultivariatePolynomial extends AMultivariatePolynomial<Monomial<E>, MultivariatePolynomial<E>> { public E content() { return isOverField() ? lc() : ring.gcd(coefficients()); } MultivariatePolynomial(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, MonomialSet<Monomial<E>> terms); static MultivariatePolynomial<E> create(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, Iterable<Monomial<E>> terms); static MultivariatePolynomial<E> create(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering, Monomial<E>... terms); static MultivariatePolynomial<E> zero(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> one(int nVariables, Ring<E> ring, Comparator<DegreeVector> ordering); static MultivariatePolynomial<BigInteger> parse(String string, String... variables); @Deprecated static MultivariatePolynomial<BigInteger> parse(String string); static MultivariatePolynomial<E> parse(String string, Ring<E> ring, String... variables); @Deprecated static MultivariatePolynomial<E> parse(String string, Ring<E> ring); static MultivariatePolynomial<BigInteger> parse(String string, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomial<BigInteger> parse(String string, Comparator<DegreeVector> ordering); static MultivariatePolynomial<E> parse(String string, Ring<E> ring, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomial<E> parse(String string, Ring<E> ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asOverZp64(MultivariatePolynomial<BigInteger> poly); static MultivariatePolynomialZp64 asOverZp64(MultivariatePolynomial<BigInteger> poly, IntegersZp64 ring); static MultivariatePolynomial<E> asMultivariate(UnivariatePolynomial<E> poly, int nVariables, int variable, Comparator<DegreeVector> ordering); @Override @SuppressWarnings("unchecked") UnivariatePolynomial<E> asUnivariate(); @Override MultivariatePolynomial<UnivariatePolynomial<E>> asOverUnivariate(int variable); @Override MultivariatePolynomial<UnivariatePolynomial<E>> asOverUnivariateEliminate(int variable); @Override MultivariatePolynomial<MultivariatePolynomial<E>> asOverMultivariate(int... variables); @Override MultivariatePolynomial<MultivariatePolynomial<E>> asOverMultivariateEliminate(int[] variables, Comparator<DegreeVector> ordering); static MultivariatePolynomial<E> asNormalMultivariate(MultivariatePolynomial<UnivariatePolynomial<E>> poly, int variable); static MultivariatePolynomial<E> asNormalMultivariate(MultivariatePolynomial<MultivariatePolynomial<E>> poly); static MultivariatePolynomial<E> asNormalMultivariate(
MultivariatePolynomial<MultivariatePolynomial<E>> poly,
int[] coefficientVariables, int[] mainVariables); static MultivariatePolynomial<BigInteger> asPolyZ(MultivariatePolynomial<BigInteger> poly, boolean copy); static MultivariatePolynomial<BigInteger> asPolyZSymmetric(MultivariatePolynomial<BigInteger> poly); @Override MultivariatePolynomial<E> contentAsPoly(); @Override MultivariatePolynomial<E> lcAsPoly(); @Override MultivariatePolynomial<E> lcAsPoly(Comparator<DegreeVector> ordering); @Override MultivariatePolynomial<E> ccAsPoly(); @Override boolean isOverField(); @Override boolean isOverFiniteField(); @Override boolean isOverZ(); @Override BigInteger coefficientRingCardinality(); @Override BigInteger coefficientRingCharacteristic(); @Override boolean isOverPerfectPower(); @Override BigInteger coefficientRingPerfectPowerBase(); @Override BigInteger coefficientRingPerfectPowerExponent(); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[] createArray(int length); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[][] createArray2d(int length); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E>[][] createArray2d(int length1, int length2); @Override boolean sameCoefficientRingWith(MultivariatePolynomial<E> oth); @Override MultivariatePolynomial<E> setCoefficientRingFrom(MultivariatePolynomial<E> poly); MultivariatePolynomial<E> setRing(Ring<E> newRing); MultivariatePolynomial<E> setRingUnsafe(Ring<E> newRing); MultivariatePolynomial<E> createConstant(E val); @Override MultivariatePolynomial<E> createConstantFromTerm(Monomial<E> monomial); @Override MultivariatePolynomial<E> createZero(); @Override MultivariatePolynomial<E> createOne(); final MultivariatePolynomial<E> createLinear(int variable, E cc, E lc); @Override boolean isMonic(); @Override int signumOfLC(); @Override boolean isOne(); @Override boolean isUnitCC(); @Override boolean isConstant(); E maxAbsCoefficient(); E lc(); E lc(Comparator<DegreeVector> ordering); MultivariatePolynomial<E> setLC(E val); E cc(); E content(); Iterable<E> coefficients(); E[] coefficientsArray(); @Override MultivariatePolynomial<E> primitivePart(int variable); @Override UnivariatePolynomial<E> contentUnivariate(int variable); @Override MultivariatePolynomial<E> primitivePart(); @Override MultivariatePolynomial<E> primitivePartSameSign(); @Override MultivariatePolynomial<E> divideByLC(MultivariatePolynomial<E> other); MultivariatePolynomial<E> divideOrNull(E factor); MultivariatePolynomial<E> divideExact(E factor); @Override MultivariatePolynomial<E> divideOrNull(Monomial<E> monomial); @Override MultivariatePolynomial<E> monic(); @Override MultivariatePolynomial<E> monic(Comparator<DegreeVector> ordering); MultivariatePolynomial<E> monic(E factor); MultivariatePolynomial<E> monic(Comparator<DegreeVector> ordering, E factor); @Override MultivariatePolynomial<E> monicWithLC(MultivariatePolynomial<E> other); @Override MultivariatePolynomial<E> monicWithLC(Comparator<DegreeVector> ordering, MultivariatePolynomial<E> other); UnivariatePolynomial toDenseRecursiveForm(); static MultivariatePolynomial<E> fromDenseRecursiveForm(UnivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static E evaluateDenseRecursiveForm(UnivariatePolynomial recForm, int nVariables, E[] values); AMultivariatePolynomial toSparseRecursiveForm(); static MultivariatePolynomial<E> fromSparseRecursiveForm(AMultivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static E evaluateSparseRecursiveForm(AMultivariatePolynomial recForm, int nVariables, E[] values); @SuppressWarnings("unchecked") HornerForm getHornerForm(int[] evaluationVariables); MultivariatePolynomial<E> evaluate(int variable, E value); @SuppressWarnings("unchecked") E evaluate(E... values); @SuppressWarnings("unchecked") MultivariatePolynomial<E> evaluate(int[] variables, E[] values); @SuppressWarnings("unchecked") MultivariatePolynomial<E>[] evaluate(int variable, E... values); MultivariatePolynomial<E> evaluate(int variable, long value); MultivariatePolynomial<E> eliminate(int variable, E value); MultivariatePolynomial<E> eliminate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomial<E> eliminate(int[] variables, E[] values); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(int variable, E value); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(int[] variables, E[] values); @SuppressWarnings("unchecked") static PrecomputedPowersHolder<E> mkPrecomputedPowers(int nVariables, Ring<E> ring, int[] variables, E[] values); @SuppressWarnings("unchecked") PrecomputedPowersHolder<E> mkPrecomputedPowers(E[] values); MultivariatePolynomial<E> substitute(int variable, MultivariatePolynomial<E> poly); MultivariatePolynomial<E> shift(int variable, long shift); @SuppressWarnings("unchecked") MultivariatePolynomial<E> shift(int variable, E shift); @SuppressWarnings("unchecked") MultivariatePolynomial<E> shift(int[] variables, E[] shifts); MultivariatePolynomial<E> add(E oth); MultivariatePolynomial<E> subtract(E oth); @Override MultivariatePolynomial<E> increment(); @Override MultivariatePolynomial<E> decrement(); MultivariatePolynomial<E> multiply(E factor); @Override MultivariatePolynomial<E> multiplyByLC(MultivariatePolynomial<E> other); @Override MultivariatePolynomial<E> multiply(Monomial<E> monomial); @Override MultivariatePolynomial<E> multiply(long factor); @Override MultivariatePolynomial<E> multiplyByBigInteger(BigInteger factor); @Override MultivariatePolynomial<E> multiply(MultivariatePolynomial<E> oth); @Override MultivariatePolynomial<E> square(); @Override MultivariatePolynomial<E> evaluateAtRandom(int variable, RandomGenerator rnd); @Override MultivariatePolynomial<E> evaluateAtRandomPreservingSkeleton(int variable, RandomGenerator rnd); @Override MultivariatePolynomial<E> derivative(int variable, int order); @Override MultivariatePolynomial<E> seriesCoefficient(int variable, int order); Stream<E> stream(); MultivariatePolynomial<T> mapTerms(Ring<T> newRing, Function<Monomial<E>, Monomial<T>> mapper); MultivariatePolynomial<T> mapCoefficients(Ring<T> newRing, Function<E, T> mapper); MultivariatePolynomialZp64 mapCoefficients(IntegersZp64 newDomain, ToLongFunction<E> mapper); @Override MultivariatePolynomial<T> mapCoefficientsAsPolys(Ring<T> ring, Function<MultivariatePolynomial<E>, T> mapper); @Override int compareTo(MultivariatePolynomial<E> oth); @Override @SuppressWarnings("unchecked") MultivariatePolynomial<E> clone(); @Override @Deprecated MultivariatePolynomial<E> parsePoly(String string); @Override String toString(IStringifier<MultivariatePolynomial<E>> stringifier); @Override String coefficientRingToString(IStringifier<MultivariatePolynomial<E>> stringifier); final Ring<E> ring; } | @Test public void testContent() { MultivariatePolynomial<BigInteger> poly = MultivariatePolynomial .parse("-x*y","x", "y"); Monomial<BigInteger> ct = poly.monomialContent(); assertEquals(2, ct.totalDegree); poly = poly.divideOrNull(ct); assertTrue(poly.isConstant()); } |
MultivariateResultants { public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> Poly ClassicalResultant(Poly a, Poly b, int variable) { if (canConvertToZp64(a)) return convertFromZp64(ClassicalResultant(asOverZp64(a), asOverZp64(b), variable)); return UnivariateResultants.Resultant(a.asUnivariateEliminate(variable), b.asUnivariateEliminate(variable)).insertVariable(variable); } private MultivariateResultants(); @SuppressWarnings("unchecked") static Poly Discriminant(Poly a, int variable); @SuppressWarnings("unchecked") static Poly Resultant(Poly a, Poly b, int variable); @SuppressWarnings("unchecked") static Poly ResultantInGF(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static Poly ClassicalResultant(Poly a, Poly b, int variable); static Poly ResultantInSmallCharacteristic(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ModularResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularResultantInNumberField(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> ModularResultantInRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b,
int variable); static MultivariatePolynomialZp64 BrownResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> BrownResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); static MultivariatePolynomialZp64 ZippelResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> ZippelResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); } | @Test public void test1() throws Exception { MultivariateRing<MultivariatePolynomial<BigInteger>> ring = MultivariateRing(3, Z); Coder<MultivariatePolynomial<BigInteger>, ?, ?> coder = Coder.mkMultivariateCoder(ring, "x", "y", "z"); MultivariatePolynomial<BigInteger> a = coder.parse("(2*x + y + z)^3 + 1"); MultivariatePolynomial<BigInteger> b = coder.parse("(x - 3*y - z)^3 + 1"); MultivariatePolynomial<BigInteger> expected = coder.parse("343 - 124509*y^3 + 2470629*y^6 - 40353607*y^9 - 160083*y^2*z + 6353046*y^5*z - 155649627*y^8*z - 68607*y*z^2 + 6806835*y^4*z^2 - 266827932*y^7*z^2 - 9801*z^3 + 3889620*y^3*z^3 - 266827932*y^6*z^3 + 1250235*y^2*z^4 - 171532242*y^5*z^4 + 214326*y*z^5 - 73513818*y^4*z^5 + 15309*z^6 - 21003948*y^3*z^6 - 3857868*y^2*z^7 - 413343*y*z^8 - 19683*z^9"); assertEquals(expected, ClassicalResultant(a, b, 0)); } |
MultivariateResultants { @SuppressWarnings("unchecked") static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> Poly BrownResultant(Poly a, Poly b, int variable) { if (a instanceof MultivariatePolynomialZp64) return (Poly) BrownResultant((MultivariatePolynomialZp64) a, (MultivariatePolynomialZp64) b, variable); else return (Poly) BrownResultant((MultivariatePolynomial) a, (MultivariatePolynomial) b, variable); } private MultivariateResultants(); @SuppressWarnings("unchecked") static Poly Discriminant(Poly a, int variable); @SuppressWarnings("unchecked") static Poly Resultant(Poly a, Poly b, int variable); @SuppressWarnings("unchecked") static Poly ResultantInGF(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static Poly ClassicalResultant(Poly a, Poly b, int variable); static Poly ResultantInSmallCharacteristic(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ModularResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularResultantInNumberField(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> ModularResultantInRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b,
int variable); static MultivariatePolynomialZp64 BrownResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> BrownResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); static MultivariatePolynomialZp64 ZippelResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> ZippelResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); } | @Test @RequiresSingular public void testBrown1_random() throws Exception { RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = getRandomData(); IntegersZp64 ring = Zp64(SmallPrimes.nextPrime(1 << 20)); DescriptiveStatistics brown = new DescriptiveStatistics(), singular = new DescriptiveStatistics(); int nIterations = its(100, 100); int nVars = 4, degree = 7; for (int i = 0; i < nIterations; ++i) { MultivariatePolynomialZp64 a = RandomMultivariatePolynomials.randomSharpPolynomial(nVars, degree, rndd.nextInt(1, 20), ring, LEX, rnd), b = RandomMultivariatePolynomials.randomSharpPolynomial(nVars, degree, rndd.nextInt(1, 20), ring, LEX, rnd); int variable = rnd.nextInt(nVars); long start = System.nanoTime(); MultivariatePolynomialZp64 actual = BrownResultant(a, b, variable); brown.addValue(System.nanoTime() - start); SingularResult<MonomialZp64, MultivariatePolynomialZp64> expected = SingularResultant(a, b, variable); if (expected != null) singular.addValue(expected.nanotime); assertEquals(expected.resultant, actual); } System.out.println("Brown: " + statisticsNanotime(brown)); System.out.println("Singular: " + statisticsNanotime(singular)); }
@Test public void testBrown2() throws Exception { MultivariateRing<MultivariatePolynomialZp64> ring = MultivariateRingZp64(5, Zp64(1048583)); Coder<MultivariatePolynomialZp64, ?, ?> coder = Coder.mkMultivariateCoder(ring, "x1", "x2", "x3", "x4", "x5"); MultivariatePolynomialZp64 a = coder.parse("637881*x1^3*x2^2*x3^4*x4*x5^2"); MultivariatePolynomialZp64 b = coder.parse("220444*x1*x2*x3*x5^2+188423*x3^2*x4*x5^3+1021013*x2*x4*x5^5+27846*x1^3*x2^2*x3*x5^4+932116*x1^4*x2^3*x3*x5^3+1029973*x2^3*x4^6*x5^2+405192*x1^6*x2*x3^2*x4^3+982184*x1^2*x3^5*x4^5*x5+867884*x1^4*x2^6*x5^5+607543*x1*x2^4*x3^2*x4^5*x5^3+124055*x2^2*x3^5*x4^6*x5^3+211592*x1^2*x2^3*x3^2*x4^6*x5^3+273881*x1*x2^6*x3^2*x4^4*x5^5+534279*x1^4*x2^3*x3^4*x4^2*x5^6+301771*x1^5*x2^4*x3^5*x4*x5^5+482564*x1^3*x2*x3^6*x4^6*x5^5+422454*x1^6*x2^3*x3^5*x4^2*x5^6"); MultivariatePolynomialZp64 expected = coder.parse("11341*x1^18*x3^28*x4^8*x5^18+939807*x1^20*x3^31*x4^12*x5^16+83676*x1^22*x3^34*x4^16*x5^14"); assertEquals(expected, BrownResultant(a, b, 1)); }
@Test public void testBrown3() throws Exception { MultivariateRing<MultivariatePolynomialZp64> ring = MultivariateRingZp64(5, Zp64(1048583)); Coder<MultivariatePolynomialZp64, ?, ?> coder = Coder.mkMultivariateCoder(ring, "x1", "x2", "x3", "x4", "x5"); MultivariatePolynomialZp64 a = coder.parse("303182*x2^2*x3^4*x4^3*x5^2+740361*x1^4*x3^3*x4^2*x5^4"); MultivariatePolynomialZp64 b = coder.parse("446331*x1^4*x3^4*x4^2+972452*x2^5*x3^2*x4^3*x5^5"); MultivariatePolynomialZp64 expected = coder.parse("822600*x2^8*x3^32*x4^20*x5^8+329308*x2^11*x3^29*x4^20*x5^15+774779*x2^14*x3^26*x4^20*x5^22+72726*x2^17*x3^23*x4^20*x5^29+1007096*x2^20*x3^20*x4^20*x5^36"); assertEquals(expected, BrownResultant(a, b, 0)); } |
MultivariateResultants { static SparseInterpolationZp64 createInterpolation(int variable, UnivariatePolynomial<MultivariatePolynomialZp64> a, UnivariatePolynomial<MultivariatePolynomialZp64> b, MultivariatePolynomialZp64 skeleton, int expectedNumberOfEvaluations, RandomGenerator rnd) { MultivariatePolynomialZp64 factory = a.lc(); assert factory.nVariables > 1; skeleton = skeleton.clone().setAllCoefficientsToUnit(); Set<DegreeVector> globalSkeleton = skeleton.getSkeleton(); TIntObjectHashMap<MultivariatePolynomialZp64> univarSkeleton = getSkeleton(skeleton); int[] sparseUnivarDegrees = univarSkeleton.keys(); IntegersZp64 ring = factory.ring; int lastVariable = variable == -1 ? factory.nVariables - 1 : variable; int[] evaluationVariables = ArraysUtil.sequence(1, lastVariable + 1); long[] evaluationPoint = new long[evaluationVariables.length]; MultivariatePolynomialZp64.lPrecomputedPowersHolder powers; int fails = 0; search_for_good_evaluation_point: while (true) { if (fails >= MAX_FAILED_SUBSTITUTIONS) return null; for (int i = lastVariable - 1; i >= 0; --i) do { evaluationPoint[i] = ring.randomElement(rnd); } while (evaluationPoint[i] == 0); powers = mkPrecomputedPowers(a, b, evaluationVariables, evaluationPoint); Iterator<MultivariatePolynomialZp64> it = Stream.concat(Stream.concat(a.stream(), b.stream()), Stream.of(skeleton)).iterator(); while (it.hasNext()) { MultivariatePolynomialZp64 p = it.next(); if (!p.getSkeleton(0).equals(p.evaluate(powers, evaluationVariables).getSkeleton())) { ++fails; continue search_for_good_evaluation_point; } } break; } int requiredNumberOfEvaluations = -1; for (TIntObjectIterator<MultivariatePolynomialZp64> it = univarSkeleton.iterator(); it.hasNext(); ) { it.advance(); MultivariatePolynomialZp64 v = it.value(); if (v.size() > requiredNumberOfEvaluations) requiredNumberOfEvaluations = v.size(); } return new SparseInterpolationZp64(ring, variable, a, b, globalSkeleton, univarSkeleton, sparseUnivarDegrees, evaluationVariables, evaluationPoint, powers, expectedNumberOfEvaluations, requiredNumberOfEvaluations, rnd); } private MultivariateResultants(); @SuppressWarnings("unchecked") static Poly Discriminant(Poly a, int variable); @SuppressWarnings("unchecked") static Poly Resultant(Poly a, Poly b, int variable); @SuppressWarnings("unchecked") static Poly ResultantInGF(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static Poly ClassicalResultant(Poly a, Poly b, int variable); static Poly ResultantInSmallCharacteristic(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ModularResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularResultantInNumberField(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> ModularResultantInRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b,
int variable); static MultivariatePolynomialZp64 BrownResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> BrownResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); static MultivariatePolynomialZp64 ZippelResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> ZippelResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); } | @Test @RequiresSingular public void testSparseInterpolation1() throws IOException, InterruptedException { MultivariateRing<MultivariatePolynomialZp64> ring = MultivariateRingZp64(3, Zp64(1048583)); Coder<MultivariatePolynomialZp64, ?, ?> coder = Coder.mkMultivariateCoder(ring, "x", "y", "z"); MultivariatePolynomialZp64 a = coder.parse("(2*x + y + z)^3 + 1"); MultivariatePolynomialZp64 b = coder.parse("(x - 3*y - z)^13 + 1"); MultivariatePolynomialZp64 expected = SingularResultant(a, b, 0).resultant; MultivariatePolynomialZp64 rEval = expected.dropVariable(0).evaluate(1, 1); SparseInterpolationZp64 interpolation = createInterpolation(1, a.asUnivariateEliminate(0), b.asUnivariateEliminate(0), rEval, expected.degree(2), getRandom()); assertEquals(expected.evaluate(2, 2), interpolation.evaluate(2).insertVariable(0)); } |
MultivariateResultants { public static MultivariatePolynomial<BigInteger> ModularResultantInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b, int variable) { ResultantInput<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> resInput = preparedResultantInput(a, b, variable); if (resInput.earlyResultant != null) return resInput.earlyResultant; return resInput.restoreResultant(ModularResultantInZ0(resInput.aReduced0, resInput.bReduced0)); } private MultivariateResultants(); @SuppressWarnings("unchecked") static Poly Discriminant(Poly a, int variable); @SuppressWarnings("unchecked") static Poly Resultant(Poly a, Poly b, int variable); @SuppressWarnings("unchecked") static Poly ResultantInGF(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static Poly ClassicalResultant(Poly a, Poly b, int variable); static Poly ResultantInSmallCharacteristic(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ModularResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularResultantInNumberField(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> ModularResultantInRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b,
int variable); static MultivariatePolynomialZp64 BrownResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> BrownResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); static MultivariatePolynomialZp64 ZippelResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> ZippelResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); } | @Test @RequiresSingular public void testModular2_random() throws Exception { RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = getRandomData(); int nIterations = its(25, 100); int nVars = 4, degree = 7; DescriptiveStatistics modular = new DescriptiveStatistics(), singular = new DescriptiveStatistics(); int cfBound = 10_000; for (int i = 0; i < nIterations; ++i) { MultivariatePolynomial<BigInteger> a = RandomMultivariatePolynomials.randomSharpPolynomial(nVars, degree, rndd.nextInt(1, 20), Zp64(cfBound), LEX, rnd).toBigPoly().setRing(Z), b = RandomMultivariatePolynomials.randomSharpPolynomial(nVars, degree, rndd.nextInt(1, 20), Zp64(cfBound), LEX, rnd).toBigPoly().setRing(Z); int variable = rnd.nextInt(nVars); try { SingularResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> si = SingularResultant(a, b, variable); MultivariatePolynomial<BigInteger> expected = null; if (si != null) { expected = si.resultant; singular.addValue(si.nanotime); System.out.println("si: " + nanosecondsToString(si.nanotime)); } long start; start = System.nanoTime(); MultivariatePolynomial<BigInteger> actual = ModularResultantInZ(a, b, variable); modular.addValue(System.nanoTime() - start); System.out.println("ri: " + nanosecondsToString(System.nanoTime() - start)); System.out.println(); if (expected != null) assertEquals(expected, actual); } catch (Throwable e) { System.out.println(a); System.out.println(b); System.out.println(variable); throw new RuntimeException(e); } } System.out.println("Modular's " + modular); System.out.println("Singulars's " + singular); }
@Test @RequiresSingular public void testModular4() throws Exception { MultivariateRing<MultivariatePolynomial<BigInteger>> ring = MultivariateRing(4, Z, LEX); Coder<MultivariatePolynomial<BigInteger>, ?, ?> coder = Coder.mkMultivariateCoder(ring, "x1", "x2", "x3", "x4"); MultivariatePolynomial<BigInteger> a = coder.parse("9789*x1^3*x3*x4+5618*x1^4*x4+5574*x1^4*x2*x3+9813*x1^6"); MultivariatePolynomial<BigInteger> b = coder.parse("3425*x2^2*x4+2575*x2^3*x3^2+1157*x2^4*x3+6413*x1*x4^4+6401*x1*x2^2*x3^2+296*x1^2+42*x1^2*x2*x4^3+3941*x1^2*x2*x3+3918*x1^3*x3^3+5245*x1^3*x2*x3^2+1114*x1^4*x3^2+8801*x1^4*x2+773*x1^4*x2^2+2744*x1^5*x3+7473*x1^5*x2+7395*x1^6"); int variable = 0; MultivariatePolynomial<BigInteger> sin = SingularResultant(a, b, variable).resultant; MultivariatePolynomial<BigInteger> mod = ModularResultantInZ(a, b, variable); assertEquals(sin, mod); } |
IntTimSort { static void sort(int[] a, int[] b) { if (a.length != b.length) throw new IllegalArgumentException(); sort(a, 0, a.length, b); } private IntTimSort(int[] a, int[] b); } | @Test public void testSomeMethod() { int pivot = K / 6; Random r = new Random(); for (int n = 0; n < 1000; ++n) { int[] main = new int[K]; int[] perm = new int[K]; int counter = 0; for (int i = 0; i < K; ++i) { perm[i] = main[i] = r.nextInt(K / 4); if (main[i] == pivot) perm[i] = counter++; } IntTimSort.sort(main, perm); counter = 0; for (int i = 0; i < K; ++i) { if (i < K - 1) assertTrue(main[i] <= main[i + 1]); if (main[i] != pivot) assertEquals(main[i], perm[i]); else assertEquals(counter++, perm[i]); } } } |
MultivariateResultants { static <E> MultivariatePolynomial<Rational<E>> ResultantInQ( MultivariatePolynomial<Rational<E>> a, MultivariatePolynomial<Rational<E>> b, int variable) { Util.Tuple2<MultivariatePolynomial<E>, E> aRat = Util.toCommonDenominator(a); Util.Tuple2<MultivariatePolynomial<E>, E> bRat = Util.toCommonDenominator(b); Ring<E> ring = aRat._1.ring; E correction = ring.multiply( ring.pow(aRat._2, b.degree(variable)), ring.pow(bRat._2, a.degree(variable))); return Util.asOverRationals(a.ring, Resultant(aRat._1, bRat._1, variable)).divideExact(new Rational<>(ring, correction)); } private MultivariateResultants(); @SuppressWarnings("unchecked") static Poly Discriminant(Poly a, int variable); @SuppressWarnings("unchecked") static Poly Resultant(Poly a, Poly b, int variable); @SuppressWarnings("unchecked") static Poly ResultantInGF(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static Poly ClassicalResultant(Poly a, Poly b, int variable); static Poly ResultantInSmallCharacteristic(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ModularResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularResultantInNumberField(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> ModularResultantInRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b,
int variable); static MultivariatePolynomialZp64 BrownResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> BrownResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); static MultivariatePolynomialZp64 ZippelResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> ZippelResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); } | @Test public void testInQ1() throws Exception { MultivariateRing<MultivariatePolynomial<Rational<BigInteger>>> ring = MultivariateRing(3, Q); Coder<MultivariatePolynomial<Rational<BigInteger>>, ?, ?> coder = Coder.mkMultivariateCoder(ring, "x", "y", "z"); MultivariatePolynomial<Rational<BigInteger>> a = coder.parse("(2*x/3 + y/4 + z)^3 + 1/5"); MultivariatePolynomial<Rational<BigInteger>> b = coder.parse("(x - 3*y/7 - z)^3 + 1/2"); MultivariatePolynomial<Rational<BigInteger>> expected = coder.parse("-343/2460375 - (24545*y^3)/197568 - (253125*y^6)/68841472 - (38443359375*y^9)/10578455953408 - (24545*y^2*z)/21168 - (84375*y^5*z)/1229312 - (38443359375*y^8*z)/377801998336 - (24545*y*z^2)/6804 - (46875*y^4*z^2)/87808 - (4271484375*y^7*z^2)/3373232128 - (24545*z^3)/6561 - (15625*y^3*z^3)/7056 - (158203125*y^6*z^3)/17210368 - (15625*y^2*z^4)/3024 - (52734375*y^5*z^4)/1229312 - (3125*y*z^5)/486 - (5859375*y^4*z^5)/43904 - (21875*z^6)/6561 - (1953125*y^3*z^6)/7056 - (1953125*y^2*z^7)/5292 - (1953125*y*z^8)/6804 - (1953125*z^9)/19683"); assertEquals(expected, ResultantInQ(a, b, 0)); } |
MultivariateResultants { @SuppressWarnings("unchecked") public static <Poly extends AMultivariatePolynomial> Poly Resultant(Poly a, Poly b, int variable) { a.assertSameCoefficientRingWith(b); if (a.isOverFiniteField()) return ResultantInGF(a, b, variable); if (a.isOverZ()) return (Poly) ResultantInZ((MultivariatePolynomial) a, (MultivariatePolynomial) b, variable); if (Util.isOverRationals(a)) return (Poly) ResultantInQ((MultivariatePolynomial) a, (MultivariatePolynomial) b, variable); if (Util.isOverSimpleNumberField(a)) return (Poly) ModularResultantInNumberField((MultivariatePolynomial) a, (MultivariatePolynomial) b, variable); if (Util.isOverRingOfIntegersOfSimpleNumberField(a)) return (Poly) ModularResultantInRingOfIntegersOfNumberField((MultivariatePolynomial) a, (MultivariatePolynomial) b, variable); if (Util.isOverMultipleFieldExtension(a)) return (Poly) ResultantInMultipleFieldExtension((MultivariatePolynomial) a, (MultivariatePolynomial) b, variable); if (a.isOverField()) return (Poly) ZippelResultant((MultivariatePolynomial<BigInteger>) a, (MultivariatePolynomial<BigInteger>) b, variable); return tryNested(a, b, variable); } private MultivariateResultants(); @SuppressWarnings("unchecked") static Poly Discriminant(Poly a, int variable); @SuppressWarnings("unchecked") static Poly Resultant(Poly a, Poly b, int variable); @SuppressWarnings("unchecked") static Poly ResultantInGF(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static Poly ClassicalResultant(Poly a, Poly b, int variable); static Poly ResultantInSmallCharacteristic(Poly a, Poly b, int variable); static MultivariatePolynomial<BigInteger> ModularResultantInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularResultantInNumberField(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
int variable); static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> ModularResultantInRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b,
int variable); static MultivariatePolynomialZp64 BrownResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> BrownResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); static MultivariatePolynomialZp64 ZippelResultant(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int variable); static MultivariatePolynomial<E> ZippelResultant(MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, int variable); } | @Test public void test9() { MultivariateRing<MultivariatePolynomial<Rational<BigInteger>>> cfRing = MultivariateRing(2, Q); Coder<MultivariatePolynomial<Rational<BigInteger>>, ?, ?> cfCoder = Coder.mkMultivariateCoder(cfRing, "c", "d"); MultivariateRing<MultivariatePolynomial<MultivariatePolynomial<Rational<BigInteger>>>> ring = MultivariateRing(2, cfRing); Coder<MultivariatePolynomial<MultivariatePolynomial<Rational<BigInteger>>>, ?, ?> coder = Coder.mkMultivariateCoder(ring, cfCoder, "x", "y"); MultivariatePolynomial<MultivariatePolynomial<Rational<BigInteger>>> a = coder.parse("2 + x^2"); MultivariatePolynomial<MultivariatePolynomial<Rational<BigInteger>>> b = coder.parse("3 + y^2"); assertEquals(coder.parse("(2 + x^2)^2"), Resultant(a, b, 1)); } |
MultivariateFactorization { static PolynomialFactorDecomposition<MultivariatePolynomialZp64> bivariateDenseFactorSquareFreeInGF(MultivariatePolynomialZp64 poly) { return bivariateDenseFactorSquareFreeInGF(poly, true); } private MultivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(final Poly poly); static PolynomialFactorDecomposition<MultivariatePolynomial<Rational<E>>> FactorInQ(MultivariatePolynomial<Rational<E>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> FactorInZ(final MultivariatePolynomial<BigInteger> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(final MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> FactorInGF(final Poly polynomial); } | @Ignore @Test public void testBivariate1() throws Exception { IntegersZp64 domain = new IntegersZp64(67); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("b*a^5 + a^4*b^2 + 11 + b^3", domain), b = MultivariatePolynomialZp64.parse("a^6*b + 66*b + 17*b^2 + 1", domain), c = MultivariatePolynomialZp64.parse("b^3*a^4 + a^4 + b", domain), d = MultivariatePolynomialZp64.parse("a^5 + b^5*a^5 + b^2 + 3", domain), base = a.clone().multiply(b, c, d); System.out.println(base); for (int i = 0; i < 1000; i++) { long start = System.nanoTime(); Assert.assertEquals(4, bivariateDenseFactorSquareFreeInGF(base).size()); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testBivariate2() throws Exception { IntegersZp64 domain = new IntegersZp64(62653); String[] vars = {"a", "b"}; MultivariatePolynomialZp64[] factors = { MultivariatePolynomialZp64.parse("17096+6578*a*b^2+54905*a^3", domain, vars), MultivariatePolynomialZp64.parse("43370+32368*a^2*b^2+45712*a^2*b^4+52302*a^4+23776*a^4*b^2", domain, vars) }; MultivariatePolynomialZp64 poly = factors[0].createOne().multiply(factors); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factorization = bivariateDenseFactorSquareFreeInGF(poly); FactorDecompositionTest.assertFactorization(poly, factorization); Assert.assertTrue(factorization.size() >= factors.length); }
@Test public void testBivariate5() throws Exception { IntegersZp64 domain = new IntegersZp64(1336151); String[] vars = {"a", "b"}; MultivariatePolynomialZp64[] factors = { MultivariatePolynomialZp64.parse("319792+402081*a^3", domain, vars), MultivariatePolynomialZp64.parse("685686+694157*a", domain, vars), MultivariatePolynomialZp64.parse("616781+1057293*b^2+158725*a+730076*a*b^2", domain, vars) }; MultivariatePolynomialZp64 poly = factors[0].createOne().multiply(factors); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factorization = bivariateDenseFactorSquareFreeInGF(poly); FactorDecompositionTest.assertFactorization(poly, factorization); Assert.assertTrue(factorization.size() >= factors.length); }
@Test public void testBivariate6() throws Exception { IntegersZp64 domain = new IntegersZp64(57352861); String[] vars = {"a", "b"}; MultivariatePolynomialZp64[] factors = { MultivariatePolynomialZp64.parse("15042434+15817122*b", domain, vars), MultivariatePolynomialZp64.parse("39330400+51579304*a^2", domain, vars) }; MultivariatePolynomialZp64 poly = factors[0].createOne().multiply(factors); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factorization = bivariateDenseFactorSquareFreeInGF(poly); FactorDecompositionTest.assertFactorization(poly, factorization); Assert.assertTrue(factorization.size() >= factors.length); }
@Test public void testBivaraiteSmallDomain7() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b"}; MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("1 + b*a^5 + a^4*b^2 + b^3", domain, vars), b = MultivariatePolynomialZp64.parse("a + a^2 + b + a^6*b + 66*b + 17*b^2 + 1", domain, vars), c = MultivariatePolynomialZp64.parse("b^3*a^4 + a^4 + b", domain, vars), d = MultivariatePolynomialZp64.parse("a^5 + b^5*a^5 + b^2 + 3", domain, vars), base = a.clone().multiply(b, c, d); for (int i = 0; i < its(2, 2); i++) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = bivariateDenseFactorSquareFreeInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(5, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testBivaraiteSmallDomain5Random8a() throws Exception { IntegersZp64 domain = new IntegersZp64(5); String[] vars = {"x", "y"}; MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("1+x^3*y+x^6*y^4+2*x^6*y^5+2*x^6*y^6", domain, vars), b = MultivariatePolynomialZp64.parse("x^5+4*y^6+2*x^5*y^2", domain, vars), c = MultivariatePolynomialZp64.parse("1+x^2+4*x^3+3*x^6+4*x^3*y^4+x^4*y^4", domain, vars), d = MultivariatePolynomialZp64.parse("1+2*x^4*y^2+x^3*y^4+2*x^6*y^6", domain, vars), e = MultivariatePolynomialZp64.parse("1+3*x^4*y+3*x^3*y^4+4*x^4*y^5", domain, vars), base = a.clone().multiply(b, c, d, e); MultivariatePolynomial<BigInteger> bBase = base.toBigPoly(); for (int i = 0; i < its(40, 40); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> decomposition = bivariateDenseFactorSquareFreeInGF(bBase); System.out.println("" + i + " " + TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(5, decomposition.size()); FactorDecompositionTest.assertFactorization(bBase, decomposition); } }
@Test public void testBivariateBenchmarkSingular() throws Exception { IntegersZp64 domain = new IntegersZp64(2); MultivariatePolynomialZp64 poly = MultivariatePolynomialZp64.parse("x^4120 + x^4118*y^2 + x^3708*y^400 + x^3706*y^402 + x^2781*y^1300 + x^2779*y^1302 + x^1339*y^2700 + x^927*y^3100 + y^4000 + x^7172*y^4167 + x^8349*y^4432 + x^8347*y^4434 + x^6760*y^4567 + x^5833*y^5467 + x^5568*y^7132 + x^11401*y^8599", domain); for (int i = 0; i < its(2, 2); i++) { long start = System.nanoTime(); Assert.assertEquals(2, bivariateDenseFactorSquareFreeInGF(poly).size()); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testBivariateBenchmarkSingular2() throws Exception { IntegersZp64 domain = new IntegersZp64(2); MultivariatePolynomialZp64 poly = MultivariatePolynomialZp64.parse("b^1300+a^927*b^400+a^1339+a^5568*b^4432", domain); for (int i = 0; i < its(2, 2); i++) { long start = System.nanoTime(); Assert.assertEquals(1, bivariateDenseFactorSquareFreeInGF(poly).size()); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } } |
MultivariateFactorization { static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> bivariateDenseFactorSquareFreeInZ(MultivariatePolynomial<BigInteger> poly) { assert poly.nUsedVariables() <= 2 && IntStream.range(2, poly.nVariables).allMatch(i -> poly.degree(i) == 0); if (poly.isEffectiveUnivariate()) return factorUnivariate(poly); Monomial<BigInteger> mContent = poly.monomialContent(); if (mContent.totalDegree != 0) return bivariateDenseFactorSquareFreeInZ(poly.divideOrNull(mContent)).addFactor(poly.create(mContent), 1); if (isBivariateCertainlyIrreducible(poly)) return PolynomialFactorDecomposition.of(poly); MultivariatePolynomial<BigInteger> content = poly.contentAsPoly(); MultivariatePolynomial<BigInteger> reducedPoly = content.isOne() ? poly : poly.clone().divideByLC(content); int[] degreeBounds = reducedPoly.degrees(); boolean swapVariables = false; if (degreeBounds[1] > degreeBounds[0]) { swapVariables = true; reducedPoly = AMultivariatePolynomial.swapVariables(reducedPoly, 0, 1); ArraysUtil.swap(degreeBounds, 0, 1); } MultivariatePolynomial<BigInteger> xDerivative = reducedPoly.derivative(0); assert !xDerivative.isZero(); MultivariatePolynomial<BigInteger> dGCD = MultivariateGCD.PolynomialGCD(xDerivative, reducedPoly); if (!dGCD.isConstant()) { PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> gcdFactorization = bivariateDenseFactorSquareFreeInZ(dGCD), restFactorization = bivariateDenseFactorSquareFreeInZ(MultivariateDivision.divideExact(reducedPoly, dGCD)); gcdFactorization.addAll(restFactorization); if (swapVariables) swap(gcdFactorization); return gcdFactorization.addUnit(content); } int degree = reducedPoly.degree(0); BigInteger ySubstitution = null; PolynomialFactorDecomposition<UnivariatePolynomial<BigInteger>> uFactorization = null; int univariateFactorizations = 0; boolean tryZeroFirst = true; UnivariatePolynomial<BigInteger> uImage = null; HashSet<BigInteger> usedSubstitutions = new HashSet<>(); while (univariateFactorizations < UNIVARIATE_FACTORIZATION_ATTEMPTS) { BigInteger substitution; if (tryZeroFirst) { substitution = BigInteger.ZERO; tryZeroFirst = false; } else { int bound = 10 * (univariateFactorizations / 5 + 1); if (bound < usedSubstitutions.size()) bound = usedSubstitutions.size(); do { if (usedSubstitutions.size() == bound) bound *= 2; substitution = BigInteger.valueOf(cc.redberry.rings.poly.multivar.PrivateRandom.getRandom().nextInt(bound)); } while (usedSubstitutions.contains(substitution)); usedSubstitutions.add(substitution); } MultivariatePolynomial<BigInteger> image = reducedPoly.evaluate(1, substitution); if (image.degree() != degree) continue; if (image.cc().isZero()) continue; uImage = image.asUnivariate(); if (!UnivariateSquareFreeFactorization.isSquareFree(uImage)) continue; PolynomialFactorDecomposition<UnivariatePolynomial<BigInteger>> factorization = UnivariateFactorization.FactorSquareFreeInZ(uImage); if (factorization.size() == 1) return PolynomialFactorDecomposition.of(poly); if (uFactorization == null || factorization.size() < uFactorization.size()) { uFactorization = factorization; ySubstitution = substitution; } ++univariateFactorizations; } assert ySubstitution != null; int basePrime = 1 << 22; BigInteger bBasePrime; while (true) { basePrime = SmallPrimes.nextPrime(basePrime); bBasePrime = BigInteger.valueOf(basePrime); if (!isGoodPrime(bBasePrime, uImage.lc(), uImage.cc())) continue; IntegersZp moduloDomain = new IntegersZp(bBasePrime); if (!PolynomialMethods.coprimeQ(uFactorization.mapTo(f -> f.setRing(moduloDomain)).factors)) continue; break; } BigInteger bound2 = coefficientsBound(reducedPoly).multiply(coefficientsBound(reducedPoly.lc(0))).shiftLeft(1); BigInteger modulus = bBasePrime; while (modulus.compareTo(bound2) < 0) modulus = modulus.multiply(bBasePrime); IntegersZp zpDomain = new IntegersZp(modulus); @SuppressWarnings("unchecked") List<UnivariatePolynomial<BigInteger>> factorsListZp = uFactorization.mapTo(f -> f.setRing(zpDomain)).monic().factors; MultivariatePolynomial<BigInteger> baseZp = reducedPoly.setRing(zpDomain), lcZp = baseZp.lc(0); baseZp = baseZp.divideOrNull(lcZp.evaluate(1, ySubstitution).lc()); assert baseZp != null; BigInteger[] evals = Rings.Z.createZeroesArray(poly.nVariables - 1); evals[0] = ySubstitution; HenselLifting.Evaluation<BigInteger> evaluation = new HenselLifting.Evaluation<>(poly.nVariables, evals, zpDomain, baseZp.ordering); if (!lcZp.isConstant()) { assert evaluation.evaluateFrom(lcZp, 1).isConstant(); factorsListZp.add(0, factorsListZp.get(0).createOne()); } @SuppressWarnings("unchecked") UnivariatePolynomial<BigInteger>[] factorsZp = factorsListZp.toArray(new UnivariatePolynomial[factorsListZp.size()]); int liftDegree = baseZp.degree(1) + 1; UnivariatePolynomial<UnivariatePolynomial<BigInteger>> baseSeriesZp = HenselLifting.seriesExpansionDense(Rings.UnivariateRingZp(modulus), baseZp, 1, evaluation); UnivariatePolynomial<UnivariatePolynomial<BigInteger>>[] liftedZp; try { liftedZp = HenselLifting.bivariateLiftDense(baseSeriesZp, factorsZp, liftDegree); } catch (ArithmeticException e) { return bivariateDenseFactorSquareFreeInZ(poly); } if (!lcZp.isConstant()) liftedZp = Arrays.copyOfRange(liftedZp, 1, factorsZp.length); UnivariatePolynomial<UnivariatePolynomial<BigInteger>> baseSeriesZ = seriesExpansionDenseZ(reducedPoly, ySubstitution); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> result = denseBivariateRecombinationZ( reducedPoly, baseZp, baseSeriesZ, liftedZp, evaluation, ySubstitution, zpDomain, liftDegree); if (swapVariables) for (int i = 0; i < result.factors.size(); i++) result.factors.set(i, AMultivariatePolynomial.swapVariables(result.get(i), 0, 1)); return result.addUnit(content); } private MultivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(final Poly poly); static PolynomialFactorDecomposition<MultivariatePolynomial<Rational<E>>> FactorInQ(MultivariatePolynomial<Rational<E>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> FactorInZ(final MultivariatePolynomial<BigInteger> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(final MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> FactorInGF(final Poly polynomial); } | @Test public void testBivariateZ10() throws Exception { MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("a^5 + a^4*b^2 + 11 + b^3"), b = MultivariatePolynomial.parse("a^6 + 66*b + 17*b^2 + 1"), c = MultivariatePolynomial.parse("a^4 + a + b*a^3 + 1"), d = MultivariatePolynomial.parse("a^5 + b^5*a^2 + b^2 + 3"), base = a.clone().multiply(b, c, d); for (int i = 0; i < its(10, 10); i++) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.bivariateDenseFactorSquareFreeInZ(base); FactorDecompositionTest.assertFactorization(base, factors); Assert.assertEquals(4, factors.size()); } }
@Test public void testBivariateZ11() throws Exception { MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("a^5*b + a^4*b^2 + 11 + b^3"), b = MultivariatePolynomial.parse("a^6 + 66*b + 17*b^2 + 1"), c = MultivariatePolynomial.parse("a^4 + a + b*a^3 + 1"), d = MultivariatePolynomial.parse("2*a^5*b^2 + a^5 + b^5*a^2 + b^2 + 3"), base = a.clone().multiply(b, c, d); for (int i = 0; i < its(10, 10); i++) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.bivariateDenseFactorSquareFreeInZ(base); FactorDecompositionTest.assertFactorization(base, factors); Assert.assertEquals(4, factors.size()); } }
@Test @SuppressWarnings("unchecked") public void testBivariateZ12() throws Exception { MultivariatePolynomial<BigInteger> arr[] = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("177522327160552394341592645703385805765313887009291257319200617192383987428268805512690222419723419649 - 3920053743382812791836333767690842621932892411052334923146683840*a*b^2 + 7033850605913160576188071720524348507893675322801660689547349600868470384122764842150502780707785405529567188627563575595567387688045087798899184801064943616*a^5*b^2"), MultivariatePolynomial.parse("-1 - 659270292030815756363107128406733811547883294165085698816218454359750870703729555961546094888322347526082389105851760640*a^4 - 46529261163122475264752208961046337576273813308064326806338441809831450970874815332813704557963583488*a*b^2 + 60352646264726941172425539163284931317263872840808599407691511712170692052757127936*a^3*b^2 + 32892567946099972602587490607087056551535159861075199340856544477051037413463904644350103239197101283178014229071574120289916042759634944*a^5*b^2 + 1082364104922388503041167216*a^3*b^3"), MultivariatePolynomial.parse("1 - 396600905*a^4 + 18362289248902900227792935099132168196824077316766057448880233870344222135220897354236903227821776949155243835602763776*a^5*b + 54170215828526082015490079767653396191028300490271559531210492014654817736810561536*a*b^2 + 22296468805300143007110377483353074672219983699113622589773332810841273786269609285556407919332417536*a^3*b^3 - 4757394916849468388862409325495215636800300577101565824900427776*a^3*b^4"), MultivariatePolynomial.parse("-74245850854698227527322345985623966516292508703727252494450071089311844567647393096878536833433600*a + 25571940100073228627212382584833434076020757173045774321723224487468121499656011190161153995868899392979405069323465864668564085877571041780306601408943225575357784608735232*a^5*b^2 + 39224050727535633086898269296188590065607395610645363228145583907532677889236133260211280579276217051952112979635702373291087160595880341698628015404428693615610586950795264*b^5 - 74103934761117655866120723755998673350750638260236056304102159227089816262619525*a^4*b^5"), MultivariatePolynomial.parse("-1 - 106855402320422968799577513764486364196813269278986918073314897723185477854153087041104406250905236480*a^2*b^2 + 8068843832123230886122491909026167511493726107894055575979325820379758367061684714670315223007513134082333814492609438418585790965664643241520071083651235840*a^2*b^5 + 35672870377471658349867981049557362295743394300549931316635340036585883874243293966739476828669154066698149127319931379517583333329668421045053945301708161614217556217781288960*a^4*b^5"),}, base = multiply(arr).multiply(-512); for (int i = 0; i < its(2, 2); i++) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.bivariateDenseFactorSquareFreeInZ(base); FactorDecompositionTest.assertFactorization(base, factors); Assert.assertEquals(5, factors.size()); } }
@Test @SuppressWarnings("unchecked") public void testBivariateZ13() throws Exception { MultivariatePolynomial<BigInteger> arr[] = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("1 + 1404971693217937738271243675250700150144919317697793951880016259765182277604375*a^3*b - 12133268343571183672190*a^2*b^2"), MultivariatePolynomial.parse("-1 - 312795970327582098045170081592831115925175*a^3 - 77950950035775481760560*a^3*b + 5401*a^3*b^2 + 40302*a^3*b^4"), MultivariatePolynomial.parse("1 - 5782055583736088058003458647322869334017577347037817545999736578862858345204522030604840232262500*a^6 - 43979083297211167074370*a^3*b^5 + 111820046899539828771390*a^6*b^6")}, base = multiply(arr).multiply(-1); for (int i = 0; i < its(2, 12); i++) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.bivariateDenseFactorSquareFreeInZ(base); FactorDecompositionTest.assertFactorization(base, factors); Assert.assertEquals(3, factors.size()); } }
@Test @SuppressWarnings("unchecked") public void testBivariateZ14() throws Exception { MultivariatePolynomial<BigInteger> arr[] = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("(-3110505)*b-4683135*a-9030239*a^2"), MultivariatePolynomial.parse("1+7266251*a*b^5+11178392*a^2*b^2+2162182*a^2*b^6+5303702*a^6"), MultivariatePolynomial.parse("4789608+3904604*b+3917626*a*b+3416219*a^2*b")}, base = multiply(arr); for (int i = 0; i < its(2, 2); i++) { long start = System.nanoTime(); PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.bivariateDenseFactorSquareFreeInZ(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); FactorDecompositionTest.assertFactorization(base, factors); Assert.assertEquals(3, factors.size()); } }
@Test @SuppressWarnings("unchecked") public void testBivariateZ15() throws Exception { MultivariatePolynomial<BigInteger> arr[] = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("(-93)-59*b+164*a^5+168*a^7*b+226*a^8*b"), MultivariatePolynomial.parse("1+245*b^3-211*a*b^2+110*a^5*b^2"), MultivariatePolynomial.parse("5-2*a*b-245*a^2+54*a^3*b^4-92*a^4*b^4")}, base = multiply(arr); for (int i = 0; i < its(2, 2); i++) { long start = System.nanoTime(); PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.bivariateDenseFactorSquareFreeInZ(base); FactorDecompositionTest.assertFactorization(base, factors); Assert.assertEquals(3, factors.size()); } }
@Test @SuppressWarnings("unchecked") public void testBivariateZ17() throws Exception { MultivariatePolynomial<BigInteger> arr[] = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("1-679*a^5*b^5-552*a^5*b^7+675*a^7*b^5"), MultivariatePolynomial.parse("1-813*b-997*a^2*b^2-230*a^4*b^4+1294*a^5*b"), MultivariatePolynomial.parse("(-1)-8*a*b^3")}, base = multiply(arr); for (int i = 0; i < its(2, 2); i++) { long start = System.nanoTime(); PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.bivariateDenseFactorSquareFreeInZ(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); FactorDecompositionTest.assertFactorization(base, factors); Assert.assertEquals(3, factors.size()); } } |
RationalReconstruction { public static long[] reconstruct(long n, long modulus, long numeratorBound, long denominatorBound) { long[] v = {modulus, 0}; long[] w = {n, 1}; while (w[0] > numeratorBound) { long q = v[0] / w[0]; long[] z = {v[0] - q * w[0], v[1] - q * w[1]}; v = w; w = z; } if (w[1] < 0) { w[0] = -w[0]; w[1] = -w[1]; } if (w[1] <= denominatorBound && MachineArithmetic.gcd(w[0], w[1]) == 1) return w; return null; } private RationalReconstruction(); static long[] reconstruct(long n, long modulus,
long numeratorBound,
long denominatorBound); static BigInteger[] reconstruct(BigInteger n, BigInteger modulus,
BigInteger numeratorBound,
BigInteger denominatorBound); static BigInteger[] reconstructFarey(BigInteger n, BigInteger modulus); static BigInteger[] reconstructFareyErrorTolerant(BigInteger n, BigInteger modulus); static Poly[] reconstruct(Poly n, Poly modulus,
int numeratorBound,
int denominatorBound); } | @Ignore @Test public void test2() throws Exception { UnivariatePolynomialZp64 num = UnivariatePolynomialZp64.create(17, new long[]{1, 2, 3, 4, 5, 6}); UnivariatePolynomialZp64 den = UnivariatePolynomialZp64.create(17, new long[]{1, 2, 3, 4, 5, 6, 8, 9, 8, 7, 6, 5, 4, 3, 2, 1}); UnivariatePolynomialZp64 mod = IrreduciblePolynomials.randomIrreduciblePolynomial(17, 1 + num.degree() * den.degree() * 2, getRandom()); Ring<UnivariatePolynomialZp64> r = Rings.GF(mod); UnivariatePolynomialZp64 n = r.multiply(num, r.reciprocal(den)); UnivariatePolynomialZp64[] rec = RationalReconstruction.reconstruct(n, mod, 20, 20); System.out.println(Arrays.toString(rec)); }
@Test public void testReconstructionRandom1() throws Exception { RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = getRandomData(); for (int i = 0; i < 1000; i++) { long num = rndd.nextLong(10, 1000); long den = rndd.nextLong(num + 1, 1100); long gcd = MachineArithmetic.gcd(num, den); num = num / gcd; den = den / gcd; long modulus = BigPrimes.nextPrime(2 * num * den); long n = MachineArithmetic.mod(num * MachineArithmetic.modInverse(den, modulus), modulus); assert num != 0 && den != 0 && n != 0; long[] re = RationalReconstruction.reconstruct(n, modulus, Math.abs(num) + 10, Math.abs(den) + 10); Assert.assertEquals(n, MachineArithmetic.mod(re[0] * MachineArithmetic.modInverse(re[1], modulus), modulus)); } } |
MultivariateFactorization { static <Poly extends IPolynomial<Poly>> void GCDFreeBasis(PolynomialFactorDecomposition<Poly>[] decompositions) { ArrayList<FactorRef<Poly>> allFactors = new ArrayList<>(); for (PolynomialFactorDecomposition<Poly> decomposition : decompositions) for (int j = 0; j < decomposition.size(); j++) allFactors.add(new FactorRef<>(decomposition, j)); for (int i = 0; i < allFactors.size() - 1; i++) { for (int j = i + 1; j < allFactors.size(); j++) { FactorRef<Poly> a = allFactors.get(i), b = allFactors.get(j); if (a == null || b == null) continue; Poly gcd = PolynomialMethods.PolynomialGCD(a.factor(), b.factor()); if (gcd.isConstant()) continue; Poly aReduced = PolynomialMethods.divideExact(a.factor(), gcd), bReduced = PolynomialMethods.divideExact(b.factor(), gcd); if (bReduced.isConstant()) allFactors.set(j, null); TIntArrayList aGCDIndexes = a.update(aReduced, gcd); TIntArrayList bGCDIndexes = b.update(bReduced, gcd); FactorRef<Poly> gcdRef = new FactorRef<>(); gcdRef.decompositions.addAll(a.decompositions); gcdRef.indexes.addAll(aGCDIndexes); gcdRef.decompositions.addAll(b.decompositions); gcdRef.indexes.addAll(bGCDIndexes); allFactors.add(gcdRef); } } Arrays.stream(decompositions).forEach(MultivariateFactorization::normalizeGCDFreeDecomposition); } private MultivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(final Poly poly); static PolynomialFactorDecomposition<MultivariatePolynomial<Rational<E>>> FactorInQ(MultivariatePolynomial<Rational<E>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> FactorInZ(final MultivariatePolynomial<BigInteger> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(final MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> FactorInGF(final Poly polynomial); } | @Test public void testGCDFreeBasis1() throws Exception { long modulus = 17; UnivariatePolynomialZp64 a = UnivariatePolynomialZ64.create(1, 2, 3).modulus(modulus), b = UnivariatePolynomialZ64.create(3, 2, 1, 2).modulus(modulus), c = UnivariatePolynomialZ64.create(1, 0, 0, 2, 3).modulus(modulus), d = UnivariatePolynomialZ64.create(1, 11, 0, 12, 4).modulus(modulus); PolynomialFactorDecomposition<UnivariatePolynomialZp64> d1 = PolynomialFactorDecomposition.of(Arrays.asList(multiply(a, b, b, b), multiply(a, c, c), multiply(a, a, d))), d2 = PolynomialFactorDecomposition.of(Arrays.asList(multiply(a, c, b), multiply(b, d, c), multiply(d, c, d))), d3 = PolynomialFactorDecomposition.of(Arrays.asList(multiply(c, c, d), multiply(b, b, c), multiply(a, b, c, d))); @SuppressWarnings("unchecked") PolynomialFactorDecomposition<UnivariatePolynomialZp64>[] decomps = new PolynomialFactorDecomposition[]{ d1.clone(), d2.clone(), d3.clone() }; MultivariateFactorization.GCDFreeBasis(decomps); Assert.assertEquals(d1.multiply(), decomps[0].multiply()); Assert.assertEquals(d2.multiply(), decomps[1].multiply()); Assert.assertEquals(d3.multiply(), decomps[2].multiply()); System.out.println(d1.multiply().equals(decomps[0].multiply())); System.out.println(Arrays.toString(UnivariateDivision.divideAndRemainder(d1.multiply(), decomps[0].multiply(), true))); for (PolynomialFactorDecomposition<UnivariatePolynomialZp64> decomp : decomps) System.out.println(decomp.size() + " => " + decomp); }
@Test public void testGCDFreeBasis2() throws Exception { UnivariatePolynomial<BigInteger> a = UnivariatePolynomial.create(0, 1), b = UnivariatePolynomial.create(4, 8), c = UnivariatePolynomial.create(2); PolynomialFactorDecomposition<UnivariatePolynomial<BigInteger>> d1 = PolynomialFactorDecomposition.of(Arrays.asList(a)), d2 = PolynomialFactorDecomposition.of(Arrays.asList(b.primitivePart())).addFactor(b.contentAsPoly(), 1), d3 = PolynomialFactorDecomposition.of(Arrays.asList(c)); @SuppressWarnings("unchecked") PolynomialFactorDecomposition<UnivariatePolynomialZp64>[] decomps = new PolynomialFactorDecomposition[]{ d1.clone(), d2.clone(), d3.clone() }; System.out.println(Arrays.asList(decomps)); MultivariateFactorization.GCDFreeBasis(decomps); System.out.println(Arrays.asList(decomps)); }
@Test public void testGCDFreeBasis3() throws Exception { UnivariatePolynomialZp64 a = UnivariatePolynomialZ64.create(9, 7, 10, 1).modulus(17), b = UnivariatePolynomialZ64.create(16, 2, 13, 1).modulus(17), c = UnivariatePolynomialZ64.create(3, 1).modulus(17), d = UnivariatePolynomialZ64.create(13, 14, 8, 1).modulus(17); PolynomialFactorDecomposition<UnivariatePolynomialZp64> d1 = PolynomialFactorDecomposition.of(a), d2 = PolynomialFactorDecomposition.of(b), d3 = PolynomialFactorDecomposition.of(c), d4 = PolynomialFactorDecomposition.of(d); @SuppressWarnings("unchecked") PolynomialFactorDecomposition<UnivariatePolynomialZp64>[] decomps = new PolynomialFactorDecomposition[]{ d1.clone(), d2.clone(), d3.clone(), d4.clone(), }; System.out.println(Arrays.asList(decomps)); MultivariateFactorization.GCDFreeBasis(decomps); System.out.println(Arrays.asList(decomps)); Assert.assertEquals(d1.multiply(), decomps[0].multiply()); Assert.assertEquals(d2.multiply(), decomps[1].multiply()); Assert.assertEquals(d3.multiply(), decomps[2].multiply()); Assert.assertEquals(d4.multiply(), decomps[3].multiply()); } |
MultivariateFactorization { @SuppressWarnings("unchecked") static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> PolynomialFactorDecomposition<Poly> factorPrimitiveInGF(final Poly polynomial) { return factorPrimitiveInGF(polynomial, true); } private MultivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(final Poly poly); static PolynomialFactorDecomposition<MultivariatePolynomial<Rational<E>>> FactorInQ(MultivariatePolynomial<Rational<E>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> FactorInZ(final MultivariatePolynomial<BigInteger> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(final MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> FactorInGF(final Poly polynomial); } | @Test public void testMultivariateFactorization1() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("c*b*a^5 + a^4*b^2*c^2 + 11*c + b^3 + a^5", domain), b = MultivariatePolynomialZp64.parse("a^6*b + 66*b*c + 17*b^2 + c", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); } }
@Test public void testMultivariateFactorization1a() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("c*b*a^5 + a^4*b^2*c^2 + 11*c + b^3 + a^5", domain), b = MultivariatePolynomialZp64.parse("a^6*b + 66*b*c + 17*b^2 + c", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(42); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test public void testMultivariateFactorization1b() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("c*b*a^5 + a^4*b^2*c^2 + 11*c + b^3 + a^5", domain), b = MultivariatePolynomialZp64.parse("a^6*b + 66*b*c + 17*b^2 + c", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(328); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test public void testMultivariateFactorization2() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("a^5 + a^4*b^2*c^2 + 11*c + b^3 + a^5", domain), b = MultivariatePolynomialZp64.parse("a^6 + 66*b*c + 17*b^2 + c^3", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(100, 100); i++) { PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); } }
@Test public void testMultivariateFactorization3() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("a^5 + a^4*b^2*c^2 + 11*c + b^3 + a^5", domain), b = MultivariatePolynomialZp64.parse("a^6 + 66*b*c + 17*b^2 + c^3", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(100, 100); i++) { PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); } }
@Test public void testMultivariateFactorization4() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("2*a^5*c + 2*a^5*b^2*c + 3*a^5*c^2 + a^5*b^2*c^2 + a^5*c^3 + 11*c + b^3 + a^5", domain), b = MultivariatePolynomialZp64.parse("a^6 + 66*b*c + 17*b^2 + c^3", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(100, 100); i++) { PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); } }
@Test public void testMultivariateFactorization4a() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("2*a^5*c + 2*a^5*b^2*c + 3*a^5*c^2 + a^5*b^2*c^2 + a^5*c^3 + 11*c + b^3 + a^5", domain), b = MultivariatePolynomialZp64.parse("a^6 + 66*b*c + 17*b^2 + c^3", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(31); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test public void testMultivariateFactorization4b() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("2*a^5*c + 2*a^5*b^2*c + 3*a^5*c^2 + a^5*b^2*c^2 + a^5*c^3 + 11*c + b^3 + a^5", domain), b = MultivariatePolynomialZp64.parse("a^6 + 66*b*c + 17*b^2 + c^3", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(88); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test public void testMultivariateFactorization4c() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("2*a^5*c + 2*a^5*b^2*c + 3*a^5*c^2 + a^5*b^2*c^2 + a^5*c^3 + 11*c + b^3 + a^5", domain), b = MultivariatePolynomialZp64.parse("a^6 + 66*b*c + 17*b^2 + c^3", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(531); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test public void testMultivariateFactorization5() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("2*a^5*c^2*b^2 + 11*c + b^3 + 1", domain), b = MultivariatePolynomialZp64.parse("a^6*b*c^3 + 66*b*c + 17*b^2 + c^3", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); } }
@Test public void testMultivariateFactorization6() throws Exception { IntegersZp64 domain = new IntegersZp64(27239); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("1+10435*c^2+21950*a*b^2*c^2+17887*a*b^3*c+4648*a^2*c+862*a^2*b*c", domain), b = MultivariatePolynomialZp64.parse("1+21170*b^2*c+7162*b^3+18183*a^2*b^2*c+16794*a^3*b+3096*a^3*b^3*c^3", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); } }
@Test public void testMultivariateFactorization7() throws Exception { IntegersZp64 domain = new IntegersZp64(63185123); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("7962775*c^3+54287330*b^3+48565396*a^2+26248711*a^3*b^3+10971203*a^3*b^3*c", domain), b = MultivariatePolynomialZp64.parse("1+48442198*b^2+36965231*b^3+35212338*a*b^2*c^3+62918195*a^2*b^2*c+47759030*a^3*b", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); } }
@Test public void testMultivariateFactorization8() throws Exception { IntegersZp64 domain = new IntegersZp64(829657); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("1+81633*a+270565*a^2*b*c+799187*a^2*b^2+159093*a^3*b+562717*a^3*b^3*c", domain), b = MultivariatePolynomialZp64.parse("1+73615*a*b^2+92694*a*b^2*c^3+582676*a^3*b*c^3+144867*a^3*b^2*c^2+132332*a^3*b^2*c^3", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); } }
@Test public void testMultivariateFactorization9() throws Exception { IntegersZp64 domain = new IntegersZp64(1734917); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("1+1179031*b^3+548360*a*b*c^2+18887*a*b^3*c+295179*a*b^3*c^3+175792*a^2*b", domain), b = MultivariatePolynomialZp64.parse("439433*b*c+197065*a+264505*a*b^3*c+1075508*a*b^3*c^3+1338483*a^2*b", domain), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); } }
@Benchmark @Test public void testMultivariateFactorization10() throws Exception { IntegersZp64 domain = new IntegersZp64(1734917); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+1179031*b^3+548360*a*b*c^2*e^2+18887*a*b^3*c+295179*a*b^3*c^3+175792*a^2*b*d^3+a^15", domain, vars), MultivariatePolynomialZp64.parse("439433*b*c*d*e+197065*a+264505*a*b^3*c+1075508*a*b^3*c^3+1338483*a^2*b+a^15", domain, vars), MultivariatePolynomialZp64.parse("439433*d*c+197065*d*e+264505*a*c^3*d+1075508*a*d^3*e^3+1338483*a^15*e +a^15 + b^2", domain, vars), MultivariatePolynomialZp64.parse("433*d^2*c+165*d*e+265*a^4*c^3*d+107*a*d^3*b+1338*a^15*e +a^15*b +a^15 + b^2", domain, vars), MultivariatePolynomialZp64.parse("433*d^2*e+165*d*e+265*b^4*c^3*d+107*c*d^3*a+1338*a^15*e +a^15*e + c^2 + a^15*b + a^15 + a^15*d + a^15*e", domain, vars), }, base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(100, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(5, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testMultivariateFactorization10a() throws Exception { IntegersZp64 domain = new IntegersZp64(1734917); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+1179031*b^3+548360*a*b*c^2*e^2+18887*a*b^3*c+295179*a*b^3*c^3+175792*a^2*b*d^3+a^15", domain, vars), MultivariatePolynomialZp64.parse("439433*b*c*d*e+197065*a+264505*a*b^3*c+1075508*a*b^3*c^3+1338483*a^2*b+a^15", domain, vars), MultivariatePolynomialZp64.parse("439433*d*c+197065*d*e+264505*a*c^3*d+1075508*a*d^3*e^3+1338483*a^15*e +a^15 + b^2", domain, vars), MultivariatePolynomialZp64.parse("433*d^2*c+165*d*e+265*a^4*c^3*d+107*a*d^3*b+1338*a^15*e +a^15*b +a^15 + b^2", domain, vars), MultivariatePolynomialZp64.parse("433*d^2*e+165*d*e+265*b^4*c^3*d+107*c*d^3*a+1338*a^15*e +a^15*e + c^2 + a^15*b + a^15 + a^15*d + a^15*e", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(0); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(5, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); }
@Test public void testMultivariateFactorization12() throws Exception { IntegersZp64 domain = new IntegersZp64(74017943); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("18370804*b^3*c^3+40724543*a+25831118*a*b+28120978*a*b*c^3+49314822*a*b^3*c^3", domain), b = MultivariatePolynomialZp64.parse("58629076*b*c^3+37897966*a*b^3*c^2+55834047*a^2*c^3+18265939*a^3*c^3+43535405*a^3*b", domain); a = AMultivariatePolynomial.renameVariables(a, new int[]{1, 2, 0}); b = AMultivariatePolynomial.renameVariables(b, new int[]{1, 2, 0}); MultivariatePolynomialZp64 base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); System.out.println(factors); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test public void testMultivariateFactorization13() throws Exception { IntegersZp64 domain = new IntegersZp64(192149); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("1+81770*b+19081*b*c+23953*a*b^3*c+7807*a^3*b+14026*a^3*b^2*c^3", domain), b = MultivariatePolynomialZp64.parse("1+105163*a^2+81015*a^2*c+166076*a^3*c^3+106464*a^3*b^2*c^2+43621*a^3*b^3", domain); MultivariatePolynomialZp64 base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test public void testMultivariateFactorization14() throws Exception { IntegersZp64 domain = new IntegersZp64(386039); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("1+377446*b*c+302126*a*b^2+97219*a*b^2*c^2+92497*a*b^2*c^3+84001*a^3*b^2", domain), b = MultivariatePolynomialZp64.parse("1+248663*a*b*c^2+10589*a*b^3*c^3+62097*a^2*c+81842*a^2*b^2*c+51504*a^3", domain); a = AMultivariatePolynomial.renameVariables(a, new int[]{0, 2, 1}); b = AMultivariatePolynomial.renameVariables(b, new int[]{0, 2, 1}); MultivariatePolynomialZp64 base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); PolynomialFactorDecomposition<MultivariatePolynomialZp64> factors = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test public void testMultivariateFactorization15() throws Exception { IntegersZp64 domain = new IntegersZp64(34957081); String[] vars = {"a", "b", "c", "d"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("2999550*b*c^3*d^2+14700809*a*c^2+13282494*a*b^3*c*d^3+30075047*a^2*c^2*d+2736476*a^3*d^2", domain, vars), MultivariatePolynomialZp64.parse("1+7381919*c^2+33667094*b*c^2*d^2+26355114*b^3*c*d^3+30536438*b^3*c^2*d^3+10734561*a*b*c", domain, vars), MultivariatePolynomialZp64.parse("1+24559556*b^2*c^2*d^3+13753085*a*b*c^2*d+22081133*a*b*c^3*d^3+30781594*a^3*b*c^2+27334226*a^3*b^3*d^3", domain, vars), }; for (int i = 0; i < factors.length; i++) { factors[i] = AMultivariatePolynomial.swapVariables(factors[i], 0, 1); factors[i] = AMultivariatePolynomial.swapVariables(factors[i], 1, 3); } MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(0); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(3, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); }
@Test public void testMultivariateFactorization16() throws Exception { IntegersZp64 domain = new IntegersZp64(316797977); String[] vars = {"a", "b", "c", "d"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("157129769*b*c*d^3+234842760*b*c^3*d^3+105538252*a+55274980*a*b^2*c^2+89647854*a^3*b^3*c^2*d^2", domain, vars), MultivariatePolynomialZp64.parse("241626121*d^2+47627151*b^2*c*d+150262012*a^2*b*c^2+299159387*a^2*b^3*c^2+53788517*a^3*b*c^3*d^3", domain, vars), MultivariatePolynomialZp64.parse("1+76011411*b*d^3+189305430*b*c^3*d+218732499*a^2*b^2*c*d^2+125990992*a^2*b^3*c^2*d+36953173*a^3*b*c^2*d", domain, vars), MultivariatePolynomialZp64.parse("1+299415864*a*b^2*c^3*d^3+154985851*a^2*c*d+157246866*a^2*b^2*c^3*d^3+32838497*a^3*b^3*c*d+41239905*a^3*b^3*c*d^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(0); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(4, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); }
@Test public void testMultivariateFactorization17() throws Exception { IntegersZp64 domain = new IntegersZp64(125617); String[] vars = {"a", "b", "c", "d"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+71543*b*c+89032*b*c*d+101233*b^2*c+69912*b^2*c^2*d^2+122146*a*c^2", domain, vars), MultivariatePolynomialZp64.parse("1+62395*b*c^2*d^2+111331*a*b*c*d^2+13129*a^3*b^2*c^2*d^2+54277*a^3*b^3*c^2+36488*a^3*b^3*c^2*d^3", domain, vars), MultivariatePolynomialZp64.parse("1+64768*a*b^2*d+66817*a*b^3*c*d+19563*a^2+13861*a^3*b*c^3+76958*a^3*b^3*d", domain, vars), }; for (int i = 0; i < factors.length; i++) factors[i] = AMultivariatePolynomial.swapVariables(factors[i], 0, 1); MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(0); for (int i = 0; i < its(10, 10); i++) { PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base, false); Assert.assertEquals(3, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorizationRandom3a() throws Exception { IntegersZp64 domain = new IntegersZp64(337965077); String[] vars = {"a", "b", "c", "d", "e", "f"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+128786660*b*c*f^2+38739797*a*b^3*c^2*d*e*f+159449306*a^2*c^2*d^2*e^3*f^3+298952491*a^2*b*c^3*d*e*f^3+263798205*a^3*c^2*e*f^3", domain, vars), MultivariatePolynomialZp64.parse("69412172*c*f+175964784*c^3*f+319203880*a^3*c*d^3*f+154158650*a^3*b^2*c^3*d^3*f^2+309716243*a^3*b^3*d^3*e^3", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(0); for (int i = 0; i < its(10, 10); i++) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(2, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization18_SmallDomain() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c", "d"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+71543*b*c+89032*b*c*d+101233*b^2*c+69912*b^2*c^2*d^2+122146*a*c^2", domain, vars), MultivariatePolynomialZp64.parse("1+62395*b*c^2*d^2+111331*a*b*c*d^2+13129*a^3*b^2*c^2*d^2+54277*a^3*b^3*c^2+36488*a^3*b^3*c^2*d^3", domain, vars), MultivariatePolynomialZp64.parse("1+64768*a*b^2*d+66817*a*b^3*c*d+19563*a^2+13861*a^3*b*c^3+76958*a^3*b^3*d", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(0); for (int i = 0; i < its(10, 30); i++) { PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); Assert.assertEquals(3, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization19_SmallDomain() throws Exception { IntegersZp64 domain = new IntegersZp64(3); String[] vars = {"a", "b", "c", "d", "e", "f"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+2*b*c^3*d*f^3+2*b^2*c^3*d^2*e^2*f^3+2*a*b^3*d*e^2*f^2+2*a^2*b*c^3*d^3*e*f^3", domain, vars), MultivariatePolynomialZp64.parse("1+2*a^2*b^2*d*e^2*f^2+a^3*b^3*c*d^3*f", domain, vars), MultivariatePolynomialZp64.parse("1+a*b^2*c^2*e*f^2+2*a^3*e^2+2*a^3*b*c*d^2*e^2+2*a^3*b^2*c*e", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*c*d^3*e^3+a*b*c^2*d*e^3*f^3+2*a^2*e^2*f", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(0); for (int i = 1; i < its(10, 10); i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(4, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization20_SmallDomain() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("b*d^3*e^2+a*c^3*d^2+a*b^3*c^3*e^3+a^3*b^2*d^3+a^3*b^3*c^2*d*e^3", domain, vars), MultivariatePolynomialZp64.parse("1+b^2*c^3*d^3*e^2+a^3*c*e^2+a^3*b^2*c^3*d", domain, vars), MultivariatePolynomialZp64.parse("1+a*b*c*e^2+a^3*b^3*c*d^3", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*c*d^2*e^2+a^3*c*e", domain, vars),}, base = multiply(arr); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(4, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization21_SmallDomain() throws Exception { IntegersZp64 domain = new IntegersZp64(11); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("1+5*a*c*e+6*a^2*c*d+9*a^2*b^3*c^3*e+2*a^3*c^3*d^3*e^2+9*a^3*b^3", domain, vars), MultivariatePolynomialZp64.parse("1+2*b^2*d*e+7*a*c^2*d*e^2+5*a^2*d*e^3+a^2*b^2*d^3*e^3+8*a^3*c^2*d*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+9*b^2*d*e+10*b^2*d^3*e+8*b^2*c^2*d+3*a*b^2*c^2*d^3+8*a*b^3*c^2*d^3*e^2", domain, vars), }, base = multiply(arr); for (int i = 11; i < its(12, 12); i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(3, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization18() throws Exception { IntegersZp64 domain = new IntegersZp64(11); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+3*c^3*d^2+9*a*c*e^3+a^2*b*c^3*d^2*e^2+2*a^2*b^2*c^3*d*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+5*a*b*c*d^3*e^3+6*a^3*d^2*e^2+5*a^3*b*c^2*d*e+9*a^3*b^2*c*d^2*e^2+2*a^3*b^3*c*e^3", domain, vars), MultivariatePolynomialZp64.parse("1+8*b^3*c^2*d+2*a^2*c*e^3+6*a^2*c^2*d^3*e+10*a^3*c^3*d^2+7*a^3*b*c^3*d^3*e^3", domain, vars), MultivariatePolynomialZp64.parse("1+4*a*b^2*c^2*d^3*e^3+4*a^2*b*c*d^2+3*a^3*b*c^3*e^3+3*a^3*b^2*c^2*d^3*e^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(4, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization18a() throws Exception { IntegersZp64 domain = new IntegersZp64(11); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+3*c^3*d^2+9*a*c*e^3+a^2*b*c^3*d^2*e^2+2*a^2*b^2*c^3*d*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+5*a*b*c*d^3*e^3+6*a^3*d^2*e^2+5*a^3*b*c^2*d*e+9*a^3*b^2*c*d^2*e^2+2*a^3*b^3*c*e^3", domain, vars), MultivariatePolynomialZp64.parse("1+8*b^3*c^2*d+2*a^2*c*e^3+6*a^2*c^2*d^3*e+10*a^3*c^3*d^2+7*a^3*b*c^3*d^3*e^3", domain, vars), MultivariatePolynomialZp64.parse("1+4*a*b^2*c^2*d^3*e^3+4*a^2*b*c*d^2+3*a^3*b*c^3*e^3+3*a^3*b^2*c^2*d^3*e^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(9); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); Assert.assertEquals(4, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); }
@Test public void testMultivariateFactorization19() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+a*b^3*d^2*e+a*b^3*c^2*d^2+a^3*b^2*c*d^2*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*d^3*e^2+a*d^3*e^3+a^2*b*c^3*d^2*e^3+a^3*b^3*c^2*d^2*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+c*d^3+b*c^2*d^2*e^2+a^3*b^2*c*d^3*e^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(3, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization19a() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+a*b^3*d^2*e+a*b^3*c^2*d^2+a^3*b^2*c*d^2*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*d^3*e^2+a*d^3*e^3+a^2*b*c^3*d^2*e^3+a^3*b^3*c^2*d^2*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+c*d^3+b*c^2*d^2*e^2+a^3*b^2*c*d^3*e^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(5); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); Assert.assertEquals(3, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); }
@Test public void testMultivariateFactorization19b() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+a*b^3*d^2*e+a*b^3*c^2*d^2+a^3*b^2*c*d^2*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*d^3*e^2+a*d^3*e^3+a^2*b*c^3*d^2*e^3+a^3*b^3*c^2*d^2*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+c*d^3+b*c^2*d^2*e^2+a^3*b^2*c*d^3*e^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(2); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); Assert.assertEquals(3, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); }
@Test public void testMultivariateFactorization19c() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+a*b^3*d^2*e+a*b^3*c^2*d^2+a^3*b^2*c*d^2*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*d^3*e^2+a*d^3*e^3+a^2*b*c^3*d^2*e^3+a^3*b^3*c^2*d^2*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+c*d^3+b*c^2*d^2*e^2+a^3*b^2*c*d^3*e^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(7); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); Assert.assertEquals(3, decomposition.size()); }
@Test public void testMultivariateFactorization19d() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+a*b^3*d^2*e+a*b^3*c^2*d^2+a^3*b^2*c*d^2*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*d^3*e^2+a*d^3*e^3+a^2*b*c^3*d^2*e^3+a^3*b^3*c^2*d^2*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+c*d^3+b*c^2*d^2*e^2+a^3*b^2*c*d^3*e^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(10); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); Assert.assertEquals(3, decomposition.size()); }
@Test public void testMultivariateFactorization20() throws Exception { IntegersZp64 domain = new IntegersZp64(3); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+b^3*e^2+2*a*b*c^3*d*e^2+a^2*b^2*c^2*e+a^3*b^3*c^3*d^3*e", domain, vars), MultivariatePolynomialZp64.parse("1+2*b^3*c*e^2+2*b^3*c^2*d*e^2+a^2*b*d^2*e^3+2*a^3*b^2*c^2*d^2", domain, vars), MultivariatePolynomialZp64.parse("1+2*b*c^3*d^2*e+a^2*b*c*e^3+a^3*b*c^3*d^3+a^3*b^3*c^3*d^2*e^3", domain, vars), MultivariatePolynomialZp64.parse("1+c^2*e+b^3*c^2*d^2*e+2*a*b^3*c^3*d^2*e+2*a^2*c^2*d*e^3+a^3*c^3*d^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(2, 2); i++) { PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); Assert.assertEquals(4, decomposition.size()); } }
@Test public void testMultivariateFactorization21() throws Exception { IntegersZp64 domain = new IntegersZp64(3); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+2*a*c*d^2+a^2*b*c^2*d^3+2*a^2*b^3*d*e", domain, vars), MultivariatePolynomialZp64.parse("b^3*c*e+2*a*d^3+2*a^3*b^3*c*e^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(20, 20); i++) { PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); Assert.assertEquals(2, decomposition.size()); } }
@Test public void testMultivariateFactorization22() throws Exception { IntegersZp64 domain = new IntegersZp64(3); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+a*b^2*c^2*d+a*b^3*c^3+a^2*b^2*c*d^2+2*a^2*b^3*c*d^2*e", domain, vars), MultivariatePolynomialZp64.parse("c^2*d+2*a^3*b^3*e", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(20, 20); i++) { PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorPrimitiveInGF(base); Assert.assertEquals(2, decomposition.size()); } }
@Test public void testMultivariateFactorization42() throws Exception { Ring<BigInteger> ring = Rings.Zp(524287); MultivariatePolynomial<BigInteger> p1 = polyPow(MultivariatePolynomial.parse("1 + 3*a*b + 5*b*c + 7*c*d + 9*d*e + 11*e*f + 13*f*g + 15*g*a", ring), 3), p2 = polyPow(MultivariatePolynomial.parse("1 + 3*a*c + 5*b*d + 7*c*e + 9*f*e + 11*g*f + 13*f*a + 15*g*b", ring), 3), p3 = polyPow(MultivariatePolynomial.parse("1 + 3*a*d + 5*b*e + 7*c*f + 9*f*g + 11*g*a + 13*f*b + 15*g*c", ring), 3), poly = p1.multiply(p2, p3); poly.decrement(); Assert.assertEquals(3, factorPrimitiveInGF(poly).size()); } |
RationalReconstruction { public static BigInteger[] reconstructFareyErrorTolerant(BigInteger n, BigInteger modulus) { BigInteger[] v = {modulus, BigInteger.ZERO}; BigInteger[] w = {n, BigInteger.ONE}; BigInteger qNum, wqDen = w[0].pow(2).add(w[1].pow(2)), vqDen; do { qNum = w[0].multiply(v[0]).add(w[1].multiply(v[1])); BigInteger q = qNum.signum() == wqDen.signum() ? qNum.abs().add(wqDen.abs()).decrement().divide(wqDen.abs()) : qNum.divide(wqDen); BigInteger[] z = {v[0].subtract(q.multiply(w[0])), v[1].subtract(q.multiply(w[1]))}; v = w; vqDen = wqDen; w = z; wqDen = z[0].pow(2).add(z[1].pow(2)); } while (wqDen.compareTo(vqDen) < 0); if (vqDen.compareTo(modulus) < 0) { if (v[1].signum() < 0) { v[0] = v[0].negate(); v[1] = v[1].negate(); } return v; } return null; } private RationalReconstruction(); static long[] reconstruct(long n, long modulus,
long numeratorBound,
long denominatorBound); static BigInteger[] reconstruct(BigInteger n, BigInteger modulus,
BigInteger numeratorBound,
BigInteger denominatorBound); static BigInteger[] reconstructFarey(BigInteger n, BigInteger modulus); static BigInteger[] reconstructFareyErrorTolerant(BigInteger n, BigInteger modulus); static Poly[] reconstruct(Poly n, Poly modulus,
int numeratorBound,
int denominatorBound); } | @Test public void test3() throws Exception { Assert.assertArrayEquals(Z.createArray(Z.valueOf(13), Z.valueOf(12)), RationalReconstruction.reconstructFareyErrorTolerant(Z.valueOf(22684), Z.valueOf(38885))); Assert.assertArrayEquals(Z.createArray(Z.valueOf(-85), Z.valueOf(40)), RationalReconstruction.reconstructFareyErrorTolerant(Z.valueOf(16524), Z.valueOf(38885))); Assert.assertArrayEquals(Z.createArray(Z.valueOf(91), Z.valueOf(84)), RationalReconstruction.reconstructFareyErrorTolerant(Z.valueOf(464), Z.valueOf(38885))); } |
MultivariateFactorization { @SuppressWarnings("unchecked") static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> PolynomialFactorDecomposition<Poly> factorToPrimitive(Poly poly) { if (poly.isEffectiveUnivariate()) return PolynomialFactorDecomposition.of(poly); PolynomialFactorDecomposition<Poly> result = PolynomialFactorDecomposition.empty(poly); for (int i = 0; i < poly.nVariables; i++) { if (poly.degree(i) == 0) continue; Poly factor = poly.asUnivariate(i).content(); result.addFactor(factor, 1); poly = MultivariateDivision.divideExact(poly, factor); } result.addFactor(poly, 1); return result; } private MultivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(final Poly poly); static PolynomialFactorDecomposition<MultivariatePolynomial<Rational<E>>> FactorInQ(MultivariatePolynomial<Rational<E>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> FactorInZ(final MultivariatePolynomial<BigInteger> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(final MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> FactorInGF(final Poly polynomial); } | @Test public void testMultivariateFactorization11() throws Exception { IntegersZp64 domain = new IntegersZp64(1734917); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("a + b + c + d", domain, vars), b = MultivariatePolynomialZp64.parse("b + c + d + e", domain, vars), c = MultivariatePolynomialZp64.parse("c + d + e + a", domain, vars), d = MultivariatePolynomialZp64.parse("2*d + 2*e + 2*a + 2*b", domain, vars), e = MultivariatePolynomialZp64.parse("e + a + b + 2*c", domain, vars), base = a.clone().multiply(b, c, d, e); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.factorToPrimitive(base); Assert.assertEquals(5, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization37() throws Exception { String[] vars = {"a", "b", "c"}; MultivariatePolynomial<BigInteger>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("(-1787086)*c^2+135144*b^2*c^2-459684*a*c^2+1379391*a^2*b*c-1357466*a^2*b*c^2", vars), MultivariatePolynomial.parse("1295770*a^2*b*c^2-418269*a^4*b*c+414642*a^6*b^6*c^3", vars), MultivariatePolynomial.parse("1274683*a+56290*a*c", vars), MultivariatePolynomial.parse("(-493283)*a^4*b^2*c^3-1192675*a^4*b^5*c^2", vars), MultivariatePolynomial.parse("476108*a*c^2-1504550*a*b*c-1519177*a*b*c^2+1007772*a*b^2*c", vars), }; MultivariatePolynomial<BigInteger> base = multiply(pp); for (int i = 1; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorToPrimitive(base); Assert.assertEquals(3, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); } }
@Test public void test1() { MultivariatePolynomial<BigInteger> poly = MultivariatePolynomial .parse("-1*x3^2*x4^2*x5+2*x1*x3*x4^2*x5-1*x1^2*x4^2*x5+2*x2*x3^2*x4*x5-4*x1*x2*x3*x4*x5+2*x1^2*x2*x4*x5-1*x2^2*x3^2*x5+2*x1*x2^2*x3*x5-1*x1^2*x2^2*x5+x3^2*x4^3-1*x1*x3*x4^3+x3^3*x4^2-2*x2*x3^2*x4^2-2*x1*x3^2*x4^2+x1*x2*x3*x4^2+x1^2*x3*x4^2+x1^2*x2*x4^2-1*x2*x3^3*x4+x2^2*x3^2*x4+x1*x2*x3^2*x4+x1*x2^2*x3*x4+x1^2*x2*x3*x4-2*x1^2*x2^2*x4-1*x1^3*x2*x4+x1*x2^2*x3^2-1*x1*x2^3*x3-2*x1^2*x2^2*x3+x1^2*x2^3+x1^3*x2^2", "x0", "x1", "x2", "x3", "x4", "x5"); assertEquals(3, factorToPrimitive(poly).size()); } |
UnivariatePolynomialZ64 extends AUnivariatePolynomial64<UnivariatePolynomialZ64> { public static UnivariatePolynomialZ64 create(long... data) { return new UnivariatePolynomialZ64(data); } private UnivariatePolynomialZ64(long[] data); private UnivariatePolynomialZ64(long[] data, int degree); static UnivariatePolynomialZ64 parse(String string); static UnivariatePolynomialZ64 create(long... data); static UnivariatePolynomialZ64 monomial(long coefficient, int exponent); static UnivariatePolynomialZ64 zero(); static UnivariatePolynomialZ64 one(); static UnivariatePolynomialZ64 constant(long value); @Override UnivariatePolynomialZ64 setCoefficientRingFrom(UnivariatePolynomialZ64 univariatePolynomialZ64); UnivariatePolynomialZp64 modulus(long modulus, boolean copy); UnivariatePolynomialZp64 modulus(long modulus); UnivariatePolynomialZp64 modulus(IntegersZp64 ring, boolean copy); UnivariatePolynomialZp64 modulus(IntegersZp64 ring); @Override UnivariatePolynomial<BigInteger> toBigPoly(); double mignotteBound(); long evaluateAtRational(long num, long den); @Override UnivariatePolynomialZ64 getRange(int from, int to); @Override UnivariatePolynomialZ64[] createArray(int length); @Override UnivariatePolynomialZ64[][] createArray2d(int length); @Override UnivariatePolynomialZ64[][] createArray2d(int length1, int length2); @Override boolean sameCoefficientRingWith(UnivariatePolynomialZ64 oth); @Override UnivariatePolynomialZ64 createFromArray(long[] data); @Override UnivariatePolynomialZ64 createMonomial(long coefficient, int degree); @Override boolean isOverField(); @Override boolean isOverFiniteField(); @Override boolean isOverZ(); @Override BigInteger coefficientRingCardinality(); @Override BigInteger coefficientRingCharacteristic(); @Override boolean isOverPerfectPower(); @Override BigInteger coefficientRingPerfectPowerBase(); @Override BigInteger coefficientRingPerfectPowerExponent(); @Override long content(); @Override UnivariatePolynomialZ64 monic(); @Override UnivariatePolynomialZ64 monic(long factor); UnivariatePolynomialZ64 divideOrNull(long factor); @Override UnivariatePolynomialZ64 divideByLC(UnivariatePolynomialZ64 other); @Override UnivariatePolynomialZ64 multiplyByBigInteger(BigInteger factor); @Override UnivariatePolynomialZ64 multiply(UnivariatePolynomialZ64 oth); @Override UnivariatePolynomialZ64 square(); @Override UnivariatePolynomialZ64 derivative(); @Override UnivariatePolynomialZ64 clone(); @Override UnivariatePolynomialZ64 parsePoly(String string); @Override String coefficientRingToString(IStringifier<UnivariatePolynomialZ64> stringifier); @Override AMultivariatePolynomial composition(AMultivariatePolynomial value); @Override AMultivariatePolynomial asMultivariate(Comparator<DegreeVector> ordering); } | @Test public void test1() throws Exception { Assert.assertEquals(-1, UnivariatePolynomialZ64.create(0).firstNonZeroCoefficientPosition()); Assert.assertEquals(-1, UnivariatePolynomialZ64.create(0, 0, 0).firstNonZeroCoefficientPosition()); Assert.assertEquals(0, UnivariatePolynomialZ64.create(1).firstNonZeroCoefficientPosition()); Assert.assertEquals(1, UnivariatePolynomialZ64.create(0, 1).firstNonZeroCoefficientPosition()); } |
MultivariateFactorization { @SuppressWarnings("unchecked") public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> PolynomialFactorDecomposition<Poly> FactorInGF(final Poly polynomial) { if (canConvertToZp64(polynomial)) return FactorInGF(asOverZp64(polynomial)).mapTo(Conversions64bit::convertFromZp64); return Factor(polynomial, MultivariateFactorization::factorPrimitiveInGF); } private MultivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(final Poly poly); static PolynomialFactorDecomposition<MultivariatePolynomial<Rational<E>>> FactorInQ(MultivariatePolynomial<Rational<E>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> FactorInZ(final MultivariatePolynomial<BigInteger> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(final MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> FactorInGF(final Poly polynomial); } | @Test public void testMultivariateFactorization22_SmallDomain() throws Exception { IntegersZp64 domain = new IntegersZp64(11); String[] vars = {"a", "b", "c", "d", "e", "f"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("12*b*c^2*d+3*a*f+8*a^2*b*d^3*f^3+13*a^2*b*c*d*e*f^3+16*a^3*c^3*d^2*e^3", domain, vars), MultivariatePolynomialZp64.parse("16*c*d^2*f+9*c*d^2*e*f^2+17*c*d^3*e^3+14*a^3*b^3*d*f^2+8*a^3*b^3*c^2*e", domain, vars), MultivariatePolynomialZp64.parse("1+8*a*b^2*c*d*f+18*a*b^3*d^3*e^2*f+22*a^2*c*d*e*f+a^2*b^2*c*d^2*e*f^2+12*a^3*b^3*d^2*f^2", domain, vars), }, base = multiply(arr); for (int i = 0; i < its(2, 2); i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.FactorInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(3, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization23_SmallDomain() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c", "d", "e", "f"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("1+a^2*b^2*c*e^3*f^2+a^3*b^2*d^2*e^2*f^2+a^3*b^2*c^3*e*f^2", domain, vars), MultivariatePolynomialZp64.parse("1+a^2*b*c*d^3*f+a^3*c^3*d*e^2*f+a^3*b^3*c^3*d*e^2*f^2", domain, vars), MultivariatePolynomialZp64.parse("1+b^2*c^2*d^3+a^3*b*c^2*e^3*f^3", domain, vars), }, base = multiply(arr); for (int i = 11; i < its(12, 12); i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.FactorInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(3, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization25_SmallDomain() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c", "d", "e", "f"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("1+b*c*d^3*e^2*f^2+b^2*e+a^2*b*d^2*f", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*c^3*d*e^2+a^2*b^3*c*e^3*f^3", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*c*d^2+a*b*c^2*d*e^2+a^2*b^3*c^2*f^3+a^3*b^2*c^3", domain, vars), MultivariatePolynomialZp64.parse("1+a*b*c*d*e*f^3+a*b^3*c*d*e^3*f^2+a^2*c*d^2*e*f^3+a^3*b^3*d^3*e", domain, vars), }, base = multiply(arr); for (int i = 0; i < its(1, 1); i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.FactorInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(4, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization26_SmallDomain() throws Exception { IntegersZp64 domain = new IntegersZp64(17); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("15*b*c^3*d^3*e^2+b^2*d^2*e^3+15*a*b^2*c^3*e+3*a^2+16*a^2*c*d^3*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+b^2*c*d^3*e+3*a*b^2+8*a^3*b^2*c*d^2*e^2+2*a^3*b^2*c^2*d*e^2+12*a^3*b^2*c^3*d^2*e", domain, vars), MultivariatePolynomialZp64.parse("1+14*b^3*d^3+10*a*b*c^3*d^2+12*a^2*b^2*d^2*e^2+6*a^2*b^3*c^3*d*e^3+11*a^3*b^2*c^3*d", domain, vars), MultivariatePolynomialZp64.parse("15*c^3*e^3+a^2*b^3*d^3+9*a^2*b^3*c^3+15*a^3*b*d^3", domain, vars), }, base = multiply(arr); for (int i = 0; i < its(1, 1); i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.FactorInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(4, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization27_SmallDomain() throws Exception { IntegersZp64 domain = new IntegersZp64(3); String[] vars = {"a", "b", "c", "d", "e", "f"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("1+b^3*c^3*d^2+a^2*b*c^3*e*f^2+2*a^3*b^2*c*d*e^3*f", domain, vars), MultivariatePolynomialZp64.parse("1+b*c^3*d*e*f^2+b^2*c*e+2*b^3*c^3*d^2+a^3*b*c*d^3*e*f^3", domain, vars), }, base = multiply(arr); for (int i = 0; i < its(1, 1); i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.FactorInGF(base); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(2, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorizationRandom4_SmallDomain_a() throws Exception { IntegersZp64 domain = new IntegersZp64(11); String[] vars = {"a", "b", "c", "d", "e", "f"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("1+10*b^2*c^3*d^3*e^2*f^2+10*b^3*d^2*e*f^3+7*a*b*c^2*d*e^2*f^3+9*a*b^3*e^3", domain, vars), MultivariatePolynomialZp64.parse("1+2*c^3*d^2*e*f^2+10*c^3*d^2*e^3+6*b*d^2*e^3*f^3+9*a^3*b*c^3*d*e*f", domain, vars), }, base = multiply(arr); for (int i = 43; i < its(50, 50); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition decomposition = MultivariateFactorization.FactorInGF(base.toBigPoly()); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(2, decomposition.size()); FactorDecompositionTest.assertFactorization(base.toBigPoly(), decomposition); } }
@Test(timeout = 200000) public void testMultivariateFactorizationRandom4_SmallDomain_b() throws Exception { IntegersZp64 domain = new IntegersZp64(3); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("1+2*c^3*d^2+2*b^3*c^3*d^3*e+a*c^3*d*e+2*a^2*b^3*c^2*d^2*e^3+a^2*b^3*c^3*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*c^2*d^3*e^3+a*c^3*d*e^2+2*a^3*e^3+2*a^3*b^3*d*e^3+2*a^3*b^3*c*d^3*e", domain, vars), MultivariatePolynomialZp64.parse("1+2*a*b^3*c+a^2*d^3*e", domain, vars), MultivariatePolynomialZp64.parse("1+2*b^3*c^3*d^3*e+2*a*b^2*c*d^2*e^3+a*b^3*c^2*d*e^2+a^3*b^2*c^3*d^2", domain, vars), }, base = multiply(arr); System.out.println(base.sparsity()); for (int i = 0; i < its(5, 5); i++) { PrivateRandom.getRandom().setSeed(i + 1); timestamp(); PolynomialFactorDecomposition decomposition = MultivariateFactorization.FactorInGF(base); timeElapsed(); Assert.assertEquals(4, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorizationRandom4_SmallDomain_c() throws Exception { IntegersZp64 domain = new IntegersZp64(5); String[] vars = {"a", "b", "c", "d", "e", "f"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("1+2*c^3*d^2*e*f^2+3*a*b*c*e^3*f^2+4*a^2*d*e+4*a^3*c^3*d^2*e^3", domain, vars), MultivariatePolynomialZp64.parse("1+4*b^2*c^2*e^3*f^2+b^3*c^2*d*e^3+a*b^3*c*d^3*f^3+a*b^3*c^2*e*f^2+3*a*b^3*c^2*e^3*f", domain, vars), }, base = multiply(arr); for (int i = 0; i < its(5, 5); i++) { PrivateRandom.getRandom().setSeed(i + 1); timestamp(); PolynomialFactorDecomposition decomposition = MultivariateFactorization.FactorInGF(base); timeElapsed(); Assert.assertEquals(2, decomposition.size()); FactorDecompositionTest.assertFactorization(base, decomposition); } }
@Test public void testMultivariateFactorization23() throws Exception { IntegersZp64 domain = new IntegersZp64(3); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+2*a*b*c*e^2+a^2*b^2*c^3*e+a^3*d^3*e^3+a^3*b^2*c^2*e^3", domain, vars), MultivariatePolynomialZp64.parse("1+d*e^3+a^3*b*e^2+a^3*b*d^3*e^3", domain, vars), MultivariatePolynomialZp64.parse("1+b^2*c^2*d*e+2*b^2*c^3*d*e^2+a^3*c^3*d*e^2+a^3*b^3*c^3*d*e^3", domain, vars), MultivariatePolynomialZp64.parse("2*b^3*c*d^3*e+2*a*b^2*c^2*e^3+2*a^2*c^3*e+2*a^2*b*c^2*d^3*e^2+a^3*b^3*d^2", domain, vars), }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(20, 20); i++) { PrivateRandom.getRandom().setSeed(3); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.FactorInGF(base); Assert.assertEquals(4, decomposition.size()); System.out.println("=> " + i + " " + TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testMultivariateFactorization24() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("1+a*b^3*d+a^3*c*d*e^3+a^3*b*c^2*e^3+a^3*b^2*c^3*d*e", domain, vars), MultivariatePolynomialZp64.parse("1+a^2*b*c*d*e^3+a^3*b^2*c*d", domain, vars), MultivariatePolynomialZp64.parse("1+b*c^2*e^2+a^3*b*c^2*e+a^3*b^3*c^3*d*e^2", domain, vars) }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(20, 20); i++) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.FactorInGF(base); Assert.assertEquals(3, decomposition.size()); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Ignore @Test public void testMultivariateFactorization26() throws Exception { IntegersZp64 domain = new IntegersZp64(7); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("b*c*d*e+5*a^2*c*d*e^2+5*a^3*b^2", domain, vars), MultivariatePolynomialZp64.parse("1+2*a*d^2+4*a*b*c^2*d*e+5*a^2*b^2*c*d*e^3+a^2*b^2*c^2*e^2+3*a^2*b^2*c^3*d*e^2", domain, vars), MultivariatePolynomialZp64.parse("3*c^3*d+5*a*b*d^3*e+2*a^2*b^3*c*d+3*a^3*d*e^2+3*a^3*b^2*c^3", domain, vars), MultivariatePolynomialZp64.parse("1+6*a*b*d^2+6*a*b^2*c^2*d^2*e^2+a^2*b^2*c^2*d^3+4*a^3*c^3*d^2", domain, vars) }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(20, 20); i++) { System.out.println(i + 20); PrivateRandom.getRandom().setSeed(i + 20); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.FactorInGF(base); Assert.assertEquals(4, decomposition.size()); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testMultivariateFactorization26a() throws Exception { IntegersZp64 domain = new IntegersZp64(7); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("b*c*d*e+5*a^2*c*d*e^2+5*a^3*b^2", domain, vars), MultivariatePolynomialZp64.parse("1+2*a*d^2+4*a*b*c^2*d*e+5*a^2*b^2*c*d*e^3+a^2*b^2*c^2*e^2+3*a^2*b^2*c^3*d*e^2", domain, vars), MultivariatePolynomialZp64.parse("3*c^3*d+5*a*b*d^3*e+2*a^2*b^3*c*d+3*a^3*d*e^2+3*a^3*b^2*c^3", domain, vars), MultivariatePolynomialZp64.parse("1+6*a*b*d^2+6*a*b^2*c^2*d^2*e^2+a^2*b^2*c^2*d^3+4*a^3*c^3*d^2", domain, vars) }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(27); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.FactorInGF(base); Assert.assertEquals(4, decomposition.size()); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); }
@Ignore @Test public void testMultivariateFactorization25() throws Exception { IntegersZp64 domain = new IntegersZp64(33554467); String[] vars = {"a", "b", "c", "d", "e", "f", "g"}; MultivariatePolynomialZp64 factors[] = { MultivariatePolynomialZp64.parse("25078271*b^5*c*d^2*e^2*f^6*g^3+22985334*a*b*c^2*d*e^7*f^3*g^7+19249719*a*b^7*d^5*e^6*g^2+6865506*a^2*b^5*c^3*d^6*e^6*f^3*g^5+20943085*a^2*b^5*c^8*d^3*e^3*f^7+733087*a^3*c^3*d^4*f^4*g^2+24327652*a^3*b^2*c^2*d^2*e^2*f^3*g^5+2508535*a^3*b^3*c*d^3*e^5*f^2*g^2+9991244*a^3*b^4*c^5*e^5*f^5*g^3+22044750*a^3*b^7*c*d^8*e*f^6+8526153*a^4*c^8*d*e^8*f^4*g^6+15162335*a^4*b^8*c^3*d^4*f^4*g^6+21943911*a^5*b*c^3*d^2*e^5*g^2+7268253*a^5*b^8*c^4*d^4*e*f*g^5+11265450*a^6*b^3*c^5*d^5*e+1307471*a^6*b^5*c^4*d^3*e*f^7+27352310*a^7*b^2*c^2*d^6*e^3*f^3*g+18596343*a^8*b^3*e^4*f^2*g+477464*a^8*b^4*c^3*d*e^3*f^5*g^3+20723946*a^8*b^4*c^8*d^3*e^2*g^3", domain, vars), MultivariatePolynomialZp64.parse("24999489*c^6*d^5*g^7+31605719*b^5*c^5*d^4*e^3*g^6+33475465*b^8*c^5*d^6*f^7+21150942*a*c^4*d^4*e^3*f^3*g+30544835*a*b^3*d^7*e*f^8*g^5+8725705*a*b^8*c^6*d^5*e^4*f*g+3830207*a^2*d^2*e*f^7*g^8+31725230*a^2*b^8*c*e*f^8*g^2+5924640*a^3*c*d^4*e^8+14191319*a^3*b*c^3*e^7*f^3*g^8+5482302*a^3*b^2*c^2*d^5*f^8*g^2+350050*a^4*b^3*c^6*d^6*e^7*f^6+246147*a^4*b^4*c^3*d^7*e^5*g^8+27052604*a^5*c^4*d^4*f+2073523*a^5*b^4*c^4*d^7*e^4*f^2*g^5+21322895*a^5*b^5*c*d^3*e^5*f^5*g^4+19375356*a^5*b^6*c^7*e^3*f^2*g^6+15676776*a^6*b^7*c^3*d^8*e^3*f^6*g^6+9971731*a^7*b^4*c^3*d*e^5*f*g^5+16734963*a^8*b^8*c^7*d^4*e*g^7", domain, vars), MultivariatePolynomialZp64.parse("21113415*b^5*c^6*d^4*e^4*f^2*g^3+20864231*b^8*c*d^6*e^5*f^8*g^5+33448448*a*b^3*c^6*d*e^4*f^7*g^2+31133965*a*b^4*c^2*d^2*e^7*f^6*g^2+27612593*a*b^5*d^5*e^2*f^7*g^4+17128197*a*b^7*c^3*d^6*e^2+4469686*a^2*b^5*c^4*d^8*e^4*f^4*g^7+1374035*a^3*c^8*e^7*f*g^5+10414621*a^3*b^6*c^5*d^7*e^7*f^6*g^6+10872067*a^3*b^8*c^3*d*e^4*f^8*g^4+6381772*a^4*b^2*c^6*d^6*e^6*f^3*g^3+26978581*a^4*b^5*d^6*e^5*f^7+30602413*a^4*b^8*c^8*d^4*e^5*f^3*g^3+13372094*a^5*b^3*c^3*d^7*e^5*f^8*g^3+25263857*a^5*b^5*c*d^7*e^6*g^5+4204332*a^6*c^2*d^2*e*f^6*g^2+13228578*a^6*b^2*c^5*d^7*e^6*f^8*g^6+17934510*a^6*b^8*c^4*d^5*e^3*f^4+17371834*a^7*b^4*c^2*d^8*e^4*f^2*g+8745908*a^8*b*c^4*d^7*e^5*f*g^6", domain, vars) }; MultivariatePolynomialZp64 base = factors[0].createOne().multiply(factors); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateFactorization.FactorInGF(base); Assert.assertEquals(3, decomposition.size()); } |
ModularComposition { public static <T extends IUnivariatePolynomial<T>> T compositionBrentKung( T poly, ArrayList<T> pointPowers, T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod, int tBrentKung) { if (poly.isConstant()) return poly; ArrayList<T> gj = new ArrayList<>(); int degree = poly.degree(); for (int i = 0; i <= degree; ) { int to = i + tBrentKung; if (to > (degree + 1)) to = degree + 1; T g = poly.getRange(i, to); gj.add(powModulusMod0(g, polyModulus, invMod, pointPowers)); i = to; } T pt = pointPowers.get(tBrentKung); T res = poly.createZero(); for (int i = gj.size() - 1; i >= 0; --i) res = UnivariatePolynomialArithmetic.polyMod(res.multiply(pt).add(gj.get(i)), polyModulus, invMod, false); return res; } private ModularComposition(); static ArrayList<T> xPowers(T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod); static ArrayList<T> polyPowers(T poly, T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod, int nIterations); static UnivariatePolynomialZp64 powModulusMod(UnivariatePolynomialZp64 poly,
UnivariatePolynomialZp64 polyModulus,
UnivariateDivision.InverseModMonomial<UnivariatePolynomialZp64> invMod,
ArrayList<UnivariatePolynomialZp64> xPowers); static UnivariatePolynomial<E> powModulusMod(UnivariatePolynomial<E> poly,
UnivariatePolynomial<E> polyModulus,
UnivariateDivision.InverseModMonomial<UnivariatePolynomial<E>> invMod,
ArrayList<UnivariatePolynomial<E>> xPowers); @SuppressWarnings("unchecked") static T powModulusMod(T poly,
T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod,
ArrayList<T> xPowers); static T compositionBrentKung(
T poly,
ArrayList<T> pointPowers,
T polyModulus,
UnivariateDivision.InverseModMonomial<T> invMod,
int tBrentKung); static T compositionBrentKung(T poly, T point, T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod); static UnivariatePolynomialZp64 compositionHorner(UnivariatePolynomialZp64 poly, UnivariatePolynomialZp64 point, UnivariatePolynomialZp64 polyModulus, UnivariateDivision.InverseModMonomial<UnivariatePolynomialZp64> invMod); static T composition(T poly, T point, T polyModulus, UnivariateDivision.InverseModMonomial<T> invMod); static T composition(T poly, T point, T polyModulus); } | @Test public void testComposition3Random_big_poly() throws Exception { RandomGenerator rnd = AbstractTest.getRandom(); for (long modulus : getSmallModulusArray(50)) { BigInteger bModulus = BigInteger.valueOf(modulus); for (int i = 0; i < 5; i++) { UnivariatePolynomial<BigInteger> poly = RandomUnivariatePolynomials.randomMonicPoly(1 + rnd.nextInt(10), bModulus, rnd); UnivariatePolynomial<BigInteger> point = RandomUnivariatePolynomials.randomMonicPoly(1 + rnd.nextInt(10), bModulus, rnd); UnivariatePolynomial<BigInteger> polyModulus = RandomUnivariatePolynomials.randomMonicPoly(1 + rnd.nextInt(10), bModulus, rnd); UnivariatePolynomial<BigInteger> bComp = compositionBrentKung(poly, point, polyModulus, UnivariateDivision.fastDivisionPreConditioning(polyModulus)); UnivariatePolynomialZp64 lPolyModulus = UnivariatePolynomial.asOverZp64(polyModulus); UnivariatePolynomialZp64 lComp = compositionBrentKung(UnivariatePolynomial.asOverZp64(poly), UnivariatePolynomial.asOverZp64(point), lPolyModulus, UnivariateDivision.fastDivisionPreConditioning(lPolyModulus)); Assert.assertEquals(lComp, UnivariatePolynomial.asOverZp64(bComp)); } } } |
UnivariateSquareFreeFactorization { @SuppressWarnings("ConstantConditions") static <Poly extends IUnivariatePolynomial<Poly>> PolynomialFactorDecomposition<Poly> SquareFreeFactorizationYun0(Poly poly) { if (poly.isConstant()) return PolynomialFactorDecomposition.of(poly); Poly content = poly.contentAsPoly(); if (poly.signumOfLC() < 0) content = content.negate(); poly = poly.clone().divideByLC(content); if (poly.degree() <= 1) return PolynomialFactorDecomposition.of(content, poly); PolynomialFactorDecomposition<Poly> factorization = PolynomialFactorDecomposition.of(content); SquareFreeFactorizationYun0(poly, factorization); return factorization; } private UnivariateSquareFreeFactorization(); static boolean isSquareFree(T poly); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<T> SquareFreeFactorization(T poly); static T SquareFreePart(T poly); static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationYunZeroCharacteristics(Poly poly); @SuppressWarnings("ConstantConditions") static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationMusserZeroCharacteristics(Poly poly); static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationMusser(Poly poly); } | @Test public void test1() throws Exception { UnivariatePolynomialZ64 poly = UnivariatePolynomialArithmetic.polyPow(UnivariatePolynomialZ64.create(1, 3).multiply(2), 3, false).multiply(UnivariatePolynomialArithmetic.polyPow(UnivariatePolynomialZ64.create(-3, -5, 7), 2, false)); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorizationYun0(poly)); poly = UnivariatePolynomialZ64.create(1, 3); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorizationYun0(poly)); poly = UnivariatePolynomialZ64.create(3); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorizationYun0(poly)); poly = UnivariatePolynomialZ64.create(33); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorizationYun0(poly)); poly = UnivariatePolynomialZ64.create(22, 22).multiply(UnivariatePolynomialZ64.create(12, 12, 12)).multiply(12); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorizationYun0(poly)); }
@Test public void test3() throws Exception { UnivariatePolynomialZ64 poly = UnivariatePolynomialZ64.create(0, 0, -1458, 6561, -6561); PolynomialFactorDecomposition<UnivariatePolynomialZ64> factorization = UnivariateSquareFreeFactorization.SquareFreeFactorizationYun0(poly); assertFactorization(poly, factorization); } |
Rationals implements Ring<Rational<E>> { @Override public String toString(IStringifier<Rational<E>> stringifier) { return ring.equals(Rings.Z) ? "Q" : "Frac(" + ring.toString(stringifier.substringifier(ring)) + ")"; } Rationals(Ring<E> ring); Rational<E> mkNumerator(E num); Rational<E> mkNumerator(long num); Rational<E> mkDenominator(E den); Rational<E> mkDenominator(long den); Rational<E> mk(E num, E den); Rational<E> mk(long num, long den); @Override boolean isField(); @Override boolean isEuclideanRing(); @Override BigInteger cardinality(); @Override BigInteger characteristic(); @Override boolean isPerfectPower(); @Override BigInteger perfectPowerBase(); @Override BigInteger perfectPowerExponent(); @Override Rational<E> add(Rational<E> a, Rational<E> b); @Override Rational<E> subtract(Rational<E> a, Rational<E> b); @Override Rational<E> multiply(Rational<E> a, Rational<E> b); @Override Rational<E> negate(Rational<E> element); @Override int signum(Rational<E> element); @Override @SuppressWarnings("unchecked") Rational<E>[] divideAndRemainder(Rational<E> dividend, Rational<E> divider); @Override Rational<E> reciprocal(Rational<E> element); @Override Rational<E> gcd(Rational<E> a, Rational<E> b); @Override FactorDecomposition<Rational<E>> factorSquareFree(Rational<E> element); @Override FactorDecomposition<Rational<E>> factor(Rational<E> element); @Override Rational<E> getZero(); @Override Rational<E> getOne(); @Override boolean isZero(Rational<E> element); @Override boolean isOne(Rational<E> element); @Override boolean isUnit(Rational<E> element); @Override Rational<E> valueOf(long val); @Override Rational<E> valueOfBigInteger(BigInteger val); @Override Rational<E> copy(Rational<E> element); @Override Rational<E> valueOf(Rational<E> val); @Override @SuppressWarnings("unchecked") Rational<E>[][] createArray2d(int length); @Override @SuppressWarnings("unchecked") Rational<E>[][] createArray2d(int m, int n); @Override int compare(Rational<E> o1, Rational<E> o2); @Override Rational<E> getNegativeOne(); @Override @SuppressWarnings("unchecked") Rational<E>[] createArray(int length); @Override Rational<E> randomElement(RandomGenerator rnd); @Override Rational<E> randomElementTree(RandomGenerator rnd); @Override Iterator<Rational<E>> iterator(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(IStringifier<Rational<E>> stringifier); @Override String toString(); final Ring<E> ring; } | @Test public void test3() { MultivariateRing<MultivariatePolynomial<BigInteger>> polyRing = MultivariateRing(7, Z); Rationals<MultivariatePolynomial<BigInteger>> fracRing = Frac(polyRing); String[] vars = {"x", "y", "z", "a", "b", "c", "d"}; Coder<Rational<MultivariatePolynomial<BigInteger>>, ?, ?> coder = Coder.mkRationalsCoder(fracRing, Coder.mkMultivariateCoder(polyRing, vars)); RandomGenerator rnd = getRandom(); rnd.setSeed(1); String[] els = {"x", "y", "z", "a", "b", "c", "d", "(a+b/c)", "(c-d/c)", "(a-x/y)", "(x -y^2)", "x^3", "y^3", "z^3", "a^3", "b^3", "c^3", "d^3", "x^4", "y^4", "z^4", "a^4", "b^4", "c^4", "d^4"}; StringBuilder sb = new StringBuilder(); for (int i = 0; i < 100; ++i) { if (i != 0) sb.append(rnd.nextBoolean() ? "+" : "-"); for (int j = 0; j < 1 + rnd.nextInt(15); ++j) { if (j != 0) sb.append(rnd.nextBoolean() ? "*" : "/"); sb.append(els[rnd.nextInt(els.length)]); } } String exprString = sb.toString(); for (int i = 0; i < 10; ++i) { long start = System.nanoTime(); Rational<MultivariatePolynomial<BigInteger>> r = coder.parse(exprString); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(2467 + 24, r.numerator().size() + r.denominator().size()); } }
@Test public void test4() { MultivariateRing<MultivariatePolynomial<BigInteger>> polyRing = MultivariateRing(7, Z); Rationals<MultivariatePolynomial<BigInteger>> fracRing = Frac(polyRing); String[] vars = {"x", "y", "z", "a", "b", "c", "d"}; Coder<Rational<MultivariatePolynomial<BigInteger>>, ?, ?> coder = Coder.mkRationalsCoder(fracRing, Coder.mkMultivariateCoder(polyRing, vars)); RandomGenerator rnd = getRandom(); String[] els = {"x", "y", "z", "a", "b", "c", "d", "(a+b/c)", "(c-d/c)", "(a-x/y)", "(x -y^2)", "x^3", "y^3", "z^3", "a^3", "b^3", "c^3", "d^3", "x^4", "y^4", "z^4", "a^4", "b^4", "c^4", "d^4"}; for (int n = 0; n < 10; ++n) { rnd.setSeed(n); System.out.println("=> " + n); StringBuilder sb = new StringBuilder(); for (int i = 0; i < 100; ++i) { if (i != 0) sb.append(rnd.nextBoolean() ? "+" : "-"); for (int j = 0; j < 1 + rnd.nextInt(15); ++j) { if (j != 0) sb.append(rnd.nextBoolean() ? "*" : "/"); sb.append(els[rnd.nextInt(els.length)]); } } String exprString = sb.toString(); Rational<MultivariatePolynomial<BigInteger>> r = coder.parse(exprString); String numString = exprString; MultivariatePolynomial<BigInteger> num = r.numerator(), den = r.denominator(); for (int i = 0; i < vars.length; i++) { numString = numString.replace(vars[i], Integer.toString(i + 1)); num = num.evaluate(i, i + 1); den = den.evaluate(i, i + 1); } Assert.assertEquals(new Rational<>(polyRing, num, den), coder.parse(numString)); } } |
MultivariateFactorization { @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factorPrimitiveInZ( MultivariatePolynomial<BigInteger> polynomial) { if (polynomial.isEffectiveUnivariate()) return factorUnivariate(polynomial); OrderByDegrees<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> input = orderByDegrees(polynomial, true, -1); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> decomposition = factorPrimitiveInZ0(input.ordered); if (decomposition == null) return null; return decomposition.mapTo(input::restoreOrder); } private MultivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(final Poly poly); static PolynomialFactorDecomposition<MultivariatePolynomial<Rational<E>>> FactorInQ(MultivariatePolynomial<Rational<E>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> FactorInZ(final MultivariatePolynomial<BigInteger> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(final MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> FactorInGF(final Poly polynomial); } | @Test public void testMultivariateFactorization27() throws Exception { MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("a^5 + a^4*b^2*c^2 + 11*c + b^3 + 2"), b = MultivariatePolynomial.parse("2*a^6 - 66*b*c + 17*b^2 + c"), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testMultivariateFactorization28() throws Exception { MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("b*a^5 + a^4*b^2*c^2 + 11*c + b^3 + 2"), b = MultivariatePolynomial.parse("2*a^6 - 66*b*c + 17*b^2 + c"), base = a.clone().multiply(b); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(2, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testMultivariateFactorization29() throws Exception { MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("b*a^5 + a^4*b^2*c^2 + 11*c + b^3 + 2"), b = MultivariatePolynomial.parse("2*a^6 - 66*b*c + 17*b^2 + c"), c = MultivariatePolynomial.parse("2*a^6 + 4*b^2*a^6 - 66*b*c + 17*b^2 + b + 1", "a", "b", "c"), base = a.clone().multiply(b, c); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(3, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testMultivariateFactorization30() throws Exception { MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("1+28136331*b*c^2-19241375*a*b^2*c+31673065*a*b^2*c^2-21766903*a^2*b^2*c^2"), b = MultivariatePolynomial.parse("1-13098013*a^2*b^2*c-32210690*a^2*b^3*c^2+20904590*a^3*b^2*c^3"), c = MultivariatePolynomial.parse("1+18527870*a*b-17012638*a*b*c+10557740*a^2*c-9843426*a^2*b^2"), d = MultivariatePolynomial.parse("(-4727463)-17684585*b+11364285*a*b^2+15438263*a^2*c^2-14902664*a^2*b*c^2"), e = MultivariatePolynomial.parse("(-4994407)+32080518*a*b^2*c"), base = a.clone().multiply(b, c, d, e); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(5, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization30a() throws Exception { MultivariatePolynomial<BigInteger>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("1+28136331*a*c^2-19241375*a^2*b*c+31673065*a^2*b*c^2-21766903*a^2*b^2*c^2"), MultivariatePolynomial.parse("1-13098013*a^2*b^2*c+20904590*a^2*b^3*c^3-32210690*a^3*b^2*c^2"), MultivariatePolynomial.parse("1+10557740*b^2*c+18527870*a*b-17012638*a*b*c-9843426*a^2*b^2"), MultivariatePolynomial.parse("(-4727463)+15438263*b^2*c^2-17684585*a-14902664*a*b^2*c^2+11364285*a^2*b"), MultivariatePolynomial.parse("(-4994407)+32080518*a^2*b*c"), }; MultivariatePolynomial<BigInteger> base = multiply(pp); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(1); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(5, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization30b() throws Exception { MultivariatePolynomial<BigInteger>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("1+28136331*a*c^2-19241375*a^2*b*c+31673065*a^2*b*c^2-21766903*a^2*b^2*c^2"), MultivariatePolynomial.parse("1-13098013*a^2*b^2*c+20904590*a^2*b^3*c^3-32210690*a^3*b^2*c^2"), MultivariatePolynomial.parse("1+10557740*b^2*c+18527870*a*b-17012638*a*b*c-9843426*a^2*b^2"), MultivariatePolynomial.parse("(-4727463)+15438263*b^2*c^2-17684585*a-14902664*a*b^2*c^2+11364285*a^2*b"), MultivariatePolynomial.parse("(-4994407)+32080518*a^2*b*c"), }; MultivariatePolynomial<BigInteger> base = multiply(pp); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(3); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(5, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization30c() throws Exception { MultivariatePolynomial<BigInteger>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("1+28136331*a*c^2-19241375*a^2*b*c+31673065*a^2*b*c^2-21766903*a^2*b^2*c^2"), MultivariatePolynomial.parse("1-13098013*a^2*b^2*c+20904590*a^2*b^3*c^3-32210690*a^3*b^2*c^2"), MultivariatePolynomial.parse("1+10557740*b^2*c+18527870*a*b-17012638*a*b*c-9843426*a^2*b^2"), MultivariatePolynomial.parse("(-4727463)+15438263*b^2*c^2-17684585*a-14902664*a*b^2*c^2+11364285*a^2*b"), MultivariatePolynomial.parse("(-4994407)+32080518*a^2*b*c"), }; MultivariatePolynomial<BigInteger> base = multiply(pp); assert MultivariateSquareFreeFactorization.isSquareFree(base); PrivateRandom.getRandom().setSeed(9); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(5, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization31() throws Exception { MultivariatePolynomial<BigInteger>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("1+47250*b^5+9661*a^2*b-118880*a^5*b*c^3"), MultivariatePolynomial.parse("1-10526*a*b*c^2+11461*a*b^2*c^3+107742*a^3-113101*a^3*c+89716*a^3*b*c^3"), MultivariatePolynomial.parse("1-77553*b^3+60044*a^3*b^2*c^2"), MultivariatePolynomial.parse("1+102974*b*c-19396*a^2*b^2*c"), MultivariatePolynomial.parse("1+81674*b^5*c^6+107381*a*b^6*c^3+5984*a^5*b^5*c^6-96446*a^6*c^6"), }; MultivariatePolynomial<BigInteger> base = multiply(pp); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(5, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization32() throws Exception { MultivariatePolynomial<BigInteger>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("1-9*b*c+435*b^2*c-460*a*b-410*a*b^2+4*a*b^2*c"), MultivariatePolynomial.parse("1-157*a^2*c^2+340*a^2*b*c"), MultivariatePolynomial.parse("(-457)*c+120*b-141*a^2*b^2*c^2"), MultivariatePolynomial.parse("1-458*a^2-118*a^2*b^2*c^3+318*a^2*b^3-256*a^2*b^4*c^2+238*a^2*b^4*c^4+192*a^5*b^3"), }; MultivariatePolynomial<BigInteger> base = multiply(pp); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 0; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(4, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization33() throws Exception { MultivariatePolynomial<BigInteger>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("1+106564457*a*b^4*c*d^2+325561484*a^3*b*d^3-494009011*a^3*b^4*d^2-340064640*a^4*b*c^5+5486146*a^5*b^3*c^4*d^2"), MultivariatePolynomial.parse("1-263084145*a^2*b^5*d^2+435163540*a^2*b^5*c^3*d^5+538303140*a^4*b^5*c^4*d^5"), MultivariatePolynomial.parse("303047887*b^5*c^4*d^5+65189925*a*c^5+310563050*a^4*b^4*d^5+197570681*a^5*b^5*c^4*d^2"), MultivariatePolynomial.parse("1+332010051*a*c^4*d^2+112027379*a^3*b*c^2*d^4+51064879*a^3*b^4*c*d^3-396600905*a^4-10945831*a^5*b^3*c^3*d"), MultivariatePolynomial.parse("1-327267807*b*c^4+106677035*a*b^3*d^2-379344971*a^5*b^5*c^3*d^2"), }; MultivariatePolynomial<BigInteger> base = multiply(pp); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 1; i < its(1, 1); i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(5, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization34() throws Exception { MultivariatePolynomial<BigInteger>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("1-3778*a^2*b^2*c+13207*a^3*b*c^4"), MultivariatePolynomial.parse("1-13694*a^3*b^5*c-16924*a^6*c^5+34818*a^6*b^6*c"), MultivariatePolynomial.parse("1+30327*a^3*c^2+24272*a^3*b*c-5401*a^3*b^2-40302*a^3*b^4"), }; MultivariatePolynomial<BigInteger> base = multiply(pp); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 3; i < its(10, 10); i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(3, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization35() throws Exception { MultivariatePolynomial<BigInteger>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("57335917*d-53377618*b*c^2+20557031*a*b^2*c*d+28290557*a*b^2*c^2*d^2+219143656*a^2*b*d+80576655*a^2*b^2*c^2*d"), MultivariatePolynomial.parse("77388697*c^2-29509948*a^2*c^3*d-15585632*a^2*b^3*c^2*d+193714032*a^3*b^2*d^3-129223469*a^3*b^3*c^3*d"), MultivariatePolynomial.parse("1-207609883*a*b*c*d^2+165695566*a*b^2*c^2*d^2+116765978*a^2*c*d^2+89347609*a^2*c^2*d^2+3700023*a^2*b*c^2*d^2"), MultivariatePolynomial.parse("1-20532829*a^4*b^4*c^3*d^3+181984105*a^5*b^3*c^5*d^4+142483093*a^5*b^5*c^2"), }; MultivariatePolynomial<BigInteger> base = multiply(pp); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 7; i < its(10, 10); i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(4, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization36() throws Exception { MultivariatePolynomial<BigInteger>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("1+324*c^2+119*a*b^3*c+461*a^2*c^3+597*a^3*b*c^3"), MultivariatePolynomial.parse("1+141*b^3*c^5-134*a*b^4*c"), MultivariatePolynomial.parse("1-519*a*b^2+98*a^2*b*c+362*a^2*b^2*c"), }; MultivariatePolynomial<BigInteger> base = multiply(pp); assert MultivariateSquareFreeFactorization.isSquareFree(base); for (int i = 7; i < its(10, 10); i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.factorPrimitiveInZ(base); Assert.assertEquals(3, factors.size()); FactorDecompositionTest.assertFactorization(base, factors); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } } |
UnivariateSquareFreeFactorization { @SuppressWarnings("unchecked") public static <T extends IUnivariatePolynomial<T>> PolynomialFactorDecomposition<T> SquareFreeFactorization(T poly) { if (poly.isOverFiniteField()) return SquareFreeFactorizationMusser(poly); else if (UnivariateFactorization.isOverMultivariate(poly)) return (PolynomialFactorDecomposition<T>) UnivariateFactorization.FactorOverMultivariate((UnivariatePolynomial) poly, MultivariateSquareFreeFactorization::SquareFreeFactorization); else if (UnivariateFactorization.isOverUnivariate(poly)) return (PolynomialFactorDecomposition<T>) UnivariateFactorization.FactorOverUnivariate((UnivariatePolynomial) poly, MultivariateSquareFreeFactorization::SquareFreeFactorization); else if (poly.coefficientRingCharacteristic().isZero()) return SquareFreeFactorizationYunZeroCharacteristics(poly); else return SquareFreeFactorizationMusser(poly); } private UnivariateSquareFreeFactorization(); static boolean isSquareFree(T poly); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<T> SquareFreeFactorization(T poly); static T SquareFreePart(T poly); static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationYunZeroCharacteristics(Poly poly); @SuppressWarnings("ConstantConditions") static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationMusserZeroCharacteristics(Poly poly); static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationMusser(Poly poly); } | @Test public void test4() throws Exception { UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(1, 0, 1, 0, 2).modulus(2); poly = poly.multiply(UnivariatePolynomialZ64.create(1, 0, 1, 0, 2).modulus(2)); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorization(poly)); }
@Test public void test5() throws Exception { UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(1, 0, 0, 0, 1).modulus(2); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorization(poly)); }
@Test @Benchmark(runAnyway = true) public void testRandom6() throws Exception { final class test { long overflows = 0; final DescriptiveStatistics arithmetics = new DescriptiveStatistics(); final DescriptiveStatistics timings = new DescriptiveStatistics(); void run(int bound, int maxDegree, int maxNBase, int maxExponent, int nIterations) { RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = new RandomDataGenerator(rnd); long start; for (int i = 0; i < nIterations; i++) { if (i == 100) timings.clear(); int nbase = rndd.nextInt(1, maxNBase); for (long modulus : getModulusArray(9, 1, 35)) { UnivariatePolynomialZp64 poly; start = System.nanoTime(); poly = UnivariatePolynomialZ64.create(rndd.nextLong(1, 1000)).modulus(modulus, false); for (int j = 0; j < nbase; j++) { UnivariatePolynomialZp64 f = RandomUnivariatePolynomials.randomPoly(rndd.nextInt(1, maxDegree), bound, rnd).modulus(modulus); poly = poly.multiply(UnivariatePolynomialArithmetic.polyPow(f, rndd.nextInt(1, maxExponent), true)); } arithmetics.addValue(System.nanoTime() - start); try { start = System.nanoTime(); PolynomialFactorDecomposition<UnivariatePolynomialZp64> factorization = UnivariateSquareFreeFactorization.SquareFreeFactorization(poly); timings.addValue(System.nanoTime() - start); assertFactorization(poly, factorization); } catch (ArithmeticException exc) { if (!exc.getMessage().contains("overflow")) throw exc; ++overflows; } } } } } test smallPolys = new test(); smallPolys.run(10, 3, 5, 5, (int) its(100, 1000)); System.out.println("Overflows: " + smallPolys.overflows); System.out.println("Timings:\n" + smallPolys.timings.getPercentile(50)); System.out.println("Arithmetics:\n" + smallPolys.arithmetics.getPercentile(50)); System.out.println("\n================== \n"); test largePolys = new test(); largePolys.run(1000, 15, 10, 20, (int) its(10, 10)); System.out.println("Overflows: " + largePolys.overflows); System.out.println("Timings:\n" + largePolys.timings.getPercentile(50)); System.out.println("Arithmetics:\n" + largePolys.arithmetics.getPercentile(50)); }
@Test public void test6a() throws Exception { UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(0, 0, 1, 3, 4, 3, 3, 2, 3).modulus(5); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorization(poly)); }
@Test public void test6b() throws Exception { UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(0, 0, 0, 2).modulus(3); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorization(poly)); }
@Test public void test6c() throws Exception { UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(0, 0, 0, 1, 1).modulus(2); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorization(poly)); }
@Test public void test6d() throws Exception { UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2).modulus(3); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorization(poly)); }
@Test public void test6e() throws Exception { UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(2, 3, 2, 1, 3, 3, 3).modulus(5); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorization(poly)); }
@Test public void test6f() throws Exception { UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(1, 0, 2, 2, 0, 1, 1, 0, 2, 2, 0, 1).modulus(3); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorization(poly)); }
@Test public void test6g() throws Exception { for (long modulus : getModulusArray(1, 1, 50)) { UnivariatePolynomialZp64 poly = UnivariatePolynomialZ64.create(0, 0, 0, 8, 20, 67, 55).modulus(modulus); assertFactorization(poly, UnivariateSquareFreeFactorization.SquareFreeFactorization(poly)); } }
@Test public void test7() throws Exception { assertEquals(1, UnivariateSquareFreeFactorization.SquareFreeFactorization(UnivariatePolynomialZ64.create(0, 0, 0, 0, 1)).factors.size()); assertEquals(1, UnivariateSquareFreeFactorization.SquareFreeFactorization(UnivariatePolynomialZ64.create(0, 0, 0, 0, 1).modulus(31)).factors.size()); }
@Test public void test9() throws Exception { assertTrue(UnivariateSquareFreeFactorization.SquareFreeFactorization(UnivariatePolynomialZ64.create(3, 7).modulus(17)).get(0).isMonic()); }
@Test public void test10() throws Exception { UnivariatePolynomial<BigInteger> poly = UnivariatePolynomial.create(Long.MAX_VALUE, Long.MAX_VALUE - 1, Long.MAX_VALUE - 2, Long.MAX_VALUE - 3); UnivariatePolynomial<BigInteger> original = poly.add(poly.derivative()); UnivariatePolynomial<BigInteger> squared = original.clone().square(); PolynomialFactorDecomposition<UnivariatePolynomial<BigInteger>> f = SquareFreeFactorization(squared); assertEquals(1, f.size()); assertEquals(2, f.getExponent(0)); assertEquals(original, f.get(0)); UnivariatePolynomial<BigInteger> squaredMod = squared.setRing(new IntegersZp(BigInteger.LONG_MAX_VALUE.multiply(BigInteger.TWO).nextProbablePrime())); squaredMod = squaredMod.square(); PolynomialFactorDecomposition<UnivariatePolynomial<BigInteger>> fMod = SquareFreeFactorization(squaredMod); assertEquals(1, fMod.size()); assertEquals(4, fMod.getExponent(0)); assertFactorization(squaredMod, fMod); }
@Test public void testRandom11() throws Exception { RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = new RandomDataGenerator(rnd); BigInteger bound = BigInteger.LONG_MAX_VALUE; bound = bound.multiply(bound).increment(); int nIterations = (int) its(20, 50); for (int i = 0; i < nIterations; i++) { UnivariatePolynomial<BigInteger> poly; poly = RandomUnivariatePolynomials.randomPoly(rndd.nextInt(2, 30), bound, rnd); int exponent = rndd.nextInt(2, 4); poly = UnivariatePolynomialArithmetic.polyPow(poly, exponent, false); PolynomialFactorDecomposition<UnivariatePolynomial<BigInteger>> zf = SquareFreeFactorization(poly); assertTrue(zf.sumExponents() >= exponent); assertFactorization(poly, zf); UnivariatePolynomial<BigInteger> polyMod = poly.setRing(new IntegersZp(RandomUtil.randomInt(bound, rnd).nextProbablePrime())); PolynomialFactorDecomposition<UnivariatePolynomial<BigInteger>> zpf = SquareFreeFactorization(polyMod); assertTrue(zpf.sumExponents() >= exponent); assertFactorization(polyMod, zpf); } }
@Test public void test11() throws Exception { UnivariatePolynomialZp64 a = UnivariatePolynomialZ64.create(1, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 6).modulus(7), b = UnivariatePolynomialZ64.create(1, 2, 3, 4, 5, 6, 5, 4).modulus(7), poly = a.square().multiply(b.square()); assertFactorization(poly, SquareFreeFactorization(poly)); }
@Test public void testFiniteField1() throws Exception { UnivariatePolynomialZp64 irreducible = UnivariatePolynomialZ64.create(1, 1, 0, 1).modulus(2); FiniteField<UnivariatePolynomialZp64> domain = new FiniteField<>(irreducible); UnivariatePolynomial<UnivariatePolynomialZp64> poly = UnivariatePolynomial.create(domain, UnivariatePolynomialZ64.create(0, 0, 1).modulus(2), UnivariatePolynomialZ64.create(0, 1, 1).modulus(2), UnivariatePolynomialZ64.create(0, 0, 1).modulus(2), UnivariatePolynomialZ64.create(1).modulus(2), UnivariatePolynomialZ64.create(0, 0, 1).modulus(2), UnivariatePolynomialZ64.create(0).modulus(2), UnivariatePolynomialZ64.create(1, 0, 1).modulus(2), UnivariatePolynomialZ64.create(0, 0, 1).modulus(2)); PolynomialFactorDecomposition<UnivariatePolynomial<UnivariatePolynomialZp64>> factors = UnivariateSquareFreeFactorization.SquareFreeFactorization(poly); assertFactorization(poly, factors); }
@Test public void test12() throws Exception { for (int i = 1; i < 11; i++) { UnivariatePolynomialZ64 poly = UnivariatePolynomialZ64.monomial(1, i); PolynomialFactorDecomposition<UnivariatePolynomialZ64> fct = SquareFreeFactorization(poly); assertEquals(1, fct.size()); assertEquals(i, fct.getExponent(0)); assertEquals(1, fct.get(0).degree); PolynomialFactorDecomposition<UnivariatePolynomialZp64> mfct = SquareFreeFactorization(poly.modulus(2)); assertEquals(1, mfct.size()); assertEquals(i, mfct.getExponent(0)); assertEquals(1, mfct.get(0).degree); } } |
MultivariateFactorization { @SuppressWarnings("unchecked") public static <Poly extends AMultivariatePolynomial<?, Poly>> PolynomialFactorDecomposition<Poly> Factor(final Poly poly) { if (poly.isOverFiniteField()) return (PolynomialFactorDecomposition<Poly>) FactorInGF((AMultivariatePolynomial) poly); else if (poly.isOverZ()) return FactorInZ((MultivariatePolynomial) poly); else if (Util.isOverRationals(poly)) return (PolynomialFactorDecomposition<Poly>) FactorInQ((MultivariatePolynomial) poly); else if (Util.isOverSimpleNumberField(poly)) return (PolynomialFactorDecomposition<Poly>) FactorInNumberField((MultivariatePolynomial) poly); else if (Util.isOverMultipleFieldExtension(poly)) return (PolynomialFactorDecomposition<Poly>) FactorInMultipleFieldExtension((MultivariatePolynomial) poly); else { PolynomialFactorDecomposition<Poly> factors = tryNested(poly, MultivariateFactorization::Factor); if (factors != null) return factors; throw new RuntimeException("Unsupported ring: " + poly.coefficientRingToString()); } } private MultivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(final Poly poly); static PolynomialFactorDecomposition<MultivariatePolynomial<Rational<E>>> FactorInQ(MultivariatePolynomial<Rational<E>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> FactorInZ(final MultivariatePolynomial<BigInteger> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(final MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> FactorInGF(final Poly polynomial); } | @Test @SuppressWarnings("unchecked") public void testMultivariateFactorization38RandomZa() throws Exception { String[] vars = {"x1", "x2", "x3", "x4"}; MultivariatePolynomial<BigInteger> pp[] = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("-1+401*x3^3*x4^3+155*x1^2*x2^2*x3^2*x4-174*x1^2*x2*x3^5*x4^3+243*x1^2*x2^5*x3^4*x4", vars), MultivariatePolynomial.parse("-1+555*x1*x3^3+89*x1*x2*x3^3*x4+255*x2^3*x3^3*x4^2+660*x1^3*x2^3*x3^2*x4+377*x1^2*x2^3*x3^2*x4^3", vars), MultivariatePolynomial.parse("-1+236*x2^2*x3^5*x4^4-481*x1^4*x2^2*x3^5*x4-642*x1^2*x2^5*x3^4*x4^3+610*x1^4*x2^4*x3^4*x4^2", vars), MultivariatePolynomial.parse("-517-223*x2^2*x3^3*x4+234*x1^2*x3^2*x4^3", vars), }, poly = multiply(pp); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.Factor(poly); Assert.assertEquals(4, factors.size()); Assert.assertEquals(poly, factors.multiply()); }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization39() throws Exception { String[] vars = {"a", "b", "c"}; MultivariatePolynomial<BigInteger> pp[] = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("a^2 + b^2 + c^2", vars), MultivariatePolynomial.parse("a*b - b*c - c*a", vars).square(), MultivariatePolynomial.parse("3", vars), MultivariatePolynomial.parse("a - b - c", vars).square(), MultivariatePolynomial.parse("a - b ", vars).square(), MultivariatePolynomial.parse("b + c", vars).square(), MultivariatePolynomial.parse("a^6 + c^2 + a*c^2 + 1", vars).square() }, poly = multiply(pp); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.Factor(poly); Assert.assertEquals(6, factors.size()); Assert.assertEquals(poly, factors.multiply()); poly = poly.setRing(new IntegersZp(Integer.MAX_VALUE)); factors = MultivariateFactorization.Factor(poly); Assert.assertEquals(6, factors.size()); Assert.assertEquals(poly, factors.multiply()); }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization40() throws Exception { String[] vars = {"a", "b", "c", "d"}; MultivariatePolynomial<BigInteger> pp[] = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("31694*c^2*d^2-9343*b^2-12027*b^2*d^2+40289*a^2*b*c*d", vars), MultivariatePolynomial.parse("(-114834)*b^2*d+119706*a*c^2-105913*a*b^2+129857*a*b^2*d", vars), MultivariatePolynomial.parse("(-27997)*b^4*d^5-120509*b^5*c^3*d^5-103731*a*c^3*d^2-71946*a*b^4*c^5*d^5+113296*a^3*b^4*c", vars), MultivariatePolynomial.parse("1-16532*b*c*d^2-101779*a*b^2*c^4*d^4-74636*a^2*b^2*c^4-110612*a^3*c^4*d^4-97709*a^3*b^2*c+120010*a^5*b^3*c*d^2", vars), }, poly = multiply(pp); for (int i = 21; i < 22; i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factors = MultivariateFactorization.Factor(poly); Assert.assertEquals(4, factors.size()); Assert.assertEquals(poly, factors.multiply()); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test @SuppressWarnings("unchecked") public void testMultivariateFactorization41() throws Exception { String[] vars = {"a", "b", "c", "d"}; MultivariatePolynomial<Rational<BigInteger>> pp[] = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("(31694/3)*c^2*d^2-(9343/1111)*b^2-12027*b^2*d^2+40289*a^2*b*c*d", Rings.Q, vars), MultivariatePolynomial.parse("(-114834)*b^2*d+119706*a*c^2-105913*a*b^2+129857*a*b^2*d", Rings.Q, vars), MultivariatePolynomial.parse("(-27997)*b^4*d^5-(120509/123)*b^5*c^3*d^5-103731*a*c^3*d^2-71946*a*b^4*c^5*d^5+113296*a^3*b^4*c", Rings.Q, vars), MultivariatePolynomial.parse("1-16532*b*c*d^2-101779*a*b^2*c^4*d^4-(74636/1234342)*a^2*b^2*c^4-110612*a^3*c^4*d^4-97709*a^3*b^2*c+120010*a^5*b^3*c*d^2", Rings.Q, vars), }, poly = multiply(pp); for (int i = 21; i < 22; i++) { PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<Rational<BigInteger>>> factors = MultivariateFactorization.Factor(poly); Assert.assertEquals(4, factors.size()); Assert.assertEquals(poly, factors.multiply()); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test(timeout = 10000) public void testMultivariateFactorization44() throws Exception { for (int i = 0; i < 50; i++) { PrivateRandom.getRandom().setSeed(i); MultivariatePolynomial<BigInteger> poly = MultivariatePolynomial.parse("25104542697922606374180382796611903776*x^5*y^7*z^4+20534636095763889368932021297717635120*x^6*y^7*z^5+76297700033840376318392368872790943968*x^7*y^4*z^7-26574785740999558717642330744030288047*x^7*y^6*z^4+17324112943714387939253008546475979840*x^8*y^3*z^3+62408844645806356433165500595194302160*x^8*y^4*z^8+14170517235134724116322359611873960800*x^9*y^3*z^4-80766061159845213267443892965900078721*x^9*y^3*z^7-18338696512889824461965469610690129230*x^10*y^2*z^3"); Assert.assertEquals(5, Factor(poly).size()); } }
@Test @SuppressWarnings("unchecked") public void testNestedRing1() throws Exception { for (Ring<?> inner1 : Arrays.asList( Rings.GF(7, 3), Rings.UnivariateRing(Rings.Z), Rings.UnivariateRingZp64(17))) { MultivariateRing<?> inner2 = MultivariateRing(2, inner1); UnivariateRing<?> inner3 = Rings.UnivariateRing(inner2); MultivariateRing<?> ring = MultivariateRing(2, inner3); for (int i = 0; i < its(4, 8); ++i) { AMultivariatePolynomial a = ring.randomElement(3, 5), b = ring.randomElement(3, 5); AMultivariatePolynomial poly = multiply(a, b); PolynomialFactorDecomposition<?> factors = Factor(poly); Assert.assertTrue(factors.sumExponents() >= 2); Assert.assertEquals(poly, factors.multiply()); } } }
@Test public void testMultivariateFactorization45() throws Exception { MultivariatePolynomialZp64 poly = MultivariatePolynomialZp64.parse( "7+4*x4^2+8*x4^4+16*x4^6+6*x3+9*x3*x4+x3*x4^2+12*x3*x4^3+2*x3*x4^4+8*x3*x4^5+4*x3*x4^6+8*x3*x4^7+16*x3*x4^9+2*x3^2+15*x3^2*x4+13*x3^2*x4^2+3*x3^2*x4^3+7*x3^2*x4^4+2*x3^2*x4^5+5*x3^2*x4^6+2*x3^2*x4^7+4*x3^2*x4^8+4*x3^2*x4^9+9*x3^3+11*x3^3*x4+16*x3^3*x4^2+2*x3^3*x4^3+6*x3^3*x4^4+10*x3^3*x4^5+14*x3^3*x4^6+15*x3^3*x4^7+x3^3*x4^8+15*x3^4+7*x3^4*x4+14*x3^4*x4^2+9*x3^4*x4^3+11*x3^4*x4^4+11*x3^4*x4^5+8*x3^4*x4^7+14*x3^4*x4^8+8*x3^5+4*x3^5*x4+12*x3^5*x4^2+9*x3^5*x4^3+7*x3^5*x4^4+14*x3^5*x4^5+12*x3^5*x4^8+x3^6*x4+15*x3^6*x4^3+4*x3^6*x4^4+12*x3^6*x4^5+11*x3^6*x4^6+8*x3^7*x4+x3^7*x4^4+7*x3^7*x4^6+2*x3^8*x4+8*x3^8*x4^4+2*x3^9*x4^4+11*x2+15*x2*x4^2+11*x2*x4^4+x2*x4^6+15*x2*x3+4*x2*x3*x4+15*x2*x3*x4^2+x2*x3*x4^3+4*x2*x3*x4^4+5*x2*x3*x4^5+7*x2*x3*x4^6+16*x2*x3*x4^7+11*x2*x3*x4^9+3*x2*x3^2+4*x2*x3^2*x4+9*x2*x3^2*x4^2+9*x2*x3^2*x4^3+x2*x3^2*x4^4+4*x2*x3^2*x4^5+10*x2*x3^2*x4^6+4*x2*x3^2*x4^7+7*x2*x3^2*x4^8+7*x2*x3^2*x4^9+16*x2*x3^3*x4+8*x2*x3^3*x4^2+15*x2*x3^3*x4^3+x2*x3^3*x4^4+x2*x3^3*x4^5+11*x2*x3^3*x4^6+5*x2*x3^3*x4^7+6*x2*x3^3*x4^8+10*x2*x3^4+2*x2*x3^4*x4+3*x2*x3^4*x4^2+8*x2*x3^4*x4^3+8*x2*x3^4*x4^4+12*x2*x3^4*x4^5+15*x2*x3^4*x4^6+14*x2*x3^4*x4^7+16*x2*x3^4*x4^8+16*x2*x3^5+12*x2*x3^5*x4+4*x2*x3^5*x4^2+2*x2*x3^5*x4^3+2*x2*x3^5*x4^4+16*x2*x3^5*x4^5+8*x2*x3^5*x4^6+4*x2*x3^5*x4^8+10*x2*x3^6*x4+7*x2*x3^6*x4^3+6*x2*x3^6*x4^4+4*x2*x3^6*x4^5+15*x2*x3^6*x4^6+9*x2*x3^7*x4+10*x2*x3^7*x4^4+8*x2*x3^7*x4^6+12*x2*x3^8*x4+14*x2*x3^8*x4^4+12*x2*x3^9*x4^4+9*x2^2+8*x2^2*x4^2+9*x2^2*x4^4+9*x2^2*x4^6+8*x2^2*x3+14*x2^2*x3*x4+9*x2^2*x3*x4^2+9*x2^2*x3*x4^3+12*x2^2*x3*x4^6+14*x2^2*x3*x4^9+6*x2^2*x3^2+15*x2^2*x3^2*x4+11*x2^2*x3^2*x4^2+12*x2^2*x3^2*x4^3+10*x2^2*x3^2*x4^4+12*x2^2*x3^2*x4^5+16*x2^2*x3^2*x4^6+12*x2^2*x3^2*x4^8+12*x2^2*x3^2*x4^9+12*x2^2*x3^3+14*x2^2*x3^3*x4+8*x2^2*x3^3*x4^2+6*x2^2*x3^3*x4^3+5*x2^2*x3^3*x4^4+8*x2^2*x3^3*x4^5+4*x2^2*x3^3*x4^6+11*x2^2*x3^3*x4^7+3*x2^2*x3^3*x4^8+14*x2^2*x3^4+3*x2^2*x3^4*x4+10*x2^2*x3^4*x4^2+15*x2^2*x3^4*x4^3+12*x2^2*x3^4*x4^4+10*x2^2*x3^4*x4^5+12*x2^2*x3^4*x4^6+7*x2^2*x3^4*x4^7+8*x2^2*x3^4*x4^8+3*x2^2*x3^5+16*x2^2*x3^5*x4+2*x2^2*x3^5*x4^2+15*x2^2*x3^5*x4^3+3*x2^2*x3^5*x4^4+8*x2^2*x3^5*x4^5+3*x2^2*x3^5*x4^6+2*x2^2*x3^5*x4^8+10*x2^2*x3^6*x4+7*x2^2*x3^6*x4^3+6*x2^2*x3^6*x4^4+2*x2^2*x3^6*x4^5+16*x2^2*x3^6*x4^6+13*x2^2*x3^7*x4+10*x2^2*x3^7*x4^4+4*x2^2*x3^7*x4^6+6*x2^2*x3^8*x4+7*x2^2*x3^8*x4^4+6*x2^2*x3^9*x4^4+2*x2^3+15*x2^3*x4^2+x2^3*x4^4+8*x2^3*x4^6+9*x2^3*x3+16*x2^3*x3*x4+4*x2^3*x3*x4^2+15*x2^3*x3*x4^3+13*x2^3*x3*x4^4+x2^3*x3*x4^5+14*x2^3*x3*x4^6+x2^3*x3*x4^7+5*x2^3*x3*x4^9+3*x2^3*x3^2+5*x2^3*x3^2*x4+x2^3*x3^2*x4^2+2*x2^3*x3^2*x4^3+2*x2^3*x3^2*x4^4+16*x2^3*x3^2*x4^5+6*x2^3*x3^2*x4^6+13*x2^3*x3^2*x4^7+14*x2^3*x3^2*x4^8+14*x2^3*x3^2*x4^9+x2^3*x3^3*x4+7*x2^3*x3^3*x4^2+7*x2^3*x3^3*x4^3+16*x2^3*x3^3*x4^4+x2^3*x3^3*x4^5+10*x2^3*x3^3*x4^6+10*x2^3*x3^3*x4^7+12*x2^3*x3^3*x4^8+3*x2^3*x3^4*x4+7*x2^3*x3^4*x4^2+8*x2^3*x3^4*x4^3+12*x2^3*x3^4*x4^4+15*x2^3*x3^4*x4^5+15*x2^3*x3^4*x4^6+11*x2^3*x3^4*x4^7+15*x2^3*x3^4*x4^8+4*x2^3*x3^5+9*x2^3*x3^5*x4+8*x2^3*x3^5*x4^2+13*x2^3*x3^5*x4^3+3*x2^3*x3^5*x4^4+15*x2^3*x3^5*x4^5+8*x2^3*x3^5*x4^6+8*x2^3*x3^5*x4^8+15*x2^3*x3^6*x4+3*x2^3*x3^6*x4^3+9*x2^3*x3^6*x4^4+8*x2^3*x3^6*x4^5+13*x2^3*x3^6*x4^6+4*x2^3*x3^7*x4+15*x2^3*x3^7*x4^4+16*x2^3*x3^7*x4^6+7*x2^3*x3^8*x4+11*x2^3*x3^8*x4^4+7*x2^3*x3^9*x4^4+12*x2^4+14*x2^4*x4^2+5*x2^4*x4^4+9*x2^4*x4^6+15*x2^4*x3+8*x2^4*x3*x4+16*x2^4*x3*x4^2+8*x2^4*x3*x4^3+6*x2^4*x3*x4^4+11*x2^4*x3*x4^5+5*x2^4*x3*x4^6+7*x2^4*x3*x4^7+3*x2^4*x3*x4^9+4*x2^4*x3^2+13*x2^4*x3^2*x4+12*x2^4*x3^2*x4^2+7*x2^4*x3^2*x4^3+2*x2^4*x3^2*x4^4+13*x2^4*x3^2*x4^5+2*x2^4*x3^2*x4^6+6*x2^4*x3^2*x4^7+5*x2^4*x3^2*x4^8+5*x2^4*x3^2*x4^9+11*x2^4*x3^3+x2^4*x3^3*x4+11*x2^4*x3^3*x4^2+11*x2^4*x3^3*x4^3+6*x2^4*x3^3*x4^4+3*x2^4*x3^3*x4^5+9*x2^4*x3^3*x4^6+6*x2^4*x3^3*x4^7+14*x2^4*x3^3*x4^8+10*x2^4*x3^4+8*x2^4*x3^4*x4+10*x2^4*x3^4*x4^2+11*x2^4*x3^4*x4^3+15*x2^4*x3^4*x4^4+9*x2^4*x3^4*x4^5+10*x2^4*x3^4*x4^7+9*x2^4*x3^4*x4^8+12*x2^4*x3^5+10*x2^4*x3^5*x4+15*x2^4*x3^5*x4^2+8*x2^4*x3^5*x4^4+9*x2^4*x3^5*x4^5+15*x2^4*x3^5*x4^8+8*x2^4*x3^6*x4^3+15*x2^4*x3^6*x4^5+x2^4*x3^6*x4^6+13*x2^4*x3^7*x4+13*x2^4*x3^7*x4^6+11*x2^4*x3^8*x4+10*x2^4*x3^8*x4^4+11*x2^4*x3^9*x4^4+2*x2^5+16*x2^5*x4^2+8*x2^5*x4^4+5*x2^5*x4^6+x2^5*x3+10*x2^5*x3*x4+11*x2^5*x3*x4^2+x2^5*x3*x4^3+2*x2^5*x3*x4^4+7*x2^5*x3*x4^5+16*x2^5*x3*x4^6+8*x2^5*x3*x4^7+13*x2^5*x3*x4^9+4*x2^5*x3^2+15*x2^5*x3^2*x4+13*x2^5*x3^2*x4^2+4*x2^5*x3^2*x4^3+2*x2^5*x3^2*x4^4+15*x2^5*x3^2*x4^5+12*x2^5*x3^2*x4^6+2*x2^5*x3^2*x4^7+16*x2^5*x3^2*x4^8+16*x2^5*x3^2*x4^9+9*x2^5*x3^3+7*x2^5*x3^3*x4+7*x2^5*x3^3*x4^2+11*x2^5*x3^3*x4^3+13*x2^5*x3^3*x4^4+9*x2^5*x3^3*x4^5+3*x2^5*x3^3*x4^6+9*x2^5*x3^3*x4^7+4*x2^5*x3^3*x4^8+9*x2^5*x3^4+4*x2^5*x3^4*x4+15*x2^5*x3^4*x4^2+2*x2^5*x3^4*x4^3+16*x2^5*x3^4*x4^4+4*x2^5*x3^4*x4^5+6*x2^5*x3^4*x4^6+15*x2^5*x3^4*x4^7+5*x2^5*x3^4*x4^8+4*x2^5*x3^5+12*x2^5*x3^5*x4+14*x2^5*x3^5*x4^2+12*x2^5*x3^5*x4^3+4*x2^5*x3^5*x4^4+5*x2^5*x3^5*x4^5+10*x2^5*x3^5*x4^6+14*x2^5*x3^5*x4^8+8*x2^5*x3^6*x4+15*x2^5*x3^6*x4^3+15*x2^5*x3^6*x4^4+14*x2^5*x3^6*x4^5+10*x2^5*x3^6*x4^6+11*x2^5*x3^7*x4+8*x2^5*x3^7*x4^4+11*x2^5*x3^7*x4^6+8*x2^5*x3^8*x4+15*x2^5*x3^8*x4^4+8*x2^5*x3^9*x4^4+4*x2^6+x2^6*x4^2+6*x2^6*x4^4+2*x2^6*x4^6+4*x2^6*x3+10*x2^6*x3*x4+6*x2^6*x3*x4^2+8*x2^6*x3*x4^3+16*x2^6*x3*x4^4+16*x2^6*x3*x4^5+6*x2^6*x3*x4^6+13*x2^6*x3*x4^7+7*x2^6*x3*x4^9+13*x2^6*x3^2+11*x2^6*x3^2*x4+2*x2^6*x3^2*x4^2+9*x2^6*x3^2*x4^3+14*x2^6*x3^2*x4^4+16*x2^6*x3^2*x4^5+3*x2^6*x3^2*x4^6+16*x2^6*x3^2*x4^7+6*x2^6*x3^2*x4^8+6*x2^6*x3^2*x4^9+8*x2^6*x3^3+8*x2^6*x3^3*x4+10*x2^6*x3^3*x4^2+5*x2^6*x3^3*x4^3+6*x2^6*x3^3*x4^4+12*x2^6*x3^3*x4^5+5*x2^6*x3^3*x4^6+14*x2^6*x3^3*x4^7+10*x2^6*x3^3*x4^8+12*x2^6*x3^4+9*x2^6*x3^4*x4+6*x2^6*x3^4*x4^2+3*x2^6*x3^4*x4^3+2*x2^6*x3^4*x4^4+11*x2^6*x3^4*x4^5+14*x2^6*x3^4*x4^6+12*x2^6*x3^4*x4^7+4*x2^6*x3^4*x4^8+5*x2^6*x3^5+9*x2^6*x3^5*x4+x2^6*x3^5*x4^2+15*x2^6*x3^5*x4^3+9*x2^6*x3^5*x4^4+4*x2^6*x3^5*x4^5+12*x2^6*x3^5*x4^6+x2^6*x3^5*x4^8+16*x2^6*x3^6*x4+7*x2^6*x3^6*x4^3+13*x2^6*x3^6*x4^4+x2^6*x3^6*x4^5+8*x2^6*x3^6*x4^6+x2^6*x3^7*x4+16*x2^6*x3^7*x4^4+2*x2^6*x3^7*x4^6+3*x2^6*x3^8*x4+12*x2^6*x3^8*x4^4+3*x2^6*x3^9*x4^4+10*x2^7+4*x2^7*x4^2+10*x2^7*x4^4+9*x2^7*x4^6+4*x2^7*x3+10*x2^7*x3*x4+2*x2^7*x3*x4^2+8*x2^7*x3*x4^3+9*x2^7*x3*x4^4+6*x2^7*x3*x4^5+x2^7*x3*x4^6+2*x2^7*x3*x4^7+4*x2^7*x3*x4^9+12*x2^7*x3^2+4*x2^7*x3^2*x4+15*x2^7*x3^2*x4^5+x2^7*x3^2*x4^6+9*x2^7*x3^2*x4^7+x2^7*x3^2*x4^8+x2^7*x3^2*x4^9+12*x2^7*x3^3+14*x2^7*x3^3*x4+8*x2^7*x3^3*x4^2+16*x2^7*x3^3*x4^3+6*x2^7*x3^3*x4^4+8*x2^7*x3^3*x4^5+13*x2^7*x3^3*x4^6+8*x2^7*x3^3*x4^7+13*x2^7*x3^3*x4^8+7*x2^7*x3^4+12*x2^7*x3^4*x4+10*x2^7*x3^4*x4^2+7*x2^7*x3^4*x4^3+14*x2^7*x3^4*x4^4+11*x2^7*x3^4*x4^5+14*x2^7*x3^4*x4^6+2*x2^7*x3^4*x4^7+12*x2^7*x3^4*x4^8+7*x2^7*x3^5+14*x2^7*x3^5*x4+3*x2^7*x3^5*x4^2+14*x2^7*x3^5*x4^3+12*x2^7*x3^5*x4^4+12*x2^7*x3^5*x4^5+12*x2^7*x3^5*x4^6+3*x2^7*x3^5*x4^8+15*x2^7*x3^6*x4+13*x2^7*x3^6*x4^3+9*x2^7*x3^6*x4^4+3*x2^7*x3^6*x4^5+7*x2^7*x3^6*x4^6+13*x2^7*x3^7*x4+15*x2^7*x3^7*x4^4+6*x2^7*x3^7*x4^6+9*x2^7*x3^8*x4+2*x2^7*x3^8*x4^4+9*x2^7*x3^9*x4^4+13*x2^8+x2^8*x4^2+2*x2^8*x4^4+12*x2^8*x4^6+16*x2^8*x3+14*x2^8*x3*x4+2*x2^8*x3*x4^3+10*x2^8*x3*x4^4+3*x2^8*x3*x4^5+9*x2^8*x3*x4^6+6*x2^8*x3*x4^7+2*x2^8*x3*x4^9+15*x2^8*x3^2*x4+15*x2^8*x3^2*x4^2+11*x2^8*x3^2*x4^3+16*x2^8*x3^2*x4^4+15*x2^8*x3^2*x4^5+14*x2^8*x3^2*x4^6+10*x2^8*x3^2*x4^7+9*x2^8*x3^2*x4^8+9*x2^8*x3^2*x4^9+10*x2^8*x3^3*x4^3+16*x2^8*x3^3*x4^4+2*x2^8*x3^3*x4^5+12*x2^8*x3^3*x4^6+4*x2^8*x3^3*x4^7+15*x2^8*x3^3*x4^8+2*x2^8*x3^4+12*x2^8*x3^4*x4+2*x2^8*x3^4*x4^2+4*x2^8*x3^4*x4^3+14*x2^8*x3^4*x4^4+10*x2^8*x3^4*x4^5+16*x2^8*x3^4*x4^6+x2^8*x3^4*x4^7+6*x2^8*x3^4*x4^8+5*x2^8*x3^5+16*x2^8*x3^5*x4+10*x2^8*x3^5*x4^2+7*x2^8*x3^5*x4^3+12*x2^8*x3^5*x4^4+6*x2^8*x3^5*x4^5+4*x2^8*x3^5*x4^6+10*x2^8*x3^5*x4^8+x2^8*x3^6*x4+8*x2^8*x3^6*x4^3+4*x2^8*x3^6*x4^4+10*x2^8*x3^6*x4^5+12*x2^8*x3^6*x4^6+6*x2^8*x3^7*x4+x2^8*x3^7*x4^4+3*x2^8*x3^7*x4^6+13*x2^8*x3^8*x4+x2^8*x3^8*x4^4+13*x2^8*x3^9*x4^4+3*x2^9+6*x2^9*x4^2+2*x2^9*x4^4+5*x2^9*x4^6+3*x2^9*x3+7*x2^9*x3*x4+8*x2^9*x3*x4^2+8*x2^9*x3*x4^3+10*x2^9*x3*x4^4+12*x2^9*x3*x4^5+6*x2^9*x3*x4^7+16*x2^9*x3^2*x4+2*x2^9*x3^2*x4^2+x2^9*x3^2*x4^3+6*x2^9*x3^2*x4^4+8*x2^9*x3^2*x4^5+9*x2^9*x3^2*x4^6+10*x2^9*x3^2*x4^7+16*x2^9*x3^3*x4+2*x2^9*x3^3*x4^2+14*x2^9*x3^3*x4^3+16*x2^9*x3^3*x4^4+6*x2^9*x3^3*x4^5+15*x2^9*x3^3*x4^6+3*x2^9*x3^4+5*x2^9*x3^4*x4+15*x2^9*x3^4*x4^2+10*x2^9*x3^4*x4^3+3*x2^9*x3^4*x4^4+2*x2^9*x3^4*x4^5+6*x2^9*x3^4*x4^6+3*x2^9*x3^5+8*x2^9*x3^5*x4+8*x2^9*x3^5*x4^3+5*x2^9*x3^5*x4^4+10*x2^9*x3^5*x4^6+3*x2^9*x3^6*x4^3+11*x2^9*x3^7*x4+2*x2^10*x4^2+8*x2^10*x4^4+12*x2^10*x4^6+9*x2^10*x3*x4+2*x2^10*x3*x4^2+2*x2^10*x3*x4^3+8*x2^10*x3*x4^4+11*x2^10*x3*x4^5+12*x2^10*x3*x4^6+15*x2^10*x3*x4^7+14*x2^10*x3*x4^9+9*x2^10*x3^2*x4+2*x2^10*x3^2*x4^3+9*x2^10*x3^2*x4^4+5*x2^10*x3^2*x4^5+8*x2^10*x3^2*x4^6+8*x2^10*x3^2*x4^7+12*x2^10*x3^2*x4^8+12*x2^10*x3^2*x4^9+6*x2^10*x3^3*x4+13*x2^10*x3^3*x4^3+16*x2^10*x3^3*x4^4+2*x2^10*x3^3*x4^5+2*x2^10*x3^3*x4^6+11*x2^10*x3^3*x4^7+3*x2^10*x3^3*x4^8+6*x2^10*x3^4*x4+2*x2^10*x3^4*x4^2+13*x2^10*x3^4*x4^3+7*x2^10*x3^4*x4^4+2*x2^10*x3^4*x4^5+x2^10*x3^4*x4^6+7*x2^10*x3^4*x4^7+8*x2^10*x3^4*x4^8+9*x2^10*x3^5*x4+2*x2^10*x3^5*x4^2+4*x2^10*x3^5*x4^3+6*x2^10*x3^5*x4^4+8*x2^10*x3^5*x4^5+13*x2^10*x3^5*x4^6+2*x2^10*x3^5*x4^8+9*x2^10*x3^6*x4+4*x2^10*x3^6*x4^3+2*x2^10*x3^6*x4^4+2*x2^10*x3^6*x4^5+16*x2^10*x3^6*x4^6+6*x2^10*x3^7*x4+9*x2^10*x3^7*x4^4+4*x2^10*x3^7*x4^6+6*x2^10*x3^8*x4+7*x2^10*x3^8*x4^4+6*x2^10*x3^9*x4^4+7*x1+2*x1*x4^2+16*x1*x4^4+4*x1*x4^6+13*x1*x3+2*x1*x3*x4+13*x1*x3*x4^2+x1*x3*x4^3+12*x1*x3*x4^4+2*x1*x3*x4^5+14*x1*x3*x4^7+7*x1*x3^2+x1*x3^2*x4+9*x1*x3^2*x4^2+x1*x3^2*x4^3+12*x1*x3^2*x4^4+13*x1*x3^2*x4^5+3*x1*x3^2*x4^6+12*x1*x3^2*x4^7+8*x1*x3^3+14*x1*x3^3*x4+11*x1*x3^3*x4^2+x1*x3^3*x4^4+5*x1*x3^3*x4^5+5*x1*x3^3*x4^6+14*x1*x3^4+6*x1*x3^4*x4+12*x1*x3^4*x4^2+7*x1*x3^4*x4^4+11*x1*x3^4*x4^5+2*x1*x3^4*x4^6+10*x1*x3^5+2*x1*x3^5*x4+13*x1*x3^5*x4^3+6*x1*x3^5*x4^4+9*x1*x3^5*x4^6+13*x1*x3^6*x4+10*x1*x3^6*x4^3+x1*x3^6*x4^4+2*x1*x3^7*x4+13*x1*x3^7*x4^4+12*x1*x2+2*x1*x2*x4^2+7*x1*x2*x4^4+7*x1*x2*x4^6+x1*x2*x3+16*x1*x2*x3*x4+7*x1*x2*x3*x4^2+12*x1*x2*x3*x4^3+4*x1*x2*x3*x4^4+16*x1*x2*x3*x4^7+15*x1*x2*x3^2+10*x1*x2*x3^2*x4+15*x1*x2*x3^2*x4^2+14*x1*x2*x3^2*x4^3+3*x1*x2*x3^2*x4^4+7*x1*x2*x3^2*x4^5+x1*x2*x3^2*x4^6+4*x1*x2*x3^2*x4^7+13*x1*x2*x3^3+15*x1*x2*x3^3*x4^2+7*x1*x2*x3^3*x4^3+10*x1*x2*x3^3*x4^4+13*x1*x2*x3^3*x4^5+13*x1*x2*x3^3*x4^6+10*x1*x2*x3^4+16*x1*x2*x3^4*x4+4*x1*x2*x3^4*x4^2+16*x1*x2*x3^4*x4^3+13*x1*x2*x3^4*x4^4+15*x1*x2*x3^4*x4^5+12*x1*x2*x3^4*x4^6+9*x1*x2*x3^5+9*x1*x2*x3^5*x4+10*x1*x2*x3^5*x4^3+16*x1*x2*x3^5*x4^4+3*x1*x2*x3^5*x4^6+10*x1*x2*x3^6*x4+9*x1*x2*x3^6*x4^3+6*x1*x2*x3^6*x4^4+12*x1*x2*x3^7*x4+10*x1*x2*x3^7*x4^4+10*x1*x2^2+5*x1*x2^2*x4^2+10*x1*x2^2*x4^4+12*x1*x2^2*x4^6+16*x1*x2^2*x3*x4+15*x1*x2^2*x3*x4^2+11*x1*x2^2*x3*x4^3+2*x1*x2^2*x3*x4^4+12*x1*x2^2*x3*x4^5+8*x1*x2^2*x3*x4^7+9*x1*x2^2*x3^2+2*x1*x2^2*x3^2*x4+3*x1*x2^2*x3^2*x4^2+15*x1*x2^2*x3^2*x4^3+15*x1*x2^2*x3^2*x4^4+15*x1*x2^2*x3^2*x4^5+9*x1*x2^2*x3^2*x4^6+2*x1*x2^2*x3^2*x4^7+16*x1*x2^2*x3^3+10*x1*x2^2*x3^3*x4+16*x1*x2^2*x3^3*x4^2+15*x1*x2^2*x3^3*x4^3+2*x1*x2^2*x3^3*x4^4+15*x1*x2^2*x3^3*x4^5+15*x1*x2^2*x3^3*x4^6+6*x1*x2^2*x3^4*x4+2*x1*x2^2*x3^4*x4^2+9*x1*x2^2*x3^4*x4^3+7*x1*x2^2*x3^4*x4^4+16*x1*x2^2*x3^4*x4^5+6*x1*x2^2*x3^4*x4^6+13*x1*x2^2*x3^5+x1*x2^2*x3^5*x4+5*x1*x2^2*x3^5*x4^3+6*x1*x2^2*x3^5*x4^4+10*x1*x2^2*x3^5*x4^6+5*x1*x2^2*x3^6*x4+13*x1*x2^2*x3^6*x4^3+3*x1*x2^2*x3^6*x4^4+6*x1*x2^2*x3^7*x4+5*x1*x2^2*x3^7*x4^4+15*x1*x2^3+13*x1*x2^3*x4^2+3*x1*x2^3*x4^4+14*x1*x2^3*x4^6+12*x1*x2^3*x3+12*x1*x2^3*x3*x4+10*x1*x2^3*x3*x4^2+8*x1*x2^3*x3*x4^4+x1*x2^3*x3*x4^5+15*x1*x2^3*x3*x4^7+15*x1*x2^3*x3^2+x1*x2^3*x3^2*x4+12*x1*x2^3*x3^2*x4^2+4*x1*x2^3*x3^2*x4^3+15*x1*x2^3*x3^2*x4^4+10*x1*x2^3*x3^2*x4^5+2*x1*x2^3*x3^2*x4^6+8*x1*x2^3*x3^2*x4^7+6*x1*x2^3*x3^3+7*x1*x2^3*x3^3*x4+13*x1*x2^3*x3^3*x4^2+16*x1*x2^3*x3^3*x4^3+x1*x2^3*x3^3*x4^4+9*x1*x2^3*x3^3*x4^5+9*x1*x2^3*x3^3*x4^6+7*x1*x2^3*x3^4+8*x1*x2^3*x3^4*x4+8*x1*x2^3*x3^4*x4^2+12*x1*x2^3*x3^4*x4^3+15*x1*x2^3*x3^4*x4^4+13*x1*x2^3*x3^4*x4^5+7*x1*x2^3*x3^4*x4^6+x1*x2^3*x3^5+7*x1*x2^3*x3^5*x4+3*x1*x2^3*x3^5*x4^3+8*x1*x2^3*x3^5*x4^4+6*x1*x2^3*x3^5*x4^6+3*x1*x2^3*x3^6*x4+x1*x2^3*x3^6*x4^3+12*x1*x2^3*x3^6*x4^4+7*x1*x2^3*x3^7*x4+3*x1*x2^3*x3^7*x4^4+7*x1*x2^4+5*x1*x2^4*x4^2+16*x1*x2^4*x4^4+5*x1*x2^4*x4^6+4*x1*x2^4*x3+14*x1*x2^4*x3*x4+14*x1*x2^4*x3*x4^2+15*x1*x2^4*x3*x4^3+15*x1*x2^4*x3*x4^4+2*x1*x2^4*x3*x4^5+9*x1*x2^4*x3*x4^7+3*x1*x2^4*x3^2+8*x1*x2^4*x3^2*x4+6*x1*x2^4*x3^2*x4^2+6*x1*x2^4*x3^2*x4^3+8*x1*x2^4*x3^2*x4^4+14*x1*x2^4*x3^2*x4^5+8*x1*x2^4*x3^2*x4^6+15*x1*x2^4*x3^2*x4^7+4*x1*x2^4*x3^3+15*x1*x2^4*x3^3*x4+x1*x2^4*x3^3*x4^2+15*x1*x2^4*x3^3*x4^3+8*x1*x2^4*x3^3*x4^4+2*x1*x2^4*x3^3*x4^5+2*x1*x2^4*x3^3*x4^6+9*x1*x2^4*x3^4+12*x1*x2^4*x3^4*x4+15*x1*x2^4*x3^4*x4^2+11*x1*x2^4*x3^4*x4^3+14*x1*x2^4*x3^4*x4^4+x1*x2^4*x3^4*x4^5+11*x1*x2^4*x3^4*x4^6+4*x1*x2^4*x3^5+8*x1*x2^4*x3^5*x4+12*x1*x2^4*x3^5*x4^3+12*x1*x2^4*x3^5*x4^4+7*x1*x2^4*x3^5*x4^6+12*x1*x2^4*x3^6*x4+4*x1*x2^4*x3^6*x4^3+14*x1*x2^4*x3^6*x4^4+11*x1*x2^4*x3^7*x4+12*x1*x2^4*x3^7*x4^4+5*x1*x2^5+6*x1*x2^5*x4^2+16*x1*x2^5*x4^6+6*x1*x2^5*x3+4*x1*x2^5*x3*x4+4*x1*x2^5*x3*x4^2+12*x1*x2^5*x3*x4^3+14*x1*x2^5*x3*x4^4+3*x1*x2^5*x3*x4^5+5*x1*x2^5*x3*x4^7+11*x1*x2^5*x3^2+11*x1*x2^5*x3^2*x4+8*x1*x2^5*x3^2*x4^2+9*x1*x2^5*x3^2*x4^3+8*x1*x2^5*x3^2*x4^4+4*x1*x2^5*x3^2*x4^5+12*x1*x2^5*x3^2*x4^6+14*x1*x2^5*x3^2*x4^7+6*x1*x2^5*x3^3+9*x1*x2^5*x3^3*x4+10*x1*x2^5*x3^3*x4^2+7*x1*x2^5*x3^3*x4^3+11*x1*x2^5*x3^3*x4^4+3*x1*x2^5*x3^3*x4^5+3*x1*x2^5*x3^3*x4^6+8*x1*x2^5*x3^4+6*x1*x2^5*x3^4*x4+14*x1*x2^5*x3^4*x4^2+8*x1*x2^5*x3^4*x4^3+7*x1*x2^5*x3^4*x4^4+10*x1*x2^5*x3^4*x4^5+8*x1*x2^5*x3^4*x4^6+6*x1*x2^5*x3^5+3*x1*x2^5*x3^5*x4+x1*x2^5*x3^5*x4^3+6*x1*x2^5*x3^5*x4^4+2*x1*x2^5*x3^5*x4^6+x1*x2^5*x3^6*x4+6*x1*x2^5*x3^6*x4^3+4*x1*x2^5*x3^6*x4^4+8*x1*x2^5*x3^7*x4+x1*x2^5*x3^7*x4^4+15*x1*x2^6+15*x1*x2^6*x4^2+5*x1*x2^6*x4^4+6*x1*x2^6*x4^6+5*x1*x2^6*x3+5*x1*x2^6*x3*x4+4*x1*x2^6*x3*x4^2+2*x1*x2^6*x3*x4^3+x1*x2^6*x3*x4^4+9*x1*x2^6*x3*x4^5+4*x1*x2^6*x3*x4^7+13*x1*x2^6*x3^2+16*x1*x2^6*x3^2*x4+7*x1*x2^6*x3^2*x4^2+4*x1*x2^6*x3^2*x4^3+8*x1*x2^6*x3^2*x4^4+4*x1*x2^6*x3^2*x4^5+13*x1*x2^6*x3^2*x4^6+x1*x2^6*x3^2*x4^7+5*x1*x2^6*x3^3+2*x1*x2^6*x3^3*x4+8*x1*x2^6*x3^3*x4^2+11*x1*x2^6*x3^3*x4^3+16*x1*x2^6*x3^3*x4^4+16*x1*x2^6*x3^3*x4^5+16*x1*x2^6*x3^3*x4^6+10*x1*x2^6*x3^4+13*x1*x2^6*x3^4*x4+x1*x2^6*x3^4*x4^2+10*x1*x2^6*x3^4*x4^3+x1*x2^6*x3^4*x4^4+8*x1*x2^6*x3^4*x4^5+3*x1*x2^6*x3^4*x4^6+15*x1*x2^6*x3^5+14*x1*x2^6*x3^5*x4+11*x1*x2^6*x3^5*x4^3+13*x1*x2^6*x3^5*x4^4+5*x1*x2^6*x3^5*x4^6+11*x1*x2^6*x3^6*x4+15*x1*x2^6*x3^6*x4^3+10*x1*x2^6*x3^6*x4^4+3*x1*x2^6*x3^7*x4+11*x1*x2^6*x3^7*x4^4+8*x1*x2^7+16*x1*x2^7*x4^2+2*x1*x2^7*x4^4+x1*x2^7*x4^6+6*x1*x2^7*x3+7*x1*x2^7*x3*x4+10*x1*x2^7*x3*x4^2+10*x1*x2^7*x3*x4^3+3*x1*x2^7*x3*x4^4+2*x1*x2^7*x3*x4^5+12*x1*x2^7*x3*x4^7+13*x1*x2^7*x3^2+10*x1*x2^7*x3^2*x4+3*x1*x2^7*x3^2*x4^2+3*x1*x2^7*x3^2*x4^3+8*x1*x2^7*x3^2*x4^4+10*x1*x2^7*x3^2*x4^5+5*x1*x2^7*x3^2*x4^6+3*x1*x2^7*x3^2*x4^7+2*x1*x2^7*x3^3+9*x1*x2^7*x3^3*x4+7*x1*x2^7*x3^3*x4^2+2*x1*x2^7*x3^3*x4^3+10*x1*x2^7*x3^3*x4^4+14*x1*x2^7*x3^3*x4^5+14*x1*x2^7*x3^3*x4^6+4*x1*x2^7*x3^4+8*x1*x2^7*x3^4*x4+3*x1*x2^7*x3^4*x4^2+15*x1*x2^7*x3^4*x4^4+7*x1*x2^7*x3^4*x4^5+9*x1*x2^7*x3^4*x4^6+11*x1*x2^7*x3^5+6*x1*x2^7*x3^5*x4+16*x1*x2^7*x3^5*x4^3+8*x1*x2^7*x3^5*x4^4+15*x1*x2^7*x3^5*x4^6+16*x1*x2^7*x3^6*x4+11*x1*x2^7*x3^6*x4^3+13*x1*x2^7*x3^6*x4^4+9*x1*x2^7*x3^7*x4+16*x1*x2^7*x3^7*x4^4+2*x1*x2^8+14*x1*x2^8*x4^2+12*x1*x2^8*x4^4+9*x1*x2^8*x4^6+7*x1*x2^8*x3+7*x1*x2^8*x3*x4+12*x1*x2^8*x3*x4^2+4*x1*x2^8*x3*x4^3+10*x1*x2^8*x3*x4^4+12*x1*x2^8*x3*x4^5+6*x1*x2^8*x3*x4^7+14*x1*x2^8*x3^2+15*x1*x2^8*x3^2*x4+16*x1*x2^8*x3^2*x4^2+14*x1*x2^8*x3^2*x4^3+10*x1*x2^8*x3^2*x4^4+12*x1*x2^8*x3^2*x4^5+11*x1*x2^8*x3^2*x4^6+10*x1*x2^8*x3^2*x4^7+8*x1*x2^8*x3^3+12*x1*x2^8*x3^3*x4^2+12*x1*x2^8*x3^3*x4^3+15*x1*x2^8*x3^3*x4^4+7*x1*x2^8*x3^3*x4^5+7*x1*x2^8*x3^3*x4^6+x1*x2^8*x3^4+5*x1*x2^8*x3^4*x4+10*x1*x2^8*x3^4*x4^2+7*x1*x2^8*x3^4*x4^3+3*x1*x2^8*x3^4*x4^4+12*x1*x2^8*x3^4*x4^5+13*x1*x2^8*x3^4*x4^6+14*x1*x2^8*x3^5+6*x1*x2^8*x3^5*x4+8*x1*x2^8*x3^5*x4^3+5*x1*x2^8*x3^5*x4^4+16*x1*x2^8*x3^5*x4^6+8*x1*x2^8*x3^6*x4+14*x1*x2^8*x3^6*x4^3+15*x1*x2^8*x3^6*x4^4+13*x1*x2^8*x3^7*x4+8*x1*x2^8*x3^7*x4^4+10*x1*x2^9+12*x1*x2^9*x4^2+8*x1*x2^9*x4^4+3*x1*x2^9*x3+12*x1*x2^9*x3*x4+13*x1*x2^9*x3*x4^2+12*x1*x2^9*x3*x4^3+x1*x2^9*x3*x4^5+11*x1*x2^9*x3^2+15*x1*x2^9*x3^2*x4+3*x1*x2^9*x3^2*x4^2+3*x1*x2^9*x3^2*x4^3+9*x1*x2^9*x3^2*x4^4+13*x1*x2^9*x3^2*x4^5+11*x1*x2^9*x3^3+9*x1*x2^9*x3^3*x4+10*x1*x2^9*x3^3*x4^3+15*x1*x2^9*x3^3*x4^4+7*x1*x2^9*x3^4+10*x1*x2^9*x3^4*x4+11*x1*x2^9*x3^4*x4^3+6*x1*x2^9*x3^4*x4^4+12*x1*x2^9*x3^5*x4+10*x1*x2^9*x3^5*x4^4+13*x1*x2^10+11*x1*x2^10*x4^2+10*x1*x2^10*x4^4+12*x1*x2^10*x4^6+13*x1*x2^10*x3+11*x1*x2^10*x3*x4+9*x1*x2^10*x3*x4^2+x1*x2^10*x3*x4^3+2*x1*x2^10*x3*x4^4+5*x1*x2^10*x3*x4^5+8*x1*x2^10*x3*x4^7+2*x1*x2^10*x3^2*x4+16*x1*x2^10*x3^2*x4^2+11*x1*x2^10*x3^2*x4^3+15*x1*x2^10*x3^2*x4^4+9*x1*x2^10*x3^2*x4^5+9*x1*x2^10*x3^2*x4^6+2*x1*x2^10*x3^2*x4^7+12*x1*x2^10*x3^3*x4+16*x1*x2^10*x3^3*x4^2+6*x1*x2^10*x3^3*x4^3+2*x1*x2^10*x3^3*x4^4+15*x1*x2^10*x3^3*x4^5+15*x1*x2^10*x3^3*x4^6+13*x1*x2^10*x3^4+6*x1*x2^10*x3^4*x4+2*x1*x2^10*x3^4*x4^2+10*x1*x2^10*x3^4*x4^3+7*x1*x2^10*x3^4*x4^4+16*x1*x2^10*x3^4*x4^5+6*x1*x2^10*x3^4*x4^6+13*x1*x2^10*x3^5+14*x1*x2^10*x3^5*x4+5*x1*x2^10*x3^5*x4^3+6*x1*x2^10*x3^5*x4^4+10*x1*x2^10*x3^5*x4^6+5*x1*x2^10*x3^6*x4+13*x1*x2^10*x3^6*x4^3+3*x1*x2^10*x3^6*x4^4+6*x1*x2^10*x3^7*x4+5*x1*x2^10*x3^7*x4^4+14*x1^2+10*x1^2*x4^2+12*x1^2*x4^6+6*x1^2*x3*x4+7*x1^2*x3*x4^2+6*x1^2*x3*x4^3+4*x1^2*x3*x4^4+14*x1^2*x3*x4^5+16*x1^2*x3*x4^7+13*x1^2*x3^2+7*x1^2*x3^2*x4+7*x1^2*x3^2*x4^2+11*x1^2*x3^2*x4^3+x1^2*x3^2*x4^4+7*x1^2*x3^2*x4^5+10*x1^2*x3^2*x4^6+4*x1^2*x3^2*x4^7+3*x1^2*x3^3+5*x1^2*x3^3*x4+4*x1^2*x3^3*x4^2+5*x1^2*x3^3*x4^3+7*x1^2*x3^3*x4^4+x1^2*x3^3*x4^5+11*x1^2*x3^3*x4^6+13*x1^2*x3^4+3*x1^2*x3^4*x4+2*x1^2*x3^4*x4^2+16*x1^2*x3^4*x4^3+12*x1^2*x3^4*x4^4+4*x1^2*x3^4*x4^5+x1^2*x3^4*x4^6+16*x1^2*x3^5+4*x1^2*x3^5*x4+3*x1^2*x3^5*x4^4+13*x1^2*x3^5*x4^6+14*x1^2*x3^6*x4+16*x1^2*x3^6*x4^3+5*x1^2*x3^6*x4^4+6*x1^2*x3^7*x4+14*x1^2*x3^7*x4^4+6*x1^2*x2+9*x1^2*x2*x4^2+4*x1^2*x2*x4^6+7*x1^2*x2*x3+11*x1^2*x2*x3*x4+13*x1^2*x2*x3*x4^3+7*x1^2*x2*x3*x4^4+x1^2*x2*x3*x4^5+11*x1^2*x2*x3*x4^7+15*x1^2*x2*x3^2+8*x1^2*x2*x3^2*x4+6*x1^2*x2*x3^2*x4^2+5*x1^2*x2*x3^2*x4^3+6*x1^2*x2*x3^2*x4^4+9*x1^2*x2*x3^2*x4^6+7*x1^2*x2*x3^2*x4^7+13*x1^2*x2*x3^3+10*x1^2*x2*x3^3*x4+7*x1^2*x2*x3^3*x4^2+10*x1^2*x2*x3^3*x4^3+8*x1^2*x2*x3^3*x4^4+6*x1^2*x2*x3^3*x4^5+15*x1^2*x2*x3^3*x4^6+10*x1^2*x2*x3^4+x1^2*x2*x3^4*x4+12*x1^2*x2*x3^4*x4^2+6*x1^2*x2*x3^4*x4^3+4*x1^2*x2*x3^4*x4^4+7*x1^2*x2*x3^4*x4^5+6*x1^2*x2*x3^4*x4^6+11*x1^2*x2*x3^5+x1^2*x2*x3^5*x4+x1^2*x2*x3^5*x4^4+10*x1^2*x2*x3^5*x4^6+16*x1^2*x2*x3^6*x4+11*x1^2*x2*x3^6*x4^3+13*x1^2*x2*x3^6*x4^4+2*x1^2*x2*x3^7*x4+16*x1^2*x2*x3^7*x4^4+9*x1^2*x2^2+13*x1^2*x2^2*x4^2+11*x1^2*x2^2*x4^4+2*x1^2*x2^2*x4^6+7*x1^2*x2^2*x3+5*x1^2*x2^2*x3*x4+8*x1^2*x2^2*x3*x4^2+16*x1^2*x2^2*x3*x4^3+12*x1^2*x2^2*x3*x4^4+7*x1^2*x2^2*x3*x4^5+14*x1^2*x2^2*x3*x4^7+9*x1^2*x2^2*x3^2+14*x1^2*x2^2*x3^2*x4+15*x1^2*x2^2*x3^2*x4^2+6*x1^2*x2^2*x3^2*x4^3+9*x1^2*x2^2*x3^2*x4^4+8*x1^2*x2^2*x3^2*x4^5+13*x1^2*x2^2*x3^2*x4^6+12*x1^2*x2^2*x3^2*x4^7+3*x1^2*x2^2*x3^3+13*x1^2*x2^2*x3^3*x4+12*x1^2*x2^2*x3^3*x4^2+5*x1^2*x2^2*x3^3*x4^3+14*x1^2*x2^2*x3^3*x4^4+3*x1^2*x2^2*x3^3*x4^5+16*x1^2*x2^2*x3^3*x4^6+7*x1^2*x2^2*x3^4+10*x1^2*x2^2*x3^4*x4+6*x1^2*x2^2*x3^4*x4^2+8*x1^2*x2^2*x3^4*x4^3+6*x1^2*x2^2*x3^4*x4^4+12*x1^2*x2^2*x3^4*x4^5+3*x1^2*x2^2*x3^4*x4^6+14*x1^2*x2^2*x3^5+7*x1^2*x2^2*x3^5*x4+10*x1^2*x2^2*x3^5*x4^4+5*x1^2*x2^2*x3^5*x4^6+8*x1^2*x2^2*x3^6*x4+14*x1^2*x2^2*x3^6*x4^3+15*x1^2*x2^2*x3^6*x4^4+x1^2*x2^2*x3^7*x4+8*x1^2*x2^2*x3^7*x4^4+11*x1^2*x2^3+15*x1^2*x2^3*x4^2+4*x1^2*x2^3*x4^4+8*x1^2*x2^3*x4^6+2*x1^2*x2^3*x3+7*x1^2*x2^3*x3*x4+11*x1^2*x2^3*x3*x4^2+x1^2*x2^3*x3*x4^3+14*x1^2*x2^3*x3*x4^4+12*x1^2*x2^3*x3*x4^5+5*x1^2*x2^3*x3*x4^7+7*x1^2*x2^3*x3^2+8*x1^2*x2^3*x3^2*x4+8*x1^2*x2^3*x3^2*x4^2+15*x1^2*x2^3*x3^2*x4^3+14*x1^2*x2^3*x3^2*x4^4+11*x1^2*x2^3*x3^2*x4^5+x1^2*x2^3*x3^2*x4^6+14*x1^2*x2^3*x3^2*x4^7+11*x1^2*x2^3*x3^3+2*x1^2*x2^3*x3^3*x4+14*x1^2*x2^3*x3^3*x4^2+15*x1^2*x2^3*x3^3*x4^3+8*x1^2*x2^3*x3^3*x4^4+12*x1^2*x2^3*x3^3*x4^5+13*x1^2*x2^3*x3^3*x4^6+11*x1^2*x2^3*x3^4+8*x1^2*x2^3*x3^4*x4+7*x1^2*x2^3*x3^4*x4^2+14*x1^2*x2^3*x3^4*x4^3+15*x1^2*x2^3*x3^4*x4^4+14*x1^2*x2^3*x3^4*x4^5+12*x1^2*x2^3*x3^4*x4^6+5*x1^2*x2^3*x3^5+8*x1^2*x2^3*x3^5*x4+8*x1^2*x2^3*x3^5*x4^4+3*x1^2*x2^3*x3^5*x4^6+15*x1^2*x2^3*x3^6*x4+5*x1^2*x2^3*x3^6*x4^3+9*x1^2*x2^3*x3^6*x4^4+4*x1^2*x2^3*x3^7*x4+15*x1^2*x2^3*x3^7*x4^4+16*x1^2*x2^4+15*x1^2*x2^4*x4^2+8*x1^2*x2^4*x4^4+15*x1^2*x2^4*x4^6+16*x1^2*x2^4*x3+6*x1^2*x2^4*x3*x4+3*x1^2*x2^4*x3*x4^2+3*x1^2*x2^4*x3*x4^3+5*x1^2*x2^4*x3*x4^4+3*x1^2*x2^4*x3*x4^5+3*x1^2*x2^4*x3*x4^7+3*x1^2*x2^4*x3^2+3*x1^2*x2^4*x3^2*x4+9*x1^2*x2^4*x3^2*x4^2+8*x1^2*x2^4*x3^2*x4^4+3*x1^2*x2^4*x3^2*x4^5+4*x1^2*x2^4*x3^2*x4^6+5*x1^2*x2^4*x3^2*x4^7+12*x1^2*x2^4*x3^3+12*x1^2*x2^4*x3^3*x4+5*x1^2*x2^4*x3^3*x4^2+12*x1^2*x2^4*x3^3*x4^3+3*x1^2*x2^4*x3^3*x4^4+14*x1^2*x2^4*x3^3*x4^5+x1^2*x2^4*x3^3*x4^6+8*x1^2*x2^4*x3^4+7*x1^2*x2^4*x3^4*x4+11*x1^2*x2^4*x3^4*x4^2+7*x1^2*x2^4*x3^4*x4^3+11*x1^2*x2^4*x3^4*x4^4+5*x1^2*x2^4*x3^4*x4^5+14*x1^2*x2^4*x3^4*x4^6+3*x1^2*x2^4*x3^5+x1^2*x2^4*x3^5*x4+7*x1^2*x2^4*x3^5*x4^4+12*x1^2*x2^4*x3^5*x4^6+9*x1^2*x2^4*x3^6*x4+3*x1^2*x2^4*x3^6*x4^3+2*x1^2*x2^4*x3^6*x4^4+16*x1^2*x2^4*x3^7*x4+9*x1^2*x2^4*x3^7*x4^4+3*x1^2*x2^5+x1^2*x2^5*x4^2+8*x1^2*x2^5*x4^4+14*x1^2*x2^5*x4^6+15*x1^2*x2^5*x3+13*x1^2*x2^5*x3*x4^2+5*x1^2*x2^5*x3*x4^3+16*x1^2*x2^5*x3*x4^4+13*x1^2*x2^5*x3*x4^5+13*x1^2*x2^5*x3*x4^7+x1^2*x2^5*x3^2+3*x1^2*x2^5*x3^2*x4+2*x1^2*x2^5*x3^2*x4^2+8*x1^2*x2^5*x3^2*x4^3+6*x1^2*x2^5*x3^2*x4^4+13*x1^2*x2^5*x3^2*x4^5+6*x1^2*x2^5*x3^2*x4^6+16*x1^2*x2^5*x3^2*x4^7+x1^2*x2^5*x3^3+14*x1^2*x2^5*x3^3*x4+16*x1^2*x2^5*x3^3*x4^2+14*x1^2*x2^5*x3^3*x4^3+3*x1^2*x2^5*x3^3*x4^4+4*x1^2*x2^5*x3^3*x4^5+10*x1^2*x2^5*x3^3*x4^6+4*x1^2*x2^5*x3^4+x1^2*x2^5*x3^4*x4+8*x1^2*x2^5*x3^4*x4^2+2*x1^2*x2^5*x3^4*x4^3+4*x1^2*x2^5*x3^4*x4^4+16*x1^2*x2^5*x3^4*x4^5+4*x1^2*x2^5*x3^4*x4^6+13*x1^2*x2^5*x3^5+x1^2*x2^5*x3^5*x4^4+x1^2*x2^5*x3^5*x4^6+5*x1^2*x2^5*x3^6*x4+13*x1^2*x2^5*x3^6*x4^3+3*x1^2*x2^5*x3^6*x4^4+7*x1^2*x2^5*x3^7*x4+5*x1^2*x2^5*x3^7*x4^4+6*x1^2*x2^6+13*x1^2*x2^6*x4^2+x1^2*x2^6*x4^6+9*x1^2*x2^6*x3+16*x1^2*x2^6*x3*x4+10*x1^2*x2^6*x3*x4^2+13*x1^2*x2^6*x3*x4^3+6*x1^2*x2^6*x3*x4^4+2*x1^2*x2^6*x3*x4^5+7*x1^2*x2^6*x3*x4^7+10*x1^2*x2^6*x3^2+2*x1^2*x2^6*x3^2*x4+6*x1^2*x2^6*x3^2*x4^2+10*x1^2*x2^6*x3^2*x4^4+10*x1^2*x2^6*x3^2*x4^5+15*x1^2*x2^6*x3^2*x4^6+6*x1^2*x2^6*x3^2*x4^7+12*x1^2*x2^6*x3^3+3*x1^2*x2^6*x3^3*x4+6*x1^2*x2^6*x3^3*x4^2+2*x1^2*x2^6*x3^3*x4^3+2*x1^2*x2^6*x3^3*x4^4+10*x1^2*x2^6*x3^3*x4^5+8*x1^2*x2^6*x3^3*x4^6+4*x1^2*x2^6*x3^4+13*x1^2*x2^6*x3^4*x4+3*x1^2*x2^6*x3^4*x4^2+6*x1^2*x2^6*x3^4*x4^3+x1^2*x2^6*x3^4*x4^4+6*x1^2*x2^6*x3^4*x4^5+10*x1^2*x2^6*x3^4*x4^6+7*x1^2*x2^6*x3^5+15*x1^2*x2^6*x3^5*x4+13*x1^2*x2^6*x3^5*x4^4+11*x1^2*x2^6*x3^5*x4^6+4*x1^2*x2^6*x3^6*x4+7*x1^2*x2^6*x3^6*x4^3+16*x1^2*x2^6*x3^6*x4^4+9*x1^2*x2^6*x3^7*x4+4*x1^2*x2^6*x3^7*x4^4+10*x1^2*x2^7+10*x1^2*x2^7*x4^2+5*x1^2*x2^7*x4^4+3*x1^2*x2^7*x4^6+4*x1^2*x2^7*x3+9*x1^2*x2^7*x3*x4+15*x1^2*x2^7*x3*x4^2+13*x1^2*x2^7*x3*x4^3+x1^2*x2^7*x3*x4^4+14*x1^2*x2^7*x3*x4^5+4*x1^2*x2^7*x3*x4^7+15*x1^2*x2^7*x3^2+8*x1^2*x2^7*x3^2*x4+6*x1^2*x2^7*x3^2*x4^2+11*x1^2*x2^7*x3^2*x4^3+4*x1^2*x2^7*x3^2*x4^4+15*x1^2*x2^7*x3^2*x4^5+11*x1^2*x2^7*x3^2*x4^6+x1^2*x2^7*x3^2*x4^7+5*x1^2*x2^7*x3^3+16*x1^2*x2^7*x3^3*x4+x1^2*x2^7*x3^3*x4^2+11*x1^2*x2^7*x3^3*x4^3+8*x1^2*x2^7*x3^3*x4^4+13*x1^2*x2^7*x3^3*x4^5+7*x1^2*x2^7*x3^3*x4^6+12*x1^2*x2^7*x3^4*x4+9*x1^2*x2^7*x3^4*x4^2+4*x1^2*x2^7*x3^4*x4^3+14*x1^2*x2^7*x3^4*x4^4+x1^2*x2^7*x3^4*x4^5+13*x1^2*x2^7*x3^4*x4^6+4*x1^2*x2^7*x3^5+16*x1^2*x2^7*x3^5*x4+12*x1^2*x2^7*x3^5*x4^4+16*x1^2*x2^7*x3^5*x4^6+12*x1^2*x2^7*x3^6*x4+4*x1^2*x2^7*x3^6*x4^3+14*x1^2*x2^7*x3^6*x4^4+10*x1^2*x2^7*x3^7*x4+12*x1^2*x2^7*x3^7*x4^4+16*x1^2*x2^8+5*x1^2*x2^8*x4^2+x1^2*x2^8*x4^4+10*x1^2*x2^8*x4^6+9*x1^2*x2^8*x3+9*x1^2*x2^8*x3*x4+8*x1^2*x2^8*x3*x4^2+10*x1^2*x2^8*x3*x4^3+9*x1^2*x2^8*x3*x4^4+9*x1^2*x2^8*x3*x4^5+2*x1^2*x2^8*x3*x4^7+x1^2*x2^8*x3^2+11*x1^2*x2^8*x3^2*x4+7*x1^2*x2^8*x3^2*x4^2+4*x1^2*x2^8*x3^2*x4^3+13*x1^2*x2^8*x3^2*x4^4+8*x1^2*x2^8*x3^2*x4^5+14*x1^2*x2^8*x3^2*x4^6+9*x1^2*x2^8*x3^2*x4^7+12*x1^2*x2^8*x3^3+2*x1^2*x2^8*x3^3*x4+9*x1^2*x2^8*x3^3*x4^2+13*x1^2*x2^8*x3^3*x4^3+11*x1^2*x2^8*x3^3*x4^4+15*x1^2*x2^8*x3^3*x4^5+12*x1^2*x2^8*x3^3*x4^6+9*x1^2*x2^8*x3^4+5*x1^2*x2^8*x3^4*x4+13*x1^2*x2^8*x3^4*x4^2+3*x1^2*x2^8*x3^4*x4^3+3*x1^2*x2^8*x3^4*x4^4+9*x1^2*x2^8*x3^4*x4^5+15*x1^2*x2^8*x3^4*x4^6+2*x1^2*x2^8*x3^5+2*x1^2*x2^8*x3^5*x4+5*x1^2*x2^8*x3^5*x4^4+8*x1^2*x2^8*x3^5*x4^6+6*x1^2*x2^8*x3^6*x4+2*x1^2*x2^8*x3^6*x4^3+7*x1^2*x2^8*x3^6*x4^4+5*x1^2*x2^8*x3^7*x4+6*x1^2*x2^8*x3^7*x4^4+2*x1^2*x2^9+15*x1^2*x2^9*x4^2+x1^2*x2^9*x4^4+5*x1^2*x2^9*x3+6*x1^2*x2^9*x3*x4+16*x1^2*x2^9*x3*x4^2+15*x1^2*x2^9*x3*x4^3+13*x1^2*x2^9*x3*x4^5+7*x1^2*x2^9*x3^2+11*x1^2*x2^9*x3^2*x4+11*x1^2*x2^9*x3^2*x4^2+5*x1^2*x2^9*x3^2*x4^3+10*x1^2*x2^9*x3^2*x4^4+16*x1^2*x2^9*x3^2*x4^5+4*x1^2*x2^9*x3^3+9*x1^2*x2^9*x3^3*x4+7*x1^2*x2^9*x3^3*x4^3+11*x1^2*x2^9*x3^3*x4^4+12*x1^2*x2^9*x3^4+13*x1^2*x2^9*x3^4*x4+4*x1^2*x2^9*x3^4*x4^3+x1^2*x2^9*x3^4*x4^4+9*x1^2*x2^9*x3^5*x4+13*x1^2*x2^9*x3^5*x4^4+11*x1^2*x2^10+2*x1^2*x2^10*x4^2+4*x1^2*x2^10*x4^4+2*x1^2*x2^10*x4^6+15*x1^2*x2^10*x3+12*x1^2*x2^10*x3*x4+4*x1^2*x2^10*x3*x4^2+12*x1^2*x2^10*x3*x4^3+12*x1^2*x2^10*x3*x4^4+8*x1^2*x2^10*x3*x4^5+14*x1^2*x2^10*x3*x4^7+8*x1^2*x2^10*x3^2+11*x1^2*x2^10*x3^2*x4^2+14*x1^2*x2^10*x3^2*x4^3+4*x1^2*x2^10*x3^2*x4^4+4*x1^2*x2^10*x3^2*x4^5+13*x1^2*x2^10*x3^2*x4^6+12*x1^2*x2^10*x3^2*x4^7+8*x1^2*x2^10*x3^3+2*x1^2*x2^10*x3^3*x4+12*x1^2*x2^10*x3^3*x4^2+x1^2*x2^10*x3^3*x4^3+3*x1^2*x2^10*x3^3*x4^5+16*x1^2*x2^10*x3^3*x4^6+10*x1^2*x2^10*x3^4+12*x1^2*x2^10*x3^4*x4+6*x1^2*x2^10*x3^4*x4^2+13*x1^2*x2^10*x3^4*x4^3+14*x1^2*x2^10*x3^4*x4^4+12*x1^2*x2^10*x3^4*x4^5+3*x1^2*x2^10*x3^4*x4^6+14*x1^2*x2^10*x3^5+6*x1^2*x2^10*x3^5*x4+12*x1^2*x2^10*x3^5*x4^4+5*x1^2*x2^10*x3^5*x4^6+8*x1^2*x2^10*x3^6*x4+14*x1^2*x2^10*x3^6*x4^3+15*x1^2*x2^10*x3^6*x4^4+x1^2*x2^10*x3^7*x4+8*x1^2*x2^10*x3^7*x4^4+16*x1^3+3*x1^3*x4^2+15*x1^3*x4^4+3*x1^3*x4^6+8*x1^3*x3+2*x1^3*x3*x4+5*x1^3*x3*x4^2+2*x1^3*x3*x4^3+4*x1^3*x3*x4^4+8*x1^3*x3*x4^5+16*x1^3*x3*x4^7+3*x1^3*x3^2+9*x1^3*x3^2*x4+12*x1^3*x3^2*x4^2+2*x1^3*x3^2*x4^3+8*x1^3*x3^2*x4^4+5*x1^3*x3^2*x4^5+10*x1^3*x3^2*x4^6+4*x1^3*x3^2*x4^7+4*x1^3*x3^3+2*x1^3*x3^3*x4+12*x1^3*x3^3*x4^2+6*x1^3*x3^3*x4^3+9*x1^3*x3^3*x4^4+6*x1^3*x3^3*x4^5+11*x1^3*x3^3*x4^6+14*x1^3*x3^4+12*x1^3*x3^4*x4+9*x1^3*x3^4*x4^2+14*x1^3*x3^4*x4^4+12*x1^3*x3^4*x4^5+x1^3*x3^4*x4^6+16*x1^3*x3^5+6*x1^3*x3^5*x4+14*x1^3*x3^5*x4^3+12*x1^3*x3^5*x4^4+13*x1^3*x3^5*x4^6+4*x1^3*x3^6*x4+16*x1^3*x3^6*x4^3+16*x1^3*x3^6*x4^4+10*x1^3*x3^7*x4+4*x1^3*x3^7*x4^4+7*x1^3*x2+13*x1^3*x2*x4^2+6*x1^3*x2*x4^4+x1^3*x2*x4^6+11*x1^3*x2*x3+10*x1^3*x2*x3*x4+10*x1^3*x2*x3*x4^2+7*x1^3*x2*x3*x4^3+7*x1^3*x2*x3*x4^4+2*x1^3*x2*x3*x4^5+11*x1^3*x2*x3*x4^7+10*x1^3*x2*x3^2+10*x1^3*x2*x3^2*x4^2+9*x1^3*x2*x3^2*x4^3+2*x1^3*x2*x3^2*x4^4+10*x1^3*x2*x3^2*x4^5+9*x1^3*x2*x3^2*x4^6+7*x1^3*x2*x3^2*x4^7+9*x1^3*x2*x3^3+3*x1^3*x2*x3^3*x4+4*x1^3*x2*x3^3*x4^2+9*x1^3*x2*x3^3*x4^3+2*x1^3*x2*x3^3*x4^5+15*x1^3*x2*x3^3*x4^6+3*x1^3*x2*x3^4+2*x1^3*x2*x3^4*x4+3*x1^3*x2*x3^4*x4^2+2*x1^3*x2*x3^4*x4^3+8*x1^3*x2*x3^4*x4^4+4*x1^3*x2*x3^4*x4^5+6*x1^3*x2*x3^4*x4^6+11*x1^3*x2*x3^5+12*x1^3*x2*x3^5*x4+16*x1^3*x2*x3^5*x4^3+2*x1^3*x2*x3^5*x4^4+10*x1^3*x2*x3^5*x4^6+7*x1^3*x2*x3^6*x4+11*x1^3*x2*x3^6*x4^3+11*x1^3*x2*x3^6*x4^4+9*x1^3*x2*x3^7*x4+7*x1^3*x2*x3^7*x4^4+4*x1^3*x2^2+15*x1^3*x2^2*x4^2+10*x1^3*x2^2*x4^4+9*x1^3*x2^2*x4^6+9*x1^3*x2^2*x3+9*x1^3*x2^2*x3*x4+14*x1^3*x2^2*x3*x4^2+10*x1^3*x2^2*x3*x4^3+12*x1^3*x2^2*x3*x4^4+3*x1^3*x2^2*x3*x4^5+14*x1^3*x2^2*x3*x4^7+x1^3*x2^2*x3^2+6*x1^3*x2^2*x3^2*x4+8*x1^3*x2^2*x3^2*x4^2+8*x1^3*x2^2*x3^2*x4^3+8*x1^3*x2^2*x3^2*x4^4+14*x1^3*x2^2*x3^2*x4^5+13*x1^3*x2^2*x3^2*x4^6+12*x1^3*x2^2*x3^2*x4^7+9*x1^3*x2^2*x3^3+2*x1^3*x2^2*x3^3*x4+2*x1^3*x2^2*x3^3*x4^2+9*x1^3*x2^2*x3^3*x4^3+6*x1^3*x2^2*x3^3*x4^4+x1^3*x2^2*x3^3*x4^5+16*x1^3*x2^2*x3^3*x4^6+2*x1^3*x2^2*x3^4+5*x1^3*x2^2*x3^4*x4+10*x1^3*x2^2*x3^4*x4^2+14*x1^3*x2^2*x3^4*x4^3+3*x1^3*x2^2*x3^4*x4^4+2*x1^3*x2^2*x3^4*x4^5+3*x1^3*x2^2*x3^4*x4^6+14*x1^3*x2^2*x3^5+14*x1^3*x2^2*x3^5*x4+8*x1^3*x2^2*x3^5*x4^3+5*x1^3*x2^2*x3^5*x4^4+5*x1^3*x2^2*x3^5*x4^6+12*x1^3*x2^2*x3^6*x4+14*x1^3*x2^2*x3^6*x4^3+14*x1^3*x2^2*x3^6*x4^4+13*x1^3*x2^2*x3^7*x4+12*x1^3*x2^2*x3^7*x4^4+14*x1^3*x2^3+16*x1^3*x2^3*x4^2+9*x1^3*x2^3*x4^4+2*x1^3*x2^3*x4^6+13*x1^3*x2^3*x3+14*x1^3*x2^3*x3*x4+6*x1^3*x2^3*x3*x4^2+11*x1^3*x2^3*x3*x4^3+14*x1^3*x2^3*x3*x4^4+16*x1^3*x2^3*x3*x4^5+5*x1^3*x2^3*x3*x4^7+10*x1^3*x2^3*x3^2+7*x1^3*x2^3*x3^2*x4+10*x1^3*x2^3*x3^2*x4^2+9*x1^3*x2^3*x3^2*x4^3+15*x1^3*x2^3*x3^2*x4^4+6*x1^3*x2^3*x3^2*x4^5+x1^3*x2^3*x3^2*x4^6+14*x1^3*x2^3*x3^2*x4^7+7*x1^3*x2^3*x3^3+16*x1^3*x2^3*x3^3*x4+8*x1^3*x2^3*x3^3*x4^2+13*x1^3*x2^3*x3^3*x4^3+7*x1^3*x2^3*x3^3*x4^4+4*x1^3*x2^3*x3^3*x4^5+13*x1^3*x2^3*x3^3*x4^6+9*x1^3*x2^3*x3^4+3*x1^3*x2^3*x3^4*x4+6*x1^3*x2^3*x3^4*x4^2+10*x1^3*x2^3*x3^4*x4^3+12*x1^3*x2^3*x3^4*x4^4+8*x1^3*x2^3*x3^4*x4^5+12*x1^3*x2^3*x3^4*x4^6+5*x1^3*x2^3*x3^5+5*x1^3*x2^3*x3^5*x4+15*x1^3*x2^3*x3^5*x4^3+3*x1^3*x2^3*x3^5*x4^4+3*x1^3*x2^3*x3^5*x4^6+14*x1^3*x2^3*x3^6*x4+5*x1^3*x2^3*x3^6*x4^3+5*x1^3*x2^3*x3^6*x4^4+x1^3*x2^3*x3^7*x4+14*x1^3*x2^3*x3^7*x4^4+4*x1^3*x2^4+13*x1^3*x2^4*x4^2+4*x1^3*x2^4*x4^4+8*x1^3*x2^4*x4^6+14*x1^3*x2^4*x3+x1^3*x2^4*x3*x4^2+x1^3*x2^4*x3*x4^3+5*x1^3*x2^4*x3*x4^4+6*x1^3*x2^4*x3*x4^5+3*x1^3*x2^4*x3*x4^7+15*x1^3*x2^4*x3^2+12*x1^3*x2^4*x3^2*x4+5*x1^3*x2^4*x3^2*x4^2+15*x1^3*x2^4*x3^2*x4^3+13*x1^3*x2^4*x3^2*x4^4+x1^3*x2^4*x3^2*x4^5+4*x1^3*x2^4*x3^2*x4^6+5*x1^3*x2^4*x3^2*x4^7+16*x1^3*x2^4*x3^3+4*x1^3*x2^4*x3^3*x4+15*x1^3*x2^4*x3^3*x4^2+3*x1^3*x2^4*x3^3*x4^3+12*x1^3*x2^4*x3^3*x4^4+16*x1^3*x2^4*x3^3*x4^5+x1^3*x2^4*x3^3*x4^6+9*x1^3*x2^4*x3^4+7*x1^3*x2^4*x3^4*x4+7*x1^3*x2^4*x3^4*x4^2+11*x1^3*x2^4*x3^4*x4^3+11*x1^3*x2^4*x3^4*x4^4+15*x1^3*x2^4*x3^4*x4^5+14*x1^3*x2^4*x3^4*x4^6+3*x1^3*x2^4*x3^5+3*x1^3*x2^4*x3^5*x4+9*x1^3*x2^4*x3^5*x4^3+7*x1^3*x2^4*x3^5*x4^4+12*x1^3*x2^4*x3^5*x4^6+5*x1^3*x2^4*x3^6*x4+3*x1^3*x2^4*x3^6*x4^3+3*x1^3*x2^4*x3^6*x4^4+4*x1^3*x2^4*x3^7*x4+5*x1^3*x2^4*x3^7*x4^4+2*x1^3*x2^5+5*x1^3*x2^5*x4^4+12*x1^3*x2^5*x4^6+5*x1^3*x2^5*x3+11*x1^3*x2^5*x3*x4+4*x1^3*x2^5*x3*x4^2+4*x1^3*x2^5*x3*x4^3+16*x1^3*x2^5*x3*x4^4+2*x1^3*x2^5*x3*x4^5+13*x1^3*x2^5*x3*x4^7+15*x1^3*x2^5*x3^2*x4+11*x1^3*x2^5*x3^2*x4^2+15*x1^3*x2^5*x3^2*x4^3+16*x1^3*x2^5*x3^2*x4^4+4*x1^3*x2^5*x3^2*x4^5+6*x1^3*x2^5*x3^2*x4^6+16*x1^3*x2^5*x3^2*x4^7+9*x1^3*x2^5*x3^3+11*x1^3*x2^5*x3^3*x4+14*x1^3*x2^5*x3^3*x4^2+3*x1^3*x2^5*x3^3*x4^3+15*x1^3*x2^5*x3^3*x4^4+7*x1^3*x2^5*x3^3*x4^5+10*x1^3*x2^5*x3^3*x4^6+3*x1^3*x2^5*x3^4+2*x1^3*x2^5*x3^4*x4^2+10*x1^3*x2^5*x3^4*x4^3+14*x1^3*x2^5*x3^4*x4^5+4*x1^3*x2^5*x3^4*x4^6+13*x1^3*x2^5*x3^5+2*x1^3*x2^5*x3^5*x4+5*x1^3*x2^5*x3^5*x4^3+x1^3*x2^5*x3^5*x4^6+16*x1^3*x2^5*x3^6*x4+13*x1^3*x2^5*x3^6*x4^3+13*x1^3*x2^5*x3^6*x4^4+6*x1^3*x2^5*x3^7*x4+16*x1^3*x2^5*x3^7*x4^4+13*x1^3*x2^6+4*x1^3*x2^6*x4^2+6*x1^3*x2^6*x4^4+13*x1^3*x2^6*x4^6+6*x1^3*x2^6*x3+4*x1^3*x2^6*x3*x4+6*x1^3*x2^6*x3*x4^2+6*x1^3*x2^6*x3*x4^4+6*x1^3*x2^6*x3*x4^5+7*x1^3*x2^6*x3*x4^7+9*x1^3*x2^6*x3^2*x4+x1^3*x2^6*x3^2*x4^2+14*x1^3*x2^6*x3^2*x4^3+11*x1^3*x2^6*x3^2*x4^4+6*x1^3*x2^6*x3^2*x4^5+15*x1^3*x2^6*x3^2*x4^6+6*x1^3*x2^6*x3^2*x4^7+6*x1^3*x2^6*x3^3+10*x1^3*x2^6*x3^3*x4+x1^3*x2^6*x3^3*x4^2+6*x1^3*x2^6*x3^3*x4^3+9*x1^3*x2^6*x3^3*x4^4+9*x1^3*x2^6*x3^3*x4^5+8*x1^3*x2^6*x3^3*x4^6+15*x1^3*x2^6*x3^4*x4+5*x1^3*x2^6*x3^4*x4^2+9*x1^3*x2^6*x3^4*x4^4+x1^3*x2^6*x3^4*x4^5+10*x1^3*x2^6*x3^4*x4^6+7*x1^3*x2^6*x3^5+4*x1^3*x2^6*x3^5*x4^3+15*x1^3*x2^6*x3^5*x4^4+11*x1^3*x2^6*x3^5*x4^6+6*x1^3*x2^6*x3^6*x4+7*x1^3*x2^6*x3^6*x4^3+7*x1^3*x2^6*x3^6*x4^4+15*x1^3*x2^6*x3^7*x4+6*x1^3*x2^6*x3^7*x4^4+14*x1^3*x2^7+10*x1^3*x2^7*x4^2+13*x1^3*x2^7*x4^4+5*x1^3*x2^7*x4^6+6*x1^3*x2^7*x3+9*x1^3*x2^7*x3*x4+10*x1^3*x2^7*x3*x4^2+14*x1^3*x2^7*x3*x4^3+x1^3*x2^7*x3*x4^4+3*x1^3*x2^7*x3*x4^5+4*x1^3*x2^7*x3*x4^7+16*x1^3*x2^7*x3^2+x1^3*x2^7*x3^2*x4+4*x1^3*x2^7*x3^2*x4^2+13*x1^3*x2^7*x3^2*x4^3+14*x1^3*x2^7*x3^2*x4^4+10*x1^3*x2^7*x3^2*x4^5+11*x1^3*x2^7*x3^2*x4^6+x1^3*x2^7*x3^2*x4^7+10*x1^3*x2^7*x3^3+6*x1^3*x2^7*x3^3*x4+3*x1^3*x2^7*x3^3*x4^2+16*x1^3*x2^7*x3^3*x4^3+x1^3*x2^7*x3^3*x4^4+10*x1^3*x2^7*x3^3*x4^5+7*x1^3*x2^7*x3^3*x4^6+6*x1^3*x2^7*x3^4+5*x1^3*x2^7*x3^4*x4+15*x1^3*x2^7*x3^4*x4^2+9*x1^3*x2^7*x3^4*x4^3+3*x1^3*x2^7*x3^4*x4^4+3*x1^3*x2^7*x3^4*x4^5+13*x1^3*x2^7*x3^4*x4^6+4*x1^3*x2^7*x3^5+8*x1^3*x2^7*x3^5*x4+12*x1^3*x2^7*x3^5*x4^3+5*x1^3*x2^7*x3^5*x4^4+16*x1^3*x2^7*x3^5*x4^6+x1^3*x2^7*x3^6*x4+4*x1^3*x2^7*x3^6*x4^3+4*x1^3*x2^7*x3^6*x4^4+11*x1^3*x2^7*x3^7*x4+x1^3*x2^7*x3^7*x4^4+13*x1^3*x2^8+6*x1^3*x2^8*x4^2+16*x1^3*x2^8*x4^4+11*x1^3*x2^8*x4^6+7*x1^3*x2^8*x3+16*x1^3*x2^8*x3*x4+9*x1^3*x2^8*x3*x4^2+x1^3*x2^8*x3*x4^3+9*x1^3*x2^8*x3*x4^4+9*x1^3*x2^8*x3*x4^5+2*x1^3*x2^8*x3*x4^7+6*x1^3*x2^8*x3^2+2*x1^3*x2^8*x3^2*x4+13*x1^3*x2^8*x3^2*x4^2+2*x1^3*x2^8*x3^2*x4^3+13*x1^3*x2^8*x3^2*x4^4+9*x1^3*x2^8*x3^2*x4^5+14*x1^3*x2^8*x3^2*x4^6+9*x1^3*x2^8*x3^2*x4^7+7*x1^3*x2^8*x3^3+10*x1^3*x2^8*x3^3*x4+10*x1^3*x2^8*x3^3*x4^2+7*x1^3*x2^8*x3^3*x4^3+2*x1^3*x2^8*x3^3*x4^4+5*x1^3*x2^8*x3^3*x4^5+12*x1^3*x2^8*x3^3*x4^6+15*x1^3*x2^8*x3^4+12*x1^3*x2^8*x3^4*x4+16*x1^3*x2^8*x3^4*x4^2+15*x1^3*x2^8*x3^4*x4^3+14*x1^3*x2^8*x3^4*x4^4+10*x1^3*x2^8*x3^4*x4^5+15*x1^3*x2^8*x3^4*x4^6+2*x1^3*x2^8*x3^5+13*x1^3*x2^8*x3^5*x4+6*x1^3*x2^8*x3^5*x4^3+12*x1^3*x2^8*x3^5*x4^4+8*x1^3*x2^8*x3^5*x4^6+9*x1^3*x2^8*x3^6*x4+2*x1^3*x2^8*x3^6*x4^3+2*x1^3*x2^8*x3^6*x4^4+14*x1^3*x2^8*x3^7*x4+9*x1^3*x2^8*x3^7*x4^4+4*x1^3*x2^9+2*x1^3*x2^9*x4^2+4*x1^3*x2^9*x4^4+11*x1^3*x2^9*x3+7*x1^3*x2^9*x3*x4+3*x1^3*x2^9*x3*x4^2+x1^3*x2^9*x3*x4^3+12*x1^3*x2^9*x3*x4^5+14*x1^3*x2^9*x3^2+12*x1^3*x2^9*x3^2*x4+8*x1^3*x2^9*x3^2*x4^2+11*x1^3*x2^9*x3^2*x4^3+14*x1^3*x2^9*x3^2*x4^4+3*x1^3*x2^9*x3^2*x4^5+6*x1^3*x2^9*x3^3+15*x1^3*x2^9*x3^3*x4+x1^3*x2^9*x3^3*x4^3+12*x1^3*x2^9*x3^3*x4^4+x1^3*x2^9*x3^4+8*x1^3*x2^9*x3^4*x4+6*x1^3*x2^9*x3^4*x4^3+15*x1^3*x2^9*x3^4*x4^4+5*x1^3*x2^9*x3^5*x4+8*x1^3*x2^9*x3^5*x4^4+5*x1^3*x2^10+x1^3*x2^10*x4^2+2*x1^3*x2^10*x4^4+9*x1^3*x2^10*x4^6+2*x1^3*x2^10*x3+5*x1^3*x2^10*x3*x4+11*x1^3*x2^10*x3*x4^2+10*x1^3*x2^10*x3*x4^3+12*x1^3*x2^10*x3*x4^4+8*x1^3*x2^10*x3*x4^5+14*x1^3*x2^10*x3*x4^7+3*x1^3*x2^10*x3^2+5*x1^3*x2^10*x3^2*x4+11*x1^3*x2^10*x3^2*x4^2+x1^3*x2^10*x3^2*x4^3+4*x1^3*x2^10*x3^2*x4^4+11*x1^3*x2^10*x3^2*x4^5+13*x1^3*x2^10*x3^2*x4^6+12*x1^3*x2^10*x3^2*x4^7+12*x1^3*x2^10*x3^3+2*x1^3*x2^10*x3^3*x4+2*x1^3*x2^10*x3^3*x4^2+5*x1^3*x2^10*x3^3*x4^4+x1^3*x2^10*x3^3*x4^5+16*x1^3*x2^10*x3^3*x4^6+16*x1^3*x2^10*x3^4+10*x1^3*x2^10*x3^4*x4+10*x1^3*x2^10*x3^4*x4^2+6*x1^3*x2^10*x3^4*x4^4+2*x1^3*x2^10*x3^4*x4^5+3*x1^3*x2^10*x3^4*x4^6+14*x1^3*x2^10*x3^5+12*x1^3*x2^10*x3^5*x4+8*x1^3*x2^10*x3^5*x4^3+10*x1^3*x2^10*x3^5*x4^4+5*x1^3*x2^10*x3^5*x4^6+12*x1^3*x2^10*x3^6*x4+14*x1^3*x2^10*x3^6*x4^3+14*x1^3*x2^10*x3^6*x4^4+13*x1^3*x2^10*x3^7*x4+12*x1^3*x2^10*x3^7*x4^4+13*x1^4+2*x1^4*x4^2+8*x1^4*x4^4+2*x1^4*x3+14*x1^4*x3*x4+16*x1^4*x3*x4^2+9*x1^4*x3*x4^3+13*x1^4*x3*x4^5+11*x1^4*x3^2+16*x1^4*x3^2*x4+11*x1^4*x3^2*x4^2+2*x1^4*x3^2*x4^3+13*x1^4*x3^2*x4^4+16*x1^4*x3^2*x4^5+15*x1^4*x3^3+3*x1^4*x3^3*x4+4*x1^4*x3^3*x4^3+16*x1^4*x3^3*x4^4+12*x1^4*x3^4+5*x1^4*x3^4*x4+15*x1^4*x3^4*x4^3+3*x1^4*x3^4*x4^4+9*x1^4*x3^5*x4+5*x1^4*x3^5*x4^4+15*x1^4*x2+15*x1^4*x2*x4^2+14*x1^4*x2*x4^4+10*x1^4*x2*x3*x4+11*x1^4*x2*x3*x4^2+6*x1^4*x2*x3*x4^3+10*x1^4*x2*x3*x4^5+2*x1^4*x2*x3^2+11*x1^4*x2*x3^2*x4+15*x1^4*x2*x3^2*x4^2+10*x1^4*x2*x3^2*x4^4+11*x1^4*x2*x3^2*x4^5+5*x1^4*x2*x3^3+14*x1^4*x2*x3^3*x4+7*x1^4*x2*x3^3*x4^3+11*x1^4*x2*x3^3*x4^4+4*x1^4*x2*x3^4+13*x1^4*x2*x3^4*x4+5*x1^4*x2*x3^4*x4^3+x1^4*x2*x3^4*x4^4+3*x1^4*x2*x3^5*x4+13*x1^4*x2*x3^5*x4^4+13*x1^4*x2^2+13*x1^4*x2^2*x4^2+7*x1^4*x2^2*x4^4+8*x1^4*x2^2*x3+9*x1^4*x2^2*x3*x4+14*x1^4*x2^2*x3*x4^2+x1^4*x2^2*x3*x4^3+5*x1^4*x2^2*x3*x4^5+14*x1^4*x2^2*x3^2*x4+16*x1^4*x2^2*x3^2*x4^2+8*x1^4*x2^2*x3^2*x4^3+5*x1^4*x2^2*x3^2*x4^4+14*x1^4*x2^2*x3^2*x4^5+11*x1^4*x2^2*x3^3+4*x1^4*x2^2*x3^3*x4+12*x1^4*x2^2*x3^3*x4^3+14*x1^4*x2^2*x3^3*x4^4+2*x1^4*x2^2*x3^4+15*x1^4*x2^2*x3^4*x4+11*x1^4*x2^2*x3^4*x4^3+9*x1^4*x2^2*x3^4*x4^4+10*x1^4*x2^2*x3^5*x4+15*x1^4*x2^2*x3^5*x4^4+12*x1^4*x2^3+2*x1^4*x2^3*x4^2+11*x1^4*x2^3*x4^4+2*x1^4*x2^3*x3+5*x1^4*x2^3*x3*x4^2+3*x1^4*x2^3*x3*x4^3+3*x1^4*x2^3*x3*x4^5+15*x1^4*x2^3*x3^2+5*x1^4*x2^3*x3^2*x4+13*x1^4*x2^3*x3^2*x4^2+2*x1^4*x2^3*x3^2*x4^3+3*x1^4*x2^3*x3^2*x4^4+5*x1^4*x2^3*x3^2*x4^5+10*x1^4*x2^3*x3^3+9*x1^4*x2^3*x3^3*x4+14*x1^4*x2^3*x3^3*x4^3+5*x1^4*x2^3*x3^3*x4^4+8*x1^4*x2^3*x3^4+9*x1^4*x2^3*x3^4*x4+10*x1^4*x2^3*x3^4*x4^3+2*x1^4*x2^3*x3^4*x4^4+6*x1^4*x2^3*x3^5*x4+9*x1^4*x2^3*x3^5*x4^4+12*x1^4*x2^4+14*x1^4*x2^4*x4^2+10*x1^4*x2^4*x4^4+4*x1^4*x2^4*x3+12*x1^4*x2^4*x3*x4+3*x1^4*x2^4*x3*x4^2+13*x1^4*x2^4*x3*x4^3+12*x1^4*x2^4*x3*x4^5+8*x1^4*x2^4*x3^2+3*x1^4*x2^4*x3^2*x4+x1^4*x2^4*x3^2*x4^2+4*x1^4*x2^4*x3^2*x4^3+12*x1^4*x2^4*x3^2*x4^4+3*x1^4*x2^4*x3^2*x4^5+6*x1^4*x2^4*x3^3+10*x1^4*x2^4*x3^3*x4+5*x1^4*x2^4*x3^3*x4^3+3*x1^4*x2^4*x3^3*x4^4+15*x1^4*x2^4*x3^4+2*x1^4*x2^4*x3^4*x4+6*x1^4*x2^4*x3^4*x4^3+8*x1^4*x2^4*x3^4*x4^4+7*x1^4*x2^4*x3^5*x4+2*x1^4*x2^4*x3^5*x4^4+4*x1^4*x2^5+15*x1^4*x2^5*x4^2+15*x1^4*x2^5*x4^4+10*x1^4*x2^5*x3+14*x1^4*x2^5*x3*x4+13*x1^4*x2^5*x3*x4^2+10*x1^4*x2^5*x3*x4^3+x1^4*x2^5*x3*x4^5+14*x1^4*x2^5*x3^2+13*x1^4*x2^5*x3^2*x4+10*x1^4*x2^5*x3^2*x4^2+10*x1^4*x2^5*x3^2*x4^3+x1^4*x2^5*x3^2*x4^4+13*x1^4*x2^5*x3^2*x4^5+9*x1^4*x2^5*x3^3+x1^4*x2^5*x3^3*x4+16*x1^4*x2^5*x3^3*x4^3+13*x1^4*x2^5*x3^3*x4^4+14*x1^4*x2^5*x3^4+3*x1^4*x2^5*x3^4*x4+9*x1^4*x2^5*x3^4*x4^3+12*x1^4*x2^5*x3^4*x4^4+2*x1^4*x2^5*x3^5*x4+3*x1^4*x2^5*x3^5*x4^4+8*x1^4*x2^6+13*x1^4*x2^6*x4^2+12*x1^4*x2^6*x4^4+11*x1^4*x2^6*x3+x1^4*x2^6*x3*x4+7*x1^4*x2^6*x3*x4^2+3*x1^4*x2^6*x3*x4^3+11*x1^4*x2^6*x3*x4^5+15*x1^4*x2^6*x3^2+7*x1^4*x2^6*x3^2*x4+8*x1^4*x2^6*x3^2*x4^2+11*x1^4*x2^6*x3^2*x4^3+11*x1^4*x2^6*x3^2*x4^4+7*x1^4*x2^6*x3^2*x4^5+14*x1^4*x2^6*x3^3+11*x1^4*x2^6*x3^3*x4+6*x1^4*x2^6*x3^3*x4^3+7*x1^4*x2^6*x3^3*x4^4+x1^4*x2^6*x3^4+16*x1^4*x2^6*x3^4*x4+14*x1^4*x2^6*x3^4*x4^3+13*x1^4*x2^6*x3^4*x4^4+5*x1^4*x2^6*x3^5*x4+16*x1^4*x2^6*x3^5*x4^4+16*x1^4*x2^7+5*x1^4*x2^7*x4^2+2*x1^4*x2^7*x4^4+12*x1^4*x2^7*x3+9*x1^4*x2^7*x3*x4+4*x1^4*x2^7*x3*x4^2+10*x1^4*x2^7*x3*x4^3+16*x1^4*x2^7*x3*x4^5+5*x1^4*x2^7*x3^2+4*x1^4*x2^7*x3^2*x4+7*x1^4*x2^7*x3^2*x4^2+12*x1^4*x2^7*x3^2*x4^3+16*x1^4*x2^7*x3^2*x4^4+4*x1^4*x2^7*x3^2*x4^5+8*x1^4*x2^7*x3^3+3*x1^4*x2^7*x3^3*x4+x1^4*x2^7*x3^3*x4^3+4*x1^4*x2^7*x3^3*x4^4+3*x1^4*x2^7*x3^4+14*x1^4*x2^7*x3^4*x4+8*x1^4*x2^7*x3^4*x4^3+5*x1^4*x2^7*x3^4*x4^4+15*x1^4*x2^7*x3^5*x4+14*x1^4*x2^7*x3^5*x4^4+5*x1^4*x2^8+5*x1^4*x2^8*x4^2+x1^4*x2^8*x4^4+2*x1^4*x2^8*x3+5*x1^4*x2^8*x3*x4+2*x1^4*x2^8*x3*x4^2+6*x1^4*x2^8*x3*x4^3+8*x1^4*x2^8*x3*x4^5+9*x1^4*x2^8*x3^2+2*x1^4*x2^8*x3^2*x4+12*x1^4*x2^8*x3^2*x4^2+2*x1^4*x2^8*x3^2*x4^3+8*x1^4*x2^8*x3^2*x4^4+2*x1^4*x2^8*x3^2*x4^5+4*x1^4*x2^8*x3^3+16*x1^4*x2^8*x3^3*x4+9*x1^4*x2^8*x3^3*x4^3+2*x1^4*x2^8*x3^3*x4^4+10*x1^4*x2^8*x3^4+7*x1^4*x2^8*x3^4*x4+4*x1^4*x2^8*x3^4*x4^3+11*x1^4*x2^8*x3^4*x4^4+16*x1^4*x2^8*x3^5*x4+7*x1^4*x2^8*x3^5*x4^4+10*x1^4*x2^9+2*x1^4*x2^9*x3+4*x1^4*x2^9*x3*x4+8*x1^4*x2^9*x3*x4^3+11*x1^4*x2^9*x3^2+2*x1^4*x2^9*x3^2*x4^3+14*x1^4*x2^9*x3^3*x4+9*x1^4*x2^10+14*x1^4*x2^10*x4^2+7*x1^4*x2^10*x4^4+16*x1^4*x2^10*x3+12*x1^4*x2^10*x3*x4+14*x1^4*x2^10*x3*x4^2+16*x1^4*x2^10*x3*x4^3+5*x1^4*x2^10*x3*x4^5+13*x1^4*x2^10*x3^2+14*x1^4*x2^10*x3^2*x4+16*x1^4*x2^10*x3^2*x4^2+16*x1^4*x2^10*x3^2*x4^3+5*x1^4*x2^10*x3^2*x4^4+14*x1^4*x2^10*x3^2*x4^5+11*x1^4*x2^10*x3^3+6*x1^4*x2^10*x3^3*x4+12*x1^4*x2^10*x3^3*x4^3+14*x1^4*x2^10*x3^3*x4^4+2*x1^4*x2^10*x3^4+15*x1^4*x2^10*x3^4*x4+11*x1^4*x2^10*x3^4*x4^3+9*x1^4*x2^10*x3^4*x4^4+10*x1^4*x2^10*x3^5*x4+15*x1^4*x2^10*x3^5*x4^4+16*x1^5+15*x1^5*x4^4+6*x1^5*x3+15*x1^5*x3*x4+9*x1^5*x3*x4^2+10*x1^5*x3*x4^3+2*x1^5*x3*x4^5+6*x1^5*x3^2+14*x1^5*x3^2*x4+5*x1^5*x3^2*x4^2+6*x1^5*x3^2*x4^3+5*x1^5*x3^2*x4^4+9*x1^5*x3^2*x4^5+8*x1^5*x3^3+14*x1^5*x3^3*x4+14*x1^5*x3^3*x4^4+9*x1^5*x3^4+15*x1^5*x3^4*x4+8*x1^5*x3^4*x4^3+9*x1^5*x3^4*x4^4+14*x1^5*x3^5*x4+15*x1^5*x3^5*x4^4+6*x1^5*x2+5*x1^5*x2*x4^2+5*x1^5*x2*x4^4+x1^5*x2*x3+12*x1^5*x2*x3*x4+3*x1^5*x2*x3*x4^2+5*x1^5*x2*x3*x4^3+12*x1^5*x2*x3*x4^5+14*x1^5*x2*x3^2+16*x1^5*x2*x3^2*x4+13*x1^5*x2*x3^2*x4^2+x1^5*x2*x3^2*x4^3+13*x1^5*x2*x3^2*x4^4+3*x1^5*x2*x3^2*x4^5+14*x1^5*x2*x3^3+15*x1^5*x2*x3^3*x4+16*x1^5*x2*x3^3*x4^4+3*x1^5*x2*x3^4+5*x1^5*x2*x3^4*x4+14*x1^5*x2*x3^4*x4^3+3*x1^5*x2*x3^4*x4^4+16*x1^5*x2*x3^5*x4+5*x1^5*x2*x3^5*x4^4+9*x1^5*x2^2+10*x1^5*x2^2*x4^2+11*x1^5*x2^2*x4^4+3*x1^5*x2^2*x3+6*x1^5*x2^2*x3*x4+10*x1^5*x2^2*x3*x4^2+4*x1^5*x2^2*x3*x4^3+6*x1^5*x2^2*x3*x4^5+3*x1^5*x2^2*x3^2+8*x1^5*x2^2*x3^2*x4+15*x1^5*x2^2*x3^2*x4^2+3*x1^5*x2^2*x3^2*x4^3+15*x1^5*x2^2*x3^2*x4^4+10*x1^5*x2^2*x3^2*x4^5+7*x1^5*x2^2*x3^3+16*x1^5*x2^2*x3^3*x4+8*x1^5*x2^2*x3^3*x4^4+10*x1^5*x2^2*x3^4+11*x1^5*x2^2*x3^4*x4+7*x1^5*x2^2*x3^4*x4^3+10*x1^5*x2^2*x3^4*x4^4+8*x1^5*x2^2*x3^5*x4+11*x1^5*x2^2*x3^5*x4^4+15*x1^5*x2^3+11*x1^5*x2^3*x4^2+10*x1^5*x2^3*x4^4+2*x1^5*x2^3*x3+9*x1^5*x2^3*x3*x4+6*x1^5*x2^3*x3*x4^2+10*x1^5*x2^3*x3*x4^3+7*x1^5*x2^3*x3*x4^5+15*x1^5*x2^3*x3^2*x4+9*x1^5*x2^3*x3^2*x4^2+2*x1^5*x2^3*x3^2*x4^3+9*x1^5*x2^3*x3^2*x4^4+6*x1^5*x2^3*x3^2*x4^5+11*x1^5*x2^3*x3^3+3*x1^5*x2^3*x3^3*x4+15*x1^5*x2^3*x3^3*x4^4+6*x1^5*x2^3*x3^4+10*x1^5*x2^3*x3^4*x4+11*x1^5*x2^3*x3^4*x4^3+6*x1^5*x2^3*x3^4*x4^4+15*x1^5*x2^3*x3^5*x4+10*x1^5*x2^3*x3^5*x4^4+14*x1^5*x2^4+3*x1^5*x2^4*x4^2+6*x1^5*x2^4*x4^4+10*x1^5*x2^4*x3+9*x1^5*x2^4*x3*x4+7*x1^5*x2^4*x3*x4^2+14*x1^5*x2^4*x3*x4^3+11*x1^5*x2^4*x3*x4^5+13*x1^5*x2^4*x3^2+9*x1^5*x2^4*x3^2*x4+2*x1^5*x2^4*x3^2*x4^2+10*x1^5*x2^4*x3^2*x4^3+2*x1^5*x2^4*x3^2*x4^4+7*x1^5*x2^4*x3^2*x4^5+10*x1^5*x2^4*x3^3+11*x1^5*x2^4*x3^3*x4+9*x1^5*x2^4*x3^3*x4^4+7*x1^5*x2^4*x3^4+6*x1^5*x2^4*x3^4*x4+10*x1^5*x2^4*x3^4*x4^3+7*x1^5*x2^4*x3^4*x4^4+9*x1^5*x2^4*x3^5*x4+6*x1^5*x2^4*x3^5*x4^4+12*x1^5*x2^5*x4^2+9*x1^5*x2^5*x4^4+5*x1^5*x2^5*x3+14*x1^5*x2^5*x3*x4+2*x1^5*x2^5*x3*x4^2+15*x1^5*x2^5*x3*x4^3+8*x1^5*x2^5*x3*x4^5+5*x1^5*x2^5*x3^2*x4+3*x1^5*x2^5*x3^2*x4^2+5*x1^5*x2^5*x3^2*x4^3+3*x1^5*x2^5*x3^2*x4^4+2*x1^5*x2^5*x3^2*x4^5+15*x1^5*x2^5*x3^3+14*x1^5*x2^5*x3^3*x4+5*x1^5*x2^5*x3^3*x4^4+2*x1^5*x2^5*x3^4+9*x1^5*x2^5*x3^4*x4+15*x1^5*x2^5*x3^4*x4^3+2*x1^5*x2^5*x3^4*x4^4+5*x1^5*x2^5*x3^5*x4+9*x1^5*x2^5*x3^5*x4^4+3*x1^5*x2^6+3*x1^5*x2^6*x4^2+14*x1^5*x2^6*x4^4+9*x1^5*x2^6*x3+5*x1^5*x2^6*x3*x4^2+15*x1^5*x2^6*x3*x4^3+3*x1^5*x2^6*x3*x4^5+11*x1^5*x2^6*x3^2+4*x1^5*x2^6*x3^2*x4+16*x1^5*x2^6*x3^2*x4^2+9*x1^5*x2^6*x3^2*x4^3+16*x1^5*x2^6*x3^2*x4^4+5*x1^5*x2^6*x3^2*x4^5+12*x1^5*x2^6*x3^3+6*x1^5*x2^6*x3^3*x4+4*x1^5*x2^6*x3^3*x4^4+5*x1^5*x2^6*x3^4+14*x1^5*x2^6*x3^4*x4+12*x1^5*x2^6*x3^4*x4^3+5*x1^5*x2^6*x3^4*x4^4+4*x1^5*x2^6*x3^5*x4+14*x1^5*x2^6*x3^5*x4^4+8*x1^5*x2^7+6*x1^5*x2^7*x4^2+8*x1^5*x2^7*x4^4+9*x1^5*x2^7*x3+2*x1^5*x2^7*x3*x4+15*x1^5*x2^7*x3*x4^2+7*x1^5*x2^7*x3*x4^3+9*x1^5*x2^7*x3*x4^5+13*x1^5*x2^7*x3^2+12*x1^5*x2^7*x3^2*x4+14*x1^5*x2^7*x3^2*x4^2+9*x1^5*x2^7*x3^2*x4^3+14*x1^5*x2^7*x3^2*x4^4+15*x1^5*x2^7*x3^2*x4^5+2*x1^5*x2^7*x3^3+8*x1^5*x2^7*x3^3*x4+12*x1^5*x2^7*x3^3*x4^4+15*x1^5*x2^7*x3^4+8*x1^5*x2^7*x3^4*x4+2*x1^5*x2^7*x3^4*x4^3+15*x1^5*x2^7*x3^4*x4^4+12*x1^5*x2^7*x3^5*x4+8*x1^5*x2^7*x3^5*x4^4+15*x1^5*x2^8+11*x1^5*x2^8*x4^2+4*x1^5*x2^8*x4^4+3*x1^5*x2^8*x3+3*x1^5*x2^8*x3*x4+16*x1^5*x2^8*x3*x4^2+6*x1^5*x2^8*x3*x4^3+13*x1^5*x2^8*x3*x4^5+7*x1^5*x2^8*x3^2+6*x1^5*x2^8*x3^2*x4+7*x1^5*x2^8*x3^2*x4^2+3*x1^5*x2^8*x3^2*x4^3+7*x1^5*x2^8*x3^2*x4^4+16*x1^5*x2^8*x3^2*x4^5+x1^5*x2^8*x3^3+11*x1^5*x2^8*x3^3*x4+6*x1^5*x2^8*x3^3*x4^4+16*x1^5*x2^8*x3^4+4*x1^5*x2^8*x3^4*x4+x1^5*x2^8*x3^4*x4^3+16*x1^5*x2^8*x3^4*x4^4+6*x1^5*x2^8*x3^5*x4+4*x1^5*x2^8*x3^5*x4^4+10*x1^5*x2^9+11*x1^5*x2^9*x4^2+12*x1^5*x2^9*x3+15*x1^5*x2^9*x3*x4+14*x1^5*x2^9*x3*x4^3+14*x1^5*x2^9*x3^2+12*x1^5*x2^9*x3^2*x4^3+10*x1^5*x2^9*x3^3*x4+6*x1^5*x2^10+9*x1^5*x2^10*x4^2+11*x1^5*x2^10*x4^4+11*x1^5*x2^10*x3+3*x1^5*x2^10*x3*x4+10*x1^5*x2^10*x3*x4^2+2*x1^5*x2^10*x3*x4^3+6*x1^5*x2^10*x3*x4^5+9*x1^5*x2^10*x3^2+8*x1^5*x2^10*x3^2*x4+15*x1^5*x2^10*x3^2*x4^2+11*x1^5*x2^10*x3^2*x4^3+15*x1^5*x2^10*x3^2*x4^4+10*x1^5*x2^10*x3^2*x4^5+7*x1^5*x2^10*x3^3+14*x1^5*x2^10*x3^3*x4+8*x1^5*x2^10*x3^3*x4^4+10*x1^5*x2^10*x3^4+11*x1^5*x2^10*x3^4*x4+7*x1^5*x2^10*x3^4*x4^3+10*x1^5*x2^10*x3^4*x4^4+8*x1^5*x2^10*x3^5*x4+11*x1^5*x2^10*x3^5*x4^4+6*x1^6+12*x1^6*x4^2+3*x1^6*x4^4+14*x1^6*x3+11*x1^6*x3*x4+8*x1^6*x3*x4^2+9*x1^6*x3*x4^3+15*x1^6*x3*x4^5+14*x1^6*x3^2+10*x1^6*x3^2*x4+9*x1^6*x3^2*x4^2+14*x1^6*x3^2*x4^3+6*x1^6*x3^2*x4^4+8*x1^6*x3^2*x4^5+15*x1^6*x3^3+9*x1^6*x3^3*x4+6*x1^6*x3^3*x4^3+10*x1^6*x3^3*x4^4+12*x1^6*x3^4+x1^6*x3^4*x4+15*x1^6*x3^4*x4^3+4*x1^6*x3^4*x4^4+3*x1^6*x3^5*x4+x1^6*x3^5*x4^4+8*x1^6*x2+3*x1^6*x2*x4^2+x1^6*x2*x4^4+x1^6*x2*x3+9*x1^6*x2*x3*x4+14*x1^6*x2*x3*x4^2+11*x1^6*x2*x3*x4^3+5*x1^6*x2*x3*x4^5+14*x1^6*x2*x3^2+9*x1^6*x2*x3^2*x4+3*x1^6*x2*x3^2*x4^2+x1^6*x2*x3^2*x4^3+2*x1^6*x2*x3^2*x4^4+14*x1^6*x2*x3^2*x4^5+5*x1^6*x2*x3^3+16*x1^6*x2*x3^3*x4+2*x1^6*x2*x3^3*x4^3+9*x1^6*x2*x3^3*x4^4+4*x1^6*x2*x3^4+6*x1^6*x2*x3^4*x4+5*x1^6*x2*x3^4*x4^3+7*x1^6*x2*x3^4*x4^4+x1^6*x2*x3^5*x4+6*x1^6*x2*x3^5*x4^4+8*x1^6*x2^2+4*x1^6*x2^2*x4^2+9*x1^6*x2^2*x4^4+13*x1^6*x2^2*x3+9*x1^6*x2^2*x3*x4+7*x1^6*x2^2*x3*x4^2+13*x1^6*x2^2*x3*x4^3+11*x1^6*x2^2*x3*x4^5+4*x1^6*x2^2*x3^2+13*x1^6*x2^2*x3^2*x4+10*x1^6*x2^2*x3^2*x4^2+13*x1^6*x2^2*x3^2*x4^3+x1^6*x2^2*x3^2*x4^4+7*x1^6*x2^2*x3^2*x4^5+11*x1^6*x2^2*x3^3+11*x1^6*x2^2*x3^3*x4+x1^6*x2^2*x3^3*x4^3+13*x1^6*x2^2*x3^3*x4^4+2*x1^6*x2^2*x3^4+3*x1^6*x2^2*x3^4*x4+11*x1^6*x2^2*x3^4*x4^3+12*x1^6*x2^2*x3^4*x4^4+9*x1^6*x2^2*x3^5*x4+3*x1^6*x2^2*x3^5*x4^4+10*x1^6*x2^3+16*x1^6*x2^3*x4^2+2*x1^6*x2^3*x4^4+14*x1^6*x2^3*x3+11*x1^6*x2^3*x3*x4^2+2*x1^6*x2^3*x3*x4^3+10*x1^6*x2^3*x3*x4^5+4*x1^6*x2^3*x3^2+x1^6*x2^3*x3^2*x4+6*x1^6*x2^3*x3^2*x4^2+14*x1^6*x2^3*x3^2*x4^3+4*x1^6*x2^3*x3^2*x4^4+11*x1^6*x2^3*x3^2*x4^5+10*x1^6*x2^3*x3^3+3*x1^6*x2^3*x3^3*x4+4*x1^6*x2^3*x3^3*x4^3+x1^6*x2^3*x3^3*x4^4+8*x1^6*x2^3*x3^4+12*x1^6*x2^3*x3^4*x4+10*x1^6*x2^3*x3^4*x4^3+14*x1^6*x2^3*x3^4*x4^4+2*x1^6*x2^3*x3^5*x4+12*x1^6*x2^3*x3^5*x4^4+11*x1^6*x2^4+5*x1^6*x2^4*x4^2+8*x1^6*x2^4*x4^4+14*x1^6*x2^4*x3+7*x1^6*x2^4*x3*x4+10*x1^6*x2^4*x3*x4^2+10*x1^6*x2^4*x3*x4^3+6*x1^6*x2^4*x3*x4^5+10*x1^6*x2^4*x3^2+4*x1^6*x2^4*x3^2*x4+7*x1^6*x2^4*x3^2*x4^2+14*x1^6*x2^4*x3^2*x4^3+16*x1^6*x2^4*x3^2*x4^4+10*x1^6*x2^4*x3^2*x4^5+6*x1^6*x2^4*x3^3+11*x1^6*x2^4*x3^3*x4+16*x1^6*x2^4*x3^3*x4^3+4*x1^6*x2^4*x3^3*x4^4+15*x1^6*x2^4*x3^4+14*x1^6*x2^4*x3^4*x4+6*x1^6*x2^4*x3^4*x4^3+5*x1^6*x2^4*x3^4*x4^4+8*x1^6*x2^4*x3^5*x4+14*x1^6*x2^4*x3^5*x4^4+5*x1^6*x2^5+3*x1^6*x2^5*x4^2+12*x1^6*x2^5*x4^4+15*x1^6*x2^5*x3+4*x1^6*x2^5*x3*x4+15*x1^6*x2^5*x3*x4^2+8*x1^6*x2^5*x3*x4^3+9*x1^6*x2^5*x3*x4^5+8*x1^6*x2^5*x3^2+6*x1^6*x2^5*x3^2*x4+2*x1^6*x2^5*x3^2*x4^2+15*x1^6*x2^5*x3^2*x4^3+7*x1^6*x2^5*x3^2*x4^4+15*x1^6*x2^5*x3^2*x4^5+9*x1^6*x2^5*x3^3+15*x1^6*x2^5*x3^3*x4+7*x1^6*x2^5*x3^3*x4^3+6*x1^6*x2^5*x3^3*x4^4+14*x1^6*x2^5*x3^4+4*x1^6*x2^5*x3^4*x4+9*x1^6*x2^5*x3^4*x4^3+16*x1^6*x2^5*x3^4*x4^4+12*x1^6*x2^5*x3^5*x4+4*x1^6*x2^5*x3^5*x4^4+2*x1^6*x2^6+9*x1^6*x2^6*x4^2+13*x1^6*x2^6*x4^4+2*x1^6*x2^6*x3+7*x1^6*x2^6*x3*x4+12*x1^6*x2^6*x3*x4^2+14*x1^6*x2^6*x3*x4^3+14*x1^6*x2^6*x3*x4^5+15*x1^6*x2^6*x3^2+15*x1^6*x2^6*x3^2*x4+5*x1^6*x2^6*x3^2*x4^2+2*x1^6*x2^6*x3^2*x4^3+9*x1^6*x2^6*x3^2*x4^4+12*x1^6*x2^6*x3^2*x4^5+14*x1^6*x2^6*x3^3+10*x1^6*x2^6*x3^3*x4+9*x1^6*x2^6*x3^3*x4^3+15*x1^6*x2^6*x3^3*x4^4+x1^6*x2^6*x3^4+10*x1^6*x2^6*x3^4*x4+14*x1^6*x2^6*x3^4*x4^3+6*x1^6*x2^6*x3^4*x4^4+13*x1^6*x2^6*x3^5*x4+10*x1^6*x2^6*x3^5*x4^4+15*x1^6*x2^7+10*x1^6*x2^7*x4^2+5*x1^6*x2^7*x4^4+5*x1^6*x2^7*x3+9*x1^6*x2^7*x3*x4+2*x1^6*x2^7*x3*x4^2+4*x1^6*x2^7*x3*x4^3+8*x1^6*x2^7*x3*x4^5+12*x1^6*x2^7*x3^2+11*x1^6*x2^7*x3^2*x4+15*x1^6*x2^7*x3^2*x4^2+5*x1^6*x2^7*x3^2*x4^3+10*x1^6*x2^7*x3^2*x4^4+2*x1^6*x2^7*x3^2*x4^5+8*x1^6*x2^7*x3^3+5*x1^6*x2^7*x3^3*x4+10*x1^6*x2^7*x3^3*x4^3+11*x1^6*x2^7*x3^3*x4^4+3*x1^6*x2^7*x3^4+13*x1^6*x2^7*x3^4*x4+8*x1^6*x2^7*x3^4*x4^3+x1^6*x2^7*x3^4*x4^4+5*x1^6*x2^7*x3^5*x4+13*x1^6*x2^7*x3^5*x4^4+9*x1^6*x2^8+6*x1^6*x2^8*x4^2+11*x1^6*x2^8*x4^4+7*x1^6*x2^8*x3+x1^6*x2^8*x3*x4+x1^6*x2^8*x3*x4^2+3*x1^6*x2^8*x3*x4^3+4*x1^6*x2^8*x3*x4^5+8*x1^6*x2^8*x3^2+14*x1^6*x2^8*x3^2*x4+16*x1^6*x2^8*x3^2*x4^2+7*x1^6*x2^8*x3^2*x4^3+5*x1^6*x2^8*x3^2*x4^4+x1^6*x2^8*x3^2*x4^5+4*x1^6*x2^8*x3^3+3*x1^6*x2^8*x3^3*x4+5*x1^6*x2^8*x3^3*x4^3+14*x1^6*x2^8*x3^3*x4^4+10*x1^6*x2^8*x3^4+15*x1^6*x2^8*x3^4*x4+4*x1^6*x2^8*x3^4*x4^3+9*x1^6*x2^8*x3^4*x4^4+11*x1^6*x2^8*x3^5*x4+15*x1^6*x2^8*x3^5*x4^4+2*x1^6*x2^9+8*x1^6*x2^9*x4^2+6*x1^6*x2^9*x3+13*x1^6*x2^9*x3*x4+7*x1^6*x2^9*x3*x4^3+2*x1^6*x2^9*x3^2+6*x1^6*x2^9*x3^2*x4^3+3*x1^6*x2^9*x3^3*x4+10*x1^6*x2^10+12*x1^6*x2^10*x4^2+9*x1^6*x2^10*x4^4+9*x1^6*x2^10*x3+3*x1^6*x2^10*x3*x4+7*x1^6*x2^10*x3*x4^2+14*x1^6*x2^10*x3*x4^3+11*x1^6*x2^10*x3*x4^5+9*x1^6*x2^10*x3^2+13*x1^6*x2^10*x3^2*x4+10*x1^6*x2^10*x3^2*x4^2+9*x1^6*x2^10*x3^2*x4^3+x1^6*x2^10*x3^2*x4^4+7*x1^6*x2^10*x3^2*x4^5+11*x1^6*x2^10*x3^3+7*x1^6*x2^10*x3^3*x4+x1^6*x2^10*x3^3*x4^3+13*x1^6*x2^10*x3^3*x4^4+2*x1^6*x2^10*x3^4+3*x1^6*x2^10*x3^4*x4+11*x1^6*x2^10*x3^4*x4^3+12*x1^6*x2^10*x3^4*x4^4+9*x1^6*x2^10*x3^5*x4+3*x1^6*x2^10*x3^5*x4^4+5*x1^7+13*x1^7*x4^2+12*x1^7*x3+13*x1^7*x3*x4+14*x1^7*x3*x4^3+12*x1^7*x3^2+12*x1^7*x3^2*x4^3+3*x1^7*x3^3*x4+7*x1^7*x2+10*x1^7*x2*x4^2+4*x1^7*x2*x3+10*x1^7*x2*x3*x4+16*x1^7*x2*x3*x4^3+4*x1^7*x2*x3^2+4*x1^7*x2*x3^2*x4^3+x1^7*x2*x3^3*x4+4*x1^7*x2^2+5*x1^7*x2^2*x4^2+2*x1^7*x2^2*x3+5*x1^7*x2^2*x3*x4+8*x1^7*x2^2*x3*x4^3+2*x1^7*x2^2*x3^2+2*x1^7*x2^2*x3^2*x4^3+9*x1^7*x2^2*x3^3*x4+3*x1^7*x2^3+3*x1^7*x2^3*x4^2+8*x1^7*x2^3*x3+3*x1^7*x2^3*x3*x4+15*x1^7*x2^3*x3*x4^3+8*x1^7*x2^3*x3^2+8*x1^7*x2^3*x3^2*x4^3+2*x1^7*x2^3*x3^3*x4+6*x1^7*x2^4+12*x1^7*x2^4*x4^2+15*x1^7*x2^4*x3+12*x1^7*x2^4*x3*x4+9*x1^7*x2^4*x3*x4^3+15*x1^7*x2^4*x3^2+15*x1^7*x2^4*x3^2*x4^3+8*x1^7*x2^4*x3^3*x4+10*x1^7*x2^5+x1^7*x2^5*x4^2+14*x1^7*x2^5*x3+x1^7*x2^5*x3*x4+5*x1^7*x2^5*x3*x4^3+14*x1^7*x2^5*x3^2+14*x1^7*x2^5*x3^2*x4^3+12*x1^7*x2^5*x3^3*x4+5*x1^7*x2^6+11*x1^7*x2^6*x4^2+x1^7*x2^6*x3+11*x1^7*x2^6*x3*x4+4*x1^7*x2^6*x3*x4^3+x1^7*x2^6*x3^2+x1^7*x2^6*x3^2*x4^3+13*x1^7*x2^6*x3^3*x4+16*x1^7*x2^7*x4^2+3*x1^7*x2^7*x3+16*x1^7*x2^7*x3*x4+12*x1^7*x2^7*x3*x4^3+3*x1^7*x2^7*x3^2+3*x1^7*x2^7*x3^2*x4^3+5*x1^7*x2^7*x3^3*x4+11*x1^7*x2^8+8*x1^7*x2^8*x4^2+10*x1^7*x2^8*x3+8*x1^7*x2^8*x3*x4+6*x1^7*x2^8*x3*x4^3+10*x1^7*x2^8*x3^2+10*x1^7*x2^8*x3^2*x4^3+11*x1^7*x2^8*x3^3*x4+16*x1^7*x2^9+5*x1^7*x2^10+5*x1^7*x2^10*x4^2+2*x1^7*x2^10*x3+5*x1^7*x2^10*x3*x4+8*x1^7*x2^10*x3*x4^3+2*x1^7*x2^10*x3^2+2*x1^7*x2^10*x3^2*x4^3+9*x1^7*x2^10*x3^3*x4+x1^8+x1^8*x4^2+9*x1^8*x3+15*x1^8*x3*x4+2*x1^8*x3*x4^3+9*x1^8*x3^2*x4^3+10*x1^8*x3^3*x4+10*x1^8*x2+6*x1^8*x2*x4^2+3*x1^8*x2*x3+5*x1^8*x2*x3*x4+12*x1^8*x2*x3*x4^3+3*x1^8*x2*x3^2*x4^3+9*x1^8*x2*x3^3*x4+4*x1^8*x2^2+3*x1^8*x2^2*x4^2+10*x1^8*x2^2*x3+11*x1^8*x2^2*x3*x4+6*x1^8*x2^2*x3*x4^3+10*x1^8*x2^2*x3^2*x4^3+13*x1^8*x2^2*x3^3*x4+10*x1^8*x2^3+12*x1^8*x2^3*x4^2+6*x1^8*x2^3*x3+10*x1^8*x2^3*x3*x4+7*x1^8*x2^3*x3*x4^3+6*x1^8*x2^3*x3^2*x4^3+x1^8*x2^3*x3^3*x4+4*x1^8*x2^4+14*x1^8*x2^4*x4^2+7*x1^8*x2^4*x3+6*x1^8*x2^4*x3*x4+11*x1^8*x2^4*x3*x4^3+7*x1^8*x2^4*x3^2*x4^3+4*x1^8*x2^4*x3^3*x4+6*x1^8*x2^5+4*x1^8*x2^5*x4^2+2*x1^8*x2^5*x3+9*x1^8*x2^5*x3*x4+8*x1^8*x2^5*x3*x4^3+2*x1^8*x2^5*x3^2*x4^3+6*x1^8*x2^5*x3^3*x4+14*x1^8*x2^6+10*x1^8*x2^6*x4^2+5*x1^8*x2^6*x3+14*x1^8*x2^6*x3*x4+3*x1^8*x2^6*x3*x4^3+5*x1^8*x2^6*x3^2*x4^3+15*x1^8*x2^6*x3^3*x4+11*x1^8*x2^7+13*x1^8*x2^7*x4^2+15*x1^8*x2^7*x3+8*x1^8*x2^7*x3*x4+9*x1^8*x2^7*x3*x4^3+15*x1^8*x2^7*x3^2*x4^3+11*x1^8*x2^7*x3^3*x4+5*x1^8*x2^8+15*x1^8*x2^8*x4^2+16*x1^8*x2^8*x3+4*x1^8*x2^8*x3*x4+13*x1^8*x2^8*x3*x4^3+16*x1^8*x2^8*x3^2*x4^3+14*x1^8*x2^8*x3^3*x4+9*x1^8*x2^10+3*x1^8*x2^10*x4^2+10*x1^8*x2^10*x3+11*x1^8*x2^10*x3*x4+6*x1^8*x2^10*x3*x4^3+10*x1^8*x2^10*x3^2*x4^3+13*x1^8*x2^10*x3^3*x4+11*x1^9+6*x1^9*x4^2+8*x1^9*x3+16*x1^9*x3*x4+15*x1^9*x3*x4^3+7*x1^9*x3^2+8*x1^9*x3^2*x4^3+5*x1^9*x3^3*x4+5*x1^9*x2+2*x1^9*x2*x4^2+14*x1^9*x2*x3+11*x1^9*x2*x3*x4+5*x1^9*x2*x3*x4^3+8*x1^9*x2*x3^2+14*x1^9*x2*x3^2*x4^3+13*x1^9*x2*x3^3*x4+14*x1^9*x2^2+x1^9*x2^2*x4^2+7*x1^9*x2^2*x3+14*x1^9*x2^2*x3*x4+11*x1^9*x2^2*x3*x4^3+4*x1^9*x2^2*x3^2+7*x1^9*x2^2*x3^2*x4^3+15*x1^9*x2^2*x3^3*x4+14*x1^9*x2^3+4*x1^9*x2^3*x4^2+11*x1^9*x2^3*x3+5*x1^9*x2^3*x3*x4+10*x1^9*x2^3*x3*x4^3+16*x1^9*x2^3*x3^2+11*x1^9*x2^3*x3^2*x4^3+9*x1^9*x2^3*x3^3*x4+4*x1^9*x2^4+16*x1^9*x2^4*x4^2+10*x1^9*x2^4*x3+3*x1^9*x2^4*x3*x4+6*x1^9*x2^4*x3*x4^3+13*x1^9*x2^4*x3^2+10*x1^9*x2^4*x3^2*x4^3+2*x1^9*x2^4*x3^3*x4+10*x1^9*x2^5+7*x1^9*x2^5*x4^2+15*x1^9*x2^5*x3+13*x1^9*x2^5*x3*x4+9*x1^9*x2^5*x3*x4^3+11*x1^9*x2^5*x3^2+15*x1^9*x2^5*x3^2*x4^3+3*x1^9*x2^5*x3^3*x4+5*x1^9*x2^6+9*x1^9*x2^6*x4^2+12*x1^9*x2^6*x3+7*x1^9*x2^6*x3*x4+14*x1^9*x2^6*x3*x4^3+2*x1^9*x2^6*x3^2+12*x1^9*x2^6*x3^2*x4^3+16*x1^9*x2^6*x3^3*x4+16*x1^9*x2^7+10*x1^9*x2^7*x4^2+2*x1^9*x2^7*x3+4*x1^9*x2^7*x3*x4+8*x1^9*x2^7*x3*x4^3+6*x1^9*x2^7*x3^2+2*x1^9*x2^7*x3^2*x4^3+14*x1^9*x2^7*x3^3*x4+3*x1^9*x2^8+5*x1^9*x2^8*x4^2+x1^9*x2^8*x3+2*x1^9*x2^8*x3*x4+4*x1^9*x2^8*x3*x4^3+3*x1^9*x2^8*x3^2+x1^9*x2^8*x3^2*x4^3+7*x1^9*x2^8*x3^3*x4+6*x1^9*x2^9+x1^9*x2^10*x4^2+7*x1^9*x2^10*x3+14*x1^9*x2^10*x3*x4+11*x1^9*x2^10*x3*x4^3+4*x1^9*x2^10*x3^2+7*x1^9*x2^10*x3^2*x4^3+15*x1^9*x2^10*x3^3*x4+10*x1^10+9*x1^10*x2+13*x1^10*x2^2+x1^10*x2^3+4*x1^10*x2^4+6*x1^10*x2^5+15*x1^10*x2^6+11*x1^10*x2^7+14*x1^10*x2^8+13*x1^10*x2^10+x1^11+6*x1^11*x2+3*x1^11*x2^2+12*x1^11*x2^3+14*x1^11*x2^4+4*x1^11*x2^5+10*x1^11*x2^6+13*x1^11*x2^7+15*x1^11*x2^8+3*x1^11*x2^10+6*x1^12+2*x1^12*x2+x1^12*x2^2+4*x1^12*x2^3+16*x1^12*x2^4+7*x1^12*x2^5+9*x1^12*x2^6+10*x1^12*x2^7+5*x1^12*x2^8+x1^12*x2^10", Zp64(17)); Assert.assertEquals(4, Factor(poly).size()); }
@Test(timeout = 200_000) public void testMultivariateFactorization46() throws Exception { MultivariatePolynomial<BigInteger> poly = PolynomialMethods.polyPow(MultivariatePolynomial.parse("z+3*y^2+x^3*y"), 50).decrement(); Assert.assertEquals(6, PolynomialMethods.Factor(poly).size()); }
@Test public void testMultivariateFactorization47() throws Exception { MultivariatePolynomialZp64 poly = PolynomialMethods.polyPow( MultivariatePolynomialZp64.parse("x^2*y - z^2*x^3 - y^2*z - 1", Rings.Zp64(2)), 20).decrement(); FactorDecompositionTest.assertFactorization(poly, Factor(poly)); }
@Test(timeout = 200_000L) public void testMultivariateFactorization48() throws Exception { MultivariateRing<MultivariatePolynomial<BigInteger>> ring = MultivariateRing(5, Z); MultivariatePolynomial<BigInteger> p1 = ring.parse("52037*x1^4*x2^3*x3^2*x4*x5+18900*x1^3*x2^10*x3*x4+42072*x1^4*x2*x4^7*x5^4+25153*x1^3*x2^10*x4^5*x5+40049*x2*x3^9*x4^3*x5^10+21479*x1^4*x3^5*x4^14*x5^2+46360*x1^2*x2^5*x3^8*x4^9*x5^2+1426*x1^5*x2^2*x3^2*x4^7*x5^12+53121*x1^3*x2^6*x3^11*x5^9+55693*x1^13*x2^2*x3^10*x5^4+47321*x1^10*x2*x3^7*x4^5*x5^7+53426*x2^11*x3^13*x4^4*x5^2+41556*x2^11*x3*x4^7*x5^12+51863*x1^2*x2^8*x3^10*x4^12*x5+15656*x1^5*x2^8*x3^6*x4^7*x5^9+12962*x1^8*x2^6*x3^5*x4^7*x5^9+51360*x1^5*x2^13*x3^8*x4^5*x5^8+63981*x1^6*x2^14*x3^5*x4^13*x5^3+36882*x1^13*x2^6*x3^8*x4^6*x5^14+3510*x1^5*x2^5*x3^12*x4^12*x5^13+21301*x1^10*x2^14*x3^11*x4^9*x5^9"), p2 = ring.parse("26692*x1^2*x2*x3^2*x5^13+62118*x1^2*x2^6*x3^5*x4^2*x5^7+828*x1^8*x2^6*x3^3*x4^4*x5+63108*x1^14*x2^2*x3^3*x4*x5^4+35392*x1^2*x2^2*x3^14*x4^6+18686*x1^6*x2^9*x3^2*x4^3*x5^5+55647*x2^4*x3^13*x4^6*x5^2+52635*x1^14*x2^5*x4^5*x5+191*x1^2*x3^8*x4^10*x5^6+65201*x1^12*x2*x3^8*x4*x5^5+3551*x1^9*x2*x3^12*x4^4*x5+23009*x1^6*x2^9*x3^6*x4^6+21159*x1^2*x2^9*x3^3*x4^13*x5^2+38666*x1^9*x2^9*x3^3*x5^10+25692*x1^12*x2^9*x3^5*x4^3*x5^5+21256*x1*x2^4*x3^12*x4^12*x5^6+32978*x1^6*x3^14*x4^6*x5^11+35661*x1^12*x2^3*x3^3*x4^14*x5^9+10212*x1^13*x2^14*x3^6*x4^8*x5+65089*x1^9*x2^13*x3^10*x4*x5^10+31555*x1^9*x2^8*x3^6*x4^9*x5^12"), p3 = ring.parse("51940*x3^12*x4*x5^9+28440*x1^7*x2^2*x3^6*x4^4*x5^6+64657*x1^4*x2^9*x3*x4^12+49150*x1*x2^7*x3^6*x4^3*x5^10+39701*x1^7*x2^4*x3^8*x5^8+55736*x1^11*x2^4*x3^7*x5^6+7442*x1^12*x2*x3^11*x4^5+20639*x1^7*x2^3*x4^13*x5^8+45382*x1^4*x2^2*x3^14*x4^4*x5^8+34045*x1^6*x2*x3^10*x4^9*x5^8+57079*x1^11*x2^9*x3^4*x4^3*x5^8+15678*x1^14*x2^5*x3^11*x4^2*x5^3+35697*x1^6*x2^11*x3^4*x4^6*x5^9+20453*x1^11*x2^12*x3^6*x4^7*x5+20337*x1^14*x2^9*x3^5*x4^7*x5^6+32687*x1^13*x2^8*x3^12*x4^3*x5^5+18470*x1^10*x2^6*x3^12*x4^10*x5^3+26468*x1^13*x2^3*x4^13*x5^13+53498*x1^13*x2^4*x3^13*x4^9*x5^6+51463*x1^9*x2^10*x3^10*x4^13*x5^5+17452*x1^11*x2^12*x3^12*x4^14*x5^11"); List<MultivariatePolynomial<BigInteger>> o = Arrays.asList(p1, p2, p3); List<MultivariatePolynomial<BigInteger>> m = Stream.of(p1, p2, p3).map(p -> p.setRing(Zp(17)).setRing(Z)).collect(Collectors.toList()); MultivariatePolynomial<BigInteger> poly = p1.createOne().multiply(m); Assert.assertEquals(3, Factor(poly).size()); }
@Ignore @Test public void testMultivariateFactorization49() throws Exception { RandomGenerator rnd = getRandom(); rnd.setSeed(1); MultivariateRing<MultivariatePolynomial<BigInteger>> ring = MultivariateRing(7, Z); Supplier<MultivariatePolynomial<BigInteger>> random = () -> randomPolynomial(ring.nVariables(), 0, 15, 20, Z, MonomialOrder.GREVLEX, r -> new BigInteger(16, r), rnd); MultivariatePolynomial<BigInteger> poly = ring.multiply(random.get(), random.get(), random.get()); for (int i = 0; i < 1000; ++i) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> factor = Factor(poly); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); Assert.assertEquals(poly, factor.multiply()); } }
@Test(timeout = 100000L) public void testMultivariateFactorization50() throws Exception { MultivariateRing<MultivariatePolynomial<BigInteger>> pRing = MultivariateRing(11, Z); Coder<MultivariatePolynomial<BigInteger>, ?, ?> pCoder = Coder.mkMultivariateCoder(pRing, "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10", "x11"); MultivariatePolynomial<BigInteger> p = pCoder.parse("(-1*x2*x7^2*x8^2*x9^3*x10^2*x11^3-1*x2*x7^2*x8^3*x9^2*x10^2*x11^3+2*x2*x3*x7*x8^3*x9^2*x10^2*x11^3+x2^2*x7^2*x8^2*x9^2*x10^2*x11^3+x2^2*x4*x7*x8^2*x9^2*x10^2*x11^3+2*x2*x3*x7*x8^4*x9*x10^2*x11^3-1*x2*x3^2*x8^4*x9*x10^2*x11^3+3*x2^2*x4*x7*x8^3*x9*x10^2*x11^3-2*x2^2*x3*x7*x8^3*x9*x10^2*x11^3+3*x2^2*x3*x4*x8^3*x9*x10^2*x11^3-2*x2^3*x4*x8^3*x9*x10^2*x11^3-1*x2^3*x4*x7*x8^2*x9*x10^2*x11^3-1*x2*x3^2*x8^5*x10^2*x11^3+x2^2*x3*x4*x8^4*x10^2*x11^3+x2^2*x3^2*x8^4*x10^2*x11^3-1*x2^3*x3*x4*x8^3*x10^2*x11^3+2*x2*x6*x7^2*x8*x9^4*x10*x11^3+2*x2*x6*x7^2*x8^2*x9^3*x10*x11^3-4*x2*x3*x6*x7*x8^2*x9^3*x10*x11^3-2*x2^2*x6*x7^2*x8*x9^3*x10*x11^3+3*x2^2*x5*x7^2*x8*x9^3*x10*x11^3-2*x2^2*x4*x6*x7*x8*x9^3*x10*x11^3-4*x2*x3*x6*x7*x8^3*x9^2*x10*x11^3+2*x2*x3^2*x6*x8^3*x9^2*x10*x11^3+x2^2*x5*x7^2*x8^2*x9^2*x10*x11^3-6*x2^2*x4*x6*x7*x8^2*x9^2*x10*x11^3+4*x2^2*x3*x6*x7*x8^2*x9^2*x10*x11^3-6*x2^2*x3*x5*x7*x8^2*x9^2*x10*x11^3-6*x2^2*x3*x4*x6*x8^2*x9^2*x10*x11^3+4*x2^3*x4*x6*x8^2*x9^2*x10*x11^3-1*x2^3*x5*x7^2*x8*x9^2*x10*x11^3+2*x2^3*x4*x6*x7*x8*x9^2*x10*x11^3-4*x2^3*x4*x5*x7*x8*x9^2*x10*x11^3+2*x2*x3^2*x6*x8^4*x9*x10*x11^3-2*x2^2*x3*x5*x7*x8^3*x9*x10*x11^3-2*x2^2*x3*x4*x6*x8^3*x9*x10*x11^3-2*x2^2*x3^2*x6*x8^3*x9*x10*x11^3+3*x2^2*x3^2*x5*x8^3*x9*x10*x11^3-4*x2^3*x4*x5*x7*x8^2*x9*x10*x11^3+2*x2^3*x3*x5*x7*x8^2*x9*x10*x11^3+2*x2^3*x3*x4*x6*x8^2*x9*x10*x11^3-8*x2^3*x3*x4*x5*x8^2*x9*x10*x11^3+4*x2^4*x4*x5*x8^2*x9*x10*x11^3+x2^4*x4^2*x5*x8*x9*x10*x11^3+x2^2*x3^2*x5*x8^4*x10*x11^3-1*x2^3*x3^2*x5*x8^3*x10*x11^3-1*x2^4*x4^2*x5*x8^2*x10*x11^3+x2^5*x4^2*x5*x8*x10*x11^3-1*x2*x6^2*x7^2*x9^5*x11^3-1*x2*x6^2*x7^2*x8*x9^4*x11^3+2*x2*x3*x6^2*x7*x8*x9^4*x11^3+x2^2*x6^2*x7^2*x9^4*x11^3+x2^2*x5*x6*x7^2*x9^4*x11^3+x2^2*x4*x6^2*x7*x9^4*x11^3+2*x2*x3*x6^2*x7*x8^2*x9^3*x11^3-1*x2*x3^2*x6^2*x8^2*x9^3*x11^3+3*x2^2*x5*x6*x7^2*x8*x9^3*x11^3-2*x2^3*x5*x7^2*x8*x9^3*x11^3+3*x2^2*x4*x6^2*x7*x8*x9^3*x11^3-2*x2^2*x3*x6^2*x7*x8*x9^3*x11^3-2*x2^2*x3*x5*x6*x7*x8*x9^3*x11^3+3*x2^2*x3*x4*x6^2*x8*x9^3*x11^3-2*x2^3*x4*x6^2*x8*x9^3*x11^3-1*x2^3*x5*x6*x7^2*x9^3*x11^3-1*x2^3*x4*x6^2*x7*x9^3*x11^3-1*x2*x3^2*x6^2*x8^3*x9^2*x11^3-6*x2^2*x3*x5*x6*x7*x8^2*x9^2*x11^3+4*x2^3*x3*x5*x7*x8^2*x9^2*x11^3+x2^2*x3*x4*x6^2*x8^2*x9^2*x11^3+x2^2*x3^2*x6^2*x8^2*x9^2*x11^3+x2^2*x3^2*x5*x6*x8^2*x9^2*x11^3-8*x2^3*x4*x5*x6*x7*x8*x9^2*x11^3+2*x2^3*x3*x5*x6*x7*x8*x9^2*x11^3+4*x2^4*x4*x5*x7*x8*x9^2*x11^3-1*x2^3*x3*x4*x6^2*x8*x9^2*x11^3-4*x2^3*x3*x4*x5*x6*x8*x9^2*x11^3+4*x2^4*x4*x5*x6*x8*x9^2*x11^3-1*x2^4*x4*x5^2*x7*x9^2*x11^3-1*x2^4*x4^2*x5*x6*x9^2*x11^3+3*x2^2*x3^2*x5*x6*x8^3*x9*x11^3-2*x2^3*x3^2*x5*x8^3*x9*x11^3-4*x2^3*x3*x4*x5*x6*x8^2*x9*x11^3-1*x2^3*x3^2*x5*x6*x8^2*x9*x11^3+4*x2^4*x3*x4*x5*x8^2*x9*x11^3+x2^4*x4*x5^2*x7*x8*x9*x11^3+x2^4*x4^2*x5*x6*x8*x9*x11^3+x2^4*x3*x4*x5^2*x8*x9*x11^3-2*x2^5*x4*x5^2*x8*x9*x11^3-2*x2^5*x4^2*x5*x8*x9*x11^3+x2^5*x4*x5^2*x7*x9*x11^3+x2^5*x4^2*x5*x6*x9*x11^3+x2^5*x4^2*x5^2*x9*x11^3-1*x2^4*x3*x4*x5^2*x8^2*x11^3+x2^5*x4^2*x5^2*x8*x11^3+x2^5*x3*x4*x5^2*x8*x11^3-1*x2^6*x4^2*x5^2*x11^3+x7^3*x8^2*x9^3*x10^3*x11^2+x7^3*x8^3*x9^2*x10^3*x11^2-4*x3*x7^2*x8^3*x9^2*x10^3*x11^2+x2*x7^2*x8^3*x9^2*x10^3*x11^2-2*x2*x7^3*x8^2*x9^2*x10^3*x11^2+x2*x4*x7^2*x8^2*x9^2*x10^3*x11^2-2*x3*x7^2*x8^4*x9*x10^3*x11^2+5*x3^2*x7*x8^4*x9*x10^3*x11^2-2*x2*x3*x7*x8^4*x9*x10^3*x11^2-4*x2*x4*x7^2*x8^3*x9*x10^3*x11^2+4*x2*x3*x7^2*x8^3*x9*x10^3*x11^2-2*x2*x3*x4*x7*x8^3*x9*x10^3*x11^2+3*x2^2*x4*x7*x8^3*x9*x10^3*x11^2+x2^2*x4*x7^2*x8^2*x9*x10^3*x11^2-2*x2^2*x4^2*x7*x8^2*x9*x10^3*x11^2+x3^2*x7*x8^5*x10^3*x11^2-2*x3^3*x8^5*x10^3*x11^2+x2*x3^2*x8^5*x10^3*x11^2-2*x2*x3^2*x7*x8^4*x10^3*x11^2+5*x2*x3^2*x4*x8^4*x10^3*x11^2-3*x2^2*x3*x4*x8^4*x10^3*x11^2-3*x2^2*x4^2*x7*x8^3*x10^3*x11^2+3*x2^2*x3*x4*x7*x8^3*x10^3*x11^2-3*x2^2*x3*x4^2*x8^3*x10^3*x11^2+2*x2^3*x4^2*x8^3*x10^3*x11^2+x2^3*x4^2*x7*x8^2*x10^3*x11^2-2*x6*x7^3*x8*x9^4*x10^2*x11^2-4*x6*x7^3*x8^2*x9^3*x10^2*x11^2+x2*x7^3*x8^2*x9^3*x10^2*x11^2+9*x3*x6*x7^2*x8^2*x9^3*x10^2*x11^2-1*x2*x6*x7^2*x8^2*x9^3*x10^2*x11^2+4*x2*x6*x7^3*x8*x9^3*x10^2*x11^2-4*x2*x5*x7^3*x8*x9^3*x10^2*x11^2-2*x2*x4*x6*x7^2*x8*x9^3*x10^2*x11^2+9*x3*x6*x7^2*x8^3*x9^2*x10^2*x11^2-1*x2*x3*x7^2*x8^3*x9^2*x10^2*x11^2-12*x3^2*x6*x7*x8^3*x9^2*x10^2*x11^2+2*x2*x3*x6*x7*x8^3*x9^2*x10^2*x11^2+x2*x5*x7^3*x8^2*x9^2*x10^2*x11^2+13*x2*x4*x6*x7^2*x8^2*x9^2*x10^2*x11^2-10*x2*x3*x6*x7^2*x8^2*x9^2*x10^2*x11^2+13*x2*x3*x5*x7^2*x8^2*x9^2*x10^2*x11^2-2*x2^2*x5*x7^2*x8^2*x9^2*x10^2*x11^2-2*x2^2*x4*x7^2*x8^2*x9^2*x10^2*x11^2+4*x2*x3*x4*x6*x7*x8^2*x9^2*x10^2*x11^2-9*x2^2*x4*x6*x7*x8^2*x9^2*x10^2*x11^2+x2^2*x5*x7^3*x8*x9^2*x10^2*x11^2-2*x2^2*x4*x6*x7^2*x8*x9^2*x10^2*x11^2+x2^2*x4*x5*x7^2*x8*x9^2*x10^2*x11^2+4*x2^2*x4^2*x6*x7*x8*x9^2*x10^2*x11^2-6*x3^2*x6*x7*x8^4*x9*x10^2*x11^2-1*x2*x3^2*x7*x8^4*x9*x10^2*x11^2+5*x3^3*x6*x8^4*x9*x10^2*x11^2-1*x2*x3^2*x6*x8^4*x9*x10^2*x11^2-2*x2*x3*x5*x7^2*x8^3*x9*x10^2*x11^2-2*x2*x3*x4*x6*x7*x8^3*x9*x10^2*x11^2+8*x2*x3^2*x6*x7*x8^3*x9*x10^2*x11^2-14*x2*x3^2*x5*x7*x8^3*x9*x10^2*x11^2+4*x2^2*x3*x5*x7*x8^3*x9*x10^2*x11^2-4*x2^2*x3*x4*x7*x8^3*x9*x10^2*x11^2-14*x2*x3^2*x4*x6*x8^3*x9*x10^2*x11^2+9*x2^2*x3*x4*x6*x8^3*x9*x10^2*x11^2+x2^2*x4*x5*x7^2*x8^2*x9*x10^2*x11^2-2*x2^2*x3*x5*x7^2*x8^2*x9*x10^2*x11^2+3*x2^2*x4^2*x6*x7*x8^2*x9*x10^2*x11^2-3*x2^2*x3*x4*x6*x7*x8^2*x9*x10^2*x11^2+9*x2^2*x3*x4*x5*x7*x8^2*x9*x10^2*x11^2-5*x2^3*x4*x5*x7*x8^2*x9*x10^2*x11^2+x2^3*x4^2*x7*x8^2*x9*x10^2*x11^2+3*x2^2*x3*x4^2*x6*x8^2*x9*x10^2*x11^2-2*x2^3*x4^2*x6*x8^2*x9*x10^2*x11^2+4*x2^3*x4*x5*x7^2*x8*x9*x10^2*x11^2-2*x2^3*x4^2*x6*x7*x8*x9*x10^2*x11^2+4*x2^3*x4^2*x5*x7*x8*x9*x10^2*x11^2+x3^3*x6*x8^5*x10^2*x11^2+x2*x3^3*x8^5*x10^2*x11^2+x2*x3^2*x5*x7*x8^4*x10^2*x11^2+x2*x3^2*x4*x6*x8^4*x10^2*x11^2-2*x2*x3^3*x6*x8^4*x10^2*x11^2+5*x2*x3^3*x5*x8^4*x10^2*x11^2-2*x2^2*x3^2*x5*x8^4*x10^2*x11^2-2*x2^2*x3^2*x4*x8^4*x10^2*x11^2-5*x2^2*x3*x4*x5*x7*x8^3*x10^2*x11^2+x2^2*x3^2*x5*x7*x8^3*x10^2*x11^2-2*x2^2*x3*x4^2*x6*x8^3*x10^2*x11^2+x2^2*x3^2*x4*x6*x8^3*x10^2*x11^2-14*x2^2*x3^2*x4*x5*x8^3*x10^2*x11^2+7*x2^3*x3*x4*x5*x8^3*x10^2*x11^2+x2^3*x3*x4^2*x8^3*x10^2*x11^2+10*x2^3*x4^2*x5*x7*x8^2*x10^2*x11^2-2*x2^3*x3*x4*x5*x7*x8^2*x10^2*x11^2+x2^3*x3*x4^2*x6*x8^2*x10^2*x11^2+10*x2^3*x3*x4^2*x5*x8^2*x10^2*x11^2-5*x2^4*x4^2*x5*x8^2*x10^2*x11^2-5*x2^4*x4^2*x5*x7*x8*x10^2*x11^2-1*x2^4*x4^3*x5*x8*x10^2*x11^2+x6^2*x7^3*x9^5*x10*x11^2+5*x6^2*x7^3*x8*x9^4*x10*x11^2-2*x2*x6*x7^3*x8*x9^4*x10*x11^2-6*x3*x6^2*x7^2*x8*x9^4*x10*x11^2-1*x2*x6^2*x7^2*x8*x9^4*x10*x11^2-2*x2*x6^2*x7^3*x9^4*x10*x11^2+x2*x4*x6^2*x7^2*x9^4*x10*x11^2-12*x3*x6^2*x7^2*x8^2*x9^3*x10*x11^2+2*x2*x3*x6*x7^2*x8^2*x9^3*x10*x11^2+9*x3^2*x6^2*x7*x8^2*x9^3*x10*x11^2+2*x2*x3*x6^2*x7*x8^2*x9^3*x10*x11^2-2*x2*x5*x6*x7^3*x8*x9^3*x10*x11^2+3*x2^2*x5*x7^3*x8*x9^3*x10*x11^2-14*x2*x4*x6^2*x7^2*x8*x9^3*x10*x11^2+8*x2*x3*x6^2*x7^2*x8*x9^3*x10*x11^2-2*x2*x3*x5*x6*x7^2*x8*x9^3*x10*x11^2-4*x2^2*x5*x6*x7^2*x8*x9^3*x10*x11^2+4*x2^2*x4*x6*x7^2*x8*x9^3*x10*x11^2-2*x2*x3*x4*x6^2*x7*x8*x9^3*x10*x11^2+9*x2^2*x4*x6^2*x7*x8*x9^3*x10*x11^2+3*x2^2*x5*x6*x7^3*x9^3*x10*x11^2-3*x2^2*x5^2*x7^3*x9^3*x10*x11^2+x2^2*x4*x6^2*x7^2*x9^3*x10*x11^2-5*x2^2*x4*x5*x6*x7^2*x9^3*x10*x11^2-2*x2^2*x4^2*x6^2*x7*x9^3*x10*x11^2+9*x3^2*x6^2*x7*x8^3*x9^2*x10*x11^2+2*x2*x3^2*x6*x7*x8^3*x9^2*x10*x11^2-4*x3^3*x6^2*x8^3*x9^2*x10*x11^2-1*x2*x3^2*x6^2*x8^3*x9^2*x10*x11^2+4*x2*x3*x5*x6*x7^2*x8^2*x9^2*x10*x11^2-9*x2^2*x3*x5*x7^2*x8^2*x9^2*x10*x11^2+4*x2*x3*x4*x6^2*x7*x8^2*x9^2*x10*x11^2-10*x2*x3^2*x6^2*x7*x8^2*x9^2*x10*x11^2+4*x2*x3^2*x5*x6*x7*x8^2*x9^2*x10*x11^2+8*x2^2*x3*x5*x6*x7*x8^2*x9^2*x10*x11^2+8*x2^2*x3*x4*x6*x7*x8^2*x9^2*x10*x11^2+13*x2*x3^2*x4*x6^2*x8^2*x9^2*x10*x11^2-9*x2^2*x3*x4*x6^2*x8^2*x9^2*x10*x11^2-2*x2^2*x5^2*x7^3*x8*x9^2*x10*x11^2+9*x2^2*x4*x5*x6*x7^2*x8*x9^2*x10*x11^2-3*x2^2*x3*x5*x6*x7^2*x8*x9^2*x10*x11^2+3*x2^2*x3*x5^2*x7^2*x8*x9^2*x10*x11^2+x2^3*x5^2*x7^2*x8*x9^2*x10*x11^2-5*x2^3*x4*x5*x7^2*x8*x9^2*x10*x11^2+3*x2^2*x4^2*x6^2*x7*x8*x9^2*x10*x11^2-3*x2^2*x3*x4*x6^2*x7*x8*x9^2*x10*x11^2+4*x2^2*x3*x4*x5*x6*x7*x8*x9^2*x10*x11^2-2*x2^3*x4*x5*x6*x7*x8*x9^2*x10*x11^2-2*x2^3*x4^2*x6*x7*x8*x9^2*x10*x11^2+3*x2^2*x3*x4^2*x6^2*x8*x9^2*x10*x11^2-2*x2^3*x4^2*x6^2*x8*x9^2*x10*x11^2+x2^3*x5^2*x7^3*x9^2*x10*x11^2-2*x2^3*x4*x5*x6*x7^2*x9^2*x10*x11^2+10*x2^3*x4*x5^2*x7^2*x9^2*x10*x11^2+x2^3*x4^2*x6^2*x7*x9^2*x10*x11^2+4*x2^3*x4^2*x5*x6*x7*x9^2*x10*x11^2-2*x3^3*x6^2*x8^4*x9*x10*x11^2-2*x2*x3^3*x6*x8^4*x9*x10*x11^2-2*x2*x3^2*x5*x6*x7*x8^3*x9*x10*x11^2+9*x2^2*x3^2*x5*x7*x8^3*x9*x10*x11^2-2*x2*x3^2*x4*x6^2*x8^3*x9*x10*x11^2+4*x2*x3^3*x6^2*x8^3*x9*x10*x11^2-2*x2*x3^3*x5*x6*x8^3*x9*x10*x11^2-4*x2^2*x3^2*x5*x6*x8^3*x9*x10*x11^2+4*x2^2*x3^2*x4*x6*x8^3*x9*x10*x11^2+4*x2^2*x3*x5^2*x7^2*x8^2*x9*x10*x11^2+4*x2^2*x3*x4*x5*x6*x7*x8^2*x9*x10*x11^2-3*x2^2*x3^2*x5*x6*x7*x8^2*x9*x10*x11^2+3*x2^2*x3^2*x5^2*x7*x8^2*x9*x10*x11^2-2*x2^3*x3*x5^2*x7*x8^2*x9*x10*x11^2-2*x2^3*x3*x4*x5*x7*x8^2*x9*x10*x11^2+4*x2^2*x3*x4^2*x6^2*x8^2*x9*x10*x11^2-2*x2^2*x3^2*x4*x6^2*x8^2*x9*x10*x11^2+9*x2^2*x3^2*x4*x5*x6*x8^2*x9*x10*x11^2-2*x2^3*x3*x4*x5*x6*x8^2*x9*x10*x11^2-2*x2^3*x3*x4^2*x6*x8^2*x9*x10*x11^2+4*x2^3*x4*x5^2*x7^2*x8*x9*x10*x11^2-2*x2^3*x3*x5^2*x7^2*x8*x9*x10*x11^2+4*x2^3*x4^2*x5*x6*x7*x8*x9*x10*x11^2+4*x2^3*x3*x4*x5^2*x7*x8*x9*x10*x11^2+x2^4*x4*x5^2*x7*x8*x9*x10*x11^2+x2^4*x4^2*x5*x7*x8*x9*x10*x11^2-2*x2^3*x3*x4^2*x6^2*x8*x9*x10*x11^2+4*x2^3*x3*x4^2*x5*x6*x8*x9*x10*x11^2-6*x2^4*x4^2*x5*x6*x8*x9*x10*x11^2-5*x2^4*x4*x5^2*x7^2*x9*x10*x11^2+x2^4*x4^2*x5*x6*x7*x9*x10*x11^2-8*x2^4*x4^2*x5^2*x7*x9*x10*x11^2+x2^4*x4^3*x5*x6*x9*x10*x11^2-3*x2^2*x3^3*x5*x8^4*x10*x11^2-2*x2^2*x3^2*x5^2*x7*x8^3*x10*x11^2-5*x2^2*x3^2*x4*x5*x6*x8^3*x10*x11^2+3*x2^2*x3^3*x5*x6*x8^3*x10*x11^2-3*x2^2*x3^3*x5^2*x8^3*x10*x11^2+x2^3*x3^2*x5^2*x8^3*x10*x11^2+7*x2^3*x3^2*x4*x5*x8^3*x10*x11^2+4*x2^3*x3*x4*x5^2*x7*x8^2*x10*x11^2+x2^3*x3^2*x5^2*x7*x8^2*x10*x11^2+4*x2^3*x3*x4^2*x5*x6*x8^2*x10*x11^2-2*x2^3*x3^2*x4*x5*x6*x8^2*x10*x11^2+10*x2^3*x3^2*x4*x5^2*x8^2*x10*x11^2-5*x2^4*x3*x4*x5^2*x8^2*x10*x11^2-5*x2^4*x3*x4^2*x5*x8^2*x10*x11^2-8*x2^4*x4^2*x5^2*x7*x8*x10*x11^2+x2^4*x3*x4*x5^2*x7*x8*x10*x11^2+x2^4*x4^3*x5*x6*x8*x10*x11^2+x2^4*x3*x4^2*x5*x6*x8*x10*x11^2-8*x2^4*x3*x4^2*x5^2*x8*x10*x11^2+4*x2^5*x4^2*x5^2*x8*x10*x11^2+x2^5*x4^3*x5*x8*x10*x11^2+4*x2^5*x4^2*x5^2*x7*x10*x11^2-2*x2^5*x4^3*x5*x6*x10*x11^2+x2^5*x4^3*x5^2*x10*x11^2-2*x6^3*x7^3*x9^5*x11^2+x2*x6^2*x7^3*x9^5*x11^2+x3*x6^3*x7^2*x9^5*x11^2+x2*x6^3*x7^2*x9^5*x11^2+5*x3*x6^3*x7^2*x8*x9^4*x11^2-1*x2*x3*x6^2*x7^2*x8*x9^4*x11^2-2*x3^2*x6^3*x7*x8*x9^4*x11^2-2*x2*x3*x6^3*x7*x8*x9^4*x11^2+5*x2*x5*x6^2*x7^3*x9^4*x11^2-3*x2^2*x5*x6*x7^3*x9^4*x11^2+5*x2*x4*x6^3*x7^2*x9^4*x11^2-2*x2*x3*x6^3*x7^2*x9^4*x11^2+x2*x3*x5*x6^2*x7^2*x9^4*x11^2-2*x2^2*x5*x6^2*x7^2*x9^4*x11^2-2*x2^2*x4*x6^2*x7^2*x9^4*x11^2-3*x2^2*x4*x6^3*x7*x9^4*x11^2-4*x3^2*x6^3*x7*x8^2*x9^3*x11^2-1*x2*x3^2*x6^2*x7*x8^2*x9^3*x11^2+x3^3*x6^3*x8^2*x9^3*x11^2+x2*x3^2*x6^3*x8^2*x9^3*x11^2-14*x2*x3*x5*x6^2*x7^2*x8*x9^3*x11^2+9*x2^2*x3*x5*x6*x7^2*x8*x9^3*x11^2-2*x2*x3*x4*x6^3*x7*x8*x9^3*x11^2+4*x2*x3^2*x6^3*x7*x8*x9^3*x11^2-2*x2*x3^2*x5*x6^2*x7*x8*x9^3*x11^2+4*x2^2*x3*x5*x6^2*x7*x8*x9^3*x11^2-4*x2^2*x3*x4*x6^2*x7*x8*x9^3*x11^2-4*x2*x3^2*x4*x6^3*x8*x9^3*x11^2+3*x2^2*x3*x4*x6^3*x8*x9^3*x11^2-3*x2^2*x5^2*x6*x7^3*x9^3*x11^2+2*x2^3*x5^2*x7^3*x9^3*x11^2-14*x2^2*x4*x5*x6^2*x7^2*x9^3*x11^2+x2^2*x3*x5*x6^2*x7^2*x9^3*x11^2-2*x2^2*x3*x5^2*x6*x7^2*x9^3*x11^2+x2^3*x5^2*x6*x7^2*x9^3*x11^2+7*x2^3*x4*x5*x6*x7^2*x9^3*x11^2-3*x2^2*x4^2*x6^3*x7*x9^3*x11^2+3*x2^2*x3*x4*x6^3*x7*x9^3*x11^2-5*x2^2*x3*x4*x5*x6^2*x7*x9^3*x11^2+7*x2^3*x4*x5*x6^2*x7*x9^3*x11^2+x2^3*x4^2*x6^2*x7*x9^3*x11^2-3*x2^2*x3*x4^2*x6^3*x9^3*x11^2+2*x2^3*x4^2*x6^3*x9^3*x11^2+x3^3*x6^3*x8^3*x9^2*x11^2+x2*x3^3*x6^2*x8^3*x9^2*x11^2+13*x2*x3^2*x5*x6^2*x7*x8^2*x9^2*x11^2-9*x2^2*x3^2*x5*x6*x7*x8^2*x9^2*x11^2+x2*x3^2*x4*x6^3*x8^2*x9^2*x11^2-2*x2*x3^3*x6^3*x8^2*x9^2*x11^2+x2*x3^3*x5*x6^2*x8^2*x9^2*x11^2-2*x2^2*x3^2*x5*x6^2*x8^2*x9^2*x11^2-2*x2^2*x3^2*x4*x6^2*x8^2*x9^2*x11^2+3*x2^2*x3*x5^2*x6*x7^2*x8*x9^2*x11^2-2*x2^3*x3*x5^2*x7^2*x8*x9^2*x11^2+9*x2^2*x3*x4*x5*x6^2*x7*x8*x9^2*x11^2-2*x2^2*x3^2*x5*x6^2*x7*x8*x9^2*x11^2+4*x2^2*x3^2*x5^2*x6*x7*x8*x9^2*x11^2-2*x2^3*x3*x5^2*x6*x7*x8*x9^2*x11^2-2*x2^3*x3*x4*x5*x6*x7*x8*x9^2*x11^2-2*x2^2*x3*x4^2*x6^3*x8*x9^2*x11^2+x2^2*x3^2*x4*x6^3*x8*x9^2*x11^2+x2^2*x3^2*x4*x5*x6^2*x8*x9^2*x11^2-5*x2^3*x3*x4*x5*x6^2*x8*x9^2*x11^2+x2^3*x3*x4^2*x6^2*x8*x9^2*x11^2+10*x2^3*x4*x5^2*x6*x7^2*x9^2*x11^2+x2^3*x3*x5^2*x6*x7^2*x9^2*x11^2-5*x2^4*x4*x5^2*x7^2*x9^2*x11^2+10*x2^3*x4^2*x5*x6^2*x7*x9^2*x11^2-2*x2^3*x3*x4*x5*x6^2*x7*x9^2*x11^2+4*x2^3*x3*x4*x5^2*x6*x7*x9^2*x11^2-5*x2^4*x4*x5^2*x6*x7*x9^2*x11^2-5*x2^4*x4^2*x5*x6*x7*x9^2*x11^2+x2^3*x3*x4^2*x6^3*x9^2*x11^2+10*x2^3*x3*x4^2*x5*x6^2*x9^2*x11^2-5*x2^4*x4^2*x5*x6^2*x9^2*x11^2-4*x2*x3^3*x5*x6^2*x8^3*x9*x11^2+3*x2^2*x3^3*x5*x6*x8^3*x9*x11^2+3*x2^2*x3^2*x5^2*x6*x7*x8^2*x9*x11^2-2*x2^3*x3^2*x5^2*x7*x8^2*x9*x11^2+x2^2*x3^2*x4*x5*x6^2*x8^2*x9*x11^2+x2^2*x3^3*x5*x6^2*x8^2*x9*x11^2-2*x2^2*x3^3*x5^2*x6*x8^2*x9*x11^2+x2^3*x3^2*x5^2*x6*x8^2*x9*x11^2-5*x2^3*x3^2*x4*x5*x6*x8^2*x9*x11^2+4*x2^3*x3*x4*x5^2*x6*x7*x8*x9*x11^2-2*x2^3*x3^2*x5^2*x6*x7*x8*x9*x11^2-6*x2^4*x3*x4*x5^2*x7*x8*x9*x11^2+4*x2^3*x3*x4^2*x5*x6^2*x8*x9*x11^2+4*x2^3*x3^2*x4*x5*x6^2*x8*x9*x11^2+4*x2^3*x3^2*x4*x5^2*x6*x8*x9*x11^2+x2^4*x3*x4*x5^2*x6*x8*x9*x11^2+x2^4*x3*x4^2*x5*x6*x8*x9*x11^2-1*x2^4*x4*x5^3*x7^2*x9*x11^2-8*x2^4*x4^2*x5^2*x6*x7*x9*x11^2+x2^4*x3*x4*x5^2*x6*x7*x9*x11^2+x2^4*x3*x4*x5^3*x7*x9*x11^2+x2^5*x4*x5^3*x7*x9*x11^2+4*x2^5*x4^2*x5^2*x7*x9*x11^2-1*x2^4*x4^3*x5*x6^2*x9*x11^2-5*x2^4*x3*x4^2*x5*x6^2*x9*x11^2-8*x2^4*x3*x4^2*x5^2*x6*x9*x11^2+4*x2^5*x4^2*x5^2*x6*x9*x11^2+x2^5*x4^3*x5*x6*x9*x11^2-3*x2^2*x3^3*x5^2*x6*x8^3*x11^2+2*x2^3*x3^3*x5^2*x8^3*x11^2+10*x2^3*x3^2*x4*x5^2*x6*x8^2*x11^2+x2^3*x3^3*x5^2*x6*x8^2*x11^2-5*x2^4*x3^2*x4*x5^2*x8^2*x11^2+x2^4*x3*x4*x5^3*x7*x8*x11^2-8*x2^4*x3*x4^2*x5^2*x6*x8*x11^2-5*x2^4*x3^2*x4*x5^2*x6*x8*x11^2-1*x2^4*x3^2*x4*x5^3*x8*x11^2+x2^5*x3*x4*x5^3*x8*x11^2+4*x2^5*x3*x4^2*x5^2*x8*x11^2+x2^5*x4^2*x5^3*x7*x11^2-2*x2^5*x3*x4*x5^3*x7*x11^2+x2^5*x4^3*x5^2*x6*x11^2+4*x2^5*x3*x4^2*x5^2*x6*x11^2+x2^5*x3*x4^2*x5^3*x11^2-1*x2^6*x4^2*x5^3*x11^2-1*x2^6*x4^3*x5^2*x11^2-1*x7^3*x8^3*x9^2*x10^4*x11+x7^4*x8^2*x9^2*x10^4*x11-2*x4*x7^3*x8^2*x9^2*x10^4*x11+2*x3*x7^2*x8^4*x9*x10^4*x11+x4*x7^3*x8^3*x9*x10^4*x11-2*x3*x7^3*x8^3*x9*x10^4*x11+3*x3*x4*x7^2*x8^3*x9*x10^4*x11-2*x2*x4*x7^2*x8^3*x9*x10^4*x11+x2*x4*x7^3*x8^2*x9*x10^4*x11+x2*x4^2*x7^2*x8^2*x9*x10^4*x11-1*x3^2*x7*x8^5*x10^4*x11-1*x3*x4*x7^2*x8^4*x10^4*x11+x3^2*x7^2*x8^4*x10^4*x11-1*x3^2*x4*x7*x8^4*x10^4*x11+4*x2*x3*x4*x7*x8^4*x10^4*x11+5*x2*x4^2*x7^2*x8^3*x10^4*x11-3*x2*x3*x4*x7^2*x8^3*x10^4*x11-3*x2^2*x4^2*x7*x8^3*x10^4*x11-2*x2^2*x4^2*x7^2*x8^2*x10^4*x11+x2^2*x4^3*x7*x8^2*x10^4*x11-1*x7^4*x8^2*x9^3*x10^3*x11+3*x6*x7^3*x8^2*x9^3*x10^3*x11-2*x6*x7^4*x8*x9^3*x10^3*x11+x5*x7^4*x8*x9^3*x10^3*x11+4*x4*x6*x7^3*x8*x9^3*x10^3*x11+3*x3*x7^3*x8^3*x9^2*x10^3*x11-5*x3*x6*x7^2*x8^3*x9^2*x10^3*x11-2*x5*x7^4*x8^2*x9^2*x10^3*x11-1*x4*x6*x7^3*x8^2*x9^2*x10^3*x11+2*x3*x6*x7^3*x8^2*x9^2*x10^3*x11-1*x3*x5*x7^3*x8^2*x9^2*x10^3*x11+x2*x5*x7^3*x8^2*x9^2*x10^3*x11+x2*x4*x7^3*x8^2*x9^2*x10^3*x11-3*x3*x4*x6*x7^2*x8^2*x9^2*x10^3*x11+2*x2*x4*x6*x7^2*x8^2*x9^2*x10^3*x11+x2*x5*x7^4*x8*x9^2*x10^3*x11-2*x2*x4*x6*x7^3*x8*x9^2*x10^3*x11+4*x2*x4*x5*x7^3*x8*x9^2*x10^3*x11-2*x2*x4^2*x6*x7^2*x8*x9^2*x10^3*x11-3*x3^2*x7^2*x8^4*x9*x10^3*x11+x3^2*x6*x7*x8^4*x9*x10^3*x11+4*x3*x5*x7^3*x8^3*x9*x10^3*x11-2*x3*x4*x6*x7^2*x8^3*x9*x10^3*x11+2*x3^2*x6*x7^2*x8^3*x9*x10^3*x11-1*x3^2*x5*x7^2*x8^3*x9*x10^3*x11-2*x2*x3*x5*x7^2*x8^3*x9*x10^3*x11+2*x2*x3*x4*x7^2*x8^3*x9*x10^3*x11-2*x3^2*x4*x6*x7*x8^3*x9*x10^3*x11-8*x2*x3*x4*x6*x7*x8^3*x9*x10^3*x11+4*x2*x4*x5*x7^3*x8^2*x9*x10^3*x11-2*x2*x3*x5*x7^3*x8^2*x9*x10^3*x11-14*x2*x4^2*x6*x7^2*x8^2*x9*x10^3*x11+8*x2*x3*x4*x6*x7^2*x8^2*x9*x10^3*x11-16*x2*x3*x4*x5*x7^2*x8^2*x9*x10^3*x11+4*x2^2*x4*x5*x7^2*x8^2*x9*x10^3*x11+x2^2*x4^2*x7^2*x8^2*x9*x10^3*x11-2*x2*x3*x4^2*x6*x7*x8^2*x9*x10^3*x11+9*x2^2*x4^2*x6*x7*x8^2*x9*x10^3*x11-8*x2^2*x4*x5*x7^3*x8*x9*x10^3*x11+4*x2^2*x4^2*x6*x7^2*x8*x9*x10^3*x11-5*x2^2*x4^2*x5*x7^2*x8*x9*x10^3*x11-2*x2^2*x4^3*x6*x7*x8*x9*x10^3*x11+x3^3*x7*x8^5*x10^3*x11+x3^3*x6*x8^5*x10^3*x11-2*x3^2*x5*x7^2*x8^4*x10^3*x11+3*x3^2*x4*x6*x7*x8^4*x10^3*x11-2*x3^3*x6*x7*x8^4*x10^3*x11+x3^3*x5*x7*x8^4*x10^3*x11+x2*x3^2*x5*x7*x8^4*x10^3*x11-3*x2*x3^2*x4*x7*x8^4*x10^3*x11+x3^3*x4*x6*x8^4*x10^3*x11-2*x2*x3^2*x4*x6*x8^4*x10^3*x11+4*x2*x3*x4*x5*x7^2*x8^3*x10^3*x11+x2*x3^2*x5*x7^2*x8^3*x10^3*x11-2*x2*x3*x4^2*x6*x7*x8^3*x10^3*x11+2*x2*x3^2*x4*x6*x7*x8^3*x10^3*x11+4*x2*x3^2*x4*x5*x7*x8^3*x10^3*x11-8*x2^2*x3*x4*x5*x7*x8^3*x10^3*x11+3*x2^2*x3*x4^2*x7*x8^3*x10^3*x11-4*x2*x3^2*x4^2*x6*x8^3*x10^3*x11+3*x2^2*x3*x4^2*x6*x8^3*x10^3*x11-14*x2^2*x4^2*x5*x7^2*x8^2*x10^3*x11+4*x2^2*x3*x4*x5*x7^2*x8^2*x10^3*x11+3*x2^2*x4^3*x6*x7*x8^2*x10^3*x11-4*x2^2*x3*x4^2*x6*x7*x8^2*x10^3*x11-5*x2^2*x3*x4^2*x5*x7*x8^2*x10^3*x11+7*x2^3*x4^2*x5*x7*x8^2*x10^3*x11-1*x2^3*x4^3*x7*x8^2*x10^3*x11+3*x2^2*x3*x4^3*x6*x8^2*x10^3*x11-2*x2^3*x4^3*x6*x8^2*x10^3*x11+7*x2^3*x4^2*x5*x7^2*x8*x10^3*x11+2*x6*x7^4*x8*x9^4*x10^2*x11-3*x6^2*x7^3*x8*x9^4*x10^2*x11+x6^2*x7^4*x9^4*x10^2*x11-1*x5*x6*x7^4*x9^4*x10^2*x11-2*x4*x6^2*x7^3*x9^4*x10^2*x11-5*x3*x6*x7^3*x8^2*x9^3*x10^2*x11+3*x3*x6^2*x7^2*x8^2*x9^3*x10^2*x11+3*x5*x6*x7^4*x8*x9^3*x10^2*x11-2*x2*x5*x7^4*x8*x9^3*x10^2*x11-1*x4*x6^2*x7^3*x8*x9^3*x10^2*x11+2*x3*x6^2*x7^3*x8*x9^3*x10^2*x11-2*x3*x5*x6*x7^3*x8*x9^3*x10^2*x11+2*x2*x5*x6*x7^3*x8*x9^3*x10^2*x11-2*x2*x4*x6*x7^3*x8*x9^3*x10^2*x11-3*x3*x4*x6^2*x7^2*x8*x9^3*x10^2*x11+2*x2*x4*x6^2*x7^2*x8*x9^3*x10^2*x11-3*x2*x5*x6*x7^4*x9^3*x10^2*x11+5*x2*x5^2*x7^4*x9^3*x10^2*x11+x2*x4*x6^2*x7^3*x9^3*x10^2*x11+4*x2*x4*x5*x6*x7^3*x9^3*x10^2*x11+x2*x4^2*x6^2*x7^2*x9^3*x10^2*x11+3*x3^2*x6*x7^2*x8^3*x9^2*x10^2*x11+3*x3^2*x6^2*x7*x8^3*x9^2*x10^2*x11-3*x3*x5*x6*x7^3*x8^2*x9^2*x10^2*x11+2*x2*x3*x5*x7^3*x8^2*x9^2*x10^2*x11+6*x3*x4*x6^2*x7^2*x8^2*x9^2*x10^2*x11-6*x3^2*x6^2*x7^2*x8^2*x9^2*x10^2*x11+6*x3^2*x5*x6*x7^2*x8^2*x9^2*x10^2*x11-7*x2*x3*x5*x6*x7^2*x8^2*x9^2*x10^2*x11-7*x2*x3*x4*x6*x7^2*x8^2*x9^2*x10^2*x11+6*x3^2*x4*x6^2*x7*x8^2*x9^2*x10^2*x11+8*x2*x3*x4*x6^2*x7*x8^2*x9^2*x10^2*x11+x2*x5^2*x7^4*x8*x9^2*x10^2*x11-16*x2*x4*x5*x6*x7^3*x8*x9^2*x10^2*x11+8*x2*x3*x5*x6*x7^3*x8*x9^2*x10^2*x11-14*x2*x3*x5^2*x7^3*x8*x9^2*x10^2*x11+x2^2*x5^2*x7^3*x8*x9^2*x10^2*x11+4*x2^2*x4*x5*x7^3*x8*x9^2*x10^2*x11+13*x2*x4^2*x6^2*x7^2*x8*x9^2*x10^2*x11-7*x2*x3*x4*x6^2*x7^2*x8*x9^2*x10^2*x11+8*x2*x3*x4*x5*x6*x7^2*x8*x9^2*x10^2*x11+8*x2^2*x4*x5*x6*x7^2*x8*x9^2*x10^2*x11-2*x2^2*x4^2*x6*x7^2*x8*x9^2*x10^2*x11+4*x2*x3*x4^2*x6^2*x7*x8*x9^2*x10^2*x11-9*x2^2*x4^2*x6^2*x7*x8*x9^2*x10^2*x11-2*x2^2*x5^2*x7^4*x9^2*x10^2*x11+4*x2^2*x4*x5*x6*x7^3*x9^2*x10^2*x11-14*x2^2*x4*x5^2*x7^3*x9^2*x10^2*x11-2*x2^2*x4^2*x6^2*x7^2*x9^2*x10^2*x11+x2^2*x4^2*x5*x6*x7^2*x9^2*x10^2*x11+x2^2*x4^3*x6^2*x7*x9^2*x10^2*x11+x3^3*x6*x7*x8^4*x9*x10^2*x11-3*x3^3*x6^2*x8^4*x9*x10^2*x11-3*x3^2*x5*x6*x7^2*x8^3*x9*x10^2*x11+2*x2*x3^2*x5*x7^2*x8^3*x9*x10^2*x11-3*x3^2*x4*x6^2*x7*x8^3*x9*x10^2*x11+2*x3^3*x6^2*x7*x8^3*x9*x10^2*x11-2*x3^3*x5*x6*x7*x8^3*x9*x10^2*x11+8*x2*x3^2*x5*x6*x7*x8^3*x9*x10^2*x11+8*x2*x3^2*x4*x6*x7*x8^3*x9*x10^2*x11-1*x3^3*x4*x6^2*x8^3*x9*x10^2*x11+2*x2*x3^2*x4*x6^2*x8^3*x9*x10^2*x11-2*x2*x3*x5^2*x7^3*x8^2*x9*x10^2*x11+8*x2*x3*x4*x5*x6*x7^2*x8^2*x9*x10^2*x11-7*x2*x3^2*x5*x6*x7^2*x8^2*x9*x10^2*x11+13*x2*x3^2*x5^2*x7^2*x8^2*x9*x10^2*x11-2*x2^2*x3*x5^2*x7^2*x8^2*x9*x10^2*x11+8*x2^2*x3*x4*x5*x7^2*x8^2*x9*x10^2*x11+4*x2*x3*x4^2*x6^2*x7*x8^2*x9*x10^2*x11-7*x2*x3^2*x4*x6^2*x7*x8^2*x9*x10^2*x11+8*x2*x3^2*x4*x5*x6*x7*x8^2*x9*x10^2*x11-8*x2^2*x3*x4*x5*x6*x7*x8^2*x9*x10^2*x11-3*x2^2*x3*x4^2*x6*x7*x8^2*x9*x10^2*x11+13*x2*x3^2*x4^2*x6^2*x8^2*x9*x10^2*x11-9*x2^2*x3*x4^2*x6^2*x8^2*x9*x10^2*x11-5*x2^2*x4*x5^2*x7^3*x8*x9*x10^2*x11+4*x2^2*x3*x5^2*x7^3*x8*x9*x10^2*x11+9*x2^2*x4^2*x5*x6*x7^2*x8*x9*x10^2*x11-8*x2^2*x3*x4*x5*x6*x7^2*x8*x9*x10^2*x11+9*x2^2*x3*x4*x5^2*x7^2*x8*x9*x10^2*x11-2*x2^3*x4*x5^2*x7^2*x8*x9*x10^2*x11-2*x2^3*x4^2*x5*x7^2*x8*x9*x10^2*x11-6*x2^2*x4^3*x6^2*x7*x8*x9*x10^2*x11+8*x2^2*x3*x4^2*x6^2*x7*x8*x9*x10^2*x11+4*x2^2*x3*x4^2*x5*x6*x7*x8*x9*x10^2*x11-2*x2^3*x4^2*x5*x6*x7*x8*x9*x10^2*x11+2*x2^3*x4^3*x6*x7*x8*x9*x10^2*x11-6*x2^2*x3*x4^3*x6^2*x8*x9*x10^2*x11+4*x2^3*x4^3*x6^2*x8*x9*x10^2*x11+7*x2^3*x4*x5^2*x7^3*x9*x10^2*x11-5*x2^3*x4^2*x5*x6*x7^2*x9*x10^2*x11+10*x2^3*x4^2*x5^2*x7^2*x9*x10^2*x11-4*x2^3*x4^3*x5*x6*x7*x9*x10^2*x11-1*x3^4*x6*x8^5*x10^2*x11+3*x3^3*x5*x6*x7*x8^4*x10^2*x11-2*x2*x3^3*x5*x7*x8^4*x10^2*x11-2*x3^3*x4*x6^2*x8^4*x10^2*x11+x3^4*x6^2*x8^4*x10^2*x11-1*x3^4*x5*x6*x8^4*x10^2*x11-3*x2*x3^3*x5*x6*x8^4*x10^2*x11+x2*x3^3*x4*x6*x8^4*x10^2*x11+x2*x3^2*x5^2*x7^2*x8^3*x10^2*x11-16*x2*x3^2*x4*x5*x6*x7*x8^3*x10^2*x11+2*x2*x3^3*x5*x6*x7*x8^3*x10^2*x11-4*x2*x3^3*x5^2*x7*x8^3*x10^2*x11+x2^2*x3^2*x5^2*x7*x8^3*x10^2*x11+4*x2^2*x3^2*x4*x5*x7*x8^3*x10^2*x11+x2*x3^2*x4^2*x6^2*x8^3*x10^2*x11+x2*x3^3*x4*x6^2*x8^3*x10^2*x11+4*x2*x3^3*x4*x5*x6*x8^3*x10^2*x11+4*x2^2*x3^2*x4*x5*x6*x8^3*x10^2*x11+x2^2*x3^2*x4^2*x6*x8^3*x10^2*x11+x2^2*x3*x4*x5^2*x7^2*x8^2*x10^2*x11-2*x2^2*x3^2*x5^2*x7^2*x8^2*x10^2*x11+9*x2^2*x3*x4^2*x5*x6*x7*x8^2*x10^2*x11+8*x2^2*x3^2*x4*x5*x6*x7*x8^2*x10^2*x11+x2^2*x3^2*x4*x5^2*x7*x8^2*x10^2*x11+4*x2^3*x3*x4*x5^2*x7*x8^2*x10^2*x11-2*x2^3*x3*x4^2*x5*x7*x8^2*x10^2*x11+x2^2*x3*x4^3*x6^2*x8^2*x10^2*x11-2*x2^2*x3^2*x4^2*x6^2*x8^2*x10^2*x11+x2^2*x3^2*x4^2*x5*x6*x8^2*x10^2*x11-5*x2^3*x3*x4^2*x5*x6*x8^2*x10^2*x11-1*x2^3*x3*x4^3*x6*x8^2*x10^2*x11+10*x2^3*x4^2*x5^2*x7^2*x8*x10^2*x11-5*x2^3*x3*x4*x5^2*x7^2*x8*x10^2*x11-8*x2^3*x4^3*x5*x6*x7*x8*x10^2*x11-2*x2^3*x3*x4^2*x5*x6*x7*x8*x10^2*x11+4*x2^3*x3*x4^2*x5^2*x7*x8*x10^2*x11-5*x2^4*x4^2*x5^2*x7*x8*x10^2*x11-4*x2^3*x3*x4^3*x5*x6*x8*x10^2*x11+4*x2^4*x4^3*x5*x6*x8*x10^2*x11-5*x2^4*x4^2*x5^2*x7^2*x10^2*x11+4*x2^4*x4^3*x5*x6*x7*x10^2*x11-1*x2^4*x4^3*x5^2*x7*x10^2*x11-1*x6^2*x7^4*x9^5*x10*x11+x6^3*x7^3*x9^5*x10*x11+x3*x6^2*x7^3*x8*x9^4*x10*x11+x3*x6^3*x7^2*x8*x9^4*x10*x11-1*x5*x6^2*x7^4*x9^4*x10*x11+4*x2*x5*x6*x7^4*x9^4*x10*x11+x4*x6^3*x7^3*x9^4*x10*x11-2*x3*x6^3*x7^3*x9^4*x10*x11+3*x3*x5*x6^2*x7^3*x9^4*x10*x11-3*x2*x5*x6^2*x7^3*x9^4*x10*x11+x2*x4*x6^2*x7^3*x9^4*x10*x11+3*x3*x4*x6^3*x7^2*x9^4*x10*x11-2*x2*x4*x6^3*x7^2*x9^4*x10*x11+3*x3^2*x6^2*x7^2*x8^2*x9^3*x10*x11-5*x3^2*x6^3*x7*x8^2*x9^3*x10*x11-2*x3*x5*x6^2*x7^3*x8*x9^3*x10*x11-8*x2*x3*x5*x6*x7^3*x8*x9^3*x10*x11-2*x3*x4*x6^3*x7^2*x8*x9^3*x10*x11+2*x3^2*x6^3*x7^2*x8*x9^3*x10*x11-3*x3^2*x5*x6^2*x7^2*x8*x9^3*x10*x11+8*x2*x3*x5*x6^2*x7^2*x8*x9^3*x10*x11+8*x2*x3*x4*x6^2*x7^2*x8*x9^3*x10*x11-2*x3^2*x4*x6^3*x7*x8*x9^3*x10*x11-8*x2*x3*x4*x6^3*x7*x8*x9^3*x10*x11-3*x2^2*x5^2*x7^4*x9^3*x10*x11+4*x2*x4*x5*x6^2*x7^3*x9^3*x10*x11+2*x2*x3*x5*x6^2*x7^3*x9^3*x10*x11-2*x2*x3*x5^2*x6*x7^3*x9^3*x10*x11+3*x2^2*x5^2*x6*x7^3*x9^3*x10*x11-8*x2^2*x4*x5*x6*x7^3*x9^3*x10*x11-4*x2*x4^2*x6^3*x7^2*x9^3*x10*x11+2*x2*x3*x4*x6^3*x7^2*x9^3*x10*x11-16*x2*x3*x4*x5*x6^2*x7^2*x9^3*x10*x11+4*x2^2*x4*x5*x6^2*x7^2*x9^3*x10*x11+x2^2*x4^2*x6^2*x7^2*x9^3*x10*x11-2*x2*x3*x4^2*x6^3*x7*x9^3*x10*x11+3*x2^2*x4^2*x6^3*x7*x9^3*x10*x11-5*x3^3*x6^2*x7*x8^3*x9^2*x10*x11+3*x3^3*x6^3*x8^3*x9^2*x10*x11+6*x3^2*x5*x6^2*x7^2*x8^2*x9^2*x10*x11+8*x2*x3^2*x5*x6*x7^2*x8^2*x9^2*x10*x11-3*x3^2*x4*x6^3*x7*x8^2*x9^2*x10*x11+2*x3^3*x6^3*x7*x8^2*x9^2*x10*x11-3*x3^3*x5*x6^2*x7*x8^2*x9^2*x10*x11-7*x2*x3^2*x5*x6^2*x7*x8^2*x9^2*x10*x11-7*x2*x3^2*x4*x6^2*x7*x8^2*x9^2*x10*x11-1*x3^3*x4*x6^3*x8^2*x9^2*x10*x11+2*x2*x3^2*x4*x6^3*x8^2*x9^2*x10*x11-2*x2*x3*x5^2*x6*x7^3*x8*x9^2*x10*x11+9*x2^2*x3*x5^2*x7^3*x8*x9^2*x10*x11+8*x2*x3*x4*x5*x6^2*x7^2*x8*x9^2*x10*x11-7*x2*x3^2*x5*x6^2*x7^2*x8*x9^2*x10*x11+4*x2*x3^2*x5^2*x6*x7^2*x8*x9^2*x10*x11-3*x2^2*x3*x5^2*x6*x7^2*x8*x9^2*x10*x11-8*x2^2*x3*x4*x5*x6*x7^2*x8*x9^2*x10*x11-2*x2*x3*x4^2*x6^3*x7*x8*x9^2*x10*x11+8*x2*x3^2*x4*x6^3*x7*x8*x9^2*x10*x11+8*x2*x3^2*x4*x5*x6^2*x7*x8*x9^2*x10*x11-8*x2^2*x3*x4*x5*x6^2*x7*x8*x9^2*x10*x11-3*x2^2*x3*x4^2*x6^2*x7*x8*x9^2*x10*x11-14*x2*x3^2*x4^2*x6^3*x8*x9^2*x10*x11+9*x2^2*x3*x4^2*x6^3*x8*x9^2*x10*x11+x2^2*x5^3*x7^4*x9^2*x10*x11-5*x2^2*x4*x5^2*x6*x7^3*x9^2*x10*x11-4*x2^2*x3*x5^2*x6*x7^3*x9^2*x10*x11+3*x2^2*x3*x5^3*x7^3*x9^2*x10*x11-1*x2^3*x5^3*x7^3*x9^2*x10*x11+7*x2^3*x4*x5^2*x7^3*x9^2*x10*x11+x2^2*x4^2*x5*x6^2*x7^2*x9^2*x10*x11+8*x2^2*x3*x4*x5*x6^2*x7^2*x9^2*x10*x11+9*x2^2*x3*x4*x5^2*x6*x7^2*x9^2*x10*x11-2*x2^3*x4*x5^2*x6*x7^2*x9^2*x10*x11+4*x2^3*x4^2*x5*x6*x7^2*x9^2*x10*x11+3*x2^2*x4^3*x6^3*x7*x9^2*x10*x11-4*x2^2*x3*x4^2*x6^3*x7*x9^2*x10*x11+9*x2^2*x3*x4^2*x5*x6^2*x7*x9^2*x10*x11-5*x2^3*x4^2*x5*x6^2*x7*x9^2*x10*x11-1*x2^3*x4^3*x6^2*x7*x9^2*x10*x11+3*x2^2*x3*x4^3*x6^3*x9^2*x10*x11-2*x2^3*x4^3*x6^3*x9^2*x10*x11+2*x3^4*x6^2*x8^4*x9*x10*x11-2*x3^3*x5*x6^2*x7*x8^3*x9*x10*x11-8*x2*x3^3*x5*x6*x7*x8^3*x9*x10*x11+4*x3^3*x4*x6^3*x8^3*x9*x10*x11-2*x3^4*x6^3*x8^3*x9*x10*x11+3*x3^4*x5*x6^2*x8^3*x9*x10*x11+2*x2*x3^3*x5*x6^2*x8^3*x9*x10*x11-2*x2*x3^3*x4*x6^2*x8^3*x9*x10*x11+4*x2*x3^2*x5^2*x6*x7^2*x8^2*x9*x10*x11-9*x2^2*x3^2*x5^2*x7^2*x8^2*x9*x10*x11+8*x2*x3^2*x4*x5*x6^2*x7*x8^2*x9*x10*x11+8*x2*x3^3*x5*x6^2*x7*x8^2*x9*x10*x11-2*x2*x3^3*x5^2*x6*x7*x8^2*x9*x10*x11-3*x2^2*x3^2*x5^2*x6*x7*x8^2*x9*x10*x11-8*x2^2*x3^2*x4*x5*x6*x7*x8^2*x9*x10*x11-2*x2*x3^2*x4^2*x6^3*x8^2*x9*x10*x11-2*x2*x3^3*x4*x6^3*x8^2*x9*x10*x11-16*x2*x3^3*x4*x5*x6^2*x8^2*x9*x10*x11+8*x2^2*x3^2*x4*x5*x6^2*x8^2*x9*x10*x11-2*x2^2*x3^2*x4^2*x6^2*x8^2*x9*x10*x11-2*x2^2*x3*x5^3*x7^3*x8*x9*x10*x11+4*x2^2*x3*x4*x5^2*x6*x7^2*x8*x9*x10*x11+8*x2^2*x3^2*x5^2*x6*x7^2*x8*x9*x10*x11-6*x2^2*x3^2*x5^3*x7^2*x8*x9*x10*x11+2*x2^3*x3*x5^3*x7^2*x8*x9*x10*x11-2*x2^3*x3*x4*x5^2*x7^2*x8*x9*x10*x11+4*x2^2*x3*x4^2*x5*x6^2*x7*x8*x9*x10*x11-8*x2^2*x3^2*x4*x5*x6^2*x7*x8*x9*x10*x11+4*x2^2*x3^2*x4*x5^2*x6*x7*x8*x9*x10*x11-2*x2^2*x3*x4^3*x6^3*x8*x9*x10*x11+4*x2^2*x3^2*x4^2*x6^3*x8*x9*x10*x11+9*x2^2*x3^2*x4^2*x5*x6^2*x8*x9*x10*x11-2*x2^3*x3*x4^2*x5*x6^2*x8*x9*x10*x11+2*x2^3*x3*x4^3*x6^2*x8*x9*x10*x11+4*x2^3*x4^2*x5^2*x6*x7^2*x9*x10*x11-2*x2^3*x3*x4*x5^2*x6*x7^2*x9*x10*x11-8*x2^3*x3*x4*x5^3*x7^2*x9*x10*x11-5*x2^4*x4^2*x5^2*x7^2*x9*x10*x11-4*x2^3*x4^3*x5*x6^2*x7*x9*x10*x11-2*x2^3*x3*x4^2*x5*x6^2*x7*x9*x10*x11+4*x2^3*x3*x4^2*x5^2*x6*x7*x9*x10*x11+x2^4*x4^2*x5^2*x6*x7*x9*x10*x11-8*x2^3*x3*x4^3*x5*x6^2*x9*x10*x11+4*x2^4*x4^3*x5*x6^2*x9*x10*x11-1*x3^4*x5*x6^2*x8^4*x10*x11+4*x2*x3^4*x5*x6*x8^4*x10*x11-2*x2*x3^3*x5^2*x6*x7*x8^3*x10*x11+3*x2^2*x3^3*x5^2*x7*x8^3*x10*x11+4*x2*x3^3*x4*x5*x6^2*x8^3*x10*x11-3*x2*x3^4*x5*x6^2*x8^3*x10*x11+3*x2^2*x3^3*x5^2*x6*x8^3*x10*x11-8*x2^2*x3^3*x4*x5*x6*x8^3*x10*x11+x2^2*x3^2*x5^3*x7^2*x8^2*x10*x11+9*x2^2*x3^2*x4*x5^2*x6*x7*x8^2*x10*x11-4*x2^2*x3^3*x5^2*x6*x7*x8^2*x10*x11+3*x2^2*x3^3*x5^3*x7*x8^2*x10*x11-1*x2^3*x3^2*x5^3*x7*x8^2*x10*x11-5*x2^3*x3^2*x4*x5^2*x7*x8^2*x10*x11+x2^2*x3^2*x4^2*x5*x6^2*x8^2*x10*x11+4*x2^2*x3^3*x4*x5*x6^2*x8^2*x10*x11-5*x2^2*x3^3*x4*x5^2*x6*x8^2*x10*x11-2*x2^3*x3^2*x4*x5^2*x6*x8^2*x10*x11+4*x2^3*x3^2*x4^2*x5*x6*x8^2*x10*x11-4*x2^3*x3*x4*x5^3*x7^2*x8*x10*x11+4*x2^3*x3*x4^2*x5^2*x6*x7*x8*x10*x11-2*x2^3*x3^2*x4*x5^2*x6*x7*x8*x10*x11-4*x2^3*x3^2*x4*x5^3*x7*x8*x10*x11+x2^4*x3*x4^2*x5^2*x7*x8*x10*x11-4*x2^3*x3*x4^3*x5*x6^2*x8*x10*x11-5*x2^3*x3^2*x4^2*x5*x6^2*x8*x10*x11+4*x2^3*x3^2*x4^2*x5^2*x6*x8*x10*x11+x2^4*x3*x4^2*x5^2*x6*x8*x10*x11-1*x2^4*x4^2*x5^3*x7^2*x10*x11+4*x2^4*x3*x4*x5^3*x7^2*x10*x11+x2^4*x4^3*x5^2*x6*x7*x10*x11-6*x2^4*x3*x4^2*x5^2*x6*x7*x10*x11+x2^4*x3*x4^2*x5^3*x7*x10*x11+x2^5*x4^2*x5^3*x7*x10*x11+x2^5*x4^3*x5^2*x7*x10*x11+4*x2^4*x3*x4^3*x5*x6^2*x10*x11+x2^4*x3*x4^3*x5^2*x6*x10*x11-2*x2^5*x4^3*x5^2*x6*x10*x11+x3*x6^3*x7^3*x9^5*x11-1*x3*x6^4*x7^2*x9^5*x11-3*x3^2*x6^3*x7^2*x8*x9^4*x11+2*x3^2*x6^4*x7*x8*x9^4*x11+x3*x5*x6^3*x7^3*x9^4*x11-2*x2*x3*x5*x6^2*x7^3*x9^4*x11-1*x3*x4*x6^4*x7^2*x9^4*x11+x3^2*x6^4*x7^2*x9^4*x11-2*x3^2*x5*x6^3*x7^2*x9^4*x11+x2*x3*x5*x6^3*x7^2*x9^4*x11-3*x2*x3*x4*x6^3*x7^2*x9^4*x11-1*x3^2*x4*x6^4*x7*x9^4*x11+4*x2*x3*x4*x6^4*x7*x9^4*x11+3*x3^3*x6^3*x7*x8^2*x9^3*x11-1*x3^3*x6^4*x8^2*x9^3*x11-1*x3^2*x5*x6^3*x7^2*x8*x9^3*x11+2*x2*x3^2*x5*x6^2*x7^2*x8*x9^3*x11+3*x3^2*x4*x6^4*x7*x8*x9^3*x11-2*x3^3*x6^4*x7*x8*x9^3*x11+4*x3^3*x5*x6^3*x7*x8*x9^3*x11-2*x2*x3^2*x5*x6^3*x7*x8*x9^3*x11+2*x2*x3^2*x4*x6^3*x7*x8*x9^3*x11+x3^3*x4*x6^4*x8*x9^3*x11-2*x2*x3^2*x4*x6^4*x8*x9^3*x11-4*x2*x3*x5^2*x6^2*x7^3*x9^3*x11+3*x2^2*x3*x5^2*x6*x7^3*x9^3*x11+4*x2*x3*x4*x5*x6^3*x7^2*x9^3*x11+x2*x3^2*x5*x6^3*x7^2*x9^3*x11+x2*x3^2*x5^2*x6^2*x7^2*x9^3*x11+x2^2*x3*x5^2*x6^2*x7^2*x9^3*x11+4*x2^2*x3*x4*x5*x6^2*x7^2*x9^3*x11-3*x2*x3^2*x4*x6^4*x7*x9^3*x11+4*x2*x3^2*x4*x5*x6^3*x7*x9^3*x11-8*x2^2*x3*x4*x5*x6^3*x7*x9^3*x11+3*x2^2*x3*x4^2*x6^3*x7*x9^3*x11+5*x2*x3^2*x4^2*x6^4*x9^3*x11-3*x2^2*x3*x4^2*x6^4*x9^3*x11-1*x3^4*x6^3*x8^3*x9^2*x11-1*x3^3*x5*x6^3*x7*x8^2*x9^2*x11+2*x2*x3^3*x5*x6^2*x7*x8^2*x9^2*x11-2*x3^3*x4*x6^4*x8^2*x9^2*x11+x3^4*x6^4*x8^2*x9^2*x11-2*x3^4*x5*x6^3*x8^2*x9^2*x11+x2*x3^3*x5*x6^3*x8^2*x9^2*x11+x2*x3^3*x4*x6^3*x8^2*x9^2*x11+13*x2*x3^2*x5^2*x6^2*x7^2*x8*x9^2*x11-9*x2^2*x3^2*x5^2*x6*x7^2*x8*x9^2*x11-16*x2*x3^2*x4*x5*x6^3*x7*x8*x9^2*x11-2*x2*x3^3*x5*x6^3*x7*x8*x9^2*x11-2*x2*x3^3*x5^2*x6^2*x7*x8*x9^2*x11-2*x2^2*x3^2*x5^2*x6^2*x7*x8*x9^2*x11+8*x2^2*x3^2*x4*x5*x6^2*x7*x8*x9^2*x11+x2*x3^2*x4^2*x6^4*x8*x9^2*x11+x2*x3^3*x4*x6^4*x8*x9^2*x11+4*x2*x3^3*x4*x5*x6^3*x8*x9^2*x11+4*x2^2*x3^2*x4*x5*x6^3*x8*x9^2*x11+x2^2*x3^2*x4^2*x6^3*x8*x9^2*x11+3*x2^2*x3*x5^3*x6*x7^3*x9^2*x11-2*x2^3*x3*x5^3*x7^3*x9^2*x11+x2^2*x3*x4*x5^2*x6^2*x7^2*x9^2*x11-2*x2^2*x3^2*x5^2*x6^2*x7^2*x9^2*x11+x2^2*x3^2*x5^3*x6*x7^2*x9^2*x11-1*x2^3*x3*x5^3*x6*x7^2*x9^2*x11-5*x2^3*x3*x4*x5^2*x6*x7^2*x9^2*x11-5*x2^2*x3*x4^2*x5*x6^3*x7*x9^2*x11+4*x2^2*x3^2*x4*x5*x6^3*x7*x9^2*x11+x2^2*x3^2*x4*x5^2*x6^2*x7*x9^2*x11+4*x2^3*x3*x4*x5^2*x6^2*x7*x9^2*x11-2*x2^3*x3*x4^2*x5*x6^2*x7*x9^2*x11+x2^2*x3*x4^3*x6^4*x9^2*x11-2*x2^2*x3^2*x4^2*x6^4*x9^2*x11-14*x2^2*x3^2*x4^2*x5*x6^3*x9^2*x11+7*x2^3*x3*x4^2*x5*x6^3*x9^2*x11-1*x2^3*x3*x4^3*x6^3*x9^2*x11+x3^4*x5*x6^3*x8^3*x9*x11-2*x2*x3^4*x5*x6^2*x8^3*x9*x11-14*x2*x3^3*x5^2*x6^2*x7*x8^2*x9*x11+9*x2^2*x3^3*x5^2*x6*x7*x8^2*x9*x11+4*x2*x3^3*x4*x5*x6^3*x8^2*x9*x11+x2*x3^4*x5*x6^3*x8^2*x9*x11+x2*x3^4*x5^2*x6^2*x8^2*x9*x11+x2^2*x3^3*x5^2*x6^2*x8^2*x9*x11+4*x2^2*x3^3*x4*x5*x6^2*x8^2*x9*x11-6*x2^2*x3^2*x5^3*x6*x7^2*x8*x9*x11+4*x2^3*x3^2*x5^3*x7^2*x8*x9*x11+9*x2^2*x3^2*x4*x5^2*x6^2*x7*x8*x9*x11+4*x2^2*x3^3*x5^2*x6^2*x7*x8*x9*x11-2*x2^2*x3^3*x5^3*x6*x7*x8*x9*x11+2*x2^3*x3^2*x5^3*x6*x7*x8*x9*x11-2*x2^3*x3^2*x4*x5^2*x6*x7*x8*x9*x11-5*x2^2*x3^2*x4^2*x5*x6^3*x8*x9*x11-8*x2^2*x3^3*x4*x5*x6^3*x8*x9*x11-5*x2^2*x3^3*x4*x5^2*x6^2*x8*x9*x11-2*x2^3*x3^2*x4*x5^2*x6^2*x8*x9*x11-2*x2^3*x3^2*x4^2*x5*x6^2*x8*x9*x11-4*x2^3*x3*x4*x5^3*x6*x7^2*x9*x11+4*x2^4*x3*x4*x5^3*x7^2*x9*x11+4*x2^3*x3*x4^2*x5^2*x6^2*x7*x9*x11-5*x2^3*x3^2*x4*x5^2*x6^2*x7*x9*x11-4*x2^3*x3^2*x4*x5^3*x6*x7*x9*x11+x2^4*x3*x4^2*x5^2*x6*x7*x9*x11+7*x2^3*x3^2*x4^2*x5*x6^3*x9*x11+10*x2^3*x3^2*x4^2*x5^2*x6^2*x9*x11-5*x2^4*x3*x4^2*x5^2*x6^2*x9*x11+5*x2*x3^4*x5^2*x6^2*x8^3*x11-3*x2^2*x3^4*x5^2*x6*x8^3*x11+3*x2^2*x3^3*x5^3*x6*x7*x8^2*x11-2*x2^3*x3^3*x5^3*x7*x8^2*x11-14*x2^2*x3^3*x4*x5^2*x6^2*x8^2*x11-2*x2^2*x3^4*x5^2*x6^2*x8^2*x11+x2^2*x3^4*x5^3*x6*x8^2*x11-1*x2^3*x3^3*x5^3*x6*x8^2*x11+7*x2^3*x3^3*x4*x5^2*x6*x8^2*x11-8*x2^3*x3^2*x4*x5^3*x6*x7*x8*x11+4*x2^4*x3^2*x4*x5^3*x7*x8*x11+10*x2^3*x3^2*x4^2*x5^2*x6^2*x8*x11+7*x2^3*x3^3*x4*x5^2*x6^2*x8*x11-5*x2^4*x3^2*x4^2*x5^2*x6*x8*x11+x2^4*x3*x4^2*x5^3*x6*x7*x11+4*x2^4*x3^2*x4*x5^3*x6*x7*x11-2*x2^5*x3*x4^2*x5^3*x7*x11-1*x2^4*x3*x4^3*x5^2*x6^2*x11-5*x2^4*x3^2*x4^2*x5^2*x6^2*x11-1*x2^4*x3^2*x4^2*x5^3*x6*x11+x2^5*x3*x4^2*x5^3*x6*x11+x2^5*x3*x4^3*x5^2*x6*x11+x4*x7^3*x8^3*x9*x10^5-1*x4*x7^4*x8^2*x9*x10^5+x4^2*x7^3*x8^2*x9*x10^5-1*x3*x4*x7^2*x8^4*x10^5-2*x4^2*x7^3*x8^3*x10^5+x3*x4*x7^3*x8^3*x10^5+x3*x4^2*x7^2*x8^3*x10^5+x2*x4^2*x7^2*x8^3*x10^5+x2*x4^2*x7^3*x8^2*x10^5-1*x2*x4^3*x7^2*x8^2*x10^5+x5*x7^4*x8^2*x9^2*x10^4+x4*x7^4*x8^2*x9^2*x10^4-3*x4*x6*x7^3*x8^2*x9^2*x10^4-1*x5*x7^5*x8*x9^2*x10^4+2*x4*x6*x7^4*x8*x9^2*x10^4-1*x4*x5*x7^4*x8*x9^2*x10^4-2*x4^2*x6*x7^3*x8*x9^2*x10^4-2*x3*x5*x7^3*x8^3*x9*x10^4-2*x3*x4*x7^3*x8^3*x9*x10^4+x3*x4*x6*x7^2*x8^3*x9*x10^4-1*x4*x5*x7^4*x8^2*x9*x10^4+2*x3*x5*x7^4*x8^2*x9*x10^4+5*x4^2*x6*x7^3*x8^2*x9*x10^4+x3*x4*x6*x7^3*x8^2*x9*x10^4+3*x3*x4*x5*x7^3*x8^2*x9*x10^4-3*x2*x4*x5*x7^3*x8^2*x9*x10^4-2*x2*x4^2*x7^3*x8^2*x9*x10^4-6*x3*x4^2*x6*x7^2*x8^2*x9*x10^4-1*x2*x4^2*x6*x7^2*x8^2*x9*x10^4+4*x2*x4*x5*x7^4*x8*x9*x10^4-2*x2*x4^2*x6*x7^3*x8*x9*x10^4+2*x2*x4^3*x6*x7^2*x8*x9*x10^4+x3^2*x5*x7^2*x8^4*x10^4+x3^2*x4*x7^2*x8^4*x10^4+2*x3^2*x4*x6*x7*x8^4*x10^4+x3*x4*x5*x7^3*x8^3*x10^4-1*x3^2*x5*x7^3*x8^3*x10^4+5*x3*x4^2*x6*x7^2*x8^3*x10^4-3*x3^2*x4*x6*x7^2*x8^3*x10^4-2*x3^2*x4*x5*x7^2*x8^3*x10^4+x2*x3*x4*x5*x7^2*x8^3*x10^4-2*x2*x3*x4^2*x7^2*x8^3*x10^4-2*x3^2*x4^2*x6*x7*x8^3*x10^4-2*x2*x3*x4^2*x6*x7*x8^3*x10^4+5*x2*x4^2*x5*x7^3*x8^2*x10^4-2*x2*x3*x4*x5*x7^3*x8^2*x10^4-1*x2*x4^3*x6*x7^2*x8^2*x10^4-1*x2*x3*x4^2*x6*x7^2*x8^2*x10^4+x2*x3*x4^2*x5*x7^2*x8^2*x10^4-2*x2^2*x4^2*x5*x7^2*x8^2*x10^4+x2^2*x4^3*x7^2*x8^2*x10^4+2*x2*x3*x4^3*x6*x7*x8^2*x10^4-3*x2^2*x4^2*x5*x7^3*x8*x10^4+x2^2*x4^3*x5*x7^2*x8*x10^4+x5*x7^5*x8*x9^3*x10^3-2*x5*x6*x7^4*x8*x9^3*x10^3-2*x4*x6*x7^4*x8*x9^3*x10^3+3*x4*x6^2*x7^3*x8*x9^3*x10^3+x5*x6*x7^5*x9^3*x10^3-2*x5^2*x7^5*x9^3*x10^3-1*x4*x6^2*x7^4*x9^3*x10^3+x4*x5*x6*x7^4*x9^3*x10^3+x4^2*x6^2*x7^3*x9^3*x10^3-3*x3*x5*x7^4*x8^2*x9^2*x10^3+2*x3*x5*x6*x7^3*x8^2*x9^2*x10^3+2*x3*x4*x6*x7^3*x8^2*x9^2*x10^3+3*x3*x4*x6^2*x7^2*x8^2*x9^2*x10^3+x5^2*x7^5*x8*x9^2*x10^3+3*x4*x5*x6*x7^4*x8*x9^2*x10^3+x3*x5*x6*x7^4*x8*x9^2*x10^3+5*x3*x5^2*x7^4*x8*x9^2*x10^3-2*x2*x5^2*x7^4*x8*x9^2*x10^3-3*x2*x4*x5*x7^4*x8*x9^2*x10^3-4*x4^2*x6^2*x7^3*x8*x9^2*x10^3-5*x3*x4*x6^2*x7^3*x8*x9^2*x10^3-2*x3*x4*x5*x6*x7^3*x8*x9^2*x10^3+2*x2*x4*x5*x6*x7^3*x8*x9^2*x10^3+4*x2*x4^2*x6*x7^3*x8*x9^2*x10^3+9*x3*x4^2*x6^2*x7^2*x8*x9^2*x10^3-1*x2*x4^2*x6^2*x7^2*x8*x9^2*x10^3+x2*x5^2*x7^5*x9^2*x10^3-2*x2*x4*x5*x6*x7^4*x9^2*x10^3+5*x2*x4*x5^2*x7^4*x9^2*x10^3+x2*x4^2*x6^2*x7^3*x9^2*x10^3-4*x2*x4^2*x5*x6*x7^3*x9^2*x10^3-1*x2*x4^3*x6^2*x7^2*x9^2*x10^3+3*x3^2*x5*x7^3*x8^3*x9*x10^3+2*x3^2*x5*x6*x7^2*x8^3*x9*x10^3+2*x3^2*x4*x6*x7^2*x8^3*x9*x10^3-5*x3^2*x4*x6^2*x7*x8^3*x9*x10^3-2*x3*x5^2*x7^4*x8^2*x9*x10^3-2*x3*x4*x5*x6*x7^3*x8^2*x9*x10^3-5*x3^2*x5*x6*x7^3*x8^2*x9*x10^3-4*x3^2*x5^2*x7^3*x8^2*x9*x10^3+4*x2*x3*x5^2*x7^3*x8^2*x9*x10^3+2*x2*x3*x4*x5*x7^3*x8^2*x9*x10^3-12*x3*x4^2*x6^2*x7^2*x8^2*x9*x10^3+3*x3^2*x4*x6^2*x7^2*x8^2*x9*x10^3-3*x3^2*x4*x5*x6*x7^2*x8^2*x9*x10^3+8*x2*x3*x4*x5*x6*x7^2*x8^2*x9*x10^3+8*x2*x3*x4^2*x6*x7^2*x8^2*x9*x10^3+9*x3^2*x4^2*x6^2*x7*x8^2*x9*x10^3+2*x2*x3*x4^2*x6^2*x7*x8^2*x9*x10^3-2*x2*x3*x5^2*x7^4*x8*x9*x10^3-2*x2*x4^2*x5*x6*x7^3*x8*x9*x10^3-8*x2*x3*x4*x5*x6*x7^3*x8*x9*x10^3-2*x2*x3*x4*x5^2*x7^3*x8*x9*x10^3+3*x2^2*x4*x5^2*x7^3*x8*x9*x10^3+3*x2^2*x4^2*x5*x7^3*x8*x9*x10^3+2*x2*x4^3*x6^2*x7^2*x8*x9*x10^3+2*x2*x3*x4^2*x6^2*x7^2*x8*x9*x10^3-2*x2*x3*x4^2*x5*x6*x7^2*x8*x9*x10^3-4*x2^2*x4^2*x5*x6*x7^2*x8*x9*x10^3-2*x2^2*x4^3*x6*x7^2*x8*x9*x10^3-4*x2*x3*x4^3*x6^2*x7*x8*x9*x10^3-3*x2^2*x4*x5^2*x7^4*x9*x10^3+3*x2^2*x4^2*x5*x6*x7^3*x9*x10^3-3*x2^2*x4^2*x5^2*x7^3*x9*x10^3+3*x2^2*x4^3*x5*x6*x7^2*x9*x10^3-1*x3^3*x5*x7^2*x8^4*x10^3-2*x3^3*x5*x6*x7*x8^4*x10^3-2*x3^3*x4*x6*x7*x8^4*x10^3-1*x3^3*x4*x6^2*x8^4*x10^3+x3^2*x5^2*x7^3*x8^3*x10^3-1*x3^2*x4*x5*x6*x7^2*x8^3*x10^3+3*x3^3*x5*x6*x7^2*x8^3*x10^3+x3^3*x5^2*x7^2*x8^3*x10^3-2*x2*x3^2*x5^2*x7^2*x8^3*x10^3+x2*x3^2*x4*x5*x7^2*x8^3*x10^3-4*x3^2*x4^2*x6^2*x7*x8^3*x10^3+3*x3^3*x4*x6^2*x7*x8^3*x10^3+4*x3^3*x4*x5*x6*x7*x8^3*x10^3-2*x2*x3^2*x4*x5*x6*x7*x8^3*x10^3+4*x2*x3^2*x4^2*x6*x7*x8^3*x10^3+x3^3*x4^2*x6^2*x8^3*x10^3+x2*x3^2*x4^2*x6^2*x8^3*x10^3-4*x2*x3*x4*x5^2*x7^3*x8^2*x10^3+x2*x3^2*x5^2*x7^3*x8^2*x10^3-14*x2*x3*x4^2*x5*x6*x7^2*x8^2*x10^3+2*x2*x3^2*x4*x5*x6*x7^2*x8^2*x10^3+x2*x3^2*x4*x5^2*x7^2*x8^2*x10^3+x2^2*x3*x4*x5^2*x7^2*x8^2*x10^3+x2^2*x3*x4^2*x5*x7^2*x8^2*x10^3+2*x2*x3*x4^3*x6^2*x7*x8^2*x10^3-1*x2*x3^2*x4^2*x6^2*x7*x8^2*x10^3-2*x2*x3^2*x4^2*x5*x6*x7*x8^2*x10^3+4*x2^2*x3*x4^2*x5*x6*x7*x8^2*x10^3-2*x2^2*x3*x4^3*x6*x7*x8^2*x10^3-1*x2*x3^2*x4^3*x6^2*x8^2*x10^3-3*x2^2*x4^2*x5^2*x7^3*x8*x10^3+3*x2^2*x3*x4*x5^2*x7^3*x8*x10^3+3*x2^2*x4^3*x5*x6*x7^2*x8*x10^3+9*x2^2*x3*x4^2*x5*x6*x7^2*x8*x10^3-2*x2^2*x3*x4^2*x5^2*x7^2*x8*x10^3+x2^3*x4^2*x5^2*x7^2*x8*x10^3-1*x2^3*x4^3*x5*x7^2*x8*x10^3-2*x2^2*x3*x4^3*x5*x6*x7*x8*x10^3+2*x2^3*x4^2*x5^2*x7^3*x10^3-2*x2^3*x4^3*x5*x6*x7^2*x10^3-1*x5*x6*x7^5*x9^4*x10^2+x5*x6^2*x7^4*x9^4*x10^2+x4*x6^2*x7^4*x9^4*x10^2-1*x4*x6^3*x7^3*x9^4*x10^2+x3*x5*x6*x7^4*x8*x9^3*x10^2+2*x3*x5*x6^2*x7^3*x8*x9^3*x10^2+2*x3*x4*x6^2*x7^3*x8*x9^3*x10^2-5*x3*x4*x6^3*x7^2*x8*x9^3*x10^2+x5^2*x6*x7^5*x9^3*x10^2+x2*x5^2*x7^5*x9^3*x10^2-2*x4*x5*x6^2*x7^4*x9^3*x10^2-3*x3*x5*x6^2*x7^4*x9^3*x10^2+5*x3*x5^2*x6*x7^4*x9^3*x10^2-2*x2*x5^2*x6*x7^4*x9^3*x10^2+x2*x4*x5*x6*x7^4*x9^3*x10^2+x4^2*x6^3*x7^3*x9^3*x10^2+3*x3*x4*x6^3*x7^3*x9^3*x10^2-1*x3*x4*x5*x6^2*x7^3*x9^3*x10^2+x2*x4*x5*x6^2*x7^3*x9^3*x10^2-2*x2*x4^2*x6^2*x7^3*x9^3*x10^2-4*x3*x4^2*x6^3*x7^2*x9^3*x10^2+x2*x4^2*x6^3*x7^2*x9^3*x10^2+3*x3^2*x5*x6*x7^3*x8^2*x9^2*x10^2-6*x3^2*x5*x6^2*x7^2*x8^2*x9^2*x10^2-6*x3^2*x4*x6^2*x7^2*x8^2*x9^2*x10^2+3*x3^2*x4*x6^3*x7*x8^2*x9^2*x10^2-6*x3*x5^2*x6*x7^4*x8*x9^2*x10^2-1*x2*x3*x5^2*x7^4*x8*x9^2*x10^2-3*x3*x4*x5*x6^2*x7^3*x8*x9^2*x10^2+3*x3^2*x5*x6^2*x7^3*x8*x9^2*x10^2-12*x3^2*x5^2*x6*x7^3*x8*x9^2*x10^2+8*x2*x3*x5^2*x6*x7^3*x8*x9^2*x10^2+8*x2*x3*x4*x5*x6*x7^3*x8*x9^2*x10^2+9*x3*x4^2*x6^3*x7^2*x8*x9^2*x10^2+3*x3^2*x4*x6^3*x7^2*x8*x9^2*x10^2+6*x3^2*x4*x5*x6^2*x7^2*x8*x9^2*x10^2-7*x2*x3*x4*x5*x6^2*x7^2*x8*x9^2*x10^2-10*x2*x3*x4^2*x6^2*x7^2*x8*x9^2*x10^2-12*x3^2*x4^2*x6^3*x7*x8*x9^2*x10^2+2*x2*x3*x4^2*x6^3*x7*x8*x9^2*x10^2-1*x2*x5^3*x7^5*x9^2*x10^2+x2*x4*x5^2*x6*x7^4*x9^2*x10^2-1*x2*x3*x5^2*x6*x7^4*x9^2*x10^2-1*x2*x3*x5^3*x7^4*x9^2*x10^2+x2^2*x5^3*x7^4*x9^2*x10^2-2*x2^2*x4*x5^2*x7^4*x9^2*x10^2+x2*x4^2*x5*x6^2*x7^3*x9^2*x10^2+2*x2*x3*x4*x5*x6^2*x7^3*x9^2*x10^2-14*x2*x3*x4*x5^2*x6*x7^3*x9^2*x10^2+x2^2*x4*x5^2*x6*x7^3*x9^2*x10^2+x2^2*x4^2*x5*x6*x7^3*x9^2*x10^2-1*x2*x4^3*x6^3*x7^2*x9^2*x10^2-1*x2*x3*x4^2*x6^3*x7^2*x9^2*x10^2+13*x2*x3*x4^2*x5*x6^2*x7^2*x9^2*x10^2-2*x2^2*x4^2*x5*x6^2*x7^2*x9^2*x10^2+x2^2*x4^3*x6^2*x7^2*x9^2*x10^2+2*x2*x3*x4^3*x6^3*x7*x9^2*x10^2-5*x3^3*x5*x6*x7^2*x8^3*x9*x10^2+2*x3^3*x5*x6^2*x7*x8^3*x9*x10^2+2*x3^3*x4*x6^2*x7*x8^3*x9*x10^2+3*x3^3*x4*x6^3*x8^3*x9*x10^2+9*x3^2*x5^2*x6*x7^3*x8^2*x9*x10^2-1*x2*x3^2*x5^2*x7^3*x8^2*x9*x10^2+6*x3^2*x4*x5*x6^2*x7^2*x8^2*x9*x10^2+3*x3^3*x5*x6^2*x7^2*x8^2*x9*x10^2+9*x3^3*x5^2*x6*x7^2*x8^2*x9*x10^2-10*x2*x3^2*x5^2*x6*x7^2*x8^2*x9*x10^2-7*x2*x3^2*x4*x5*x6*x7^2*x8^2*x9*x10^2+9*x3^2*x4^2*x6^3*x7*x8^2*x9*x10^2-5*x3^3*x4*x6^3*x7*x8^2*x9*x10^2-3*x3^3*x4*x5*x6^2*x7*x8^2*x9*x10^2-7*x2*x3^2*x4*x5*x6^2*x7*x8^2*x9*x10^2-10*x2*x3^2*x4^2*x6^2*x7*x8^2*x9*x10^2-4*x3^3*x4^2*x6^3*x8^2*x9*x10^2-1*x2*x3^2*x4^2*x6^3*x8^2*x9*x10^2+2*x2*x3*x5^3*x7^4*x8*x9*x10^2-2*x2*x3*x4*x5^2*x6*x7^3*x8*x9*x10^2+2*x2*x3^2*x5^2*x6*x7^3*x8*x9*x10^2+2*x2*x3^2*x5^3*x7^3*x8*x9*x10^2-2*x2^2*x3*x5^3*x7^3*x8*x9*x10^2-4*x2^2*x3*x4*x5^2*x7^3*x8*x9*x10^2+4*x2*x3*x4^2*x5*x6^2*x7^2*x8*x9*x10^2+8*x2*x3^2*x4*x5*x6^2*x7^2*x8*x9*x10^2+4*x2*x3^2*x4*x5^2*x6*x7^2*x8*x9*x10^2-3*x2^2*x3*x4*x5^2*x6*x7^2*x8*x9*x10^2-3*x2^2*x3*x4^2*x5*x6*x7^2*x8*x9*x10^2-4*x2*x3*x4^3*x6^3*x7*x8*x9*x10^2+2*x2*x3^2*x4^2*x6^3*x7*x8*x9*x10^2+4*x2*x3^2*x4^2*x5*x6^2*x7*x8*x9*x10^2+8*x2^2*x3*x4^2*x5*x6^2*x7*x8*x9*x10^2+4*x2^2*x3*x4^3*x6^2*x7*x8*x9*x10^2+2*x2*x3^2*x4^3*x6^3*x8*x9*x10^2+x2^2*x4*x5^3*x7^4*x9*x10^2-2*x2^2*x4^2*x5^2*x6*x7^3*x9*x10^2+9*x2^2*x3*x4*x5^2*x6*x7^3*x9*x10^2+3*x2^2*x3*x4*x5^3*x7^3*x9*x10^2-1*x2^3*x4*x5^3*x7^3*x9*x10^2+x2^3*x4^2*x5^2*x7^3*x9*x10^2+x2^2*x4^3*x5*x6^2*x7^2*x9*x10^2-9*x2^2*x3*x4^2*x5*x6^2*x7^2*x9*x10^2+3*x2^2*x3*x4^2*x5^2*x6*x7^2*x9*x10^2+x2^3*x4^2*x5^2*x6*x7^2*x9*x10^2-1*x2^3*x4^3*x5*x6*x7^2*x9*x10^2-6*x2^2*x3*x4^3*x5*x6^2*x7*x9*x10^2+2*x3^4*x5*x6*x7*x8^4*x10^2+x3^4*x5*x6^2*x8^4*x10^2+x3^4*x4*x6^2*x8^4*x10^2-4*x3^3*x5^2*x6*x7^2*x8^3*x10^2+x2*x3^3*x5^2*x7^2*x8^3*x10^2-1*x3^3*x4*x5*x6^2*x7*x8^3*x10^2-3*x3^4*x5*x6^2*x7*x8^3*x10^2-2*x3^4*x5^2*x6*x7*x8^3*x10^2+4*x2*x3^3*x5^2*x6*x7*x8^3*x10^2-2*x2*x3^3*x4*x5*x6*x7*x8^3*x10^2+x3^3*x4^2*x6^3*x8^3*x10^2-1*x3^4*x4*x6^3*x8^3*x10^2-2*x3^4*x4*x5*x6^2*x8^3*x10^2+x2*x3^3*x4*x5*x6^2*x8^3*x10^2-2*x2*x3^3*x4^2*x6^2*x8^3*x10^2-1*x2*x3^2*x5^3*x7^3*x8^2*x10^2+13*x2*x3^2*x4*x5^2*x6*x7^2*x8^2*x10^2-1*x2*x3^3*x5^2*x6*x7^2*x8^2*x10^2-1*x2*x3^3*x5^3*x7^2*x8^2*x10^2+x2^2*x3^2*x5^3*x7^2*x8^2*x10^2-2*x2^2*x3^2*x4*x5^2*x7^2*x8^2*x10^2+13*x2*x3^2*x4^2*x5*x6^2*x7*x8^2*x10^2+2*x2*x3^3*x4*x5*x6^2*x7*x8^2*x10^2-2*x2*x3^3*x4*x5^2*x6*x7*x8^2*x10^2-2*x2^2*x3^2*x4*x5^2*x6*x7*x8^2*x10^2-2*x2^2*x3^2*x4^2*x5*x6*x7*x8^2*x10^2-1*x2*x3^2*x4^3*x6^3*x8^2*x10^2+x2*x3^3*x4^2*x6^3*x8^2*x10^2+x2*x3^3*x4^2*x5*x6^2*x8^2*x10^2-2*x2^2*x3^2*x4^2*x5*x6^2*x8^2*x10^2+x2^2*x3^2*x4^3*x6^2*x8^2*x10^2+3*x2^2*x3*x4*x5^3*x7^3*x8*x10^2+3*x2^2*x3*x4^2*x5^2*x6*x7^2*x8*x10^2-9*x2^2*x3^2*x4*x5^2*x6*x7^2*x8*x10^2+x2^2*x3^2*x4*x5^3*x7^2*x8*x10^2-1*x2^3*x3*x4*x5^3*x7^2*x8*x10^2+x2^3*x3*x4^2*x5^2*x7^2*x8*x10^2-6*x2^2*x3*x4^3*x5*x6^2*x7*x8*x10^2-9*x2^2*x3^2*x4^2*x5*x6^2*x7*x8*x10^2+4*x2^2*x3^2*x4^2*x5^2*x6*x7*x8*x10^2-2*x2^3*x3*x4^2*x5^2*x6*x7*x8*x10^2+2*x2^3*x3*x4^3*x5*x6*x7*x8*x10^2+x2^2*x3^2*x4^3*x5*x6^2*x8*x10^2-2*x2^3*x3*x4*x5^3*x7^3*x10^2-2*x2^3*x3*x4^2*x5^2*x6*x7^2*x10^2+4*x2^3*x3*x4^3*x5*x6^2*x7*x10^2+2*x3*x5*x6^2*x7^4*x9^4*x10-2*x3*x5*x6^3*x7^3*x9^4*x10-2*x3*x4*x6^3*x7^3*x9^4*x10+2*x3*x4*x6^4*x7^2*x9^4*x10-5*x3^2*x5*x6^2*x7^3*x8*x9^3*x10+2*x3^2*x5*x6^3*x7^2*x8*x9^3*x10+2*x3^2*x4*x6^3*x7^2*x8*x9^3*x10+x3^2*x4*x6^4*x7*x8*x9^3*x10-2*x3*x5^2*x6^2*x7^4*x9^3*x10-2*x2*x3*x5^2*x6*x7^4*x9^3*x10+4*x3*x4*x5*x6^3*x7^3*x9^3*x10+3*x3^2*x5*x6^3*x7^3*x9^3*x10-4*x3^2*x5^2*x6^2*x7^3*x9^3*x10+4*x2*x3*x5^2*x6^2*x7^3*x9^3*x10-2*x2*x3*x4*x5*x6^2*x7^3*x9^3*x10-2*x3*x4^2*x6^4*x7^2*x9^3*x10-3*x3^2*x4*x6^4*x7^2*x9^3*x10-1*x3^2*x4*x5*x6^3*x7^2*x9^3*x10-2*x2*x3*x4*x5*x6^3*x7^2*x9^3*x10+4*x2*x3*x4^2*x6^3*x7^2*x9^3*x10+5*x3^2*x4^2*x6^4*x7*x9^3*x10-2*x2*x3*x4^2*x6^4*x7*x9^3*x10+3*x3^3*x5*x6^2*x7^2*x8^2*x9^2*x10+2*x3^3*x5*x6^3*x7*x8^2*x9^2*x10+2*x3^3*x4*x6^3*x7*x8^2*x9^2*x10-3*x3^3*x4*x6^4*x8^2*x9^2*x10+9*x3^2*x5^2*x6^2*x7^3*x8*x9^2*x10+2*x2*x3^2*x5^2*x6*x7^3*x8*x9^2*x10-3*x3^2*x4*x5*x6^3*x7^2*x8*x9^2*x10-5*x3^3*x5*x6^3*x7^2*x8*x9^2*x10+9*x3^3*x5^2*x6^2*x7^2*x8*x9^2*x10-10*x2*x3^2*x5^2*x6^2*x7^2*x8*x9^2*x10-7*x2*x3^2*x4*x5*x6^2*x7^2*x8*x9^2*x10-6*x3^2*x4^2*x6^4*x7*x8*x9^2*x10+x3^3*x4*x6^4*x7*x8*x9^2*x10-2*x3^3*x4*x5*x6^3*x7*x8*x9^2*x10+8*x2*x3^2*x4*x5*x6^3*x7*x8*x9^2*x10+8*x2*x3^2*x4^2*x6^3*x7*x8*x9^2*x10+5*x3^3*x4^2*x6^4*x8*x9^2*x10-1*x2*x3^2*x4^2*x6^4*x8*x9^2*x10+2*x2*x3*x5^3*x6*x7^4*x9^2*x10-2*x2*x3*x4*x5^2*x6^2*x7^3*x9^2*x10-1*x2*x3^2*x5^2*x6^2*x7^3*x9^2*x10+2*x2*x3^2*x5^3*x6*x7^3*x9^2*x10-2*x2^2*x3*x5^3*x6*x7^3*x9^2*x10+4*x2^2*x3*x4*x5^2*x6*x7^3*x9^2*x10-2*x2*x3*x4^2*x5*x6^3*x7^2*x9^2*x10+2*x2*x3^2*x4*x5*x6^3*x7^2*x9^2*x10+13*x2*x3^2*x4*x5^2*x6^2*x7^2*x9^2*x10-2*x2^2*x3*x4*x5^2*x6^2*x7^2*x9^2*x10-2*x2^2*x3*x4^2*x5*x6^2*x7^2*x9^2*x10+2*x2*x3*x4^3*x6^4*x7*x9^2*x10-1*x2*x3^2*x4^2*x6^4*x7*x9^2*x10-14*x2*x3^2*x4^2*x5*x6^3*x7*x9^2*x10+4*x2^2*x3*x4^2*x5*x6^3*x7*x9^2*x10-2*x2^2*x3*x4^3*x6^3*x7*x9^2*x10-1*x2*x3^2*x4^3*x6^4*x9^2*x10+x3^4*x5*x6^2*x7*x8^3*x9*x10-2*x3^4*x5*x6^3*x8^3*x9*x10-2*x3^4*x4*x6^3*x8^3*x9*x10-12*x3^3*x5^2*x6^2*x7^2*x8^2*x9*x10+2*x2*x3^3*x5^2*x6*x7^2*x8^2*x9*x10-2*x3^3*x4*x5*x6^3*x7*x8^2*x9*x10+x3^4*x5*x6^3*x7*x8^2*x9*x10-6*x3^4*x5^2*x6^2*x7*x8^2*x9*x10+8*x2*x3^3*x5^2*x6^2*x7*x8^2*x9*x10+8*x2*x3^3*x4*x5*x6^2*x7*x8^2*x9*x10-2*x3^3*x4^2*x6^4*x8^2*x9*x10+2*x3^4*x4*x6^4*x8^2*x9*x10+3*x3^4*x4*x5*x6^3*x8^2*x9*x10+2*x2*x3^3*x4*x5*x6^3*x8^2*x9*x10+4*x2*x3^3*x4^2*x6^3*x8^2*x9*x10-4*x2*x3^2*x5^3*x6*x7^3*x8*x9*x10+4*x2*x3^2*x4*x5^2*x6^2*x7^2*x8*x9*x10+2*x2*x3^3*x5^2*x6^2*x7^2*x8*x9*x10-4*x2*x3^3*x5^3*x6*x7^2*x8*x9*x10+4*x2^2*x3^2*x5^3*x6*x7^2*x8*x9*x10+8*x2^2*x3^2*x4*x5^2*x6*x7^2*x8*x9*x10-2*x2*x3^2*x4^2*x5*x6^3*x7*x8*x9*x10-8*x2*x3^3*x4*x5*x6^3*x7*x8*x9*x10-2*x2*x3^3*x4*x5^2*x6^2*x7*x8*x9*x10-3*x2^2*x3^2*x4*x5^2*x6^2*x7*x8*x9*x10-3*x2^2*x3^2*x4^2*x5*x6^2*x7*x8*x9*x10+2*x2*x3^2*x4^3*x6^4*x8*x9*x10-2*x2*x3^3*x4^2*x6^4*x8*x9*x10-2*x2*x3^3*x4^2*x5*x6^3*x8*x9*x10-4*x2^2*x3^2*x4^2*x5*x6^3*x8*x9*x10-2*x2^2*x3^2*x4^3*x6^3*x8*x9*x10-2*x2^2*x3*x4*x5^3*x6*x7^3*x9*x10+4*x2^2*x3*x4^2*x5^2*x6^2*x7^2*x9*x10-9*x2^2*x3^2*x4*x5^2*x6^2*x7^2*x9*x10-6*x2^2*x3^2*x4*x5^3*x6*x7^2*x9*x10+2*x2^3*x3*x4*x5^3*x6*x7^2*x9*x10-2*x2^3*x3*x4^2*x5^2*x6*x7^2*x9*x10-2*x2^2*x3*x4^3*x5*x6^3*x7*x9*x10+9*x2^2*x3^2*x4^2*x5*x6^3*x7*x9*x10+3*x2^2*x3^2*x4^2*x5^2*x6^2*x7*x9*x10-2*x2^3*x3*x4^2*x5^2*x6^2*x7*x9*x10+2*x2^3*x3*x4^3*x5*x6^2*x7*x9*x10+3*x2^2*x3^2*x4^3*x5*x6^3*x9*x10-1*x3^5*x5*x6^2*x8^4*x10+5*x3^4*x5^2*x6^2*x7*x8^3*x10-2*x2*x3^4*x5^2*x6*x7*x8^3*x10+x3^4*x4*x5*x6^3*x8^3*x10+x3^5*x5*x6^3*x8^3*x10+x3^5*x5^2*x6^2*x8^3*x10-2*x2*x3^4*x5^2*x6^2*x8^3*x10+x2*x3^4*x4*x5*x6^2*x8^3*x10+2*x2*x3^3*x5^3*x6*x7^2*x8^2*x10-14*x2*x3^3*x4*x5^2*x6^2*x7*x8^2*x10-1*x2*x3^4*x5^2*x6^2*x7*x8^2*x10+2*x2*x3^4*x5^3*x6*x7*x8^2*x10-2*x2^2*x3^3*x5^3*x6*x7*x8^2*x10+4*x2^2*x3^3*x4*x5^2*x6*x7*x8^2*x10-4*x2*x3^3*x4^2*x5*x6^3*x8^2*x10-2*x2*x3^4*x4*x5*x6^3*x8^2*x10+x2*x3^4*x4*x5^2*x6^2*x8^2*x10+x2^2*x3^3*x4*x5^2*x6^2*x8^2*x10+x2^2*x3^3*x4^2*x5*x6^2*x8^2*x10-6*x2^2*x3^2*x4*x5^3*x6*x7^2*x8*x10+3*x2^2*x3^2*x4^2*x5^2*x6^2*x7*x8*x10+9*x2^2*x3^3*x4*x5^2*x6^2*x7*x8*x10-2*x2^2*x3^3*x4*x5^3*x6*x7*x8*x10+2*x2^3*x3^2*x4*x5^3*x6*x7*x8*x10-2*x2^3*x3^2*x4^2*x5^2*x6*x7*x8*x10+3*x2^2*x3^2*x4^3*x5*x6^3*x8*x10+3*x2^2*x3^3*x4^2*x5*x6^3*x8*x10-2*x2^2*x3^3*x4^2*x5^2*x6^2*x8*x10+x2^3*x3^2*x4^2*x5^2*x6^2*x8*x10-1*x2^3*x3^2*x4^3*x5*x6^2*x8*x10+4*x2^3*x3^2*x4*x5^3*x6*x7^2*x10-2*x2^3*x3^2*x4^2*x5^2*x6^2*x7*x10-2*x2^3*x3^2*x4^3*x5*x6^3*x10-1*x3^2*x5*x6^3*x7^3*x9^4+x3^2*x5*x6^4*x7^2*x9^4+x3^2*x4*x6^4*x7^2*x9^4-1*x3^2*x4*x6^5*x7*x9^4+3*x3^3*x5*x6^3*x7^2*x8*x9^3-2*x3^3*x5*x6^4*x7*x8*x9^3-2*x3^3*x4*x6^4*x7*x8*x9^3+x3^3*x4*x6^5*x8*x9^3+x3^2*x5^2*x6^3*x7^3*x9^3+x2*x3^2*x5^2*x6^2*x7^3*x9^3-2*x3^2*x4*x5*x6^4*x7^2*x9^3-1*x3^3*x5*x6^4*x7^2*x9^3+x3^3*x5^2*x6^3*x7^2*x9^3-2*x2*x3^2*x5^2*x6^3*x7^2*x9^3+x2*x3^2*x4*x5*x6^3*x7^2*x9^3+x3^2*x4^2*x6^5*x7*x9^3+x3^3*x4*x6^5*x7*x9^3+x3^3*x4*x5*x6^4*x7*x9^3+x2*x3^2*x4*x5*x6^4*x7*x9^3-2*x2*x3^2*x4^2*x6^4*x7*x9^3-2*x3^3*x4^2*x6^5*x9^3+x2*x3^2*x4^2*x6^5*x9^3-3*x3^4*x5*x6^3*x7*x8^2*x9^2+x3^4*x5*x6^4*x8^2*x9^2+x3^4*x4*x6^4*x8^2*x9^2-4*x3^3*x5^2*x6^3*x7^2*x8*x9^2-1*x2*x3^3*x5^2*x6^2*x7^2*x8*x9^2+3*x3^3*x4*x5*x6^4*x7*x8*x9^2+2*x3^4*x5*x6^4*x7*x8*x9^2-2*x3^4*x5^2*x6^3*x7*x8*x9^2+4*x2*x3^3*x5^2*x6^3*x7*x8*x9^2+2*x2*x3^3*x4*x5*x6^3*x7*x8*x9^2+x3^3*x4^2*x6^5*x8*x9^2-1*x3^4*x4*x6^5*x8*x9^2-1*x3^4*x4*x5*x6^4*x8*x9^2-3*x2*x3^3*x4*x5*x6^4*x8*x9^2-2*x2*x3^3*x4^2*x6^4*x8*x9^2-1*x2*x3^2*x5^3*x6^2*x7^3*x9^2+x2*x3^2*x4*x5^2*x6^3*x7^2*x9^2+x2*x3^3*x5^2*x6^3*x7^2*x9^2-1*x2*x3^3*x5^3*x6^2*x7^2*x9^2+x2^2*x3^2*x5^3*x6^2*x7^2*x9^2-2*x2^2*x3^2*x4*x5^2*x6^2*x7^2*x9^2+x2*x3^2*x4^2*x5*x6^4*x7*x9^2-2*x2*x3^3*x4*x5*x6^4*x7*x9^2-4*x2*x3^3*x4*x5^2*x6^3*x7*x9^2+x2^2*x3^2*x4*x5^2*x6^3*x7*x9^2+x2^2*x3^2*x4^2*x5*x6^3*x7*x9^2-1*x2*x3^2*x4^3*x6^5*x9^2+x2*x3^3*x4^2*x6^5*x9^2+5*x2*x3^3*x4^2*x5*x6^4*x9^2-2*x2^2*x3^2*x4^2*x5*x6^4*x9^2+x2^2*x3^2*x4^3*x6^4*x9^2+x3^5*x5*x6^3*x8^3*x9+5*x3^4*x5^2*x6^3*x7*x8^2*x9-1*x2*x3^4*x5^2*x6^2*x7*x8^2*x9-1*x3^4*x4*x5*x6^4*x8^2*x9-1*x3^5*x5*x6^4*x8^2*x9+x3^5*x5^2*x6^3*x8^2*x9-2*x2*x3^4*x5^2*x6^3*x8^2*x9-3*x2*x3^4*x4*x5*x6^3*x8^2*x9+2*x2*x3^3*x5^3*x6^2*x7^2*x8*x9-2*x2*x3^3*x4*x5^2*x6^3*x7*x8*x9-2*x2*x3^4*x5^2*x6^3*x7*x8*x9+2*x2*x3^4*x5^3*x6^2*x7*x8*x9-2*x2^2*x3^3*x5^3*x6^2*x7*x8*x9-4*x2^2*x3^3*x4*x5^2*x6^2*x7*x8*x9+4*x2*x3^4*x4*x5*x6^4*x8*x9+3*x2^2*x3^3*x4*x5^2*x6^3*x8*x9+3*x2^2*x3^3*x4^2*x5*x6^3*x8*x9+x2^2*x3^2*x4*x5^3*x6^2*x7^2*x9-2*x2^2*x3^2*x4^2*x5^2*x6^3*x7*x9+3*x2^2*x3^3*x4*x5^2*x6^3*x7*x9+3*x2^2*x3^3*x4*x5^3*x6^2*x7*x9-1*x2^3*x3^2*x4*x5^3*x6^2*x7*x9+x2^3*x3^2*x4^2*x5^2*x6^2*x7*x9+x2^2*x3^2*x4^3*x5*x6^4*x9-3*x2^2*x3^3*x4^2*x5*x6^4*x9-3*x2^2*x3^3*x4^2*x5^2*x6^3*x9+x2^3*x3^2*x4^2*x5^2*x6^3*x9-1*x2^3*x3^2*x4^3*x5*x6^3*x9-2*x3^5*x5^2*x6^3*x8^3+x2*x3^5*x5^2*x6^2*x8^3-1*x2*x3^4*x5^3*x6^2*x7*x8^2+5*x2*x3^4*x4*x5^2*x6^3*x8^2+x2*x3^5*x5^2*x6^3*x8^2-1*x2*x3^5*x5^3*x6^2*x8^2+x2^2*x3^4*x5^3*x6^2*x8^2-2*x2^2*x3^4*x4*x5^2*x6^2*x8^2+3*x2^2*x3^3*x4*x5^3*x6^2*x7*x8-3*x2^2*x3^3*x4^2*x5^2*x6^3*x8-3*x2^2*x3^4*x4*x5^2*x6^3*x8+x2^2*x3^4*x4*x5^3*x6^2*x8-1*x2^3*x3^3*x4*x5^3*x6^2*x8+x2^3*x3^3*x4^2*x5^2*x6^2*x8-2*x2^3*x3^3*x4*x5^3*x6^2*x7+2*x2^3*x3^3*x4^2*x5^2*x6^3)*(3-1*x1)"); assertEquals(p, Factor(p).multiply()); }
@Test public void testNumberField4() { UnivariatePolynomial<Rational<BigInteger>> minimalPoly = UnivariatePolynomial.create(Q, Q.valueOf(1), Q.valueOf(0), Q.valueOf(1)); AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = new AlgebraicNumberField<>(minimalPoly); MultivariateRing<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> mRing = Rings.MultivariateRing(3, field); Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> uCoder = Coder.mkUnivariateCoder(field, "t"); Coder<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>, Monomial<UnivariatePolynomial<Rational<BigInteger>>>, MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> coder = Coder.mkMultivariateCoder(mRing, uCoder, "x", "y", "z"); MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> p1 = coder.parse("x^2 - 1 "); MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> p2 = coder.parse("x^4 + 1"); for (MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> p : Arrays.asList(p1, p2)) { PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> facs = MultivariateFactorization.Factor(p); assertEquals(p, facs.multiply()); assertEquals(2, facs.size()); } }
@Test public void testBivariateWithSingularConvexHull1() { String[] vars = {"x", "y"}; MultivariatePolynomial<BigInteger> poly = MultivariatePolynomial.parse("4*y^2-5*x*y+x^2 ", Rings.Z, vars); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> f = Factor(poly); assertEquals(2, f.size()); FactorDecompositionTest.assertFactorization(poly, f); } |
MultivariateFactorization { @SuppressWarnings("unchecked") public static PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(final MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> polynomial) { return Factor(polynomial, MultivariateFactorization::factorPrimitiveInNumberField); } private MultivariateFactorization(); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> Factor(final Poly poly); static PolynomialFactorDecomposition<MultivariatePolynomial<Rational<E>>> FactorInQ(MultivariatePolynomial<Rational<E>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> FactorInZ(final MultivariatePolynomial<BigInteger> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> FactorInNumberField(final MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> polynomial); @SuppressWarnings("unchecked") static PolynomialFactorDecomposition<Poly> FactorInGF(final Poly polynomial); } | @Test public void testNumberField1() { Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> pCoder = Coder.mkUnivariateCoder(UnivariateRing(Q), "x"); AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = new AlgebraicNumberField<>(pCoder.parse("1 + x^2")); Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> cfCoder = Coder.mkUnivariateCoder(field, "s"); Coder<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>, ?, ?> coder = Coder.mkMultivariateCoder(MultivariateRing(3, field), cfCoder, "x", "y", "z"); MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> poly = coder.parse("1 + x^2*y^2*z^2"); for (int i = 0; i < 100; ++i) { long start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> factors = FactorInNumberField(poly); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); assertTrue(factors.size() == 2); FactorDecompositionTest.assertFactorization(poly, factors); } }
@Test public void testNumberField3_random() { RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = getRandomData(); int nVars = 3, degree = 4; for (int i = 0; i < its(10, 10); ++i) { UnivariatePolynomial<Rational<BigInteger>> minimalPoly = RandomUnivariatePolynomials .randomPoly(rndd.nextInt(2, 5), rnd) .toBigPoly() .mapCoefficients(Q, cf -> Q.mkNumerator(cf.mod(10))); minimalPoly.setLC(Q.mkNumerator(rndd.nextInt(1, 10))); if (!IrreduciblePolynomials.irreducibleQ(minimalPoly)) { --i; continue; } AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = new AlgebraicNumberField<>(minimalPoly); System.out.println("Field : " + field); Supplier<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> rndPoly = () -> RandomMultivariatePolynomials.randomSharpPolynomial( nVars, rndd.nextInt(degree / 2, degree), rndd.nextInt(4, 9), field, GREVLEX, __ -> RandomUnivariatePolynomials.randomPoly(minimalPoly.degree(), Q, ___ -> Q.mk(rnd.nextInt(10), 1 + rnd.nextInt(10)), rnd), rnd); Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> cfCoder = Coder.mkUnivariateCoder(field, "s"); Coder<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>, ?, ?> coder = Coder.mkMultivariateCoder(MultivariateRing(nVars, field), cfCoder, "x1", "x2", "x3"); for (int j = 0; j < 2; ++j) { MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a = rndPoly.get(), b = rndPoly.get(), c = rndPoly.get(), poly = a.clone().multiply(b, c); long start, elapsed; start = System.nanoTime(); PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> factors = FactorInNumberField(poly); elapsed = System.nanoTime() - start; FactorDecompositionTest.assertFactorization(poly, factors); System.out.println("Elapsed : " + TimeUnits.nanosecondsToString(elapsed)); } } } |
GroebnerMethods { static boolean algebraicallyDependentMonomialsQ(List<DegreeVector> sys) { if (sys.isEmpty()) return false; int nVariables = sys.get(0).exponents.length; int nUnknowns = sys.size(); @SuppressWarnings("unchecked") Rational<BigInteger>[][] lhs = new Rational[nVariables][nUnknowns]; for (int i = 0; i < nVariables; ++i) for (int j = 0; j < nUnknowns; ++j) lhs[i][j] = Q.valueOf(sys.get(j).exponents[i]); Rational<BigInteger>[] rhs = Q.createZeroesArray(nVariables); Rational<BigInteger>[] solution = Q.createZeroesArray(nUnknowns); LinearSolver.SystemInfo solveResult = LinearSolver.solve(Q, lhs, rhs, solution); if (solveResult == Consistent && Arrays.stream(solution).allMatch(Rational::isZero)) return false; if (solveResult == LinearSolver.SystemInfo.Inconsistent) return false; return true; } private GroebnerMethods(); @SuppressWarnings("unchecked") static List<Poly> eliminate(List<Poly> ideal, int variable); static List<Poly> eliminate(List<Poly> ideal, int... variables); @SuppressWarnings("unchecked") static boolean probablyAlgebraicallyDependentQ(List<Poly> sys); static boolean algebraicallyDependentQ(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> algebraicRelations(List<Poly> polys); static Poly[][] JacobianMatrix(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzSolver(List<Poly> polynomials, Poly rhs, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Rational<Poly>> LeinartasDecomposition(Rational<Poly> fraction); } | @Test public void test1() { List<DegreeVector> dvs; dvs = Arrays.asList( new DegreeVector(new int[]{1, 2, 3}), new DegreeVector(new int[]{2, 1, 2}), new DegreeVector(new int[]{3, 4, 5}), new DegreeVector(new int[]{9, 8, 7}), new DegreeVector(new int[]{1, -1, -1})); assertTrue(algebraicallyDependentMonomialsQ(dvs)); dvs = Arrays.asList( new DegreeVector(new int[]{1, 2, 3}), new DegreeVector(new int[]{2, 1, 2})); assertFalse(algebraicallyDependentMonomialsQ(dvs)); dvs = Arrays.asList( new DegreeVector(new int[]{1, 2, 3}), new DegreeVector(new int[]{2, 1, 2}), new DegreeVector(new int[]{3, 1, 2}), new DegreeVector(new int[]{4, 1, 2}), new DegreeVector(new int[]{5, 1, 2})); assertTrue(algebraicallyDependentMonomialsQ(dvs)); } |
GroebnerMethods { @SuppressWarnings("unchecked") public static <Poly extends AMultivariatePolynomial> boolean probablyAlgebraicallyDependentQ(List<Poly> sys) { if (sys.isEmpty()) return false; Poly representative = sys.get(0); if (sys.size() > representative.nVariables) return true; List<DegreeVector> leadTerms; if (sys.stream().allMatch(p -> p.ordering == LEX)) leadTerms = sys.stream().map(AMultivariatePolynomial::lt).collect(Collectors.toList()); else leadTerms = sys.stream().map(p -> p.lt(LEX)).collect(Collectors.toList()); if (!algebraicallyDependentMonomialsQ(leadTerms)) return false; if (isMonomialIdeal(sys)) return true; if (probablyMaximalJacobianRankQ(JacobianMatrix(sys))) return false; return true; } private GroebnerMethods(); @SuppressWarnings("unchecked") static List<Poly> eliminate(List<Poly> ideal, int variable); static List<Poly> eliminate(List<Poly> ideal, int... variables); @SuppressWarnings("unchecked") static boolean probablyAlgebraicallyDependentQ(List<Poly> sys); static boolean algebraicallyDependentQ(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> algebraicRelations(List<Poly> polys); static Poly[][] JacobianMatrix(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzSolver(List<Poly> polynomials, Poly rhs, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Rational<Poly>> LeinartasDecomposition(Rational<Poly> fraction); } | @Test public void test2() { MultivariateRing<MultivariatePolynomial<Rational<BigInteger>>> ring = MultivariateRing(3, Q); Coder<MultivariatePolynomial<Rational<BigInteger>>, ?, ?> coder = Coder.mkMultivariateCoder(ring, "x", "y", "z"); assertFalse(probablyAlgebraicallyDependentQ(Arrays.asList(coder.parse("x"), coder.parse("y")))); assertFalse(probablyAlgebraicallyDependentQ(Arrays.asList(coder.parse("x^2 + x"), coder.parse("x^2 + y")))); } |
GroebnerMethods { @SuppressWarnings("unchecked") public static <Poly extends AMultivariatePolynomial> List<Poly> eliminate(List<Poly> ideal, int variable) { return eliminate0(ideal, variable); } private GroebnerMethods(); @SuppressWarnings("unchecked") static List<Poly> eliminate(List<Poly> ideal, int variable); static List<Poly> eliminate(List<Poly> ideal, int... variables); @SuppressWarnings("unchecked") static boolean probablyAlgebraicallyDependentQ(List<Poly> sys); static boolean algebraicallyDependentQ(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> algebraicRelations(List<Poly> polys); static Poly[][] JacobianMatrix(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzSolver(List<Poly> polynomials, Poly rhs, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Rational<Poly>> LeinartasDecomposition(Rational<Poly> fraction); } | @Ignore @Test public void test3() { List<MultivariatePolynomial<Rational<BigInteger>>> katsura = GroebnerBasesData.katsura(8); eliminate(katsura.stream().map(p -> p.mapCoefficients(Zp64(17), r -> r.numerator().longValueExact())).collect(Collectors.toList()), 0) .stream().sorted(Comparator.comparingInt(AMultivariatePolynomial::nUsedVariables)) .forEach(System.out::println); }
@Test public void test4() { MultivariateRing<MultivariatePolynomialZp64> ring = Rings.MultivariateRingZp64(3, Zp64(32003)); Coder<MultivariatePolynomialZp64, ?, ?> coder = Coder.mkPolynomialCoder(ring, "x", "y", "z"); List<MultivariatePolynomialZp64> ideal = Arrays.asList( coder.parse("x^2"), coder.parse("x*y"), coder.parse("y^5") ); assertTrue(Ideal.create(eliminate(ideal, 0)).isPrincipal()); }
@Test public void test5() { MultivariateRing<MultivariatePolynomial<Rational<BigInteger>>> ring = MultivariateRing(5, Q); Coder<MultivariatePolynomial<Rational<BigInteger>>, ?, ?> coder = Coder.mkPolynomialCoder(ring, "x", "y", "t", "s", "z"); List<MultivariatePolynomial<Rational<BigInteger>>> ideal = Arrays.asList( coder.parse("x - t"), coder.parse("y - t^2"), coder.parse("z - t^3"), coder.parse("s - x + y^3") ); Ideal eliminate = Ideal.create(eliminate(ideal, 2, 3), GREVLEX); Ideal el1 = Ideal.create(eliminate(eliminate(ideal, 2), 3), GREVLEX); Ideal el2 = Ideal.create(eliminate(eliminate(ideal, 3), 2), GREVLEX); assertEquals(eliminate, el1); assertEquals(eliminate, el2); }
@Test @RequiresSingular public void test7() throws IOException, InterruptedException { MultivariateRing<MultivariatePolynomial<Rational<BigInteger>>> ring = MultivariateRing(5, Q); Coder<MultivariatePolynomial<Rational<BigInteger>>, ?, ?> coder = Coder.mkPolynomialCoder(ring, "x", "y", "t", "s", "z"); List<MultivariatePolynomial<Rational<BigInteger>>> ideal = Arrays.asList( coder.parse("x - t"), coder.parse("y - t^2"), coder.parse("z - t^3"), coder.parse("s - x + y^3") ); assertEquals( SingularGB(ideal, GREVLEX, 2, 3), GroebnerBasis(eliminate(ideal, 2, 3), GREVLEX)); }
@Ignore @Test @RequiresSingular public void test8_eliminate_singular_random() throws IOException, InterruptedException { RandomGenerator rnd = getRandom(); IntegersZp64 domain = new IntegersZp64(17); int nIterations = its(100, 1); int nEls = 4; DescriptiveStatistics tF4 = new DescriptiveStatistics(), tSingular = new DescriptiveStatistics(); for (int i = 0; i < nIterations; i++) { System.out.println(); List<MultivariatePolynomialZp64> ideal = new ArrayList<>(); for (int j = 0; j < nEls; j++) ideal.add(RandomMultivariatePolynomials.randomPolynomial(4, 3, 4, domain, GREVLEX, rnd)); System.out.println(ideal); int eliminateVar = rnd.nextInt(4); System.out.println("var: " + eliminateVar); GroebnerBasesTest.SingularResult<MonomialZp64, MultivariatePolynomialZp64> singular = SingularGB(ideal, GREVLEX, eliminateVar); tSingular.addValue(singular.nanoseconds); System.out.println("Empty:" + singular.list.isEmpty()); System.out.println("Singular : " + nanosecondsToString(singular.nanoseconds)); long start; start = System.nanoTime(); List<MultivariatePolynomialZp64> eliminate = eliminate(ideal, eliminateVar); System.out.println("Rings (eliminate): " + nanosecondsToString(System.nanoTime() - start)); List<MultivariatePolynomialZp64> actual = GroebnerBasis(eliminate, GREVLEX); long time = System.nanoTime() - start; tF4.addValue(time); System.out.println("Rings : " + nanosecondsToString(time)); List<MultivariatePolynomialZp64> expected = singular; if (!actual.equals(expected)) { System.out.println(ideal); System.out.println(actual.size()); } assertEquals(expected, actual); } System.out.println("F4 : " + TimeUnits.statisticsNanotime(tF4)); System.out.println("Singular : " + TimeUnits.statisticsNanotime(tSingular)); }
@Test @RequiresSingular public void test8() throws IOException, InterruptedException { MultivariateRing<MultivariatePolynomialZp64> ring = MultivariateRingZp64(4, 17); Coder<MultivariatePolynomialZp64, ?, ?> coder = Coder.mkPolynomialCoder(ring, "x1", "x2", "x3", "x4"); List<MultivariatePolynomialZp64> ideal = Arrays.asList( coder.parse("8*x1^3*x2^2+6*x1^3*x4^3"), coder.parse("16*x2^2*x4+11*x1*x2^2*x4^2+15*x1*x3^3*x4+5*x1*x3^2*x4^3"), coder.parse("8*x2^2*x3^2+2*x2^2*x4^3+2*x1^3*x2^2+12*x1*x2^3*x3^3*x4^2"), coder.parse("2*x1^3*x2*x3+12*x2^3*x3*x4^2+11*x1*x2^3*x4^3+12*x1*x2^2*x3^2*x4^2")); for (int eliminateVar = 0; eliminateVar < 4; eliminateVar++) { GroebnerBasesTest.SingularResult<MonomialZp64, MultivariatePolynomialZp64> singular = SingularGB(ideal, GREVLEX, eliminateVar); System.out.println("Singular : " + nanosecondsToString(singular.nanoseconds)); long start; start = System.nanoTime(); List<MultivariatePolynomialZp64> eliminate = eliminate(ideal, eliminateVar); System.out.println("Rings (eliminate): " + nanosecondsToString(System.nanoTime() - start)); List<MultivariatePolynomialZp64> actual = GroebnerBasis(eliminate, GREVLEX); long time = System.nanoTime() - start; System.out.println("Rings : " + nanosecondsToString(time)); List<MultivariatePolynomialZp64> expected = singular; if (!actual.equals(expected)) { System.out.println(ideal); System.out.println(actual.size()); } assertEquals(expected, actual); } } |
GroebnerMethods { @SuppressWarnings("unchecked") public static <Poly extends AMultivariatePolynomial> List<Poly> algebraicRelations(List<Poly> polys) { return algebraicRelations0(polys); } private GroebnerMethods(); @SuppressWarnings("unchecked") static List<Poly> eliminate(List<Poly> ideal, int variable); static List<Poly> eliminate(List<Poly> ideal, int... variables); @SuppressWarnings("unchecked") static boolean probablyAlgebraicallyDependentQ(List<Poly> sys); static boolean algebraicallyDependentQ(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> algebraicRelations(List<Poly> polys); static Poly[][] JacobianMatrix(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzSolver(List<Poly> polynomials, Poly rhs, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Rational<Poly>> LeinartasDecomposition(Rational<Poly> fraction); } | @Test public void test6() { MultivariateRing<MultivariatePolynomial<Rational<BigInteger>>> ring = MultivariateRing(3, Q); Coder<MultivariatePolynomial<Rational<BigInteger>>, ?, ?> coder = Coder.mkPolynomialCoder(ring, "x", "y", "z"); List<MultivariatePolynomial<Rational<BigInteger>>> sys; sys = Arrays.asList( coder.parse("x - y"), coder.parse("x + y"), coder.parse("x^2 + y^2")); assertNonEmptyAnnihilators(sys, algebraicRelations(sys)); assertTrue(algebraicRelations(Arrays.asList( coder.parse("x * z"), coder.parse("y * z"))).isEmpty()); sys = Arrays.asList( coder.parse("x * y + z^2"), coder.parse("z^2 + y^2"), coder.parse("x^2*y^2 -2 * x * y^3 + y^4")); assertNonEmptyAnnihilators(sys, algebraicRelations(sys)); } |
GroebnerMethods { @SuppressWarnings("unchecked") public static <Poly extends AMultivariatePolynomial> List<Poly> NullstellensatzCertificate(List<Poly> polynomials) { return NullstellensatzCertificate(polynomials, true); } private GroebnerMethods(); @SuppressWarnings("unchecked") static List<Poly> eliminate(List<Poly> ideal, int variable); static List<Poly> eliminate(List<Poly> ideal, int... variables); @SuppressWarnings("unchecked") static boolean probablyAlgebraicallyDependentQ(List<Poly> sys); static boolean algebraicallyDependentQ(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> algebraicRelations(List<Poly> polys); static Poly[][] JacobianMatrix(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzSolver(List<Poly> polynomials, Poly rhs, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Rational<Poly>> LeinartasDecomposition(Rational<Poly> fraction); } | @Test public void testNullstellensatzCertificate1() { MultivariateRing<MultivariatePolynomialZp64> ring = MultivariateRingZp64(3, 17); Coder<MultivariatePolynomialZp64, ?, ?> coder = Coder.mkPolynomialCoder(ring, "x", "y", "z"); List<MultivariatePolynomialZp64> ideal = Arrays.asList( coder.parse("x^2 + 1"), coder.parse("z + x * y + 2"), coder.parse("z^2 - x * y + 2"), coder.parse("z - x * y + x + y")); assertNullstellensatzCertificate(ideal, NullstellensatzCertificate(ideal, true)); assertNullstellensatzCertificate(ideal, NullstellensatzCertificate(ideal, false)); } |
GroebnerMethods { @SuppressWarnings("unchecked") public static <Poly extends AMultivariatePolynomial> List<Rational<Poly>> LeinartasDecomposition(Rational<Poly> fraction) { return LeinartasDecomposition0(fraction); } private GroebnerMethods(); @SuppressWarnings("unchecked") static List<Poly> eliminate(List<Poly> ideal, int variable); static List<Poly> eliminate(List<Poly> ideal, int... variables); @SuppressWarnings("unchecked") static boolean probablyAlgebraicallyDependentQ(List<Poly> sys); static boolean algebraicallyDependentQ(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> algebraicRelations(List<Poly> polys); static Poly[][] JacobianMatrix(List<Poly> sys); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzCertificate(List<Poly> polynomials, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Poly> NullstellensatzSolver(List<Poly> polynomials, Poly rhs, boolean boundTotalDeg); @SuppressWarnings("unchecked") static List<Rational<Poly>> LeinartasDecomposition(Rational<Poly> fraction); } | @Test public void testLeinartasDecomposition1() { MultivariateRing<MultivariatePolynomialZp64> mRing = MultivariateRingZp64(3, 17); Coder<MultivariatePolynomialZp64, ?, ?> mCoder = Coder.mkPolynomialCoder(mRing, "x", "y", "z"); Rationals<MultivariatePolynomialZp64> fRing = Frac(mRing); Coder<Rational<MultivariatePolynomialZp64>, ?, ?> fCoder = Coder.mkRationalsCoder(fRing, mCoder); Rational<MultivariatePolynomialZp64> f = fCoder.parse("(x + y) / (x^2 + y^2) / (x^3 - x * y - 1) / (x - y)"); List<Rational<MultivariatePolynomialZp64>> decomposition = LeinartasDecomposition(f); assertTrue(f.subtract(decomposition.stream().reduce(fRing.getZero(), fRing::add)).isZero()); }
@Test public void test10() { MultivariateRing<MultivariatePolynomial<BigInteger>> paramsRing = MultivariateRing(3, Z); Coder<Rational<MultivariatePolynomial<BigInteger>>, ?, ?> cfCoder = Coder.mkRationalsCoder(Frac(paramsRing), Coder.mkMultivariateCoder(paramsRing, "m1", "m2", "m3")); MultivariateRing<MultivariatePolynomial<Rational<MultivariatePolynomial<BigInteger>>>> ring = MultivariateRing(2, Frac(paramsRing)); Coder<MultivariatePolynomial<Rational<MultivariatePolynomial<BigInteger>>>, ?, ?> coder = Coder.mkMultivariateCoder(ring, cfCoder, "p", "q"); Rationals<MultivariatePolynomial<Rational<MultivariatePolynomial<BigInteger>>>> fRing = Frac(ring); Coder<Rational<MultivariatePolynomial<Rational<MultivariatePolynomial<BigInteger>>>>, ?, ?> fCoder = Coder.mkRationalsCoder(fRing, coder); Rational<MultivariatePolynomial<Rational<MultivariatePolynomial<BigInteger>>>> f = new Rational<>(ring, coder.parse("1"), coder.parse("((p - q)^2 - m3^2)*(p^2 - m1^2)*(q^2 - m2^2)")); List<Rational<MultivariatePolynomial<Rational<MultivariatePolynomial<BigInteger>>>>> decomposition = LeinartasDecomposition(f); assertTrue(f.subtract(decomposition.stream().reduce(fRing.getZero(), fRing::add)).isZero()); for (int i = 0; i < decomposition.size(); i++) { FactorDecomposition<Rational<MultivariatePolynomial<Rational<MultivariatePolynomial<BigInteger>>>>> facs = fRing.factor(decomposition.get(i)); System.out.println(facs.toString(fCoder)); } }
@Test public void test11() { MultivariateRing<MultivariatePolynomial<UnivariatePolynomialZp64>> paramsRing = MultivariateRing(3, GF(2, 16)); Coder<Rational<MultivariatePolynomial<UnivariatePolynomialZp64>>, ?, ?> cfCoder = Coder.mkRationalsCoder(Frac(paramsRing), Coder.mkMultivariateCoder(paramsRing, "m1", "m2", "m3")); MultivariateRing<MultivariatePolynomial<Rational<MultivariatePolynomial<UnivariatePolynomialZp64>>>> ring = MultivariateRing(2, Frac(paramsRing)); Coder<MultivariatePolynomial<Rational<MultivariatePolynomial<UnivariatePolynomialZp64>>>, ?, ?> coder = Coder.mkMultivariateCoder(ring, cfCoder, "p", "q"); Rationals<MultivariatePolynomial<Rational<MultivariatePolynomial<UnivariatePolynomialZp64>>>> fRing = Frac(ring); Coder<Rational<MultivariatePolynomial<Rational<MultivariatePolynomial<UnivariatePolynomialZp64>>>>, ?, ?> fCoder = Coder.mkRationalsCoder(fRing, coder); Rational<MultivariatePolynomial<Rational<MultivariatePolynomial<UnivariatePolynomialZp64>>>> f = new Rational<>(ring, coder.parse("1"), coder.parse("((p - q)^2 - m3^2)*(p^2 - m1^2)*(q^2 - m2^2)")); List<Rational<MultivariatePolynomial<Rational<MultivariatePolynomial<UnivariatePolynomialZp64>>>>> decomposition = LeinartasDecomposition(f); for (int i = 0; i < decomposition.size(); i++) { FactorDecomposition<Rational<MultivariatePolynomial<Rational<MultivariatePolynomial<UnivariatePolynomialZp64>>>>> facs = fRing.factor(decomposition.get(i)); System.out.println(facs.toString(fCoder)); } assertTrue(f.subtract(decomposition.stream().reduce(fRing.getZero(), fRing::add)).isZero()); } |
MultivariateConversions { @SuppressWarnings("unchecked") public static <Poly extends AMultivariatePolynomial<?, Poly>> UnivariatePolynomial<Poly> asUnivariate(Poly poly, int variable) { return poly.asUnivariateEliminate(variable); } private MultivariateConversions(); @SuppressWarnings("unchecked") static MultivariatePolynomial<Poly> split(Poly poly, int... variables); @SuppressWarnings("unchecked") static Poly merge(MultivariatePolynomial<Poly> poly, int... variables); static MultivariateRing<MultivariatePolynomial<Poly>> split(IPolynomialRing<Poly> ring, int... variables); @SuppressWarnings("unchecked") static MultivariateRing<Poly> merge(IPolynomialRing<MultivariatePolynomial<Poly>> ring, int... variables); @SuppressWarnings("unchecked") static UnivariatePolynomial<Poly> asUnivariate(Poly poly, int variable); @SuppressWarnings("unchecked") static Poly fromUnivariate(UnivariatePolynomial<Poly> poly, int variable); static UnivariateRing<UnivariatePolynomial<Poly>> asUnivariate(IPolynomialRing<Poly> ring, int variable); @SuppressWarnings("unchecked") static IPolynomialRing<Poly> fromUnivariate(IPolynomialRing<UnivariatePolynomial<Poly>> ring, int variable); } | @Test public void test2() throws Exception { MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("x1*x2 + 12*x2*x3 + 3*x3*x4^5 + 4*x4*x5 + 5*x5*x6"), b = MultivariatePolynomial.parse("x1*x2 + 2*x2^2*x3 + 3*x3^6*x4^7 + 41*x4*x5 + 1*x5*x6"); MultivariateRing<MultivariatePolynomial<BigInteger>> ring = Rings.MultivariateRing(a); int var = 3; IPolynomialRing<UnivariatePolynomial<MultivariatePolynomial<BigInteger>>> uRing = MultivariateConversions.asUnivariate(ring, var); Rationals<MultivariatePolynomial<BigInteger>> frac = Rings.Frac(uRing.factory().ring); UnivariatePolynomial<Rational<MultivariatePolynomial<BigInteger>>> ra = asUnivariate(a, var).mapCoefficients(frac, p -> new Rational<>(frac.ring, p)), rb = asUnivariate(b, var).mapCoefficients(frac, p -> new Rational<>(frac.ring, p)); System.out.println(Arrays.toString(PolynomialMethods.divideAndRemainder(rb, ra))); } |
GroebnerBases { @SuppressWarnings("unchecked") public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> GBResult<Term, Poly> F4GB(List<Poly> generators, Comparator<DegreeVector> monomialOrder) { return F4GB(generators, monomialOrder, null); } private GroebnerBases(); @SuppressWarnings("unchecked") static List<Poly> GroebnerBasis(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> GroebnerBasisInGF(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> GroebnerBasisInZ(List<MultivariatePolynomial<BigInteger>> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean tryModular); static List<MultivariatePolynomial<Rational<BigInteger>>> GroebnerBasisInQ(List<MultivariatePolynomial<Rational<BigInteger>>> generators,
Comparator<DegreeVector> monomialOrder, HilbertSeries hilbertSeries, boolean tryModular); static List<Poly> ConvertBasis(List<Poly> generators, Comparator<DegreeVector> desiredOrder); static void minimizeGroebnerBases(List<Poly> basis); static void removeRedundant(List<Poly> basis); static Poly syzygy(Poly a, Poly b); static Poly syzygy(SyzygyPair<Term, Poly> sPair); static boolean isGroebnerBasis(List<Poly> ideal, List<Poly> generators, Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> normalSelectionStrategy(Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> withSugar(Comparator<SyzygyPair> initial); static Comparator<SyzygyPair> defaultSelectionStrategy(Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
Comparator<SyzygyPair> strategy); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Term, Poly> HilbertConvertBasis(List<Poly> groebnerBasis,
Comparator<DegreeVector> desiredOrdering); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisRegardingGrevLexWithPermutation(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm, GrevLexWithPermutation order); static Comparator<DegreeVector> optimalOrder(List<Poly> ideal); @SuppressWarnings("unchecked") static GBResult<Term, Poly> F4GB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static boolean isMonomialIdeal(List<? extends AMultivariatePolynomial> ideal); static boolean isHomogeneousIdeal(List<? extends AMultivariatePolynomial> ideal); static List<DegreeVector> leadTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeriesOfLeadingTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeries(List<DegreeVector> ideal); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean trySparse); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm modularAlgorithm,
GroebnerAlgorithm defaultAlgorithm,
BigInteger firstPrime,
HilbertSeries hilbertSeries,
boolean trySparse); static List<Poly> solveGB(List<Poly> generators,
List<Collection<DegreeVector>> gbSkeleton,
Comparator<DegreeVector> monomialOrder); static MinimizationStrategy NO_MINIMIZATION; } | @Test @RequiresSingular public void test6_katsura() throws Exception { IntegersZp64 ring = new IntegersZp64(17); for (int i = 3; i <= its(8, 9); i++) { System.out.println(String.format("=> Katsura%s:", i)); List<MultivariatePolynomialZp64> ideal = GroebnerBasesData.katsura(i) .stream() .map(p -> p.mapCoefficients(ring, r -> ring.modulus(r.numerator()))) .map(p -> p.setOrdering(GREVLEX)) .collect(Collectors.toList()); long start; SingularResult<MonomialZp64, MultivariatePolynomialZp64> singular = SingularGB(ideal, GREVLEX); List<MultivariatePolynomialZp64> expected = singular; System.out.println(" Singular : " + nanosecondsToString(singular.nanoseconds)); start = System.nanoTime(); List<MultivariatePolynomialZp64> actualF4 = F4GB(ideal, GREVLEX); long f4 = System.nanoTime() - start; System.out.println(" F4 : " + nanosecondsToString(f4)); assertEquals(expected, actualF4); if (i <= 8) { List<MultivariatePolynomialZp64> actualE = F4GB(ideal.stream().map(MultivariatePolynomialZp64::toBigPoly).collect(Collectors.toList()), GREVLEX) .stream().map(MultivariatePolynomial::asOverZp64).collect(Collectors.toList()); assertEquals(expected, actualE); } } }
@Test @RequiresSingular public void test6_cyclic() throws Exception { IntegersZp64 ring = new IntegersZp64(17); for (int i = 5; i <= its(7, 7); i++) { System.out.println(String.format("=> Cyclic%s:", i)); List<MultivariatePolynomialZp64> ideal = GroebnerBasesData.cyclic(i) .stream() .map(p -> p.mapCoefficients(ring, r -> ring.modulus(r.numerator()))) .map(p -> p.setOrdering(GREVLEX)) .collect(Collectors.toList()); long start; SingularResult<MonomialZp64, MultivariatePolynomialZp64> singular = SingularGB(ideal, GREVLEX); List<MultivariatePolynomialZp64> expected = singular; System.out.println(" Singular : " + nanosecondsToString(singular.nanoseconds)); start = System.nanoTime(); List<MultivariatePolynomialZp64> actualF4 = F4GB(ideal, GREVLEX); long f4 = System.nanoTime() - start; System.out.println(" F4 : " + nanosecondsToString(f4)); assertEquals(expected, actualF4); if (i <= 7) { List<MultivariatePolynomialZp64> actualE = F4GB(ideal.stream().map(MultivariatePolynomialZp64::toBigPoly).collect(Collectors.toList()), GREVLEX) .stream().map(MultivariatePolynomial::asOverZp64).collect(Collectors.toList()); assertEquals(expected, actualE); } } }
@Test @RequiresSingular public void test10_random() throws Exception { RandomGenerator rnd = getRandom(); IntegersZp64 domain = new IntegersZp64(17); int nIterations = its(100, 300); int nEls = 3; for (int i = 0; i < nIterations; i++) { List<MultivariatePolynomialZp64> ideal = new ArrayList<>(); for (int j = 0; j < nEls; j++) ideal.add(RandomMultivariatePolynomials.randomPolynomial(3, 4, 3, domain, GREVLEX, rnd)); List<MultivariatePolynomialZp64> actual = F4GB(ideal, GREVLEX); List<MultivariatePolynomialZp64> expected = SingularGB(ideal, GREVLEX); if (!actual.equals(expected)) { System.out.println(ideal); System.out.println(actual.size()); } assertEquals(expected, actual); } }
@Test @RequiresSingular public void test14_random() throws Exception { RandomGenerator rnd = getRandom(); IntegersZp64 domain = new IntegersZp64(17); int nIterations = its(1, 1); int nEls = 4; DescriptiveStatistics tF4 = new DescriptiveStatistics(), tSingular = new DescriptiveStatistics(); for (int i = 0; i < nIterations; i++) { System.out.println(); List<MultivariatePolynomialZp64> ideal = new ArrayList<>(); for (int j = 0; j < nEls; j++) ideal.add(RandomMultivariatePolynomials.randomPolynomial(4, 4, 4, domain, GREVLEX, rnd)); long start = System.nanoTime(); List<MultivariatePolynomialZp64> actual = F4GB(ideal, GREVLEX); long time = System.nanoTime() - start; tF4.addValue(time); System.out.println("F4 : " + nanosecondsToString(time)); SingularResult<MonomialZp64, MultivariatePolynomialZp64> singular = SingularGB(ideal, GREVLEX); tSingular.addValue(singular.nanoseconds); System.out.println("Singular : " + nanosecondsToString(singular.nanoseconds)); List<MultivariatePolynomialZp64> expected = singular; if (!actual.equals(expected)) { System.out.println(ideal); System.out.println(actual.size()); } assertEquals(expected, actual); } System.out.println("F4 : " + TimeUnits.statisticsNanotime(tF4)); System.out.println("Singular : " + TimeUnits.statisticsNanotime(tSingular)); }
@Test @RequiresSingular public void test15a_random() throws Exception { RandomGenerator rnd = getRandom(); int nIterations = its(50, 100); int nEls = 3; DescriptiveStatistics tF4 = new DescriptiveStatistics(), tBuch = new DescriptiveStatistics(), tSingular = new DescriptiveStatistics(); for (int i = 0; i < nIterations; i++) { List<MultivariatePolynomial<BigInteger>> ideal = new ArrayList<>(); for (int j = 0; j < nEls; j++) { MultivariatePolynomial<BigInteger> p = RandomMultivariatePolynomials.randomPolynomial(3, 3, 4, Z, GREVLEX, rnd); p = p.setRing(Zp(100)).setRing(Z); ideal.add(p); } long start, time; start = System.nanoTime(); List<MultivariatePolynomial<BigInteger>> f4 = F4GB(ideal, GREVLEX); time = System.nanoTime() - start; tF4.addValue(time); System.out.println("F4 : " + nanosecondsToString(time)); SingularResult<?, MultivariatePolynomial<BigInteger>> singular = SingularGB(ideal, GREVLEX); tSingular.addValue(singular.nanoseconds); System.out.println("Singular : " + nanosecondsToString(singular.nanoseconds)); System.out.println(); List<MultivariatePolynomial<BigInteger>> expected = singular; assertEquals(expected, f4); } System.out.println("F4 : " + TimeUnits.statisticsNanotime(tF4)); System.out.println("Singular : " + TimeUnits.statisticsNanotime(tSingular)); } |
GroebnerBases { @SuppressWarnings("unchecked") public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> GBResult<Term, Poly> BuchbergerGB(List<Poly> generators, Comparator<DegreeVector> monomialOrder) { return BuchbergerGB(generators, monomialOrder, (HilbertSeries) null); } private GroebnerBases(); @SuppressWarnings("unchecked") static List<Poly> GroebnerBasis(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> GroebnerBasisInGF(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> GroebnerBasisInZ(List<MultivariatePolynomial<BigInteger>> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean tryModular); static List<MultivariatePolynomial<Rational<BigInteger>>> GroebnerBasisInQ(List<MultivariatePolynomial<Rational<BigInteger>>> generators,
Comparator<DegreeVector> monomialOrder, HilbertSeries hilbertSeries, boolean tryModular); static List<Poly> ConvertBasis(List<Poly> generators, Comparator<DegreeVector> desiredOrder); static void minimizeGroebnerBases(List<Poly> basis); static void removeRedundant(List<Poly> basis); static Poly syzygy(Poly a, Poly b); static Poly syzygy(SyzygyPair<Term, Poly> sPair); static boolean isGroebnerBasis(List<Poly> ideal, List<Poly> generators, Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> normalSelectionStrategy(Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> withSugar(Comparator<SyzygyPair> initial); static Comparator<SyzygyPair> defaultSelectionStrategy(Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
Comparator<SyzygyPair> strategy); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Term, Poly> HilbertConvertBasis(List<Poly> groebnerBasis,
Comparator<DegreeVector> desiredOrdering); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisRegardingGrevLexWithPermutation(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm, GrevLexWithPermutation order); static Comparator<DegreeVector> optimalOrder(List<Poly> ideal); @SuppressWarnings("unchecked") static GBResult<Term, Poly> F4GB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static boolean isMonomialIdeal(List<? extends AMultivariatePolynomial> ideal); static boolean isHomogeneousIdeal(List<? extends AMultivariatePolynomial> ideal); static List<DegreeVector> leadTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeriesOfLeadingTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeries(List<DegreeVector> ideal); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean trySparse); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm modularAlgorithm,
GroebnerAlgorithm defaultAlgorithm,
BigInteger firstPrime,
HilbertSeries hilbertSeries,
boolean trySparse); static List<Poly> solveGB(List<Poly> generators,
List<Collection<DegreeVector>> gbSkeleton,
Comparator<DegreeVector> monomialOrder); static MinimizationStrategy NO_MINIMIZATION; } | @Test public void test17() throws Exception { for (int i = 0; i < 1; ++i) { System.out.println(i); long start = System.nanoTime(); String[] vars = {"x1", "x2", "x3", "x4"}; MultivariatePolynomial<BigInteger> a = parse("6*x2*x4^3 + 11*x1*x3^3*x4 + 15*x2^3*x3^2*x4 + 13*x1^3*x2^3*x4", Z, GREVLEX, vars), b = parse("11*x1^3 + 13*x3^2*x4^2 + x1^3*x2^3*x3 + 10*x1^3*x2^2*x3^2*x4", Z, GREVLEX, vars), c = parse("7*x1^2*x2*x4 + 4*x1^3*x3 + 12*x1^2*x2^2*x3^2*x4^2", Z, GREVLEX, vars); List<MultivariatePolynomial<BigInteger>> gens = Arrays.asList(a, b, c); List<MultivariatePolynomial<Rational<MultivariatePolynomial<BigInteger>>>> funcGens = gens.stream() .map(p -> MultivariateConversions.split(p, 2, 3)) .map(p -> p.mapCoefficients(Frac(p.ring), cf -> new Rational<>(p.ring, cf))) .collect(Collectors.toList()); List<MultivariatePolynomial<Rational<MultivariatePolynomial<BigInteger>>>> funcGB = BuchbergerGB(funcGens, GREVLEX); assertTrue(funcGB.get(0).isConstant()); System.out.println(nanosecondsToString(System.nanoTime() - start)); } } |
GroebnerBases { @SuppressWarnings("unchecked") public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> List<Poly> GroebnerBasis(List<Poly> generators, Comparator<DegreeVector> monomialOrder) { if (generators.isEmpty()) return Collections.emptyList(); if (monomialOrder instanceof GrevLexWithPermutation) { GroebnerAlgorithm<Term, Poly> ga = (p, o, s) -> GBResult.notBuchberger(GroebnerBasis(p, o)); return GroebnerBasisRegardingGrevLexWithPermutation(generators, ga, (GrevLexWithPermutation) monomialOrder); } Poly factory = generators.get(0); if (factory.isOverFiniteField()) return GroebnerBasisInGF(generators, monomialOrder, null); if (factory.isOverZ()) return (List<Poly>) GroebnerBasisInZ((List) generators, monomialOrder, null, true); if (Util.isOverRationals(factory) && ((MultivariatePolynomial) factory).ring.equals(Rings.Q)) return (List<Poly>) GroebnerBasisInQ((List) generators, monomialOrder, null, true); else return BuchbergerGB(generators, monomialOrder); } private GroebnerBases(); @SuppressWarnings("unchecked") static List<Poly> GroebnerBasis(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> GroebnerBasisInGF(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> GroebnerBasisInZ(List<MultivariatePolynomial<BigInteger>> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean tryModular); static List<MultivariatePolynomial<Rational<BigInteger>>> GroebnerBasisInQ(List<MultivariatePolynomial<Rational<BigInteger>>> generators,
Comparator<DegreeVector> monomialOrder, HilbertSeries hilbertSeries, boolean tryModular); static List<Poly> ConvertBasis(List<Poly> generators, Comparator<DegreeVector> desiredOrder); static void minimizeGroebnerBases(List<Poly> basis); static void removeRedundant(List<Poly> basis); static Poly syzygy(Poly a, Poly b); static Poly syzygy(SyzygyPair<Term, Poly> sPair); static boolean isGroebnerBasis(List<Poly> ideal, List<Poly> generators, Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> normalSelectionStrategy(Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> withSugar(Comparator<SyzygyPair> initial); static Comparator<SyzygyPair> defaultSelectionStrategy(Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
Comparator<SyzygyPair> strategy); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Term, Poly> HilbertConvertBasis(List<Poly> groebnerBasis,
Comparator<DegreeVector> desiredOrdering); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisRegardingGrevLexWithPermutation(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm, GrevLexWithPermutation order); static Comparator<DegreeVector> optimalOrder(List<Poly> ideal); @SuppressWarnings("unchecked") static GBResult<Term, Poly> F4GB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static boolean isMonomialIdeal(List<? extends AMultivariatePolynomial> ideal); static boolean isHomogeneousIdeal(List<? extends AMultivariatePolynomial> ideal); static List<DegreeVector> leadTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeriesOfLeadingTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeries(List<DegreeVector> ideal); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean trySparse); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm modularAlgorithm,
GroebnerAlgorithm defaultAlgorithm,
BigInteger firstPrime,
HilbertSeries hilbertSeries,
boolean trySparse); static List<Poly> solveGB(List<Poly> generators,
List<Collection<DegreeVector>> gbSkeleton,
Comparator<DegreeVector> monomialOrder); static MinimizationStrategy NO_MINIMIZATION; } | @Test(timeout = 10_000) public void test21() throws Exception { String[] vars = {"x", "y", "z"}; MultivariatePolynomial<BigInteger> a = parse("x^2 - y*z*x^2 + 2", Z, LEX, vars), b = parse("x^2*y*z^3 - y*z^2 + 2*x^5", Z, LEX, vars), c = parse("x*y*z^3 - y*z^12 + 2*x*y*z^5", Z, LEX, vars); List<MultivariatePolynomial<BigInteger>> gens = Arrays.asList(a, b, c); List<MultivariatePolynomial<BigInteger>> gb = GroebnerBasis(gens, LEX); assertEquals(3, gb.size()); } |
GroebnerBases { public static HilbertSeries HilbertSeriesOfLeadingTermsSet(List<? extends AMultivariatePolynomial> ideal) { if (!isHomogeneousIdeal(ideal) && !isGradedOrder(ideal.get(0).ordering)) throw new IllegalArgumentException("Basis should be homogeneous or use graded (degree compatible) monomial order"); if (ideal.stream().anyMatch(IPolynomial::isZero)) return new HilbertSeries(UnivariatePolynomial.one(Q), ideal.get(0).nVariables); return HilbertSeries(leadTermsSet(ideal)); } private GroebnerBases(); @SuppressWarnings("unchecked") static List<Poly> GroebnerBasis(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> GroebnerBasisInGF(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> GroebnerBasisInZ(List<MultivariatePolynomial<BigInteger>> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean tryModular); static List<MultivariatePolynomial<Rational<BigInteger>>> GroebnerBasisInQ(List<MultivariatePolynomial<Rational<BigInteger>>> generators,
Comparator<DegreeVector> monomialOrder, HilbertSeries hilbertSeries, boolean tryModular); static List<Poly> ConvertBasis(List<Poly> generators, Comparator<DegreeVector> desiredOrder); static void minimizeGroebnerBases(List<Poly> basis); static void removeRedundant(List<Poly> basis); static Poly syzygy(Poly a, Poly b); static Poly syzygy(SyzygyPair<Term, Poly> sPair); static boolean isGroebnerBasis(List<Poly> ideal, List<Poly> generators, Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> normalSelectionStrategy(Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> withSugar(Comparator<SyzygyPair> initial); static Comparator<SyzygyPair> defaultSelectionStrategy(Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
Comparator<SyzygyPair> strategy); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Term, Poly> HilbertConvertBasis(List<Poly> groebnerBasis,
Comparator<DegreeVector> desiredOrdering); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisRegardingGrevLexWithPermutation(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm, GrevLexWithPermutation order); static Comparator<DegreeVector> optimalOrder(List<Poly> ideal); @SuppressWarnings("unchecked") static GBResult<Term, Poly> F4GB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static boolean isMonomialIdeal(List<? extends AMultivariatePolynomial> ideal); static boolean isHomogeneousIdeal(List<? extends AMultivariatePolynomial> ideal); static List<DegreeVector> leadTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeriesOfLeadingTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeries(List<DegreeVector> ideal); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean trySparse); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm modularAlgorithm,
GroebnerAlgorithm defaultAlgorithm,
BigInteger firstPrime,
HilbertSeries hilbertSeries,
boolean trySparse); static List<Poly> solveGB(List<Poly> generators,
List<Collection<DegreeVector>> gbSkeleton,
Comparator<DegreeVector> monomialOrder); static MinimizationStrategy NO_MINIMIZATION; } | @Test public void testHilbertSeries1() throws Exception { String[] vars = {"x", "y", "z"}; MultivariatePolynomial a = parse("x^3*y^2*z^3", Q, GREVLEX, vars), b = parse("x^4*y*z^3", Q, GREVLEX, vars), c = parse("x^2*y^4*z^3", Q, GREVLEX, vars); List<MultivariatePolynomial> ideal = new ArrayList<>(Arrays.asList(a, b, c)); HilbertSeries hps = HilbertSeriesOfLeadingTermsSet(ideal); assertEquals(2, hps.dimension()); assertEquals(UnivariatePolynomial.parse("-5 + 6*x", Q), hps.hilbertPolynomial()); }
@Test public void testHilbertSeries2() throws Exception { String[] vars = {"x", "y", "z"}; MultivariatePolynomial a = parse("x*z", Q, GREVLEX, vars), b = parse("y*z", Q, GREVLEX, vars); List<MultivariatePolynomial> ideal = new ArrayList<>(Arrays.asList(a, b)); HilbertSeries hps = HilbertSeriesOfLeadingTermsSet(ideal); assertEquals(2, hps.dimension()); assertEquals(UnivariatePolynomial.parse("x + 2", Q), hps.hilbertPolynomial()); }
@Test public void testHilbertSeries3() throws Exception { String[] vars = {"x", "y", "z", "w", "u"}; MultivariatePolynomial a = parse("x^13*y^2*z^3*w^7", Q, GREVLEX, vars), b = parse("x^4*y*z^3*w^6*u^8", Q, GREVLEX, vars), c = parse("x^2*y^4*z^3", Q, GREVLEX, vars), d = parse("x*y^14*z^3*u^6*w^6", Q, GREVLEX, vars); List<MultivariatePolynomial> ideal = new ArrayList<>(Arrays.asList(a, b, c, d)); HilbertSeries hps = HilbertSeriesOfLeadingTermsSet(ideal); assertEquals(4, hps.dimension()); assertEquals(UnivariatePolynomial.parse("2134+(-1702/3)*x+(57/2)*x^2+(5/6)*x^3", Q), hps.hilbertPolynomial()); }
@Test public void testHilbertSeries4() throws Exception { HilbertSeries hps = HilbertSeriesOfLeadingTermsSet(Collections.singletonList(MultivariatePolynomial.parse("1"))); assertEquals(0, hps.dimension()); assertEquals(0, hps.degree()); }
@Test public void testHilbertSeries5() throws Exception { HilbertSeries hps = HilbertSeriesOfLeadingTermsSet(Collections.singletonList(MultivariatePolynomial.parse("0*x*y*z"))); assertEquals(3, hps.dimension()); assertEquals(1, hps.degree()); } |
GroebnerBases { public static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal, Comparator<DegreeVector> monomialOrder) { return ModularGB(ideal, monomialOrder, null, false); } private GroebnerBases(); @SuppressWarnings("unchecked") static List<Poly> GroebnerBasis(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> GroebnerBasisInGF(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> GroebnerBasisInZ(List<MultivariatePolynomial<BigInteger>> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean tryModular); static List<MultivariatePolynomial<Rational<BigInteger>>> GroebnerBasisInQ(List<MultivariatePolynomial<Rational<BigInteger>>> generators,
Comparator<DegreeVector> monomialOrder, HilbertSeries hilbertSeries, boolean tryModular); static List<Poly> ConvertBasis(List<Poly> generators, Comparator<DegreeVector> desiredOrder); static void minimizeGroebnerBases(List<Poly> basis); static void removeRedundant(List<Poly> basis); static Poly syzygy(Poly a, Poly b); static Poly syzygy(SyzygyPair<Term, Poly> sPair); static boolean isGroebnerBasis(List<Poly> ideal, List<Poly> generators, Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> normalSelectionStrategy(Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> withSugar(Comparator<SyzygyPair> initial); static Comparator<SyzygyPair> defaultSelectionStrategy(Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
Comparator<SyzygyPair> strategy); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Term, Poly> HilbertConvertBasis(List<Poly> groebnerBasis,
Comparator<DegreeVector> desiredOrdering); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisRegardingGrevLexWithPermutation(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm, GrevLexWithPermutation order); static Comparator<DegreeVector> optimalOrder(List<Poly> ideal); @SuppressWarnings("unchecked") static GBResult<Term, Poly> F4GB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static boolean isMonomialIdeal(List<? extends AMultivariatePolynomial> ideal); static boolean isHomogeneousIdeal(List<? extends AMultivariatePolynomial> ideal); static List<DegreeVector> leadTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeriesOfLeadingTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeries(List<DegreeVector> ideal); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean trySparse); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm modularAlgorithm,
GroebnerAlgorithm defaultAlgorithm,
BigInteger firstPrime,
HilbertSeries hilbertSeries,
boolean trySparse); static List<Poly> solveGB(List<Poly> generators,
List<Collection<DegreeVector>> gbSkeleton,
Comparator<DegreeVector> monomialOrder); static MinimizationStrategy NO_MINIMIZATION; } | @Test public void testModularGB2() throws Exception { String[] vars = {"x", "y", "z"}; MultivariatePolynomial<BigInteger> a = parse("8*x^2*y^2 + 5*x*y^3 + 3*x^3*z + x^2*y*z", Z, GREVLEX, vars), b = parse("x^5 + 2*y^3*z^2 + 13*y^2*z^3 + 5*y*z^4", Z, GREVLEX, vars), c = parse("8*x^3 + 12*y^3 + x*z^2 + 3", Z, GREVLEX, vars), d = parse("7*x^2*y^4 + 18*x*y^3*z^2 + y^3*z^3", Z, GREVLEX, vars); List<MultivariatePolynomial<BigInteger>> gens = Arrays.asList(a, b, c, d); List<MultivariatePolynomial<BigInteger>> expected = Arrays.asList( parse("x", Z, GREVLEX, vars), parse("z^2", Z, GREVLEX, vars), parse("1 + 4*y^3", Z, GREVLEX, vars) ); for (int i = 0; i < 1; ++i) { long start; start = System.nanoTime(); List<MultivariatePolynomial<BigInteger>> mod = ModularGB(gens, GREVLEX); System.out.println("Modular: " + nanosecondsToString(System.nanoTime() - start)); assertEquals(expected, mod); } }
@Test public void testModularGB4() throws Exception { String[] vars = {"x", "y", "z"}; MultivariatePolynomial<BigInteger> a = parse("8*x^2*y^2 + 5*x*y^3 + 3*x^3*z + x^2*y*z", Z, GREVLEX, vars), b = parse("x^5 + 2*y^3*z^2 + 13*y^2*z^3 + 5*y*z^4", Z, GREVLEX, vars), c = parse("8*x^3 + 12*y^3 + x*z^2 + 3", Z, GREVLEX, vars), d = parse("7*x^2*y^4 + 18*x*y^3*z^2 + y^3*z^3", Z, GREVLEX, vars); List<MultivariatePolynomial<BigInteger>> gens = Arrays.asList(a, b, c, d); RandomGenerator rnd = getRandom(); for (int i = 0; i < its(1, 2); ++i) { rnd.setSeed(123 + i); List<MultivariatePolynomial<BigInteger>> shuffled = shuffleGB(gens, rnd, 2, 3); long start; start = System.nanoTime(); List<MultivariatePolynomial<BigInteger>> mod = ModularGB(shuffled, GREVLEX, null, false); System.out.println("Modular: " + nanosecondsToString(System.nanoTime() - start)); start = System.nanoTime(); List<MultivariatePolynomial<BigInteger>> sparse = ModularGB(shuffled, GREVLEX, null, true); System.out.println("Sparse: " + nanosecondsToString(System.nanoTime() - start)); assertEquals(mod, sparse); } } |
GroebnerBases { public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> List<Poly> solveGB(List<Poly> generators, List<Collection<DegreeVector>> gbSkeleton, Comparator<DegreeVector> monomialOrder) { return solveGB0(generators, gbSkeleton.stream().map(c -> { TreeSet<DegreeVector> set = new TreeSet<>(monomialOrder); set.addAll(c); return set; }).collect(Collectors.toList()), monomialOrder); } private GroebnerBases(); @SuppressWarnings("unchecked") static List<Poly> GroebnerBasis(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> GroebnerBasisInGF(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> GroebnerBasisInZ(List<MultivariatePolynomial<BigInteger>> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean tryModular); static List<MultivariatePolynomial<Rational<BigInteger>>> GroebnerBasisInQ(List<MultivariatePolynomial<Rational<BigInteger>>> generators,
Comparator<DegreeVector> monomialOrder, HilbertSeries hilbertSeries, boolean tryModular); static List<Poly> ConvertBasis(List<Poly> generators, Comparator<DegreeVector> desiredOrder); static void minimizeGroebnerBases(List<Poly> basis); static void removeRedundant(List<Poly> basis); static Poly syzygy(Poly a, Poly b); static Poly syzygy(SyzygyPair<Term, Poly> sPair); static boolean isGroebnerBasis(List<Poly> ideal, List<Poly> generators, Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> normalSelectionStrategy(Comparator<DegreeVector> monomialOrder); static Comparator<SyzygyPair> withSugar(Comparator<SyzygyPair> initial); static Comparator<SyzygyPair> defaultSelectionStrategy(Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); @SuppressWarnings("unchecked") static GBResult<Term, Poly> BuchbergerGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
Comparator<SyzygyPair> strategy); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); static GBResult<Term, Poly> HilbertConvertBasis(List<Poly> groebnerBasis,
Comparator<DegreeVector> desiredOrdering); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static GBResult<Term, Poly> HilbertGB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal); static List<Poly> GroebnerBasisWithOptimizedGradedOrder(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm); static List<Poly> GroebnerBasisRegardingGrevLexWithPermutation(List<Poly> ideal, GroebnerAlgorithm<Term, Poly> baseAlgorithm, GrevLexWithPermutation order); static Comparator<DegreeVector> optimalOrder(List<Poly> ideal); @SuppressWarnings("unchecked") static GBResult<Term, Poly> F4GB(List<Poly> generators,
Comparator<DegreeVector> monomialOrder); static boolean isMonomialIdeal(List<? extends AMultivariatePolynomial> ideal); static boolean isHomogeneousIdeal(List<? extends AMultivariatePolynomial> ideal); static List<DegreeVector> leadTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeriesOfLeadingTermsSet(List<? extends AMultivariatePolynomial> ideal); static HilbertSeries HilbertSeries(List<DegreeVector> ideal); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder); static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
HilbertSeries hilbertSeries,
boolean trySparse); @SuppressWarnings("unchecked") static GBResult<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> ModularGB(List<MultivariatePolynomial<BigInteger>> ideal,
Comparator<DegreeVector> monomialOrder,
GroebnerAlgorithm modularAlgorithm,
GroebnerAlgorithm defaultAlgorithm,
BigInteger firstPrime,
HilbertSeries hilbertSeries,
boolean trySparse); static List<Poly> solveGB(List<Poly> generators,
List<Collection<DegreeVector>> gbSkeleton,
Comparator<DegreeVector> monomialOrder); static MinimizationStrategy NO_MINIMIZATION; } | @Test public void testSparseGB1() throws Exception { String[] vars = {"x", "y", "z"}; MultivariatePolynomial<BigInteger> a = parse("8*x^2*y^2 + 5*x*y^3 + 3*x^3*z + x^2*y*z", Z, GREVLEX, vars), b = parse("x^5 + 2*y^3*z^2 + 13*y^2*z^3 + 5*y*z^4", Z, GREVLEX, vars), c = parse("8*x^3 + 12*y^3 + x*z^2 + 3", Z, GREVLEX, vars), d = parse("7*x^2*y^4 + 18*x*y^3*z^2 + y^3*z^3", Z, GREVLEX, vars); List<MultivariatePolynomial<BigInteger>> gens = Arrays.asList(a, b, c, d); List<MultivariatePolynomial<BigInteger>> expected = new ArrayList<>(Arrays.asList( parse("x", Z, GREVLEX, vars), parse("z^2", Z, GREVLEX, vars), parse("1 + 4*y^3", Z, GREVLEX, vars) )); List<MultivariatePolynomial<BigInteger>> gb = solveGB(gens, expected.stream().map(p -> ((SortedSet<DegreeVector>) p.terms.keySet())).collect(Collectors.toList()), GREVLEX); assertEquals(expected, gb); } |
RandomMultivariatePolynomials { public static MultivariatePolynomial<BigInteger> randomPolynomial(int nVars, int degree, int size, BigInteger bound, Comparator<DegreeVector> ordering, RandomGenerator rnd) { int nd = 3 * degree / 2; @SuppressWarnings("unchecked") Monomial<BigInteger>[] terms = new Monomial[size]; for (int i = 0; i < size; i++) { BigInteger cfx = RandomUtil.randomInt(bound, rnd); if (rnd.nextBoolean() && rnd.nextBoolean()) cfx = cfx.negate(); int[] exponents = RandomUtil.randomIntArray(nVars, 0, nd, rnd); terms[i] = new Monomial<>(exponents, cfx); } return MultivariatePolynomial.create(nVars, Rings.Z, ordering, terms); } private RandomMultivariatePolynomials(); static MultivariatePolynomial<BigInteger> randomPolynomial(int nVars, int degree, int size, BigInteger bound, Comparator<DegreeVector> ordering, RandomGenerator rnd); static MultivariatePolynomial<BigInteger> randomPolynomial(int nVars, int degree, int size, RandomGenerator rnd); static MultivariatePolynomial<E> randomPolynomial(int nVars, int degree, int size, Ring<E> ring,
Comparator<DegreeVector> ordering,
Function<RandomGenerator, E> method, RandomGenerator rnd); static MultivariatePolynomial<E> randomPolynomial(int nVars, int minDegree, int maxDegree, int size, Ring<E> ring,
Comparator<DegreeVector> ordering,
Function<RandomGenerator, E> method, RandomGenerator rnd); static MultivariatePolynomial<E> randomPolynomial(int nVars, int degree, int size, Ring<E> ring, Comparator<DegreeVector> ordering, RandomGenerator rnd); static MultivariatePolynomialZp64 randomPolynomial(int nVars, int degree, int size, IntegersZp64 ring, RandomGenerator rnd); static MultivariatePolynomialZp64 randomPolynomial(int nVars, int degree, int size, IntegersZp64 ring, Comparator<DegreeVector> ordering, RandomGenerator rnd); static MultivariatePolynomialZp64 randomSharpPolynomial(int nVars, int degree, int size, IntegersZp64 ring, Comparator<DegreeVector> ordering, RandomGenerator rnd); static MultivariatePolynomial<E> randomSharpPolynomial(int nVars, int degree, int size, Ring<E> ring,
Comparator<DegreeVector> ordering,
Function<RandomGenerator, E> rndCoefficients,
RandomGenerator rnd); @SuppressWarnings("unchecked") static Poly randomPolynomial(Poly factory, int degree, int size, RandomGenerator rnd); } | @Test public void name() throws Exception { System.out.println(RandomMultivariatePolynomials.randomPolynomial(5, 5, 5, BigInteger.valueOf(123), MonomialOrder.LEX, getRandom())); } |
MultivariateDivision { @SuppressWarnings("unchecked") public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> Poly[] divideAndRemainder(Poly dividend, Poly... dividers) { Poly[] quotients = dividend.createArray(dividers.length + 1); int i = 0; int constDivider = -1; for (; i < dividers.length; i++) { if (dividers[i].isZero()) throw new ArithmeticException("divide by zero"); if (dividers[i].isConstant()) constDivider = i; quotients[i] = dividend.createZero(); } quotients[i] = dividend.createZero(); if (constDivider != -1) { if (dividers[constDivider].isOne()) { quotients[constDivider] = dividend.clone(); return quotients; } Poly dd = dividend.clone().divideByLC(dividers[constDivider]); if (dd != null) { quotients[constDivider] = dd; return quotients; } } IMonomialAlgebra<Term> mAlgebra = dividend.monomialAlgebra; Term[] dividersLTs = Arrays.stream(dividers).map(Poly::lt).toArray(mAlgebra::createArray); dividend = dividend.clone(); Poly remainder = quotients[quotients.length - 1]; while (!dividend.isZero()) { Term ltDiv = null; Term lt = dividend.lt(); for (i = 0; i < dividers.length; i++) { ltDiv = mAlgebra.divideOrNull(lt, dividersLTs[i]); if (ltDiv != null) break; } if (ltDiv != null) { quotients[i] = quotients[i].add(ltDiv); dividend = dividend.subtract(ltDiv, dividers[i]); } else { remainder = remainder.add(lt); dividend = dividend.subtractLt(); } } return quotients; } private MultivariateDivision(); @SuppressWarnings("unchecked") static Poly[] divideAndRemainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly[] divideAndRemainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Collection<Poly> dividers); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Collection<Poly> dividers); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly divideExact(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly divideOrNull(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static boolean dividesQ(Poly dividend, Poly divider); static boolean nontrivialQuotientQ(Poly dividend, Poly divider); } | @Test public void test1() throws Exception { String[] vars = {"a", "b"}; Comparator<DegreeVector> ordering = MonomialOrder.LEX; MultivariatePolynomial<BigInteger> dividend = MultivariatePolynomial.parse("a*b^2 + 1", ordering, vars); MultivariatePolynomial<BigInteger> f1 = MultivariatePolynomial.parse("a*b + 1", ordering, vars); MultivariatePolynomial<BigInteger> f2 = MultivariatePolynomial.parse("b + 1", ordering, vars); MultivariatePolynomial<BigInteger>[] qd; qd = MultivariateDivision.divideAndRemainder(dividend, f1, f2); assertQuotientReminder(qd, dividend, f1, f2); assertArrayEquals(new MultivariatePolynomial[]{ MultivariatePolynomial.parse("b", ordering, vars), MultivariatePolynomial.parse("-1", ordering, vars), MultivariatePolynomial.parse("2", ordering, vars) }, qd); qd = MultivariateDivision.divideAndRemainder(dividend, f2, f1); assertQuotientReminder(qd, dividend, f2, f1); assertArrayEquals(new MultivariatePolynomial[]{ MultivariatePolynomial.parse("a*b - a", ordering, vars), MultivariatePolynomial.parse("0", ordering, vars), MultivariatePolynomial.parse("a+1", ordering, vars) }, qd); }
@Test public void test2() throws Exception { String[] vars = {"a", "b"}; Comparator<DegreeVector> ordering = MonomialOrder.LEX; MultivariatePolynomial<BigInteger> dividend = MultivariatePolynomial.parse("a^2*b+a*b^2+b^2", ordering, vars); MultivariatePolynomial<BigInteger> f1 = MultivariatePolynomial.parse("a*b - 1", ordering, vars); MultivariatePolynomial<BigInteger> f2 = MultivariatePolynomial.parse("b^2 - 1", ordering, vars); MultivariatePolynomial<BigInteger>[] qd; qd = MultivariateDivision.divideAndRemainder(dividend, f1, f2); assertQuotientReminder(qd, dividend, f1, f2); assertArrayEquals(new MultivariatePolynomial[]{ MultivariatePolynomial.parse("a+b", ordering, vars), MultivariatePolynomial.parse("1", ordering, vars), MultivariatePolynomial.parse("a+b+1", ordering, vars) }, qd); assertQuotientReminder(dividend, f2, f1); }
@Test public void test3() throws Exception { MultivariatePolynomial<BigInteger> a = RandomMultivariatePolynomials.randomPolynomial(5, 10, 10, getRandom()); MultivariatePolynomial<BigInteger> b = RandomMultivariatePolynomials.randomPolynomial(5, 10, 10, getRandom()); for (Comparator<DegreeVector> order : Arrays.asList(MonomialOrder.LEX, MonomialOrder.GRLEX, MonomialOrder.GREVLEX)) { MultivariatePolynomial c = a.clone().multiply(b).setOrdering(order); assertTrue(MultivariateDivision.divideAndRemainder(c, a.setOrdering(order))[1].isZero()); assertTrue(MultivariateDivision.divideAndRemainder(c, b.setOrdering(order))[1].isZero()); } }
@Test public void test6() throws Exception { String[] vars = {"a", "b"}; Ring<BigInteger> ring = new IntegersZp(2); Comparator<DegreeVector> ordering = MonomialOrder.LEX; MultivariatePolynomial<BigInteger> dividend = MultivariatePolynomial.parse("a^2*b+a*b^2+b^2", ring, ordering, vars); MultivariatePolynomial<BigInteger> f1 = MultivariatePolynomial.parse("a*b - 1", ring, ordering, vars); MultivariatePolynomial<BigInteger> f2 = MultivariatePolynomial.parse("b^2 - 1", ring, ordering, vars); MultivariatePolynomial<BigInteger>[] qd; qd = MultivariateDivision.divideAndRemainder(dividend, f1, f2); assertQuotientReminder(qd, dividend, f1, f2); assertArrayEquals(new MultivariatePolynomial[]{ MultivariatePolynomial.parse("a+b", ordering, vars), MultivariatePolynomial.parse("1", ordering, vars), MultivariatePolynomial.parse("a+b+1", ordering, vars) }, qd); assertQuotientReminder(dividend, f2, f1); }
@Test public void test7() throws Exception { String[] vars = {"a", "b"}; Ring<BigInteger> ring = new IntegersZp(2); Comparator<DegreeVector> ordering = MonomialOrder.LEX; MultivariatePolynomial<BigInteger> dividend = MultivariatePolynomial.parse("a^2*b+a*b^2+b^2", ring, ordering, vars); MultivariatePolynomial<BigInteger> divider = MultivariatePolynomial.parse("1", ring, ordering, vars); Assert.assertArrayEquals(new MultivariatePolynomial[]{dividend, dividend.createZero()}, MultivariateDivision.divideAndRemainder(dividend, divider)); }
@Test public void test8() throws Exception { MultivariatePolynomial<BigInteger> dividend = MultivariatePolynomial.parse("b*c^2+6*b*c^9+2*b*c^16+4*b^15*c^9+3*b^15*c^16+b^15*c^23+4*b^29*c^16+3*b^29*c^23+b^29*c^30+5*a*c+2*a*c^8+3*a*c^15+6*a*b^14*c^8+a*b^14*c^15+5*a*b^14*c^22+6*a*b^28*c^15+a*b^28*c^22+5*a*b^28*c^29+4*a^7*b*c^2+3*a^7*b*c^9+6*a^7*b*c^16+a^7*b*c^23+a^7*b^15*c^9+6*a^7*b^15*c^16+a^7*b^15*c^23+4*a^7*b^15*c^30+6*a^7*b^29*c^30+4*a^7*b^29*c^37+6*a^8*c+a^8*c^8+2*a^8*c^15+5*a^8*c^22+5*a^8*b^14*c^8+2*a^8*b^14*c^15+5*a^8*b^14*c^22+6*a^8*b^14*c^29+2*a^8*b^28*c^29+6*a^8*b^28*c^36+4*a^11*b^11*c^8+3*a^11*b^11*c^15+a^11*b^11*c^22+2*a^11*b^25*c^15+5*a^11*b^25*c^22+4*a^11*b^25*c^29+2*a^11*b^39*c^22+5*a^11*b^39*c^29+4*a^11*b^39*c^36+2*a^12*b^10*c^7+5*a^12*b^10*c^14+4*a^12*b^10*c^21+a^12*b^24*c^14+6*a^12*b^24*c^21+2*a^12*b^24*c^28+a^12*b^38*c^21+6*a^12*b^38*c^28+2*a^12*b^38*c^35+4*a^14*b*c^2+3*a^14*b*c^9+4*a^14*b*c^23+a^14*b*c^30+6*a^14*b^8*c^2+2*a^14*b^8*c^9+a^14*b^8*c^16+5*a^14*b^15*c^23+a^14*b^15*c^30+4*a^14*b^15*c^37+2*a^14*b^22*c^9+2*a^14*b^22*c^16+2*a^14*b^22*c^23+4*a^14*b^29*c^44+a^14*b^36*c^16+3*a^14*b^36*c^23+6*a^15*c+a^15*c^8+6*a^15*c^22+5*a^15*c^29+2*a^15*b^7*c+3*a^15*b^7*c^8+5*a^15*b^7*c^15+4*a^15*b^14*c^22+5*a^15*b^14*c^29+6*a^15*b^14*c^36+3*a^15*b^21*c^8+3*a^15*b^21*c^15+3*a^15*b^21*c^22+6*a^15*b^28*c^43+5*a^15*b^35*c^15+a^15*b^35*c^22+2*a^18*b^11*c^8+5*a^18*b^11*c^15+3*a^18*b^11*c^22+4*a^18*b^11*c^29+4*a^18*b^25*c^15+3*a^18*b^25*c^22+4*a^18*b^25*c^29+2*a^18*b^25*c^36+3*a^18*b^39*c^36+2*a^18*b^39*c^43+a^19*b^10*c^7+6*a^19*b^10*c^14+5*a^19*b^10*c^21+2*a^19*b^10*c^28+2*a^19*b^24*c^14+5*a^19*b^24*c^21+2*a^19*b^24*c^28+a^19*b^24*c^35+5*a^19*b^38*c^35+a^19*b^38*c^42+6*a^21*b*c^16+4*a^21*b*c^23+4*a^21*b*c^30+2*a^21*b^8*c^2+2*a^21*b^8*c^9+6*a^21*b^8*c^16+4*a^21*b^8*c^23+a^21*b^15*c^37+2*a^21*b^22*c^9+6*a^21*b^22*c^16+4*a^21*b^22*c^23+a^21*b^22*c^30+6*a^21*b^36*c^30+2*a^22*c^15+6*a^22*c^22+6*a^22*c^29+3*a^22*b^7*c+3*a^22*b^7*c^8+2*a^22*b^7*c^15+6*a^22*b^7*c^22+5*a^22*b^14*c^36+3*a^22*b^21*c^8+2*a^22*b^21*c^14+2*a^22*b^21*c^15+5*a^22*b^21*c^21+6*a^22*b^21*c^22+4*a^22*b^21*c^28+5*a^22*b^21*c^29+a^22*b^35*c^21+6*a^22*b^35*c^28+2*a^22*b^35*c^29+2*a^22*b^35*c^35+a^22*b^49*c^28+6*a^22*b^49*c^35+2*a^22*b^49*c^42+2*a^25*b^11*c^8+5*a^25*b^11*c^15+2*a^25*b^11*c^29+4*a^25*b^11*c^36+3*a^25*b^18*c^8+a^25*b^18*c^15+4*a^25*b^18*c^22+6*a^25*b^25*c^29+4*a^25*b^25*c^36+2*a^25*b^25*c^43+a^25*b^32*c^15+a^25*b^32*c^22+a^25*b^32*c^29+2*a^25*b^39*c^50+4*a^25*b^46*c^22+5*a^25*b^46*c^29+a^26*b^10*c^7+6*a^26*b^10*c^14+a^26*b^10*c^28+2*a^26*b^10*c^35+5*a^26*b^17*c^7+4*a^26*b^17*c^14+2*a^26*b^17*c^21+3*a^26*b^24*c^28+2*a^26*b^24*c^35+a^26*b^24*c^42+4*a^26*b^31*c^14+4*a^26*b^31*c^21+4*a^26*b^31*c^28+a^26*b^38*c^49+2*a^26*b^45*c^21+6*a^26*b^45*c^28+4*a^28*b*c^30+a^28*b^8*c^2+3*a^28*b^8*c^9+4*a^28*b^8*c^16+a^28*b^8*c^23+4*a^28*b^8*c^30+6*a^28*b^15*c^2+6*a^28*b^15*c^9+a^28*b^15*c^16+5*a^28*b^22*c^23+a^28*b^22*c^37+6*a^28*b^29*c^9+6*a^28*b^29*c^16+4*a^28*b^43*c^16+6*a^29*c^29+5*a^29*b^7*c+a^29*b^7*c^8+6*a^29*b^7*c^15+5*a^29*b^7*c^22+6*a^29*b^7*c^29+2*a^29*b^14*c+2*a^29*b^14*c^8+5*a^29*b^14*c^15+a^29*b^21*c^14+6*a^29*b^21*c^21+4*a^29*b^21*c^22+5*a^29*b^21*c^28+2*a^29*b^21*c^35+5*a^29*b^21*c^36+2*a^29*b^28*c^8+2*a^29*b^28*c^15+2*a^29*b^35*c^21+5*a^29*b^35*c^28+2*a^29*b^35*c^35+a^29*b^35*c^42+6*a^29*b^42*c^15+5*a^29*b^49*c^42+a^29*b^49*c^49+3*a^32*b^11*c^22+2*a^32*b^11*c^29+2*a^32*b^11*c^36+a^32*b^18*c^8+a^32*b^18*c^15+3*a^32*b^18*c^22+2*a^32*b^18*c^29+4*a^32*b^25*c^43+a^32*b^32*c^15+3*a^32*b^32*c^22+2*a^32*b^32*c^29+4*a^32*b^32*c^36+3*a^32*b^46*c^36+5*a^33*b^10*c^21+a^33*b^10*c^28+a^33*b^10*c^35+4*a^33*b^17*c^7+4*a^33*b^17*c^14+5*a^33*b^17*c^21+a^33*b^17*c^28+2*a^33*b^24*c^42+4*a^33*b^31*c^14+5*a^33*b^31*c^21+a^33*b^31*c^28+2*a^33*b^31*c^35+5*a^33*b^45*c^35+6*a^35*b^8*c^16+a^35*b^8*c^30+6*a^35*b^15*c^2+6*a^35*b^15*c^9+5*a^35*b^15*c^16+4*a^35*b^15*c^23+a^35*b^29*c^9+5*a^35*b^29*c^23+2*a^36*b^7*c^15+5*a^36*b^7*c^29+2*a^36*b^14*c+2*a^36*b^14*c^8+4*a^36*b^14*c^15+6*a^36*b^14*c^22+a^36*b^21*c^14+6*a^36*b^21*c^21+a^36*b^21*c^35+2*a^36*b^21*c^42+5*a^36*b^28*c^8+5*a^36*b^28*c^14+4*a^36*b^28*c^21+4*a^36*b^28*c^22+2*a^36*b^28*c^28+3*a^36*b^35*c^35+2*a^36*b^35*c^42+a^36*b^35*c^49+4*a^36*b^42*c^21+4*a^36*b^42*c^28+4*a^36*b^42*c^35+a^36*b^49*c^56+2*a^36*b^56*c^28+6*a^36*b^56*c^35+2*a^39*b^11*c^36+4*a^39*b^18*c^8+5*a^39*b^18*c^15+2*a^39*b^18*c^22+4*a^39*b^18*c^29+2*a^39*b^18*c^36+3*a^39*b^25*c^8+3*a^39*b^25*c^15+4*a^39*b^25*c^22+6*a^39*b^32*c^29+4*a^39*b^32*c^43+3*a^39*b^39*c^15+3*a^39*b^39*c^22+2*a^39*b^53*c^22+a^40*b^10*c^35+2*a^40*b^17*c^7+6*a^40*b^17*c^14+a^40*b^17*c^21+2*a^40*b^17*c^28+a^40*b^17*c^35+5*a^40*b^24*c^7+5*a^40*b^24*c^14+2*a^40*b^24*c^21+3*a^40*b^31*c^28+2*a^40*b^31*c^42+5*a^40*b^38*c^14+5*a^40*b^38*c^21+a^40*b^52*c^21+4*a^42*b^15*c^2+5*a^42*b^15*c^16+4*a^42*b^15*c^30+5*a^42*b^22*c^2+3*a^42*b^22*c^9+a^42*b^36*c^9+6*a^43*b^14*c+4*a^43*b^14*c^15+6*a^43*b^14*c^29+4*a^43*b^21*c+a^43*b^21*c^8+5*a^43*b^21*c^28+a^43*b^21*c^35+a^43*b^21*c^42+4*a^43*b^28*c^14+4*a^43*b^28*c^21+5*a^43*b^28*c^28+a^43*b^28*c^35+5*a^43*b^35*c^8+2*a^43*b^35*c^49+4*a^43*b^42*c^21+5*a^43*b^42*c^28+a^43*b^42*c^35+2*a^43*b^42*c^42+5*a^43*b^56*c^42+3*a^46*b^18*c^22+4*a^46*b^18*c^36+3*a^46*b^25*c^8+3*a^46*b^25*c^15+6*a^46*b^25*c^22+2*a^46*b^25*c^29+4*a^46*b^39*c^15+6*a^46*b^39*c^29+5*a^47*b^17*c^21+2*a^47*b^17*c^35+5*a^47*b^24*c^7+5*a^47*b^24*c^14+3*a^47*b^24*c^21+a^47*b^24*c^28+2*a^47*b^38*c^14+3*a^47*b^38*c^28+a^49*b^22*c^2+6*a^49*b^22*c^16+5*a^50*b^21*c+2*a^50*b^21*c^15+a^50*b^21*c^42+2*a^50*b^28*c^14+6*a^50*b^28*c^21+a^50*b^28*c^28+2*a^50*b^28*c^35+a^50*b^28*c^42+5*a^50*b^35*c^14+5*a^50*b^35*c^21+2*a^50*b^35*c^28+3*a^50*b^42*c^35+2*a^50*b^42*c^49+5*a^50*b^49*c^21+5*a^50*b^49*c^28+a^50*b^63*c^28"); MultivariatePolynomial<BigInteger> divider = MultivariatePolynomial.parse("c", "a", "b", "c"); IntegersZp domain = new IntegersZp(7); dividend = dividend.setRing(domain); divider = divider.setRing(domain); assertQuotientReminder(MultivariateDivision.divideAndRemainder(dividend, divider), dividend, divider); }
@Test public void test9() throws Exception { MultivariatePolynomial<BigInteger> dividend = MultivariatePolynomial.parse("b*c^2+6*b*c^9+2*b*c^16+4*b^15*c^9+3*b^15*c^16+b^15*c^23+4*b^29*c^16+3*b^29*c^23+b^29*c^30+5*a*c+2*a*c^8+3*a*c^15+6*a*b^14*c^8+a*b^14*c^15+5*a*b^14*c^22+6*a*b^28*c^15+a*b^28*c^22+5*a*b^28*c^29+4*a^7*b*c^2+3*a^7*b*c^9+6*a^7*b*c^16+a^7*b*c^23+a^7*b^15*c^9+6*a^7*b^15*c^16+a^7*b^15*c^23+4*a^7*b^15*c^30+6*a^7*b^29*c^30+4*a^7*b^29*c^37+6*a^8*c+a^8*c^8+2*a^8*c^15+5*a^8*c^22+5*a^8*b^14*c^8+2*a^8*b^14*c^15+5*a^8*b^14*c^22+6*a^8*b^14*c^29+2*a^8*b^28*c^29+6*a^8*b^28*c^36+4*a^11*b^11*c^8+3*a^11*b^11*c^15+a^11*b^11*c^22+2*a^11*b^25*c^15+5*a^11*b^25*c^22+4*a^11*b^25*c^29+2*a^11*b^39*c^22+5*a^11*b^39*c^29+4*a^11*b^39*c^36+2*a^12*b^10*c^7+5*a^12*b^10*c^14+4*a^12*b^10*c^21+a^12*b^24*c^14+6*a^12*b^24*c^21+2*a^12*b^24*c^28+a^12*b^38*c^21+6*a^12*b^38*c^28+2*a^12*b^38*c^35+4*a^14*b*c^2+3*a^14*b*c^9+4*a^14*b*c^23+a^14*b*c^30+6*a^14*b^8*c^2+2*a^14*b^8*c^9+a^14*b^8*c^16+5*a^14*b^15*c^23+a^14*b^15*c^30+4*a^14*b^15*c^37+2*a^14*b^22*c^9+2*a^14*b^22*c^16+2*a^14*b^22*c^23+4*a^14*b^29*c^44+a^14*b^36*c^16+3*a^14*b^36*c^23+6*a^15*c+a^15*c^8+6*a^15*c^22+5*a^15*c^29+2*a^15*b^7*c+3*a^15*b^7*c^8+5*a^15*b^7*c^15+4*a^15*b^14*c^22+5*a^15*b^14*c^29+6*a^15*b^14*c^36+3*a^15*b^21*c^8+3*a^15*b^21*c^15+3*a^15*b^21*c^22+6*a^15*b^28*c^43+5*a^15*b^35*c^15+a^15*b^35*c^22+2*a^18*b^11*c^8+5*a^18*b^11*c^15+3*a^18*b^11*c^22+4*a^18*b^11*c^29+4*a^18*b^25*c^15+3*a^18*b^25*c^22+4*a^18*b^25*c^29+2*a^18*b^25*c^36+3*a^18*b^39*c^36+2*a^18*b^39*c^43+a^19*b^10*c^7+6*a^19*b^10*c^14+5*a^19*b^10*c^21+2*a^19*b^10*c^28+2*a^19*b^24*c^14+5*a^19*b^24*c^21+2*a^19*b^24*c^28+a^19*b^24*c^35+5*a^19*b^38*c^35+a^19*b^38*c^42+6*a^21*b*c^16+4*a^21*b*c^23+4*a^21*b*c^30+2*a^21*b^8*c^2+2*a^21*b^8*c^9+6*a^21*b^8*c^16+4*a^21*b^8*c^23+a^21*b^15*c^37+2*a^21*b^22*c^9+6*a^21*b^22*c^16+4*a^21*b^22*c^23+a^21*b^22*c^30+6*a^21*b^36*c^30+2*a^22*c^15+6*a^22*c^22+6*a^22*c^29+3*a^22*b^7*c+3*a^22*b^7*c^8+2*a^22*b^7*c^15+6*a^22*b^7*c^22+5*a^22*b^14*c^36+3*a^22*b^21*c^8+2*a^22*b^21*c^14+2*a^22*b^21*c^15+5*a^22*b^21*c^21+6*a^22*b^21*c^22+4*a^22*b^21*c^28+5*a^22*b^21*c^29+a^22*b^35*c^21+6*a^22*b^35*c^28+2*a^22*b^35*c^29+2*a^22*b^35*c^35+a^22*b^49*c^28+6*a^22*b^49*c^35+2*a^22*b^49*c^42+2*a^25*b^11*c^8+5*a^25*b^11*c^15+2*a^25*b^11*c^29+4*a^25*b^11*c^36+3*a^25*b^18*c^8+a^25*b^18*c^15+4*a^25*b^18*c^22+6*a^25*b^25*c^29+4*a^25*b^25*c^36+2*a^25*b^25*c^43+a^25*b^32*c^15+a^25*b^32*c^22+a^25*b^32*c^29+2*a^25*b^39*c^50+4*a^25*b^46*c^22+5*a^25*b^46*c^29+a^26*b^10*c^7+6*a^26*b^10*c^14+a^26*b^10*c^28+2*a^26*b^10*c^35+5*a^26*b^17*c^7+4*a^26*b^17*c^14+2*a^26*b^17*c^21+3*a^26*b^24*c^28+2*a^26*b^24*c^35+a^26*b^24*c^42+4*a^26*b^31*c^14+4*a^26*b^31*c^21+4*a^26*b^31*c^28+a^26*b^38*c^49+2*a^26*b^45*c^21+6*a^26*b^45*c^28+4*a^28*b*c^30+a^28*b^8*c^2+3*a^28*b^8*c^9+4*a^28*b^8*c^16+a^28*b^8*c^23+4*a^28*b^8*c^30+6*a^28*b^15*c^2+6*a^28*b^15*c^9+a^28*b^15*c^16+5*a^28*b^22*c^23+a^28*b^22*c^37+6*a^28*b^29*c^9+6*a^28*b^29*c^16+4*a^28*b^43*c^16+6*a^29*c^29+5*a^29*b^7*c+a^29*b^7*c^8+6*a^29*b^7*c^15+5*a^29*b^7*c^22+6*a^29*b^7*c^29+2*a^29*b^14*c+2*a^29*b^14*c^8+5*a^29*b^14*c^15+a^29*b^21*c^14+6*a^29*b^21*c^21+4*a^29*b^21*c^22+5*a^29*b^21*c^28+2*a^29*b^21*c^35+5*a^29*b^21*c^36+2*a^29*b^28*c^8+2*a^29*b^28*c^15+2*a^29*b^35*c^21+5*a^29*b^35*c^28+2*a^29*b^35*c^35+a^29*b^35*c^42+6*a^29*b^42*c^15+5*a^29*b^49*c^42+a^29*b^49*c^49+3*a^32*b^11*c^22+2*a^32*b^11*c^29+2*a^32*b^11*c^36+a^32*b^18*c^8+a^32*b^18*c^15+3*a^32*b^18*c^22+2*a^32*b^18*c^29+4*a^32*b^25*c^43+a^32*b^32*c^15+3*a^32*b^32*c^22+2*a^32*b^32*c^29+4*a^32*b^32*c^36+3*a^32*b^46*c^36+5*a^33*b^10*c^21+a^33*b^10*c^28+a^33*b^10*c^35+4*a^33*b^17*c^7+4*a^33*b^17*c^14+5*a^33*b^17*c^21+a^33*b^17*c^28+2*a^33*b^24*c^42+4*a^33*b^31*c^14+5*a^33*b^31*c^21+a^33*b^31*c^28+2*a^33*b^31*c^35+5*a^33*b^45*c^35+6*a^35*b^8*c^16+a^35*b^8*c^30+6*a^35*b^15*c^2+6*a^35*b^15*c^9+5*a^35*b^15*c^16+4*a^35*b^15*c^23+a^35*b^29*c^9+5*a^35*b^29*c^23+2*a^36*b^7*c^15+5*a^36*b^7*c^29+2*a^36*b^14*c+2*a^36*b^14*c^8+4*a^36*b^14*c^15+6*a^36*b^14*c^22+a^36*b^21*c^14+6*a^36*b^21*c^21+a^36*b^21*c^35+2*a^36*b^21*c^42+5*a^36*b^28*c^8+5*a^36*b^28*c^14+4*a^36*b^28*c^21+4*a^36*b^28*c^22+2*a^36*b^28*c^28+3*a^36*b^35*c^35+2*a^36*b^35*c^42+a^36*b^35*c^49+4*a^36*b^42*c^21+4*a^36*b^42*c^28+4*a^36*b^42*c^35+a^36*b^49*c^56+2*a^36*b^56*c^28+6*a^36*b^56*c^35+2*a^39*b^11*c^36+4*a^39*b^18*c^8+5*a^39*b^18*c^15+2*a^39*b^18*c^22+4*a^39*b^18*c^29+2*a^39*b^18*c^36+3*a^39*b^25*c^8+3*a^39*b^25*c^15+4*a^39*b^25*c^22+6*a^39*b^32*c^29+4*a^39*b^32*c^43+3*a^39*b^39*c^15+3*a^39*b^39*c^22+2*a^39*b^53*c^22+a^40*b^10*c^35+2*a^40*b^17*c^7+6*a^40*b^17*c^14+a^40*b^17*c^21+2*a^40*b^17*c^28+a^40*b^17*c^35+5*a^40*b^24*c^7+5*a^40*b^24*c^14+2*a^40*b^24*c^21+3*a^40*b^31*c^28+2*a^40*b^31*c^42+5*a^40*b^38*c^14+5*a^40*b^38*c^21+a^40*b^52*c^21+4*a^42*b^15*c^2+5*a^42*b^15*c^16+4*a^42*b^15*c^30+5*a^42*b^22*c^2+3*a^42*b^22*c^9+a^42*b^36*c^9+6*a^43*b^14*c+4*a^43*b^14*c^15+6*a^43*b^14*c^29+4*a^43*b^21*c+a^43*b^21*c^8+5*a^43*b^21*c^28+a^43*b^21*c^35+a^43*b^21*c^42+4*a^43*b^28*c^14+4*a^43*b^28*c^21+5*a^43*b^28*c^28+a^43*b^28*c^35+5*a^43*b^35*c^8+2*a^43*b^35*c^49+4*a^43*b^42*c^21+5*a^43*b^42*c^28+a^43*b^42*c^35+2*a^43*b^42*c^42+5*a^43*b^56*c^42+3*a^46*b^18*c^22+4*a^46*b^18*c^36+3*a^46*b^25*c^8+3*a^46*b^25*c^15+6*a^46*b^25*c^22+2*a^46*b^25*c^29+4*a^46*b^39*c^15+6*a^46*b^39*c^29+5*a^47*b^17*c^21+2*a^47*b^17*c^35+5*a^47*b^24*c^7+5*a^47*b^24*c^14+3*a^47*b^24*c^21+a^47*b^24*c^28+2*a^47*b^38*c^14+3*a^47*b^38*c^28+a^49*b^22*c^2+6*a^49*b^22*c^16+5*a^50*b^21*c+2*a^50*b^21*c^15+a^50*b^21*c^42+2*a^50*b^28*c^14+6*a^50*b^28*c^21+a^50*b^28*c^28+2*a^50*b^28*c^35+a^50*b^28*c^42+5*a^50*b^35*c^14+5*a^50*b^35*c^21+2*a^50*b^35*c^28+3*a^50*b^42*c^35+2*a^50*b^42*c^49+5*a^50*b^49*c^21+5*a^50*b^49*c^28+a^50*b^63*c^28+2*a^53*b^25*c^8+6*a^53*b^25*c^22+2*a^53*b^25*c^36+6*a^53*b^32*c^8+5*a^53*b^32*c^15+4*a^53*b^46*c^15+a^54*b^24*c^7+3*a^54*b^24*c^21+a^54*b^24*c^35+3*a^54*b^31*c^7+6*a^54*b^31*c^14+2*a^54*b^45*c^14+4*a^56*b^29*c^2+6*a^57*b^28*c+5*a^57*b^28*c^28+2*a^57*b^28*c^42+5*a^57*b^35*c^14+5*a^57*b^35*c^21+3*a^57*b^35*c^28+a^57*b^35*c^35+2*a^57*b^49*c^21+3*a^57*b^49*c^35+4*a^60*b^32*c^8+3*a^60*b^32*c^22+2*a^61*b^31*c^7+5*a^61*b^31*c^21+a^64*b^35*c^14+3*a^64*b^35*c^28+a^64*b^35*c^42+3*a^64*b^42*c^14+6*a^64*b^42*c^21+2*a^64*b^56*c^21+2*a^67*b^39*c^8+a^68*b^38*c^7+2*a^71*b^42*c^14+5*a^71*b^42*c^28+a^78*b^49*c^14"); MultivariatePolynomial<BigInteger> divider = MultivariatePolynomial.parse("c", "a", "b", "c"); IntegersZp domain = new IntegersZp(7); dividend = dividend.setRing(domain); divider = divider.setRing(domain); assertQuotientReminder(MultivariateDivision.divideAndRemainder(dividend, divider), dividend, divider); } |
MultivariateDivision { @SuppressWarnings("unchecked") public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> boolean dividesQ(Poly dividend, Poly divider) { if (divider.isOne()) return true; dividend = dividend.clone(); if (divider.isConstant()) return dividend.divideByLC(divider) != null; int[] dividendDegrees = dividend.degrees(), dividerDegrees = divider.degrees(); for (int i = 0; i < dividendDegrees.length; i++) if (dividendDegrees[i] < dividerDegrees[i]) return false; IMonomialAlgebra<Term> mAlgebra = dividend.monomialAlgebra; while (!dividend.isZero()) { Term ltDiv = mAlgebra.divideOrNull(dividend.lt(), divider.lt()); if (ltDiv == null) return false; dividend = dividend.subtract(divider.clone().multiply(ltDiv)); } return true; } private MultivariateDivision(); @SuppressWarnings("unchecked") static Poly[] divideAndRemainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly[] divideAndRemainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Collection<Poly> dividers); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Collection<Poly> dividers); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly divideExact(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly divideOrNull(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static boolean dividesQ(Poly dividend, Poly divider); static boolean nontrivialQuotientQ(Poly dividend, Poly divider); } | @Test public void test10() throws Exception { MultivariatePolynomial<BigInteger> dividend = MultivariatePolynomial.parse("738*b^18*c^20+28*b^26*c^14+393*a*b^8*c^13+32*a*b^13*c^16+32*a*b^16*c^7+377*a*b^18*c^17+24*a*b^21*c^10+20*a*b^26*c^11+722*a^2*b^9*c^18+42*a^2*b^11*c^25+16*a^2*b^17*c^12+49*a^2*b^24*c^23+48*a^3*b*c^18+36*a^3*b^6*c^21+30*a^3*b^11*c^22+56*a^3*b^14*c^16+361*a^3*b^18*c^14+42*a^3*b^19*c^19+35*a^3*b^24*c^20+8*a^3*b^26*c^8+24*a^4*b^2*c^23+28*a^4*b^15*c^21+12*a^5*b^11*c^19+14*a^5*b^24*c^17+393*a^6*b^8*c^15+623*a^6*b^8*c^17+32*a^6*b^16*c^9+730*a^6*b^16*c^11+262*a^7*b^10*c^17+393*a^7*b^12*c^22+722*a^7*b^18*c^11+32*a^7*b^20*c^16+42*a^7*b^27*c^25+48*a^8*b*c^20+44*a^8*b*c^22+377*a^8*b^14*c^14+56*a^8*b^14*c^18+752*a^8*b^14*c^20+48*a^8*b^17*c^18+20*a^8*b^22*c^8+36*a^8*b^22*c^21+30*a^8*b^27*c^22+32*a^9*b^3*c^22+48*a^9*b^5*c^27+738*a^9*b^16*c^20+968*a^9*b^17*c^18+24*a^9*b^18*c^23+56*a^9*b^18*c^25+726*a^9*b^25*c^12+14*a^9*b^29*c^8+30*a^10*b^7*c^19+7*a^10*b^13*c^24+16*a^10*b^19*c+35*a^10*b^20*c^17+12*a^10*b^24*c^4+12*a^10*b^27*c^19+10*a^10*b^29*c^5+8*a^11*b^3*c^17+706*a^11*b^7*c^22+6*a^11*b^8*c^20+38*a^11*b^10*c^23+5*a^11*b^13*c^21+4*a^11*b^15*c^16+8*a^11*b^20*c^6+745*a^11*b^23*c^21+4*a^12*b^4*c^22+4*a^12*b^29*c^2+6*a^13*c^27+2*a^13*b^13*c^18+7*a^13*b^13*c^25+48*a^13*b^17*c^20+44*a^13*b^17*c^22+32*a^14*b^19*c^22+48*a^14*b^21*c^27+35*a^15*b^18*c^11+16*a^15*b^19*c^3+365*a^15*b^19*c^5+30*a^15*b^23*c^19+8*a^16*b^3*c^19+708*a^16*b^3*c^21+40*a^16*b^8*c^4+30*a^16*b^13*c^7+25*a^16*b^18*c^8+361*a^16*b^21*c^5+16*a^16*b^23*c^10+38*a^16*b^26*c^23+706*a^17*b^5*c^21+8*a^17*b^7*c^26+20*a^17*b^9*c^9+10*a^17*b^25*c^2+5*a^18*b^9*c^18+6*a^18*b^16*c^27+10*a^18*b^18*c^5+49*a^18*b^23*c^20+363*a^18*b^28*c^6+707*a^19*b^12*c^22+56*a^19*b^13*c^13+42*a^19*b^18*c^16+35*a^19*b^23*c^17+28*a^20*b^14*c^18+2*a^20*b^18*c^10+a^21*b^2*c^26+40*a^21*b^8*c^6+387*a^21*b^8*c^8+14*a^21*b^23*c^14+377*a^22*b^10*c^8+40*a^22*b^12*c^13+25*a^23*b^14*c^5+56*a^24*b^13*c^15+752*a^24*b^13*c^17+382*a^24*b^17*c^9+738*a^25*b^15*c^17+56*a^25*b^17*c^22+5*a^26*b^7*c^13+35*a^26*b^19*c^14+745*a^27*b^22*c^18+7*a^29*b^12*c^22"); MultivariatePolynomial<BigInteger> divider = MultivariatePolynomial.parse("b", "a", "b", "c"); assertFalse(MultivariateDivision.dividesQ(dividend, divider)); } |
MultivariateDivision { @SuppressWarnings("unchecked") public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> Poly divideExact(Poly dividend, Poly divider) { Poly[] qd = divideAndRemainder(dividend, divider); if (qd == null || !qd[1].isZero()) throw new ArithmeticException("not divisible: " + dividend + " / " + divider); return qd[0]; } private MultivariateDivision(); @SuppressWarnings("unchecked") static Poly[] divideAndRemainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly[] divideAndRemainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Collection<Poly> dividers); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Collection<Poly> dividers); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly divideExact(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly divideOrNull(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static boolean dividesQ(Poly dividend, Poly divider); static boolean nontrivialQuotientQ(Poly dividend, Poly divider); } | @Test public void test11() throws Exception { IntegersZp64 domain = new IntegersZp64(1361); String[] vars = {"a", "b"}; MultivariatePolynomialZp64 dividend = MultivariatePolynomialZp64.parse("a^2*b", domain, vars), divider = MultivariatePolynomialZp64.parse("b", domain, vars); System.out.println(MultivariateDivision.divideExact(dividend, divider)); } |
MultivariateDivision { @SuppressWarnings("unchecked") public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> Poly pseudoRemainder(Poly dividend, Poly... dividers) { if (dividend.isOverField()) return remainder(dividend, dividers); return (Poly) pseudoRemainder0((MultivariatePolynomial) dividend, (MultivariatePolynomial[]) dividers); } private MultivariateDivision(); @SuppressWarnings("unchecked") static Poly[] divideAndRemainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Poly... dividers); @SuppressWarnings("unchecked") static Poly[] divideAndRemainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Collection<Poly> dividers); @SuppressWarnings("unchecked") static Poly remainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Collection<Poly> dividers); @SuppressWarnings("unchecked") static Poly pseudoRemainder(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly divideExact(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static Poly divideOrNull(Poly dividend, Poly divider); @SuppressWarnings("unchecked") static boolean dividesQ(Poly dividend, Poly divider); static boolean nontrivialQuotientQ(Poly dividend, Poly divider); } | @Test public void test12() throws Exception { RandomGenerator rnd = getRandom(); for (int i = 0; i < 100; ++i) { UnivariatePolynomial<BigInteger> dividend = RandomUnivariatePolynomials.randomPoly(30, Rings.Z, rnd), divider = RandomUnivariatePolynomials.randomPoly(10, Rings.Z, rnd); UnivariatePolynomial<BigInteger> expected = UnivariateDivision.pseudoDivideAndRemainder(dividend, divider, false)[1].canonical(); UnivariatePolynomial<BigInteger> actual = MultivariateDivision.pseudoRemainder( MultivariatePolynomial.asMultivariate(dividend, 1, 0, MonomialOrder.GREVLEX), MultivariatePolynomial.asMultivariate(divider, 1, 0, MonomialOrder.GREVLEX) ).asUnivariate().canonical(); assertEquals(expected, actual); } } |
MultivariateGCD { @SuppressWarnings("unchecked") public static <E> MultivariatePolynomial<E> BrownGCD( MultivariatePolynomial<E> a, MultivariatePolynomial<E> b) { Util.ensureOverField(a, b); a.assertSameCoefficientRingWith(b); if (canConvertToZp64(a)) return convertFromZp64(BrownGCD(asOverZp64(a), asOverZp64(b))); GCDInput<Monomial<E>, MultivariatePolynomial<E>> gcdInput = preparedGCDInput(a, b, MultivariateGCD::BrownGCD); if (gcdInput.earlyGCD != null) return gcdInput.earlyGCD; if (gcdInput.finiteExtensionDegree > 1) return KaltofenMonaganSparseModularGCDInGF(gcdInput); MultivariatePolynomial<E> result = BrownGCD( gcdInput.aReduced, gcdInput.bReduced, PrivateRandom.getRandom(), gcdInput.lastPresentVariable, gcdInput.degreeBounds, gcdInput.evaluationStackLimit); if (result == null) return KaltofenMonaganSparseModularGCDInGF(gcdInput); return gcdInput.restoreGCD(result); } private MultivariateGCD(); static Poly PolynomialGCD(Poly... arr); static Poly PolynomialGCD(Iterable<Poly> arr); @SuppressWarnings("unchecked") static Poly PolynomialGCD(Poly a, Poly b); @SuppressWarnings("unchecked") static Poly PolynomialGCDinGF(Poly a, Poly b); @SuppressWarnings("unchecked") static MultivariatePolynomial<BigInteger> PolynomialGCDinZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDinNumberField(MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDinRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b,
KaltofenMonaganAlgorithm algorithm); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> BrownGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> ZippelGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 BrownGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 ZippelGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 EZGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static Poly EEZGCD(Poly a, Poly b); } | @Test public void testBrown10() throws Exception { IntegersZp domain = new IntegersZp(5642359); String[] vars = {"a", "b"}; MultivariatePolynomial<BigInteger> a = parse("1199884 + 4783764*b + b^2 + 3215597*a*b + 2196297*a*b^2 + 4781733*a^4 + a^4*b + 2196297*a^5*b", domain, MonomialOrder.DEFAULT, vars), b = parse("4645946 + 3921107*b + b^2 + 5605437*a*b + 2196297*a*b^2 + 4781733*a^3 + a^3*b + 2196297*a^4*b", domain, MonomialOrder.DEFAULT, vars); MultivariatePolynomial<BigInteger> gcdActual = BrownGCD(a, b); gcdActual = gcdActual.monic().multiply(domain.valueOf(4781733)); MultivariatePolynomial<BigInteger> expected = parse("1574588 + 4559668*b + 4781733*a*b", domain, MonomialOrder.DEFAULT, vars); assertEquals(expected, gcdActual); } |
MultivariateGCD { static <E> SparseInterpolation<E> createInterpolation(int variable, MultivariatePolynomial<E> a, MultivariatePolynomial<E> b, MultivariatePolynomial<E> skeleton, int expectedNumberOfEvaluations, RandomGenerator rnd) { assert a.nVariables > 1; skeleton = skeleton.clone().setAllCoefficientsToUnit(); if (skeleton.size() == 1) return new TrivialSparseInterpolation<>(skeleton); boolean monic = a.coefficientOf(0, a.degree(0)).isConstant() && b.coefficientOf(0, a.degree(0)).isConstant(); Set<DegreeVector> globalSkeleton = skeleton.getSkeleton(); TIntObjectHashMap<MultivariatePolynomial<E>> univarSkeleton = getSkeleton(skeleton); int[] sparseUnivarDegrees = univarSkeleton.keys(); Ring<E> ring = a.ring; int lastVariable = variable == -1 ? a.nVariables - 1 : variable; int[] evaluationVariables = ArraysUtil.sequence(1, lastVariable + 1); E[] evaluationPoint = ring.createArray(evaluationVariables.length); MultivariatePolynomial.PrecomputedPowersHolder<E> powers; int fails = 0; search_for_good_evaluation_point: while (true) { if (fails >= MAX_FAILED_SUBSTITUTIONS) return null; for (int i = lastVariable - 1; i >= 0; --i) do { evaluationPoint[i] = randomElement(ring, rnd); } while (ring.isZero(evaluationPoint[i])); powers = mkPrecomputedPowers(a, b, evaluationVariables, evaluationPoint); for (MultivariatePolynomial<E> p : Arrays.asList(a, b, skeleton)) if (!p.getSkeleton(0).equals(p.evaluate(powers, evaluationVariables).getSkeleton())) { ++fails; continue search_for_good_evaluation_point; } break; } int requiredNumberOfEvaluations = -1, monicScalingExponent = -1; for (TIntObjectIterator<MultivariatePolynomial<E>> it = univarSkeleton.iterator(); it.hasNext(); ) { it.advance(); MultivariatePolynomial<E> v = it.value(); if (v.size() > requiredNumberOfEvaluations) requiredNumberOfEvaluations = v.size(); if (v.size() == 1) monicScalingExponent = it.key(); } if (!ALWAYS_LINZIP) { if (monic) monicScalingExponent = -1; if (monic || monicScalingExponent != -1) return new MonicInterpolation<>(ring, variable, a, b, globalSkeleton, univarSkeleton, sparseUnivarDegrees, evaluationVariables, evaluationPoint, powers, expectedNumberOfEvaluations, rnd, requiredNumberOfEvaluations, monicScalingExponent); } return new LinZipInterpolation<>(ring, variable, a, b, globalSkeleton, univarSkeleton, sparseUnivarDegrees, evaluationVariables, evaluationPoint, powers, expectedNumberOfEvaluations, rnd); } private MultivariateGCD(); static Poly PolynomialGCD(Poly... arr); static Poly PolynomialGCD(Iterable<Poly> arr); @SuppressWarnings("unchecked") static Poly PolynomialGCD(Poly a, Poly b); @SuppressWarnings("unchecked") static Poly PolynomialGCDinGF(Poly a, Poly b); @SuppressWarnings("unchecked") static MultivariatePolynomial<BigInteger> PolynomialGCDinZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDinNumberField(MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDinRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b,
KaltofenMonaganAlgorithm algorithm); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> BrownGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> ZippelGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 BrownGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 ZippelGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 EZGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static Poly EEZGCD(Poly a, Poly b); } | @Test public void testZippel5() throws Exception { String[] vars = {"a", "b", "c"}; IntegersZp domain = new IntegersZp(BigPrimes.nextPrime(31579447)); System.out.println(domain); MultivariatePolynomial<BigInteger> a = parse("b^2 + a*c + a*b*c^2 + a*b^2 + a^5", domain, MonomialOrder.DEFAULT, vars), b = parse("1 + a*b", domain, MonomialOrder.DEFAULT, vars), gcd = parse("1 + a*b*c^2 + a^2*c^2 + a^2*b*c^2 + a^2*b^2*c^2 + a^7", domain, MonomialOrder.DEFAULT, vars); a = a.clone().multiply(gcd); b = b.clone().multiply(gcd); RandomGenerator rnd = getRandom(); rnd.setSeed(123); int variable = a.nVariables - 1; BigInteger seed = BigInteger.valueOf(7893482); MultivariatePolynomial<BigInteger> skeleton = gcd.evaluate(variable, seed); for (int expEvals : Arrays.asList(1, Integer.MAX_VALUE)) { SparseInterpolation<BigInteger> sparseInterpolation = createInterpolation(variable, a, b, skeleton, expEvals, rnd); BigInteger point = domain.valueOf(1324); assertEquals(gcd.evaluate(variable, point), sparseInterpolation.evaluate(point)); } }
@Test public void testZippel6() throws Exception { MultivariateGCD.ALWAYS_LINZIP = true; String[] vars = {"a", "b", "c"}; IntegersZp domain = new IntegersZp(BigPrimes.nextPrime(31579447)); MultivariatePolynomial<BigInteger> a = parse("1+3*b*c^2+7*b^2*c^2+4*a+7*a^3*c^2+a^6", domain, MonomialOrder.DEFAULT, vars), b = parse("b^3*c^2+a*b^2*c+9*a^2*b*c+9*a^3*b*c^2+a^7", domain, MonomialOrder.DEFAULT, vars), gcd = parse("b^3*c^2+2*a*c+5*a*b+2*a*b^2*c+4*a*b^3*c^2+5*a^3*b+a^7", domain, MonomialOrder.DEFAULT, vars); a = a.clone().multiply(gcd); b = b.clone().multiply(gcd); RandomGenerator rnd = getRandom(); rnd.setSeed(123); int variable = a.nVariables - 1; BigInteger seed = BigInteger.valueOf(7893482); MultivariatePolynomial<BigInteger> skeleton = gcd.evaluate(variable, seed); for (int expEvals : Arrays.asList(1, Integer.MAX_VALUE)) { SparseInterpolation<BigInteger> sparseInterpolation = createInterpolation(variable, a, b, skeleton, expEvals, rnd); BigInteger point = domain.valueOf(1324); assertEquals(gcd.evaluate(variable, point), sparseInterpolation.evaluate(point)); } }
@Test public void testZippel7() throws Exception { MultivariateGCD.ALWAYS_LINZIP = true; String[] vars = {"a", "b", "c", "d"}; IntegersZp domain = new IntegersZp(BigPrimes.nextPrime(31579447)); MultivariatePolynomial<BigInteger> a = parse("29322275*b+5*b*c+6*a^2*b^3*c^2+29322274*a^2*b^3*c^2*d^3+5*a^3*b*c^2*d^2+a^11", domain, MonomialOrder.DEFAULT, vars), b = parse("7*a^3*b^3*c^3*d^4+9*a^3*b^4*c+29322274*a^3*b^4*c^5*d^2+29322277*a^5*b*c*d+a^5*b^4+a^15", domain, MonomialOrder.DEFAULT, vars), gcd = parse("4*d^2+8*c^2*d+4*b*c+6*b^3*c^2*d^2+2*a^3*b^2*c^3*d+a^10", domain, MonomialOrder.DEFAULT, vars); a = a.clone().multiply(gcd); b = b.clone().multiply(gcd); RandomGenerator rnd = getRandom(); rnd.setSeed(123); int variable = a.nVariables - 1; BigInteger seed = BigInteger.valueOf(7893482); MultivariatePolynomial<BigInteger> skeleton = gcd.evaluate(variable, seed); for (int expEvals : Arrays.asList(1, Integer.MAX_VALUE)) { SparseInterpolation<BigInteger> sparseInterpolation = createInterpolation(variable, a, b, skeleton, expEvals, rnd); BigInteger point = domain.valueOf(1324); assertEquals(gcd.evaluate(variable, point), sparseInterpolation.evaluate(point)); } }
@Test public void testZippel8() throws Exception { MultivariateGCD.ALWAYS_LINZIP = true; String[] vars = {"a", "b", "c"}; IntegersZp domain = new IntegersZp(31579447); MultivariatePolynomial<BigInteger> a = parse("5*a+29923129*a*b*c^2+3*a*b^2+29923132*a^2*b*c^2+7*a^3*c", domain, MonomialOrder.DEFAULT, vars), b = parse("4*c^2+29923126*a*c^2+5*a*b+6*a^2*b^2*c^3+29923128*a^3*c^3", domain, MonomialOrder.DEFAULT, vars), gcd = parse("29923132+8*b*c^3+29923132*b^2*c^3+8*a*b*c+7*a^3*b^3*c", domain, MonomialOrder.DEFAULT, vars); a = a.clone().multiply(gcd); b = b.clone().multiply(gcd); RandomGenerator rnd = getRandom(); rnd.setSeed(123); int variable = a.nVariables - 1; BigInteger seed = BigInteger.valueOf(7893482); MultivariatePolynomial<BigInteger> skeleton = gcd.evaluate(variable, seed); for (int expEvals : Arrays.asList(1, Integer.MAX_VALUE)) { SparseInterpolation<BigInteger> sparseInterpolation = createInterpolation(variable, a, b, skeleton, expEvals, rnd); BigInteger point = domain.valueOf(1324); assertEquals(gcd.evaluate(variable, point).monic(), sparseInterpolation.evaluate(point).monic()); } } |
MultivariateGCD { @SuppressWarnings("unchecked") public static <E> MultivariatePolynomial<E> ZippelGCD( MultivariatePolynomial<E> a, MultivariatePolynomial<E> b) { Util.ensureOverField(a, b); a.assertSameCoefficientRingWith(b); if (canConvertToZp64(a)) return convertFromZp64(ZippelGCD(asOverZp64(a), asOverZp64(b))); GCDInput<Monomial<E>, MultivariatePolynomial<E>> gcdInput = preparedGCDInput(a, b, MultivariateGCD::ZippelGCD); if (gcdInput.earlyGCD != null) return gcdInput.earlyGCD; if (gcdInput.finiteExtensionDegree > 1) return KaltofenMonaganSparseModularGCDInGF(gcdInput); a = gcdInput.aReduced; b = gcdInput.bReduced; MultivariatePolynomial<E> content = contentGCD(a, b, 0, MultivariateGCD::ZippelGCD); a = MultivariateDivision.divideExact(a, content); b = MultivariateDivision.divideExact(b, content); MultivariatePolynomial<E> result = ZippelGCD(a, b, PrivateRandom.getRandom(), gcdInput.lastPresentVariable, gcdInput.degreeBounds, gcdInput.evaluationStackLimit); if (result == null) return KaltofenMonaganSparseModularGCDInGF(gcdInput); result = result.multiply(content); return gcdInput.restoreGCD(result); } private MultivariateGCD(); static Poly PolynomialGCD(Poly... arr); static Poly PolynomialGCD(Iterable<Poly> arr); @SuppressWarnings("unchecked") static Poly PolynomialGCD(Poly a, Poly b); @SuppressWarnings("unchecked") static Poly PolynomialGCDinGF(Poly a, Poly b); @SuppressWarnings("unchecked") static MultivariatePolynomial<BigInteger> PolynomialGCDinZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDinNumberField(MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDinRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b,
KaltofenMonaganAlgorithm algorithm); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> BrownGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> ZippelGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 BrownGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 ZippelGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 EZGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static Poly EEZGCD(Poly a, Poly b); } | @Test(timeout = 10000) public void testZippel9() throws Exception { String[] vars = {"a", "b", "c"}; IntegersZp domain = new IntegersZp(26478253); PrivateRandom.getRandom().setSeed(0); MultivariatePolynomial<BigInteger> a = parse("26478246*a*c^2+7*a*b+26478250*a*b*c^2+26478249*a*b^3*c^2+26478248*a^2*c^2+8*a^3*b*c^2+a^7", domain, MonomialOrder.DEFAULT, vars), b = parse("4*b^3*c^2+7*a+5*a*b+8*a*b^2+6*a^3*b^2*c+a^7", domain, MonomialOrder.DEFAULT, vars), gcd = parse("26478248*a*b^2*c^2+3*a*b^3*c^2+2*a^2*b^3*c^2+5*a^3*c+a^8", domain, MonomialOrder.DEFAULT, vars); a = a.clone().multiply(gcd); b = b.clone().multiply(gcd); assertNotNull(ZippelGCD(a, b)); assertNotNull(ZippelGCD(asOverZp64(a), asOverZp64(b))); }
@Ignore @Test public void testZippel4_performance() throws Exception { PrivateRandom.getRandom().setSeed(1232); String[] vars = {"a", "b", "c", "d", "e"}; IntegersZp domain = new IntegersZp(SmallPrimes.nextPrime(100000)); MultivariatePolynomial<BigInteger> a = parse("2147483167*a^4*b^60*c^57*d^26*e+44*a^8*b^39*c^67*d^22*e^17+38*a^32*b^6*c^13*d^10*e^3+357*a^36*b^34*c^60*d^2*e^59+563*a^42*b^41*c^45*d^52*e^14+257*a^44*b^68*c^43*d^2*e^73+613*a^48*b^55*c^22*d^32*e^19+2147483093*a^52*b^26*c^4*d^72*e^32+19*a^52*b^40*c^26*d^45*e^55+639*a^55*b^72*c^55*d^65", domain, MonomialOrder.DEFAULT, vars), b = parse("2147483150*b^25*c^18*d^62*e^59+2147482723*a^4*b^5*c^65*d^26*e^7+261*a^15*b^60*c^59*d^63*e^53+394*a^27*b^22*c^34*d^54*e^13+952*a^39*b^48*c^17*d^54*e^16+243*a^60*b^15*c^3*d^51*e^46+40*a^61*b^56*c^39*d^40*e^21+555*a^62*b^20*c^20*d^60*e^47+627*a^67*b^8*c^22*d^67*e^61+447*a^70*b^59*c^71*d^24*e^5", domain, MonomialOrder.DEFAULT, vars), gcd = parse("35*a*b^36*c^74*d^62*e^51+376*a^2*b^28*c^64*e^53+893*a^6*b^13*c^60*d^44*e^42+23*a^8*b^71*c^40*d^36*e^11+783*a^20*b^28*c^12*d^31*e^68+2147482938*a^31*b^30*c^40*d^65*e^72+2147482960*a^31*b^49*c^38*d^71*e^55+737*a^47*b^15*c^71*d^13*e^72+868*a^53*b^30*c^40*d^29*e^46+898*a^61*b^71*c^13*d^50*e^66", domain, MonomialOrder.DEFAULT, vars); a = a.clone().multiply(gcd); b = b.clone().multiply(gcd); System.out.println(a); System.out.println(b); MultivariatePolynomialZp64 aL = asOverZp64(a), bL = asOverZp64(b); for (int i = 0; i < 1000; i++) { long start = System.nanoTime(); assertEquals(10, ZippelGCD(aL, bL).size()); System.out.println(nanosecondsToString(System.nanoTime() - start)); start = System.nanoTime(); System.out.println(ZippelGCD(aL.clone().increment(), bL)); System.out.println(nanosecondsToString(System.nanoTime() - start)); System.out.println(); } }
@Ignore @Test public void testZippel5_bivariate_performance() throws Exception { PrivateRandom.getRandom().setSeed(1232); String[] vars = {"a", "b"}; IntegersZp domain = new IntegersZp(100011111111101L); MultivariatePolynomial<BigInteger> a = parse("38*a^32*b^6 + 2147483093*a^52*b^26 + 357*a^36*b^34 + 44*a^8*b^39 + 19*a^52*b^40 + 563*a^42*b^41 + 613*a^48*b^55 + 2147483167*a^4*b^60 + 257*a^44*b^68 + 639*a^55*b^72", domain, MonomialOrder.DEFAULT, vars), b = parse("2147482723*a^4*b^5 + 627*a^67*b^8 + 243*a^60*b^15 + 555*a^62*b^20 + 394*a^27*b^22 + 2147483150*b^25 + 952*a^39*b^48 + 40*a^61*b^56 + 447*a^70*b^59 + 261*a^15*b^60", domain, MonomialOrder.DEFAULT, vars), gcd = parse("893*a^6*b^13 + 737*a^47*b^15 + 376*a^2*b^28 + 783*a^20*b^28 + 2147482938*a^31*b^30 + 868*a^53*b^30 + 35*a*b^36 + 2147482960*a^31*b^49 + 23*a^8*b^71 + 898*a^61*b^71", domain, MonomialOrder.DEFAULT, vars); a = a.clone().multiply(gcd); b = b.clone().multiply(gcd); System.out.println(a); System.out.println(b); MultivariatePolynomialZp64 aL = asOverZp64(a), bL = asOverZp64(b); for (int i = 0; i < 1000; i++) { long start = System.nanoTime(); assertEquals(10, ZippelGCD(aL, bL).size()); System.out.println(nanosecondsToString(System.nanoTime() - start)); start = System.nanoTime(); System.out.println(ZippelGCD(aL.clone().increment(), bL)); System.out.println(nanosecondsToString(System.nanoTime() - start)); System.out.println(); } }
@Ignore("too expensive (memory limit in CI)") @Test public void testHugePoly1() throws Exception { MultivariateRing<MultivariatePolynomialZp64> R = Rings.MultivariateRingZp64(3, SmallPrimes.nextPrime(1 << 25)); for (int j = 1; j < 2; ++j) { try (BufferedReader in = new BufferedReader(new InputStreamReader(new GZIPInputStream( new FileInputStream( "src/test/resources/cc/redberry/rings/poly/multivar/HugeGCDinZp.txt.gz"))))) { String s1 = in.readLine(); String s2 = in.readLine(); MultivariatePolynomialZp64 p = R.parse(s1); MultivariatePolynomialZp64 q = R.parse(s2); long t1 = System.nanoTime(); MultivariatePolynomialZp64 gcd = MultivariateGCD.ZippelGCD(p, q); long t2 = System.nanoTime(); System.out.println("Total time : " + nanosecondsToString(t2 - t1)); System.out.println("GCD size : " + gcd.size()); System.out.println(); } } } |
MultivariateGCD { static MultivariatePolynomialZp64 interpolateGCD(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, MultivariatePolynomialZp64 skeleton, RandomGenerator rnd) { a.assertSameCoefficientRingWith(b); a.assertSameCoefficientRingWith(skeleton); assert contentGCD(a, b, 0, MultivariateGCD::PolynomialGCD).isConstant(); lSparseInterpolation interpolation = createInterpolation(-1, a, b, skeleton, 1, rnd); if (interpolation == null) return null; MultivariatePolynomialZp64 gcd = interpolation.evaluate(); if (gcd == null) return null; return gcd; } private MultivariateGCD(); static Poly PolynomialGCD(Poly... arr); static Poly PolynomialGCD(Iterable<Poly> arr); @SuppressWarnings("unchecked") static Poly PolynomialGCD(Poly a, Poly b); @SuppressWarnings("unchecked") static Poly PolynomialGCDinGF(Poly a, Poly b); @SuppressWarnings("unchecked") static MultivariatePolynomial<BigInteger> PolynomialGCDinZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDinNumberField(MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDinRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b,
KaltofenMonaganAlgorithm algorithm); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> BrownGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> ZippelGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 BrownGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 ZippelGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 EZGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static Poly EEZGCD(Poly a, Poly b); } | @Test public void testSparseInterpolation2() throws Exception { IntegersZp domain = new IntegersZp(24001871); MultivariatePolynomial<BigInteger> a = parse("3*b^4*c^2+7*b^4*c^3+4*a*b^5*c^3+6*a^4*b^6+24001865*a^5*b", domain, MonomialOrder.DEFAULT, "a", "b", "c"), b = parse("5*a*c^4+9*a^4*b^4*c^2+9*a^6*b*c^6", domain, MonomialOrder.DEFAULT, "a", "b", "c"), gcd = parse("5*a*b^2*c^2+a*b^2*c^4+24001866*a*b^4*c^3 + 1", domain, MonomialOrder.DEFAULT, "a", "b", "c"); a = a.multiply(gcd); b = b.multiply(gcd); assertEquals(asOverZp64(gcd).monic(), interpolateGCD(asOverZp64(a), asOverZp64(b), asOverZp64(gcd), getRandom()).monic()); }
@Test public void testSparseInterpolation3() throws Exception { IntegersZp domain = new IntegersZp(17312587); MultivariatePolynomial<BigInteger> a = parse("5*a^3*c^6+9*a^5*b^2*c^3+7*a^5*b^6*c^5+8*a^5*b^6*c^6+6*a^6*b^6*c", domain, MonomialOrder.DEFAULT, "a", "b", "c"), b = parse("17312581*c^6+5*a^2*b^2*c^6+3*a^4*b^6*c^4+2*a^5+4*a^5*b^3*c^6", domain, MonomialOrder.DEFAULT, "a", "b", "c"), gcd = parse("1 + 5*a^5*b*c^2+6*a^5*b^3*c^6+2*a^5*b^4*c^4", domain, MonomialOrder.DEFAULT, "a", "b", "c"); a = a.multiply(gcd); b = b.multiply(gcd); MultivariatePolynomialZp64 intrp = interpolateGCD(asOverZp64(a), asOverZp64(b), asOverZp64(gcd), getRandom()); assertEquals(asOverZp64(gcd).monic(), intrp.monic()); } |
MultivariateGCD { @SuppressWarnings("ConstantConditions") public static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b) { Util.ensureOverZ(a, b); if (a == b) return a.clone(); if (a.isZero()) return b.clone(); if (b.isZero()) return a.clone(); if (a.degree() < b.degree()) return ZippelGCDInZ(b, a); BigInteger aContent = a.content(), bContent = b.content(); BigInteger contentGCD = BigIntegerUtil.gcd(aContent, bContent); if (a.isConstant() || b.isConstant()) return a.createConstant(contentGCD); a = a.clone().divideOrNull(aContent); b = b.clone().divideOrNull(bContent); return ZippelGCDInZ0(a, b).multiply(contentGCD); } private MultivariateGCD(); static Poly PolynomialGCD(Poly... arr); static Poly PolynomialGCD(Iterable<Poly> arr); @SuppressWarnings("unchecked") static Poly PolynomialGCD(Poly a, Poly b); @SuppressWarnings("unchecked") static Poly PolynomialGCDinGF(Poly a, Poly b); @SuppressWarnings("unchecked") static MultivariatePolynomial<BigInteger> PolynomialGCDinZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDinNumberField(MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDinRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b,
KaltofenMonaganAlgorithm algorithm); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> BrownGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> ZippelGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 BrownGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 ZippelGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 EZGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static Poly EEZGCD(Poly a, Poly b); } | @Test public void testModularGCD1() throws Exception { MultivariatePolynomial<BigInteger> a = parse("a + 17*b + 2*c"), b = parse("3*a + b - c"), gcd = parse("1273465812736485821734523745*a*b - 21475715234*b - c"); assertEquals(gcd, ZippelGCDInZ(a.clone().multiply(gcd), b.clone().multiply(gcd))); }
@Test public void testModularGCD2() throws Exception { MultivariatePolynomial<BigInteger> a = parse("1234324234*a + 12317*b + 2*c"), b = parse("3*a + 143423423423423412314*b - c"), gcd = parse("1273465812736485821734523745*a*b - 21475715234*b - 143423423423423412314123123*c"); assertEquals(gcd, ZippelGCDInZ(a.clone().multiply(gcd), b.clone().multiply(gcd))); }
@Test public void testModularGCD3() throws Exception { PrivateRandom.getRandom().setSeed(29); MultivariatePolynomial<BigInteger> a = parse("5*b^6*c^15*d^3+4*b^8*c*d^11+17492152*a^2*b^8*c^15*d^10+8*a^2*b^10*d^11+9*a^3*b^2*c^10*d+5*a^4*b*c^5*d^3+6*a^4*b^13*c^3*d^13+17492156*a^8*b^6*c^12*d^4+5*a^9*b^9*d^11+5*a^10*b^6*c^15*d^10"), b = parse("b^8*d^3+a^4*b^2*c^7*d+4*a^5*d^2+4*a^5*b^6*c+17492153*a^7*c^8*d^6"), gcd = parse("7*a^2*b^7*c^9*d^6+17492158*a^2*b^8*c*d^9+4*a^2*b^9*c^7*d^3+3*a^3*d+7*a^3*b^2*c^2*d^2+4*a^3*b^2*c^2*d^3+17492156*a^3*b^9*c^9*d^3+a^5*b^6*c^9*d^2+17492153*a^6*b^8*c^3*d^3+8*a^9*b^3*c^6*d^8+9*a^9*b^6*c^4*d^5"); assertEquals(gcd, ZippelGCDInZ(a.clone().multiply(gcd), b.clone().multiply(gcd))); }
@Test public void testModularGCD4() throws Exception { PrivateRandom.getRandom().setSeed(29); MultivariatePolynomial<BigInteger> a = parse("4*a*b^7*c*d^2+a^2*b^6*c^8*d^4+7*a^3*b^5*c^6*d^4+5*a^4*b^3*c*d^7+6*a^5*b^4*c^7+8*a^7*c^8*d+a^8*b^5*c^3*d^2"), b = parse("25987600*b^18*c^17*d^14+25987597*a*b^9*c^9*d^2+2*a^2*b^7*c^12*d^7+4*a^4*b^14*c^11*d^2+6*a^6*b^2*d+2*a^6*b^3*c^16*d^14+5*a^9*b^17*c^16*d^2+a^14*b^18*c^17*d^4"), gcd = parse("25987593*a^4*c^4*d^4+9*a^6*c^3*d^10+7*a^6*b^14*c^4*d^7+8*a^7*b^9*c^13*d+7*a^9*b^2*c^13*d^4+2*a^10*b^6*c^9*d^7+2*a^11*b^5*c^7*d^3+2*a^11*b^12*c^13*d^14+7*a^14*b^8*c^14*d^3+6*a^14*b^13*c^4*d^11"); assertEquals(gcd, ZippelGCDInZ(a.clone().multiply(gcd), b.clone().multiply(gcd))); }
@Test public void testModularGCD5() throws Exception { PrivateRandom.getRandom().setSeed(29); MultivariatePolynomial<BigInteger> a = parse("5*a*b^5*c^10*d^7*e^16+2*a^4*b^3*c^9*d^6*e^8+5*a^4*b^6*c^16*d^11*e^2+a^4*b^13*d^5*e^6+30844060*a^5*b*c^9*d^8*e^12+4*a^8*b*c^17*d^11*e^3+9*a^8*b^13*c^16*d^17*e^11+a^9*b^2*c^2*d^10*e^14+5*a^9*b^6*c^3*d^7*e^4+7*a^9*b^8*c^3*d^16*e^2+9*a^14*b^5*c^2*d^3*e^16"), b = parse("7*b^6*c^18*d^5*e+30844053*a^2*b^8*c^10*d^8*e^6+a^3*b^14*c^4*d^11*e^7+a^4*b^10*c*d^15*e^18+3*a^15*b^9*c^3*e^11+5*a^18*b^13*c^16*d^15*e^15"), gcd = parse("9*a^3*b^11*c^7*d^4*e^6+30844059*a^5*b^6*c^15*d^8*e^10+8*a^5*b^10*c^15*d^2*e^9+5*a^10*b^11*c^7*d^9*e^16+2*a^13*b^3*c^13*d^6*e^2+30844060*a^14*b^3*c^6*d^3*e^13+30844055*a^14*b^6*c^4*d^13+30844055*a^14*b^17*c^2*d^8*e^13+2*a^17*b^5*c^7*d*e^11"); assertTrue(dividesQ(ZippelGCDInZ(a.clone().multiply(gcd), b.clone().multiply(gcd)), gcd)); }
@Test public void testModularGCD6() throws Exception { for (int i = 46; i < 100; i++) { PrivateRandom.getRandom().setSeed(46); MultivariatePolynomial<BigInteger> a = parse("8*a*c^5*d^10*e^5+31118523*a*b^3*c^5*d^8*e^10+a^2*b^7*c*d*e^12+4*a^2*b^8*c*d^9*e^10+31118524*a^3*b^5*c^14*d^5*e^13+31118529*a^4*b^3*c^12*d^6*e^8+3*a^5*b^4*d^11*e^9+31118526*a^5*b^8*c^6*d^12*e+4*a^7*b^13*c^11*d^3+31118529*a^9*b^12*c^4*d^2*e^11+5*a^11*b^9*c^2*d*e^11+8*a^13*b^13*c^7*d^2*e^8+8*a^14*b^5*c^14*d^6*e^4"), b = parse("31118526*c^3*d^4*e^2+31118530*b^4*c^6*d^5*e^6+5*a*b*c^4*d^4*e^3+31118527*a*b^3*d*e^2+31118525*a^2*b*c^7*d*e^4+5*a^2*b^4*c^8*d^2*e^5+6*a^2*b^6*d^7*e^5+9*a^2*b^7*c^8*d*e^5+4*a^4*b^6*e^7+3*a^5*b^2*c^6*d^4*e^3+31118529*a^7*b*c^2*d^5*e^8+8*a^7*b^3*c^3*d^4*e^5+7*a^8*b*c^2*d^5*e^8+6*a^8*b^3*c^3*d^5*e^3"), gcd = parse("2*c^3*d*e^5+31118524*b^6*c^2*d^3*e^4+31118528*a^2*b^3*c^2*d^3+7*a^3*b*c^3*d^2+5*a^3*b^3*c^4*d^5*e^2+31118527*a^4*c^2*d^3+7*a^4*b*c*d*e^4+9*a^4*b*c^6*d^3*e^4+5*a^5*d^2*e^2+4*a^6*b^2*c^4*e+7*a^6*b^3*c^5*d^4*e^3"); assertTrue(dividesQ(ZippelGCDInZ(a.clone().multiply(gcd), b.clone().multiply(gcd)), gcd)); } }
@Test public void testModularGCD7() throws Exception { PrivateRandom.getRandom().setSeed(46); MultivariatePolynomial<BigInteger> a = parse("5*b*d^4+2*a^3*b*c*d^4+a^5*b^2*c^2*d^6+6*a^5*b^5*c^3*d^6+4*a^6*b*c^2+8*a^6*b^5*c^5*d^5"), b = parse("8*a*b*c^3*d^6+4*a*b^4*c*d+4*a*b^5*c*d^3+3*a^3*b^4*c^2"), gcd = parse("5*a^7*b^2*c^13*d^4"); assertTrue(dividesQ(ZippelGCDInZ(a.clone().multiply(gcd), b.clone().multiply(gcd)), gcd)); }
@Test public void testModularGCD8() throws Exception { PrivateRandom.getRandom().setSeed(48); MultivariatePolynomial<BigInteger> a = parse("8*a*b^19*c^11+8*a^3*b^4*c^9+7*a^3*b^10*c^12+3*a^5*b^14*c^21+7*a^9*b^21*c+8*a^10*b^8*c^5+a^14*b^21*c^12+15477328*a^21*b^20*c^8"), b = parse("15477335*b^8*c^4+7*b^9*c^8+15477332*a^3*b^13*c^4+15477335*a^9*b^13*c^6+15477328*a^12*c^9"), gcd = parse("15477332*a^10*b^13*c^5+7*a^14*b^5*c^3+6*a^19*b^12*c^5+2*a^19*b^12*c^13+15477329*a^20*b*c^19+15477332*a^20*b^8*c^12+7*a^21*b^8*c^2"); assertTrue(dividesQ(ZippelGCDInZ(a.clone().multiply(gcd), b.clone().multiply(gcd)), gcd)); }
@Test public void testModularGCD9() throws Exception { String[] vars = {"a", "b", "c"}; MultivariatePolynomial<BigInteger> a = parse("428678675174997*b - 576309141757314*c - 1799929908190992*b*c + 43581966762456*b^2*c + 2155012404966050*c^2 + 1356161027210220*b*c^2 - 162945010788840*b^2*c^2 - 579102861059775*b^6*c^2 + 667785318790236*b^5*c^3 + 569898197386650*b^6*c^3 - 41635029186864*b^7*c^3", vars), b = parse("-c", vars), gcd = parse("-2287341106126463750*b^7*c^5 + 1532098182980478300*b^8*c^5 - 946030127950514950*b^4*c^6 + 633666328207734108*b^5*c^6 + 723818682898978700*b^6*c^6 - 2410587259891460925*b^7*c^6 + 67657454221929000*b^8*c^6 + 299366928422627212*b^3*c^7 - 997003974528718653*b^4*c^7 + 27982704417344040*b^5*c^7 + 31963832309981000*b^6*c^7 - 101990974478857750*b^7*c^7 + 13220043258527560*b^3*c^8 - 42182835947642390*b^4*c^8", vars); assertTrue(dividesQ(ZippelGCDInZ(a.clone().multiply(gcd), b.clone().multiply(gcd)), gcd)); } |
MultivariateGCD { public static <Poly extends AMultivariatePolynomial> Poly PolynomialGCD(Poly... arr) { return PolynomialGCD(arr, MultivariateGCD::PolynomialGCD); } private MultivariateGCD(); static Poly PolynomialGCD(Poly... arr); static Poly PolynomialGCD(Iterable<Poly> arr); @SuppressWarnings("unchecked") static Poly PolynomialGCD(Poly a, Poly b); @SuppressWarnings("unchecked") static Poly PolynomialGCDinGF(Poly a, Poly b); @SuppressWarnings("unchecked") static MultivariatePolynomial<BigInteger> PolynomialGCDinZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDinNumberField(MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDinRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b,
KaltofenMonaganAlgorithm algorithm); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> BrownGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> ZippelGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 BrownGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 ZippelGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 EZGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static Poly EEZGCD(Poly a, Poly b); } | @Test public void testFiniteField1() throws Exception { for (int i = 0; i < 10; i++) { FiniteField<UnivariatePolynomialZp64> field = FiniteField.GF17p5; MultivariatePolynomial<UnivariatePolynomialZp64> a = MultivariatePolynomial.zero(3, field, MonomialOrder.DEFAULT) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(1, 2, 3, 4, 5).modulus(17)), 1, 1, 3)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 1, 3, 2, 13).modulus(17)), 3, 2, 1)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 11, 13, 12, 13).modulus(17)), 0, 2, 1)), b = MultivariatePolynomial.zero(3, field, MonomialOrder.DEFAULT) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(1, 1, 3, 4, 5).modulus(17)), 1, 1, 13)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 1, 1, 2, 13).modulus(17)), 2, 2, 1)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 11, 113, 112, 13).modulus(17)), 10, 2, 1)), gcd = MultivariatePolynomial.one(3, field, MonomialOrder.DEFAULT) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(1, 1, 3, 4, 5, 12).modulus(17)), 11, 1, 13)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(11, 2, 1, 1, 2, 13).modulus(17)), 21, 2, 1)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 111, 113, 112, 13, 12).modulus(17)), 10, 12, 1)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 111, 113, 112, 13, 12).modulus(17)), 0, 0, 1)); a = a.clone().add(b).multiply(gcd); b = b.clone().subtract(gcd).multiply(gcd); long start = System.nanoTime(); assertTrue(dividesQ(PolynomialGCD(a, b), gcd)); System.out.println(nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testSmallDomain3() throws Exception { IntegersZp64 domain = new IntegersZp64(5); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("2*a*c^3*d^2+4*a*b*c^2*d", domain), b = MultivariatePolynomialZp64.parse("a*c^4*d+a^3*b^2*c*d^4+3*a^3*b^2*c^2*d^3+2*a^3*b^3*d^3", domain); for (int i = 0; i < 10; i++) { PrivateRandom.getRandom().setSeed(i); timestamp(); assertTrue(PolynomialGCD(a, b).isMonomial()); timeElapsed(); } }
@Test public void testArrayGCD1() throws Exception { IntegersZp64 domain = new IntegersZp64(BigPrimes.nextPrime(1321323)); MultivariatePolynomialZp64 gcd = MultivariatePolynomialZp64.parse("c*a + b + a + c^15*a^3 + b*c*a^5 + d^2*c*a", domain, MonomialOrder.DEFAULT), arr[] = { MultivariatePolynomialZp64.parse("c*b*a^2 + b^2 + c + b*a^15 + d", domain, MonomialOrder.DEFAULT).multiply(gcd), MultivariatePolynomialZp64.parse("a^12 + 2*b^12 + 2*c + c*a^5 + d*a", domain, MonomialOrder.DEFAULT).multiply(gcd), MultivariatePolynomialZp64.parse("a^2 + 2*b^12 + 2*c + c*a^5 + d*a", domain, MonomialOrder.DEFAULT).multiply(gcd), MultivariatePolynomialZp64.parse("a^12 - 2*b^2 + 2*c^3 + c*a^5 + d*a", domain, MonomialOrder.DEFAULT).multiply(gcd), MultivariatePolynomialZp64.parse("b^12 - 2*b^2 + 2*c^3 + c*a^5 + d*a", domain, MonomialOrder.DEFAULT).multiply(gcd) }; MultivariatePolynomialZp64 aGcd = MultivariateGCD.PolynomialGCD(arr); assertEquals(gcd, aGcd); }
@Test @SuppressWarnings("unchecked") public void testArrayGCD2() throws Exception { FiniteField<UnivariatePolynomialZp64> minorDomain = new FiniteField<>(UnivariatePolynomialZ64.create(1, 0, 1, 1).modulus(2)); Coder<UnivariatePolynomialZp64, ?, ?> yParser = Coder.mkPolynomialCoder(minorDomain, "y"); Coder<UnivariatePolynomial<UnivariatePolynomialZp64>, ?, ?> xyParser = Coder.mkUnivariateCoder(Rings.UnivariateRing(minorDomain), yParser, "x"); FiniteField<UnivariatePolynomial<UnivariatePolynomialZp64>> domain = new FiniteField<>(xyParser.parse("(1+y^2)+(y^2)*x+(y+y^2)*x^2+x^3")); Coder<MultivariatePolynomial<UnivariatePolynomial<UnivariatePolynomialZp64>>, ?, ?> parser = Coder.mkMultivariateCoder(Rings.MultivariateRing(2, domain), xyParser, "a", "b"); MultivariatePolynomial<UnivariatePolynomialZp64> arr[] = new MultivariatePolynomial[]{ parser.parse("((y)*x^0)*b+((y+y^2)*x^0)*b^2+b^3+((1+y)*x^0)*b^4"), parser.parse("((1+y+y^2)*x^0)*b^4+((1+y)*x^0)*b^8"), parser.parse("((y+y^2)*x^0)*b^3+((1+y)*x^0)*b^4+((1+y^2)*x^0)*b^5"), parser.parse("((y)*x^0)*b^2+((y+y^2)*x^0)*b^3+((y)*x^0)*b^4+((y^2)*x^0)*b^5+((1+y+y^2)*x^0)*b^6"), parser.parse("((y^2)*x^0)+b+((y)*x^0)*b^3+((y+y^2)*x^0)*b^4+((1+y)*x^0)*b^6+((1+y^2)*x^0)*b^7"), parser.parse("((y+y^2)*x^0)*b^7"), parser.parse("((1+y^2)*x^0)*b^5"), parser.parse("((1+y+y^2)*x^0)*b^4+((1+y)*x^0)*b^8"), parser.parse("((1+y)*x^0)*b^4+((y^2)*x^0)*b^5+((y+y^2)*x^0)*b^6+((y^2)*x^0)*b^7"), parser.parse("((y+y^2)*x^0)*b^3+((1+y)*x^0)*b^4+((1+y^2)*x^0)*b^5"), parser.parse("b^2+((y+y^2)*x^0)*b^3+((1+y+y^2)*x^0)*b^5+((y^2)*x^0)*b^6+b^7+((y)*x^0)*b^8"), parser.parse("((y)*x^0)*b^2+((y+y^2)*x^0)*b^3+((y)*x^0)*b^4+((y^2)*x^0)*b^5+((1+y+y^2)*x^0)*b^6"), parser.parse("((y+y^2)*x^0)*b^7"), parser.parse("((y^2)*x^0)+b+((y)*x^0)*b^3+((y+y^2)*x^0)*b^4+((1+y)*x^0)*b^6+((1+y^2)*x^0)*b^7"), parser.parse("((1+y^2)*x^0)+((y)*x^0)*b+b^3+((1+y)*x^0)*b^4"), }; for (int i = 0; i < 100; i++) assertTrue(MultivariateGCD.PolynomialGCD(arr).isConstant()); }
@Test @SuppressWarnings("unchecked") public void testArrayGCD3() throws Exception { FiniteField<UnivariatePolynomialZp64> minorDomain = new FiniteField<>(UnivariatePolynomialZ64.create(1, 0, 1, 1).modulus(2)); Coder<UnivariatePolynomialZp64, ?, ?> yParser = Coder.mkPolynomialCoder(minorDomain, "y"); Coder<UnivariatePolynomial<UnivariatePolynomialZp64>, ?, ?> xyParser = Coder.mkUnivariateCoder(Rings.UnivariateRing(minorDomain), yParser, "x"); FiniteField<UnivariatePolynomial<UnivariatePolynomialZp64>> domain = new FiniteField<>(xyParser.parse("(1+y^2)+(y^2)*x+(y+y^2)*x^2+x^3")); Coder<MultivariatePolynomial<UnivariatePolynomial<UnivariatePolynomialZp64>>, ?, ?> parser = Coder.mkMultivariateCoder(Rings.MultivariateRing(2, domain), xyParser, "a", "b"); MultivariatePolynomial<UnivariatePolynomialZp64> arr[] = new MultivariatePolynomial[]{ parser.parse("(x)*b+(x+x^2)*b^2+b^3+(1+x)*b^4"), parser.parse("(1+x+x^2)*b^4+(1+x)*b^8"), parser.parse("(x+x^2)*b^3+(1+x)*b^4+(1+x^2)*b^5"), parser.parse("(x)*b^2+(x+x^2)*b^3+(x)*b^4+(x^2)*b^5+(1+x+x^2)*b^6"), parser.parse("(x^2)+b+(x)*b^3+(x+x^2)*b^4+(1+x)*b^6+(1+x^2)*b^7"), parser.parse("(x+x^2)*b^7"), parser.parse("(1+x^2)*b^5"), parser.parse("(1+x+x^2)*b^4+(1+x)*b^8"), parser.parse("(1+x)*b^4+(x^2)*b^5+(x+x^2)*b^6+(x^2)*b^7"), parser.parse("(x+x^2)*b^3+(1+x)*b^4+(1+x^2)*b^5"), parser.parse("b^2+(x+x^2)*b^3+(1+x+x^2)*b^5+(x^2)*b^6+b^7+(x)*b^8"), parser.parse("(x)*b^2+(x+x^2)*b^3+(x)*b^4+(x^2)*b^5+(1+x+x^2)*b^6"), parser.parse("(x+x^2)*b^7"), parser.parse("(x^2)+b+(x)*b^3+(x+x^2)*b^4+(1+x)*b^6+(1+x^2)*b^7"), parser.parse("(1+x^2)+(x)*b+b^3+(1+x)*b^4"), }; assertTrue(MultivariateGCD.PolynomialGCD(arr).isConstant()); }
@Test @SuppressWarnings("unchecked") public void testArrayGCD4() throws Exception { MultivariatePolynomial<MultivariatePolynomial<BigInteger>>[] pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("2").setNVariables(4).asOverMultivariateEliminate(2, 3), MultivariatePolynomial.parse("4").setNVariables(4).asOverMultivariateEliminate(2, 3), MultivariatePolynomial.parse("6").setNVariables(4).asOverMultivariateEliminate(2, 3)}; assertEquals(pp[0].parsePoly("2"), MultivariateGCD.PolynomialGCD(pp)); pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("2*x*y*z*t").setNVariables(4).asOverMultivariateEliminate(2, 3), MultivariatePolynomial.parse("4 - 2").setNVariables(4).asOverMultivariateEliminate(2, 3), MultivariatePolynomial.parse("6*x*y*z*t - 2").setNVariables(4).asOverMultivariateEliminate(2, 3)}; assertEquals(pp[0].parsePoly("2"), MultivariateGCD.PolynomialGCD(pp)); pp = new MultivariatePolynomial[]{ MultivariatePolynomial.parse("2*x*y*z*t - 16").setNVariables(4).asOverMultivariateEliminate(2, 3), MultivariatePolynomial.parse("4*x - 2").setNVariables(4).asOverMultivariateEliminate(2, 3), MultivariatePolynomial.parse("6*x*y*z*t - 2").setNVariables(4).asOverMultivariateEliminate(2, 3)}; assertEquals(pp[0].parsePoly("2"), MultivariateGCD.PolynomialGCD(pp)); }
@Test public void testPolynomialGCD1() throws Exception { IntegersZp64 domain = new IntegersZp64(19); String[] vars = {"a", "b"}; MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("2 + 3*b + b^2", domain, vars); MultivariatePolynomialZp64 b = MultivariatePolynomialZp64.parse("2 + b + a^2 + a^2*b", domain, vars); for (int i = 0; i < 1000; i++) assertTrue(PolynomialGCD(a, b).isConstant()); }
@Test public void testPolynomialGCD2() throws Exception { IntegersZp64 domain = new IntegersZp64(19); String[] vars = {"a", "b"}; MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("a^2 + b*a", domain, vars), b = MultivariatePolynomialZp64.parse("b + 1", domain, vars), gcd = MultivariatePolynomialZp64.parse("2 + b", domain, vars); a = a.multiply(gcd); b = b.multiply(gcd); for (int i = 0; i < 1000; i++) assertEquals(gcd, PolynomialGCD(a, b)); }
@Test(timeout = 1000) public void testPolynomialGCD3() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b"}; MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("a^2*b + a*b + b + 1", domain, vars), b = MultivariatePolynomialZp64.parse("b + 1", domain, vars), gcd = MultivariatePolynomialZp64.parse("b + 1", domain, vars); a = a.multiply(gcd); b = b.multiply(gcd); for (int i = 0; i < 10; i++) assertEquals(gcd, PolynomialGCD(a, b)); }
@Test(timeout = 1000000) public void testSmallDomain4() throws Exception { IntegersZp64 domain = new IntegersZp64(3); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("1+2*c^3*d^2+2*b^3*c^3*d^3*e+a*c^3*d*e+2*a^2*b^3*c^2*d^2*e^3+a^2*b^3*c^3*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*c^2*d^3*e^3+a*c^3*d*e^2+2*a^3*e^3+2*a^3*b^3*d*e^3+2*a^3*b^3*c*d^3*e", domain, vars), MultivariatePolynomialZp64.parse("1+2*a*b^3*c+a^2*d^3*e", domain, vars), MultivariatePolynomialZp64.parse("1+2*b^3*c^3*d^3*e+2*a*b^2*c*d^2*e^3+a*b^3*c^2*d*e^2+a^3*b^2*c^3*d^2", domain, vars), }, base = arr[0].createOne().multiply(arr); MultivariatePolynomialZp64 a = MultivariateFactorization.orderByDegrees(base, false, -1).ordered; MultivariatePolynomialZp64 b = a.derivative(0); for (int i = 1; i < 5; i++) { System.out.println(i); PrivateRandom.getRandom().setSeed(i); long start = System.nanoTime(); Assert.assertFalse(PolynomialGCD(a, b).isConstant()); System.out.println(nanosecondsToString(System.nanoTime() - start)); } }
@Test(timeout = 100000) public void testSmallDomain5() throws Exception { IntegersZp64 domain = new IntegersZp64(3); String[] vars = {"x", "y"}; MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("y^2+y^3+x*y^2+x*y^3+2*x^3*y^6+2*x^4*y^2+2*x^4*y^3+x^4*y^5+2*x^5*y^2+x^5*y^3+x^5*y^9+2*x^6+2*x^6*y^3+2*x^6*y^5+2*x^6*y^8+2*x^6*y^9+2*x^7+2*x^7*y^5+x^7*y^6+x^7*y^9+2*x^8*y^5+x^8*y^6+2*x^8*y^12+x^9*y^3+x^9*y^8+2*x^9*y^9+2*x^9*y^12+x^10*y^8+x^10*y^9+x^11*y^5+2*x^11*y^6+x^11*y^9+2*x^11*y^11+x^12*y^5+2*x^12*y^6+2*x^12*y^9+2*x^12*y^11+x^12*y^12+x^13*y^12+2*x^14*y^8+x^14*y^9+x^14*y^12+x^14*y^14+x^16*y^11+x^17*y^11+2*x^19*y^14", domain, vars); MultivariatePolynomialZp64 b = MultivariatePolynomialZp64.parse("1+y^4+2*y^5+2*y^9+x+x*y^4+2*x*y^5+2*x*y^9+x^3*y^8+x^3*y^12+2*x^4+x^4*y^3+2*x^4*y^4+x^4*y^5+x^4*y^7+x^4*y^9+2*x^5+2*x^5*y^4+2*x^5*y^5+x^5*y^6+2*x^5*y^9+2*x^5*y^11+x^6*y^2+x^6*y^5+x^6*y^6+2*x^6*y^7+x^6*y^9+2*x^6*y^10+x^6*y^11+x^7*y^2+x^7*y^6+2*x^7*y^7+2*x^7*y^8+2*x^7*y^11+2*x^7*y^12+2*x^8*y^3+2*x^8*y^7+2*x^8*y^8+2*x^8*y^12+x^8*y^14+2*x^9*y^5+2*x^9*y^6+x^9*y^10+x^9*y^11+x^9*y^14+x^10*y^10+2*x^10*y^11+x^11*y^7+x^11*y^8+2*x^11*y^11+2*x^11*y^12+2*x^11*y^13+x^12*y^7+x^12*y^8+x^12*y^11+2*x^12*y^13+2*x^12*y^14+2*x^13*y^9+2*x^13*y^14+2*x^14*y^10+2*x^14*y^11+2*x^14*y^14+x^14*y^16+x^15*y^12+x^16*y^13+x^17*y^13+2*x^19*y^16", domain, vars); for (int i = 5; i < 100; i++) { PrivateRandom.getRandom().setSeed(i); assertFalse(PolynomialGCD(a, b).isConstant()); } }
@Ignore("issue #20") @Test public void testSmallDomain6() throws Exception { IntegersZp64 ring = Rings.Zp64(3); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("1 + a + 5*b + 7*c + d + 11*e + 13*f + g", ring), b = MultivariatePolynomialZp64.parse("1 - a + 5*b - 7*c + d - 11*e + 13*f - g", ring), g = MultivariatePolynomialZp64.parse("1 + a - 5*b + 7*c - d + 11*e - 13*f + g", ring); int exp = 7; a = PolynomialMethods.polyPow(a, exp); b = PolynomialMethods.polyPow(b, exp); g = PolynomialMethods.polyPow(g, exp); MultivariatePolynomialZp64 ag = a.clone().multiply(g); MultivariatePolynomialZp64 bg = b.clone().multiply(g); System.out.println(PolynomialGCD(ag, bg)); }
@Ignore("too expensive (memory limit in CI)") @Test public void testHugePoly2() throws Exception { MultivariateRing<MultivariatePolynomial<BigInteger>> R = Rings.MultivariateRing(3, Rings.Z); for (int j = 1; j < 4; ++j) { try (BufferedReader in = new BufferedReader(new InputStreamReader(new GZIPInputStream( new FileInputStream( "src/test/resources/cc/redberry/rings/poly/multivar/HugeGCDinZ.txt.gz"))))) { String s1 = in.readLine(); String s2 = in.readLine(); MultivariatePolynomial<BigInteger> p = R.parse(s1); MultivariatePolynomial<BigInteger> q = R.parse(s2); long t1 = System.nanoTime(); MultivariatePolynomial<BigInteger> gcd = MultivariateGCD.PolynomialGCD(p, q); long t2 = System.nanoTime(); System.out.println("Total time : " + nanosecondsToString(t2 - t1)); System.out.println("GCD size : " + gcd.size()); System.out.println(); } } }
@Ignore("too expensive (memory limit in CI)") @Test public void testHugePoly3() throws Exception { MultivariateRing<MultivariatePolynomial<BigInteger>> R = Rings.MultivariateRing(7, Rings.Z); try (BufferedReader in = new BufferedReader(new InputStreamReader(new GZIPInputStream( new FileInputStream( "src/test/resources/cc/redberry/rings/poly/multivar/HugeGCDinZ.LinZip.txt.gz"))))) { int iProblem = 0; String line; while ((line = in.readLine()) != null) { if (line.startsWith("#")) continue; String[] split = line.split("\t"); MultivariatePolynomial<BigInteger> p = R.parse(split[1]), q = R.parse(split[2]), expected = R.parse(split[3]); long t1 = System.nanoTime(); MultivariatePolynomial<BigInteger> gcd = MultivariateGCD.PolynomialGCD(p, q); long t2 = System.nanoTime(); assertTrue(dividesQ(gcd, expected)); System.out.println("Problem : " + iProblem); System.out.println("Total time : " + nanosecondsToString(t2 - t1)); System.out.println("GCD size : " + gcd.size()); System.out.println(); ++iProblem; } } }
@Ignore("too expensive (memory limit in CI)") @Test public void testHugePoly4() throws Exception { MultivariateRing<MultivariatePolynomial<BigInteger>> R = Rings.MultivariateRing(3, Rings.Z), modR = Rings.MultivariateRing(3, Rings.Zp(1073741827)); try (BufferedReader in = new BufferedReader(new InputStreamReader(new GZIPInputStream( new FileInputStream( "src/test/resources/cc/redberry/rings/poly/multivar/HugeHugeGCDinZ.txt.gz"))))) { int iProblem = 0; String line; while ((line = in.readLine()) != null) { if (line.startsWith("#")) continue; String[] split = line.split("\t"); MultivariatePolynomial<BigInteger> p = R.parse(split[1]), q = R.parse(split[2]), expected = R.parse(split[3]); System.out.println("Problem : " + iProblem++); long t1 = System.nanoTime(); MultivariatePolynomial<BigInteger> gcd = MultivariateGCD.PolynomialGCD(p, q); long t2 = System.nanoTime(); assertTrue(dividesQ(gcd, expected)); System.out.println("Total time (Z) : " + nanosecondsToString(t2 - t1)); System.out.println("GCD size : " + gcd.size()); System.out.println(); t1 = System.nanoTime(); MultivariatePolynomial<BigInteger> mgcd = MultivariateGCD.PolynomialGCD(modR.valueOf(p), modR.valueOf(q)); t2 = System.nanoTime(); assertTrue(dividesQ(gcd, expected)); System.out.println("Total time (mod) : " + nanosecondsToString(t2 - t1)); System.out.println("MGCD size : " + mgcd.size()); System.out.println(); } } }
@Test(timeout = 100_000L) public void testMediumCharacteristic1() throws Exception { MultivariateRing<MultivariatePolynomial<BigInteger>> ring = Rings.MultivariateRing(5, Rings.Zp(4099)); try (BufferedReader in = new BufferedReader(new InputStreamReader(new GZIPInputStream( MultivariateGCDTest.class.getClassLoader().getResourceAsStream( "MediumCharacteristicHugePoly.txt.gz"))))) { MultivariatePolynomial<BigInteger> a = ring.parse(in.readLine()); MultivariatePolynomial<BigInteger> b = ring.parse(in.readLine()); for (boolean switch64 : Arrays.asList(true, false)) { Conversions64bit.SWITCH_TO_64bit = switch64; long start = System.nanoTime(); MultivariatePolynomial<BigInteger> gcd = PolynomialGCD(a, b); System.out.println(nanosecondsToString(System.nanoTime() - start)); } } }
@Test public void testTrivial1() { MultivariateRing<MultivariatePolynomial<BigInteger>> ring = Rings.MultivariateRing(7, Rings.Z); RandomGenerator rnd = getRandom(); rnd.setSeed(1); MultivariatePolynomial<BigInteger> a = RandomMultivariatePolynomials.randomPolynomial(ring.nVariables(), 15, 20, 2500, Rings.Z, MonomialOrder.GREVLEX, r -> Rings.Z.valueOf(1 + r.nextInt(100)), rnd); MultivariatePolynomial<BigInteger> b = RandomMultivariatePolynomials.randomPolynomial(ring.nVariables(), 15, 20, 2, Rings.Z, MonomialOrder.GREVLEX, r -> Rings.Z.valueOf(1 + r.nextInt(100)), rnd); for (int i = 0; i < 10; ++i) { long start = System.nanoTime(); PolynomialGCD(a, b).size(); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testTrivial2() { MultivariateRing<MultivariatePolynomial<BigInteger>> ring = Rings.MultivariateRing(7, Rings.Z); MultivariatePolynomial<BigInteger> a = ring.parse("x1*x2^3*x3*x4^3*x5^4-1*x2^5*x3*x4^3*x5^4-1*x1^7*x3^4*x4^3*x5*x6^2*x7^4+x1^6*x2^2*x3^4*x4^3*x5*x6^2*x7^4+x1^7*x3^4*x4^3*x5*x6^4*x7^3+x1^5*x3^2*x4^6*x5^2*x6^6*x7+x1^8*x3*x4^2*x5*x6^7*x7^4+x1^8*x2*x3*x4^3*x6^6*x7^4-1*x1^6*x2^2*x3^4*x4^3*x5*x6^4*x7^3-1*x1^4*x2^2*x3^2*x4^6*x5^2*x6^6*x7-1*x1^5*x3^2*x4^6*x5^2*x6^8-1*x1^7*x2^2*x3*x4^2*x5*x6^7*x7^4-1*x1^9*x3*x4^3*x5*x6^6*x7^4+x1^7*x3*x4^6*x6^6*x7^4-1*x1^7*x2^3*x3*x4^3*x6^6*x7^4-1*x1^8*x3*x4^2*x5*x6^9*x7^3-1*x1^8*x2*x3*x4^3*x6^8*x7^3+x1^4*x2^2*x3^2*x4^6*x5^2*x6^8+x1^8*x2^2*x3*x4^3*x5*x6^6*x7^4+x1^7*x2^2*x3*x4^2*x5*x6^9*x7^3+x1^9*x3*x4^3*x5*x6^8*x7^3-1*x1^7*x3*x4^6*x6^8*x7^3+x1^7*x2^3*x3*x4^3*x6^8*x7^3+x1^4*x2^3*x3^5*x5*x6^6*x7^7-1*x1^8*x2^2*x3*x4^3*x5*x6^8*x7^3-1*x1^3*x2^5*x3^5*x5*x6^6*x7^7-1*x1^4*x2^3*x3^5*x5*x6^8*x7^6+x1^8*x3^5*x4^3*x5^2*x6^5*x7^4+x1^3*x2^5*x3^5*x5*x6^8*x7^6+x1^8*x3^5*x4^4*x5*x6^6*x7^4-1*x1^7*x2^2*x3^5*x4^3*x5^2*x6^5*x7^4-1*x1^8*x3^5*x4^3*x5^2*x6^7*x7^3-1*x1^7*x2^2*x3^5*x4^4*x5*x6^6*x7^4-1*x1^8*x3^5*x4^4*x5*x6^8*x7^3+x1^7*x2^2*x3^5*x4^3*x5^2*x6^7*x7^3-1*x1^8*x2^6*x3^2*x4^3*x5*x6^6*x7^4+x1^7*x2^2*x3^5*x4^4*x5*x6^8*x7^3+x1^7*x2^8*x3^2*x4^3*x5*x6^6*x7^4+x1^8*x2^6*x3^2*x4^3*x5*x6^8*x7^3-1*x1^7*x2^8*x3^2*x4^3*x5*x6^8*x7^3-1*x1^11*x4^3*x5^5*x6^10*x7^4+x1^10*x2^2*x4^3*x5^5*x6^10*x7^4+x1^11*x4^3*x5^5*x6^12*x7^3-1*x1^10*x2^2*x4^3*x5^5*x6^12*x7^3"); MultivariatePolynomial<BigInteger> b = ring.parse("-1*x1^8*x3*x4^2*x5*x6^6*x7^4+x1^7*x2^2*x3*x4^2*x5*x6^6*x7^4+x1^8*x3*x4^2*x5*x6^8*x7^3-1*x1^7*x2^2*x3*x4^2*x5*x6^8*x7^3"); for (int i = 0; i < 10; ++i) { long start = System.nanoTime(); PolynomialGCD(a, b).size(); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void testAlgExt1() { AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = AlgebraicNumberField(UnivariatePolynomial.create(Q, Q.valueOf(-2), Q.valueOf(0), Q.valueOf(1))); Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> cfCoder = Coder.mkUnivariateCoder(field, "s"); MultivariateRing<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> mRing = Rings.MultivariateRing(3, field); Coder<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>, ?, ?> coder = Coder.mkMultivariateCoder(mRing, cfCoder, "x", "y", "z"); MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a = coder.parse("(1 - s + s*x^5 - s*y + z) * ( 1 + s*x^2 + 12*x^5)"); MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b = coder.parse("(1 - s + s*x^5 - s*y + z) * ( 14 - s*x + 2*x^17)"); MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> gcd = PolynomialGCD(a, b); assertTrue(dividesQ(a, gcd)); assertTrue(dividesQ(b, gcd)); }
@Test(timeout = 50000L) public void testZippel22() { FiniteField<UnivariatePolynomialZp64> cfField = Rings.GF(UnivariatePolynomialZ64.create(6, 7, 14, 1).modulus(17)); MultivariateRing<MultivariatePolynomial<UnivariatePolynomialZp64>> ring = MultivariateRing(4, cfField); Coder<UnivariatePolynomialZp64, ?, ?> cfCoder = Coder.mkUnivariateCoder(cfField, "x"); Coder<MultivariatePolynomial<UnivariatePolynomialZp64>, ?, ?> coder = Coder.mkMultivariateCoder(ring, cfCoder, "a", "b", "c", "d"); MultivariatePolynomial<UnivariatePolynomialZp64> a = coder.parse("16*x*d+16*a*c+a*b"); MultivariatePolynomial<UnivariatePolynomialZp64> b = coder.parse("(12+15*x+4*x^2)*d+16*x*d^2+(10+10*x^2)*a*d+(1+10*x+15*x^2)*a*c+(16+7*x+2*x^2)*a*b+16*x^2*a*d^2+16*a*c*d+16*x*b^2*d+a*b*d+16*x^2*a^2*d+(11+15*x+4*x^2)*a^2*c+(6+2*x+13*x^2)*a^2*b+16*x^2*d^4+(5+2*x+12*x^2)*a*d^3+16*x^2*c^2*d^2+(5+2*x+12*x^2)*a*c^2*d+16*x*a^2*c*d+16*x^2*a*b^2*d+x*a^2*b*d+16*a*b^2*c+16*x*a^3*c+a*b^3+x*a^3*b+(6+8*x+14*x^2)*a*d^4+16*x*a*c*d^3+16*x^2*b^2*d^3+x*a*b*d^3+(6+8*x+14*x^2)*a^2*d^3+16*x*c^3*d^2+(6+8*x+14*x^2)*a*c^2*d^2+(16+6*x+2*x^2)*a^2*c*d^2+(1+11*x+15*x^2)*a^2*b*d^2+15*x*a*c^3*d+16*x^2*b^2*c^2*d+x*a*b*c^2*d+(6+8*x+14*x^2)*a^2*c^2*d+x*b^4*d+(16+6*x+2*x^2)*a^2*c^3+(1+11*x+15*x^2)*a^2*b*c^2+16*x*a^2*b^2*c+x*a^2*b^3+(1+16*x^2)*a^2*c*d^3+(6+8*x+14*x^2)*a*b^2*d^3+(16+x^2)*a^2*b*d^3+16*x^2*a*c^3*d^2+16*x*a*b^2*c*d^2+(1+16*x^2)*a^3*c*d^2+x*a*b^3*d^2+(16+x^2)*a^3*b*d^2+16*a*c^4*d+16*x*b^2*c^3*d+a*b*c^3*d+(1+15*x^2)*a^2*c^3*d+(6+8*x+14*x^2)*a*b^2*c^2*d+(16+x^2)*a^2*b*c^2*d+x^2*a*b^4*d+16*a^2*c^4+16*x*a*b^2*c^3+a^2*b*c^3+(1+16*x^2)*a^3*c^3+x*a*b^3*c^2+(16+x^2)*a^3*b*c^2+a*b^4*c+16*a*b^5+x^2*a*d^6+x^2*a^2*d^5+2*x^2*a*c^2*d^4+2*x^2*a^2*c^2*d^3+x^2*b^4*d^3+x^2*a*c^4*d^2+(1+16*x^2)*a^2*b^2*c*d^2+(16+x^2)*a^2*b^3*d^2+(16*x+x^2)*a^2*c^4*d+16*x^2*a*b^2*c^3*d+x*a^2*b*c^3*d+x^2*b^4*c^2*d+16*a*b^2*c^4+16*x*a^3*c^4+a*b^3*c^3+(1+16*x^2)*a^2*b^2*c^3+x*a^3*b*c^3+(16+x^2)*a^2*b^3*c^2+x*a^2*b^4*c+16*x*a^2*b^5+x*a^2*c*d^5+x^2*a*b^2*d^5+16*x*a^2*b*d^5+x*a*c^3*d^4+x*a^3*c*d^4+16*x*a^3*b*d^4+3*x*a^2*c^3*d^3+2*x^2*a*b^2*c^2*d^3+15*x*a^2*b*c^2*d^3+(11+9*x+3*x^2)*a*b^4*d^3+x*a*c^5*d^2+2*x*a^3*c^3*d^2+15*x*a^3*b*c^2*d^2+x*a*b^4*c*d^2+15*x*a*b^5*d^2+2*x*a^2*c^5*d+x^2*a*b^2*c^4*d+16*x*a^2*b*c^4*d+x*b^4*c^3*d+(11+9*x+3*x^2)*a*b^4*c^2*d+16*x*a^2*b^5*d+x*a^3*c^5+16*x*a^2*b^2*c^4+16*x*a^3*b*c^4+x*a*b^4*c^3+x*a^2*b^3*c^3+16*x*a*b^5*c^2+x*a^2*b^2*c*d^4+16*x*a^2*b^3*d^4+a^2*c^4*d^3+x*a*b^2*c^3*d^3+16*a^2*b*c^3*d^3+a^3*c^4*d^2+2*x*a^2*b^2*c^3*d^2+16*a^3*b*c^3*d^2+15*x*a^2*b^3*c^2*d^2+(16+x^2)*a^2*b^4*c*d^2+(1+15*x^2)*a^2*b^5*d^2+a^2*c^6*d+x*a*b^2*c^5*d+16*a^2*b*c^5*d+x^2*a*b^4*c^3*d+16*a^2*b^5*c*d+16*x*a*b^7*d+a^2*b^6*d+16*x^2*a^3*b^5*d+a^3*c^6+x*a^2*b^2*c^5+16*a^3*b*c^5+a*b^4*c^4+16*x*a^2*b^3*c^4+16*a*b^5*c^3+(16+x^2)*a^2*b^4*c^3+(1+16*x^2)*a^2*b^5*c^2+16*a^3*b^5*c+a^3*b^6+16*x^2*a*b^4*d^5+15*x^2*a*b^4*c^2*d^3+a^2*b^2*c^4*d^2+16*a^2*b^3*c^3*d^2+16*x^2*a*b^4*c^4*d+16*x*a^3*b^5*c*d+16*x^2*a^2*b^7*d+x*a^3*b^6*d+a^2*b^2*c^6+16*a^2*b^3*c^5+x*a^2*b^4*c^4+16*x*a^2*b^5*c^3+16*a^2*b^7*c+16*x*a^4*b^5*c+a^2*b^8+x*a^4*b^6+16*x*a^2*b^4*c*d^4+2*x*a^2*b^5*d^4+16*x*a*b^4*c^3*d^3+x*a^3*b^5*d^3+15*x*a^2*b^4*c^3*d^2+3*x*a^2*b^5*c^2*d^2+16*x*a*b^4*c^5*d+x*a^3*b^5*c^2*d+x*a*b^9*d+16*x*a^2*b^4*c^5+x*a^2*b^5*c^4+16*x*a^3*b^7*c+x*a^3*b^8+a^3*b^5*c*d^3+x*a^2*b^7*d^3+16*a^3*b^6*d^3+16*a^2*b^4*c^4*d^2+a^2*b^5*c^3*d^2+a^4*b^5*c*d^2+16*a^4*b^6*d^2+a^3*b^5*c^3*d+x*a^2*b^7*c^2*d+16*a^3*b^6*c^2*d+x^2*a^2*b^9*d+16*a^2*b^4*c^6+a^2*b^5*c^5+a^4*b^5*c^3+16*a^4*b^6*c^2+a^2*b^9*c+16*a^2*b^10+a^3*b^7*c*d^2+16*a^3*b^8*d^2+a^3*b^7*c^3+16*a^3*b^8*c^2+x*a^3*b^9*c+16*x*a^3*b^10+16*x*a^2*b^9*d^3+16*x*a^2*b^9*c^2*d+16*a^3*b^9*c*d^2+a^3*b^10*d^2+16*a^3*b^9*c^3+a^3*b^10*c^2"); for (int i = 11; i < 100; ++i) { PrivateRandom.getRandom().setSeed(i); assertNotNull(PolynomialGCD(a, b)); } } |
MultivariateGCD { @SuppressWarnings({"ConstantConditions", "unchecked"}) public static <E> MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF( MultivariatePolynomial<E> a, MultivariatePolynomial<E> b) { return KaltofenMonaganModularGCDInGF(a, b, MultivariateGCD::KaltofenMonaganSparseModularGCDInGF0); } private MultivariateGCD(); static Poly PolynomialGCD(Poly... arr); static Poly PolynomialGCD(Iterable<Poly> arr); @SuppressWarnings("unchecked") static Poly PolynomialGCD(Poly a, Poly b); @SuppressWarnings("unchecked") static Poly PolynomialGCDinGF(Poly a, Poly b); @SuppressWarnings("unchecked") static MultivariatePolynomial<BigInteger> PolynomialGCDinZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDinNumberField(MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDinRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b,
KaltofenMonaganAlgorithm algorithm); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> BrownGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> ZippelGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 BrownGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 ZippelGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 EZGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static Poly EEZGCD(Poly a, Poly b); } | @Test public void testSmallDomain1() throws Exception { MultivariatePolynomial<BigInteger> a = parse("a + 2*b + c"), b = parse("a*b + 17*a*b^13 + a*c^2"), gcd = parse("1 + a^2*b^31*c + c^3*a^3*b - 2*a^5*b^2 - b*c^2"); for (long modulus : new long[]{2, 3, 5, 7, 11, 17, 19, 23, 29, 31, 37, 41, 43}) { IntegersZp domain = new IntegersZp(modulus); MultivariatePolynomial<BigInteger> a1 = a.clone().setRing(domain), b1 = b.clone().setRing(domain), gcd1 = gcd.clone().setRing(domain); a1 = a1.multiply(gcd1); b1 = b1.multiply(gcd1); assertEquals(gcd1.monic(), KaltofenMonaganSparseModularGCDInGF(a1, b1).monic()); } }
@Test public void testSmallDomain_sparse_variables_random_a() throws Exception { for (int i = 220; i < 250; ++i) { PrivateRandom.getRandom().setSeed(i); IntegersZp64 domain = new IntegersZp64(29); String[] vars = IStringifier.defaultVars(100); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("x4*x6^3*x7^4*x8*x9^3*x13^4*x17^2*x18^3*x21^5*x22*x23^3*x26*x27*x28^5*x30^2*x31^4*x32^3*x34*x37^4*x40^5*x41*x42^5*x44^2*x48^4*x49^5*x50^5*x52^5*x53^4*x56^2*x58*x59^5*x61*x64^3*x70^5*x72^3*x73^5*x75*x76^5*x79^3*x81*x83^2*x84*x85^5*x88*x90*x92^5*x93^5*x95^2*x97^5*x99+23*x4*x6^3*x7^4*x8*x9^3*x13^4*x18^3*x21^5*x22*x23^3*x26*x27*x28^5*x30^2*x31^4*x32^3*x34*x37^4*x40^5*x41*x42^5*x44^2*x48^4*x49^5*x50^6*x52^5*x53^4*x56^2*x58*x59^5*x61*x64^3*x70^5*x72^3*x73^5*x75*x76^5*x79^3*x81^3*x83^2*x84*x85^5*x88*x90*x92^5*x93^5*x95^2*x97^5*x99+17*x4*x6^3*x7^4*x8*x9^3*x13^4*x18^3*x21^5*x22*x23^3*x26*x27*x28^5*x30^2*x31^4*x32^3*x34*x37^4*x40^5*x41*x42^5*x44^2*x48^4*x49^5*x50^7*x52^5*x53^4*x56^2*x58*x59^5*x61*x64^3*x70^5*x72^3*x73^5*x75*x76^5*x79^3*x81^2*x83^2*x84*x85^5*x88*x90*x92^5*x93^5*x95^2*x97^5*x99+3*x4*x6^3*x7^4*x8*x9^3*x13^4*x17^2*x18^3*x21^5*x22*x23^3*x26*x27*x28^5*x30^2*x31^4*x32^3*x34*x37^4*x40^5*x41*x42^5*x44^2*x48^4*x49^5*x50^5*x52^5*x53^4*x56^2*x58*x59^5*x61*x64^3*x70^5*x72^3*x73^5*x75*x76^5*x79^3*x81^3*x83^2*x84*x85^5*x88*x90*x92^5*x93^5*x95^2*x97^5*x99+15*x4*x6^3*x7^4*x8*x9^3*x13^4*x17^2*x18^3*x21^5*x22*x23^3*x26*x27*x28^5*x30^2*x31^4*x32^3*x34*x37^4*x40^5*x41*x42^5*x44^2*x48^4*x49^5*x50^7*x52^5*x53^4*x56^2*x58*x59^5*x61*x64^3*x70^5*x72^3*x73^5*x75*x76^5*x79^3*x81^2*x83^2*x84*x85^5*x88*x90*x92^5*x93^5*x95^2*x97^5*x99", domain, vars), b = MultivariatePolynomialZp64.parse("24*x1^3*x2^3*x3*x5^3*x10^2*x11*x12^4*x15^4*x16^2*x17^4*x19*x20^4*x33^5*x36^4*x38*x39^4*x43^4*x45^3*x46^2*x47^3*x50*x51^4*x55*x57*x60^3*x62^5*x63^4*x65^4*x66^3*x67^2*x68*x69^2*x71*x74*x77*x78^3*x80*x81*x87*x89*x96^5*x100^2+x1^3*x2^3*x3*x5^3*x10^2*x11*x12^4*x15^4*x16^2*x17^2*x19*x20^4*x33^5*x36^4*x38*x39^4*x43^4*x45^3*x46^2*x47^3*x50^2*x51^4*x55*x57*x60^3*x62^5*x63^4*x65^4*x66^3*x67^2*x68*x69^2*x71*x74*x77*x78^3*x80*x81^3*x87*x89*x96^5*x100^2+2*x1^3*x2^3*x3*x5^3*x10^2*x11*x12^4*x15^4*x16^2*x17^2*x19*x20^4*x33^5*x36^4*x38*x39^4*x43^4*x45^3*x46^2*x47^3*x50^3*x51^4*x55*x57*x60^3*x62^5*x63^4*x65^4*x66^3*x67^2*x68*x69^2*x71*x74*x77*x78^3*x80*x81^2*x87*x89*x96^5*x100^2+14*x1^3*x2^3*x3*x5^3*x10^2*x11*x12^4*x15^4*x16^2*x17^4*x19*x20^4*x33^5*x36^4*x38*x39^4*x43^4*x45^3*x46^2*x47^3*x50*x51^4*x55*x57*x60^3*x62^5*x63^4*x65^4*x66^3*x67^2*x68*x69^2*x71*x74*x77*x78^3*x80*x81^3*x87*x89*x96^5*x100^2+12*x1^3*x2^3*x3*x5^3*x10^2*x11*x12^4*x15^4*x16^2*x17^4*x19*x20^4*x33^5*x36^4*x38*x39^4*x43^4*x45^3*x46^2*x47^3*x50^3*x51^4*x55*x57*x60^3*x62^5*x63^4*x65^4*x66^3*x67^2*x68*x69^2*x71*x74*x77*x78^3*x80*x81^2*x87*x89*x96^5*x100^2", domain, vars), gcd = MultivariatePolynomialZp64.parse("23*x17^2*x50+7*x50^2*x81^2+14*x50^3*x81+11*x17^2*x50*x81^2+26*x17^2*x50^3*x81", domain, vars), actual = MultivariatePolynomialZp64.parse("2*x17^2*x50*x81+17*x50^2*x81^3+5*x50^3*x81^2+6*x17^2*x50*x81^3+x17^2*x50^3*x81^2", domain, vars); MultivariatePolynomialZp64 lResult = KaltofenMonaganSparseModularGCDInGF(a, b); checkConsistency(lResult); assertTrue(dividesQ(lResult, gcd)); Conversions64bit.SWITCH_TO_64bit = false; MultivariatePolynomial<BigInteger> result = KaltofenMonaganSparseModularGCDInGF(a.toBigPoly(), b.toBigPoly()); checkConsistency(result); assertTrue(dividesQ(result, gcd.toBigPoly())); assertEquals(result.size(), lResult.size()); } }
@Test public void testSmallDomain2() throws Exception { IntegersZp64 domain = new IntegersZp64(3); String[] vars = {"a", "b", "c", "d", "e"}; MultivariatePolynomialZp64 arr[] = { MultivariatePolynomialZp64.parse("1+2*c^3*d^2+2*b^3*c^3*d^3*e+a*c^3*d*e+2*a^2*b^3*c^2*d^2*e^3+a^2*b^3*c^3*e^2", domain, vars), MultivariatePolynomialZp64.parse("1+b^3*c^2*d^3*e^3+a*c^3*d*e^2+2*a^3*e^3+2*a^3*b^3*d*e^3+2*a^3*b^3*c*d^3*e", domain, vars), MultivariatePolynomialZp64.parse("1+2*a*b^3*c+a^2*d^3*e", domain, vars), MultivariatePolynomialZp64.parse("1+2*b^3*c^3*d^3*e+2*a*b^2*c*d^2*e^3+a*b^3*c^2*d*e^2+a^3*b^2*c^3*d^2", domain, vars), }, base = arr[0].createOne().multiply(arr); MultivariatePolynomialZp64 a = base; MultivariatePolynomialZp64 b = a.derivative(1); for (int i = 0; i < its(5, 5); i++) { timestamp(); MultivariatePolynomialZp64 gcd = MultivariateGCD.KaltofenMonaganSparseModularGCDInGF(a, b); timeElapsed(); assertTrue(dividesQ(a, gcd)); assertTrue(dividesQ(b, gcd)); } }
@Test public void testSmallDomain7() { IntegersZp64 domain = new IntegersZp64(5); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("2*x^5+3*y^6+2*x^6+3*x*y^6+4*x^5*y^2+3*x^6*y+2*x*y^7+4*x^6*y^2+2*x^7*y+3*x^2*y^7+x^6*y^3+3*x^7*y^2+3*x^9+2*x^2*y^8+2*x^4*y^6+4*x^6*y^4+4*x^7*y^3+2*x^9*y+x*y^10+3*x^4*y^7+3*x^9*y^2+4*x^10*y+x^2*y^10+3*x^4*y^8+x^5*y^7+3*x^6*y^6+x^7*y^5+4*x^9*y^3+2*x^10*y^2+4*x^2*y^11+3*x^5*y^8+3*x^7*y^6+x^9*y^4+2*x^10*y^3+2*x^12*y+3*x^4*y^10+x^5*y^9+4*x^9*y^5+4*x^10*y^4+3*x^11*y^3+2*x^12*y^2+x^4*y^11+2*x^6*y^9+3*x^7*y^8+3*x^9*y^6+2*x^10*y^5+3*x^11*y^4+2*x^12*y^3+x^4*y^12+x^5*y^11+2*x^6*y^10+2*x^7*y^9+3*x^9*y^7+x^10*y^6+3*x^11*y^5+3*x^12*y^4+4*x^5*y^12+3*x^6*y^11+x^7*y^10+2*x^9*y^8+3*x^10*y^7+4*x^11*y^6+4*x^12*y^5+4*x^14*y^3+x^4*y^14+2*x^6*y^12+2*x^7*y^11+x^9*y^9+3*x^11*y^7+2*x^12*y^6+x^14*y^4+2*x^16*y^2+2*x^5*y^14+x^6*y^13+x^7*y^12+2*x^9*y^10+3*x^11*y^8+4*x^12*y^7+3*x^14*y^5+x^15*y^4+3*x^16*y^3+x^6*y^14+2*x^7*y^13+2*x^11*y^9+3*x^12*y^8+2*x^15*y^5+2*x^16*y^4+2*x^17*y^3+3*x^6*y^15+2*x^9*y^12+3*x^10*y^11+3*x^15*y^6+4*x^16*y^5+x^17*y^4+4*x^7*y^15+4*x^10*y^12+x^11*y^11+4*x^12*y^10+3*x^14*y^8+x^15*y^7+3*x^16*y^6+4*x^17*y^5+3*x^9*y^14+3*x^10*y^13+3*x^11*y^12+2*x^12*y^11+4*x^14*y^9+2*x^17*y^6+x^9*y^15+2*x^10*y^14+x^11*y^13+3*x^12*y^12+3*x^14*y^10+4*x^16*y^8+4*x^19*y^5+x^20*y^4+2*x^7*y^18+x^9*y^16+4*x^10*y^15+x^14*y^11+2*x^16*y^9+2*x^17*y^8+3*x^19*y^6+3*x^9*y^17+x^11*y^15+4*x^12*y^14+x^15*y^11+2*x^16*y^10+2*x^20*y^6+x^10*y^17+3*x^11*y^16+x^14*y^13+x^15*y^12+4*x^16*y^11+x^17*y^10+4*x^19*y^8+3*x^20*y^7+x^9*y^19+4*x^10*y^18+4*x^11*y^17+3*x^12*y^16+2*x^14*y^14+4*x^16*y^12+4*x^20*y^8+2*x^14*y^15+2*x^15*y^14+2*x^20*y^9+x^10*y^20+2*x^11*y^19+4*x^12*y^18+x^14*y^16+4*x^15*y^15+4*x^17*y^13+x^19*y^11+3*x^20*y^10+2*x^22*y^8+x^12*y^19+x^14*y^17+3*x^15*y^16+2*x^16*y^15+2*x^17*y^14+4*x^20*y^11+3*x^21*y^10+x^22*y^9+4*x^11*y^21+3*x^12*y^20+3*x^14*y^18+3*x^15*y^17+2*x^16*y^16+x^17*y^15+4*x^19*y^13+x^20*y^12+x^21*y^11+3*x^22*y^10+x^12*y^21+4*x^14*y^19+4*x^15*y^18+x^16*y^17+x^19*y^14+4*x^20*y^13+x^21*y^12+4*x^22*y^11+3*x^14*y^20+x^17*y^17+4*x^19*y^15+3*x^20*y^14+3*x^21*y^13+3*x^14*y^21+4*x^15*y^20+4*x^16*y^19+3*x^17*y^18+2*x^19*y^16+4*x^20*y^15+x^21*y^14+4*x^22*y^13+2*x^14*y^22+x^15*y^21+4*x^16*y^20+2*x^19*y^17+4*x^20*y^16+4*x^21*y^15+x^25*y^11+2*x^14*y^23+3*x^15*y^22+3*x^16*y^21+4*x^17*y^20+4*x^19*y^18+3*x^20*y^17+2*x^21*y^16+2*x^25*y^12+2*x^14*y^24+4*x^15*y^23+3*x^19*y^19+3*x^20*y^18+3*x^24*y^14+4*x^25*y^13+3*x^14*y^25+4*x^15*y^24+4*x^16*y^23+2*x^17*y^22+3*x^19*y^20+x^20*y^19+2*x^21*y^18+3*x^22*y^17+x^24*y^15+4*x^25*y^14+4*x^15*y^25+3*x^16*y^24+2*x^17*y^23+3*x^19*y^21+2*x^20*y^20+x^21*y^19+2*x^24*y^16+2*x^25*y^15+x^16*y^25+x^17*y^24+4*x^19*y^22+4*x^20*y^21+3*x^21*y^20+2*x^22*y^19+2*x^24*y^17+x^25*y^16+x^16*y^26+4*x^17*y^25+4*x^20*y^22+3*x^21*y^21+2*x^22*y^20+2*x^24*y^18+2*x^25*y^17+x^17*y^26+4*x^20*y^23+3*x^21*y^22+3*x^22*y^21+2*x^25*y^18+4*x^17*y^27+3*x^22*y^22+2*x^25*y^19+2*x^22*y^23", domain, "x", "y"), b = MultivariatePolynomialZp64.parse("x^5+4*y^6+2*x^5*y^2+x^7+4*x^2*y^6+4*x^8+x^3*y^6+2*x^7*y^2+x^8*y+4*x^3*y^7+3*x^8*y^2+3*x^9*y+2*x^4*y^7+2*x^8*y^3+2*x^9*y^2+x^10*y+3*x^11+3*x^4*y^8+4*x^5*y^7+2*x^6*y^6+3*x^8*y^4+x^9*y^3+2*x^11*y+2*x^3*y^10+3*x^6*y^7+2*x^10*y^3+3*x^11*y^2+2*x^12*y+4*x^4*y^10+3*x^6*y^8+3*x^7*y^7+x^8*y^6+4*x^9*y^5+4*x^10*y^4+4*x^11*y^3+x^12*y^2+x^4*y^11+x^5*y^10+4*x^7*y^8+2*x^9*y^6+x^11*y^4+x^12*y^3+3*x^14*y+3*x^6*y^10+3*x^7*y^9+3*x^10*y^6+4*x^11*y^5+2*x^12*y^4+x^13*y^3+3*x^14*y^2+4*x^15*y+x^6*y^11+4*x^8*y^9+2*x^9*y^8+x^10*y^7+3*x^11*y^6+x^12*y^5+x^13*y^4+3*x^14*y^3+3*x^15*y^2+x^6*y^12+3*x^7*y^11+4*x^8*y^10+3*x^9*y^9+2*x^10*y^8+3*x^11*y^7+3*x^12*y^6+x^13*y^5+2*x^14*y^4+2*x^15*y^3+2*x^7*y^12+x^8*y^11+4*x^9*y^10+x^10*y^9+2*x^11*y^8+4*x^12*y^7+3*x^13*y^6+x^14*y^5+x^15*y^4+4*x^16*y^3+x^6*y^14+4*x^8*y^12+3*x^9*y^11+x^11*y^9+x^13*y^7+3*x^14*y^6+x^16*y^4+4*x^18*y^2+x^7*y^14+2*x^8*y^13+4*x^9*y^12+3*x^10*y^11+2*x^11*y^10+x^13*y^8+x^14*y^7+3*x^15*y^6+3*x^16*y^5+3*x^17*y^4+x^18*y^3+2*x^8*y^14+3*x^9*y^13+2*x^10*y^12+4*x^13*y^9+2*x^14*y^8+2*x^15*y^7+x^17*y^5+4*x^18*y^4+3*x^19*y^3+x^8*y^15+2*x^10*y^13+2*x^11*y^12+4*x^12*y^11+x^15*y^8+4*x^17*y^6+3*x^18*y^5+4*x^19*y^4+x^9*y^15+2*x^12*y^12+2*x^13*y^11+x^14*y^10+4*x^15*y^9+3*x^16*y^8+3*x^17*y^7+x^18*y^6+x^19*y^5+2*x^10*y^15+3*x^11*y^14+4*x^12*y^13+x^13*y^12+3*x^14*y^11+x^15*y^10+4*x^16*y^9+3*x^19*y^6+4*x^10*y^16+x^11*y^15+x^12*y^14+2*x^13*y^13+2*x^14*y^12+2*x^15*y^11+3*x^16*y^10+3*x^18*y^8+4*x^21*y^5+3*x^22*y^4+3*x^9*y^18+4*x^10*y^17+x^11*y^16+2*x^12*y^15+x^16*y^11+4*x^18*y^9+3*x^19*y^8+x^20*y^7+3*x^21*y^6+2*x^10*y^18+3*x^11*y^17+2*x^13*y^15+x^14*y^14+2*x^15*y^13+3*x^17*y^11+4*x^18*y^10+4*x^20*y^8+x^22*y^6+4*x^10*y^19+3*x^12*y^17+x^13*y^16+2*x^15*y^14+x^16*y^13+3*x^17*y^12+3*x^18*y^11+4*x^19*y^10+3*x^20*y^9+4*x^21*y^8+4*x^22*y^7+x^11*y^19+2*x^12*y^18+3*x^13*y^17+2*x^14*y^16+x^15*y^15+2*x^16*y^14+3*x^18*y^12+2*x^22*y^8+3*x^15*y^16+2*x^16*y^15+x^17*y^14+x^22*y^9+3*x^12*y^20+4*x^13*y^19+x^14*y^18+2*x^15*y^17+x^16*y^16+2*x^17*y^15+x^19*y^13+x^21*y^11+4*x^22*y^10+3*x^24*y^8+3*x^25*y^7+4*x^14*y^19+4*x^15*y^18+x^16*y^17+4*x^17*y^16+4*x^18*y^15+3*x^19*y^14+x^20*y^13+2*x^22*y^11+x^23*y^10+4*x^24*y^9+x^25*y^8+3*x^13*y^21+2*x^14*y^20+2*x^15*y^19+3*x^16*y^18+4*x^17*y^17+4*x^18*y^16+4*x^19*y^15+2*x^20*y^14+4*x^21*y^13+3*x^22*y^12+2*x^23*y^11+2*x^24*y^10+2*x^25*y^9+4*x^14*y^21+4*x^15*y^20+4*x^16*y^19+2*x^17*y^18+2*x^18*y^17+x^21*y^14+2*x^22*y^13+2*x^23*y^12+x^24*y^11+2*x^25*y^10+3*x^16*y^20+4*x^19*y^17+2*x^20*y^16+4*x^21*y^15+4*x^22*y^14+x^23*y^13+x^25*y^11+3*x^16*y^21+2*x^17*y^20+3*x^18*y^19+2*x^19*y^18+2*x^21*y^16+2*x^22*y^15+2*x^23*y^14+x^24*y^13+3*x^25*y^12+x^15*y^23+2*x^16*y^22+3*x^17*y^21+3*x^18*y^20+x^20*y^18+2*x^21*y^17+2*x^22*y^16+3*x^23*y^15+x^25*y^13+3*x^27*y^11+x^15*y^24+2*x^16*y^23+4*x^17*y^22+x^18*y^21+x^19*y^20+4*x^21*y^18+4*x^22*y^17+4*x^23*y^16+x^25*y^14+x^27*y^12+2*x^16*y^24+2*x^17*y^23+3*x^20*y^20+3*x^21*y^19+4*x^22*y^18+2*x^25*y^15+3*x^26*y^14+2*x^27*y^13+3*x^16*y^25+2*x^17*y^24+3*x^18*y^23+3*x^19*y^22+4*x^20*y^21+3*x^21*y^20+3*x^22*y^19+4*x^23*y^18+2*x^24*y^17+2*x^25*y^16+x^26*y^15+2*x^27*y^14+2*x^17*y^25+x^18*y^24+3*x^19*y^23+3*x^20*y^22+3*x^21*y^21+x^22*y^20+2*x^23*y^19+4*x^25*y^17+2*x^26*y^16+x^27*y^15+2*x^18*y^25+4*x^19*y^24+3*x^20*y^23+4*x^21*y^22+2*x^22*y^21+x^23*y^20+3*x^24*y^19+4*x^25*y^18+2*x^26*y^17+3*x^27*y^16+2*x^18*y^26+x^19*y^25+2*x^22*y^22+x^23*y^21+3*x^24*y^20+2*x^25*y^19+2*x^26*y^18+x^27*y^17+4*x^19*y^26+2*x^20*y^25+2*x^22*y^23+x^23*y^22+2*x^24*y^21+x^25*y^20+x^27*y^18+x^19*y^27+4*x^20*y^26+2*x^24*y^22+2*x^25*y^21+x^27*y^19+4*x^20*y^27+3*x^24*y^23+2*x^25*y^22+2*x^25*y^23", domain, "x", "y"); for (int i = 0; i < 50; ++i) { PrivateRandom.getRandom().setSeed(i); MultivariatePolynomialZp64 gcd = MultivariateGCD.KaltofenMonaganSparseModularGCDInGF(a, b); assertTrue(dividesQ(a, gcd)); assertTrue(dividesQ(b, gcd)); } } |
MultivariateGCD { static ZeroVariables commonPossibleZeroes(MultivariatePolynomialZp64 a, MultivariatePolynomialZp64 b, int nVariables) { return commonPossibleZeroes(possibleZeros(a, nVariables), possibleZeros(b, nVariables)); } private MultivariateGCD(); static Poly PolynomialGCD(Poly... arr); static Poly PolynomialGCD(Iterable<Poly> arr); @SuppressWarnings("unchecked") static Poly PolynomialGCD(Poly a, Poly b); @SuppressWarnings("unchecked") static Poly PolynomialGCDinGF(Poly a, Poly b); @SuppressWarnings("unchecked") static MultivariatePolynomial<BigInteger> PolynomialGCDinZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDinNumberField(MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDinRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b,
KaltofenMonaganAlgorithm algorithm); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> BrownGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> ZippelGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 BrownGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 ZippelGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 EZGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static Poly EEZGCD(Poly a, Poly b); } | @Test public void testCommonZeroes1() throws Exception { IntegersZp64 domain = new IntegersZp64(BigPrimes.nextPrime(1321323)); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("1 + c*b*a^2+b^2 + c + a^5", domain, MonomialOrder.DEFAULT), b = MultivariatePolynomialZp64.parse("a^2+2*b^2 + 2*c + a^5", domain, MonomialOrder.DEFAULT); ZeroVariables pZeros = commonPossibleZeroes(a, b, a.nVariables); assertTrue(pZeros.pZeros.size() > 0); for (BitSet z : pZeros.pZeros) { assertFalse(setZeroes(a, z).isZero()); assertFalse(setZeroes(b, z).isZero()); } }
@Test public void testCommonZeroes2() throws Exception { IntegersZp64 domain = new IntegersZp64(BigPrimes.nextPrime(1321323)); MultivariatePolynomialZp64 a = MultivariatePolynomialZp64.parse("1 + c*b*a^2+b^2 + c + a^5*d + e*a + b*g - f", domain, MonomialOrder.DEFAULT), b = MultivariatePolynomialZp64.parse("a^2+2*b^2 + 2*c + a^5 + a*b*c*d*e*f + g", domain, MonomialOrder.DEFAULT); MultivariatePolynomialZp64 ac = a.clone(); ZeroVariables pZeros = commonPossibleZeroes(a, b, a.nVariables); assertTrue(pZeros.pZeros.size() > 0); for (BitSet z : pZeros.pZeros) { assertFalse(setZeroes(a, z).isZero()); assertFalse(setZeroes(b, z).isZero()); } } |
MultivariateGCD { @SuppressWarnings("ConstantConditions") public static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b, BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp) { return ModularGCDInZ(a, b, gcdInZp, false); } private MultivariateGCD(); static Poly PolynomialGCD(Poly... arr); static Poly PolynomialGCD(Iterable<Poly> arr); @SuppressWarnings("unchecked") static Poly PolynomialGCD(Poly a, Poly b); @SuppressWarnings("unchecked") static Poly PolynomialGCDinGF(Poly a, Poly b); @SuppressWarnings("unchecked") static MultivariatePolynomial<BigInteger> PolynomialGCDinZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDinNumberField(MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDinRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b,
KaltofenMonaganAlgorithm algorithm); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> BrownGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> ZippelGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 BrownGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 ZippelGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 EZGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static Poly EEZGCD(Poly a, Poly b); } | @Test public void testModularGCDInZ1() throws Exception { BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> modAlg = MultivariateGCD::ZippelGCD; MultivariatePolynomial<BigInteger> a = parse("x*y*z^2 + y*z*x^6 + 1"), b = parse("x*y*z^2 + 12342134234233*y*z*x^6 - 123*z + x"), g = parse("x^6*y + 1212423413*y*z^7*x^6 - 1231241234234*z + 164287246876423*y"), ag = a.clone().multiply(g), bg = b.clone().multiply(g); assertEquals(g.primitivePart(), ModularGCDInZ(ag, bg, modAlg).primitivePart()); }
@Test public void testModularGCDInZRandom1() throws Exception { BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> modAlg = MultivariateGCD::ZippelGCD; BiFunction<MultivariatePolynomial<BigInteger>, MultivariatePolynomial<BigInteger>, MultivariatePolynomial<BigInteger>> zAlg = (a, b) -> MultivariateGCD.ModularGCDInZ(a, b, modAlg); int nIterations = its(1000, 1000); RandomGenerator rnd = getRandom(); GCDSampleData<Monomial<BigInteger>, MultivariatePolynomial<BigInteger>> sampleData = new GCDSampleDataGeneric<>(Rings.Z, 3, 5, 5, 15, 5, 15, rnd); testGCDAlgorithms(sampleData, nIterations, GCDAlgorithm.named("Modular gcd in Z", zAlg)); } |
MultivariateGCD { public static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction( MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a, MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b) { return PolynomialGCDInNumberFieldSwitchToRingOfInteger(a, b, (l, r) -> PolynomialGCDAssociateInRingOfIntegerOfNumberField(l, r, MultivariateGCD::ZippelGCDInNumberFieldViaRationalReconstruction0)); } private MultivariateGCD(); static Poly PolynomialGCD(Poly... arr); static Poly PolynomialGCD(Iterable<Poly> arr); @SuppressWarnings("unchecked") static Poly PolynomialGCD(Poly a, Poly b); @SuppressWarnings("unchecked") static Poly PolynomialGCDinGF(Poly a, Poly b); @SuppressWarnings("unchecked") static MultivariatePolynomial<BigInteger> PolynomialGCDinZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> PolynomialGCDinNumberField(MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<UnivariatePolynomial<BigInteger>> PolynomialGCDinRingOfIntegersOfNumberField(MultivariatePolynomial<UnivariatePolynomial<BigInteger>> a,
MultivariatePolynomial<UnivariatePolynomial<BigInteger>> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ZippelGCDInZ(MultivariatePolynomial<BigInteger> a, MultivariatePolynomial<BigInteger> b); @SuppressWarnings("ConstantConditions") static MultivariatePolynomial<BigInteger> ModularGCDInZ(MultivariatePolynomial<BigInteger> a,
MultivariatePolynomial<BigInteger> b,
BiFunction<MultivariatePolynomialZp64, MultivariatePolynomialZp64, MultivariatePolynomialZp64> gcdInZp); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ZippelGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaRationalReconstruction(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); static MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> ModularGCDInNumberFieldViaLangemyrMcCallum(
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a,
MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b,
BiFunction<
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>,
MultivariatePolynomial<UnivariatePolynomialZp64>
> modularAlgorithm); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomial<E> KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganSparseModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganEEZModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings({"ConstantConditions", "unchecked"}) static MultivariatePolynomialZp64 KaltofenMonaganModularGCDInGF(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b,
KaltofenMonaganAlgorithm algorithm); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> BrownGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> ZippelGCD(
MultivariatePolynomial<E> a,
MultivariatePolynomial<E> b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 BrownGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 ZippelGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static MultivariatePolynomialZp64 EZGCD(
MultivariatePolynomialZp64 a,
MultivariatePolynomialZp64 b); @SuppressWarnings("unchecked") static Poly EEZGCD(Poly a, Poly b); } | @Test public void testAlgExt2() { AlgebraicNumberField<UnivariatePolynomial<Rational<BigInteger>>> field = AlgebraicNumberField(UnivariatePolynomial.create(13, 0, 1, 2, 3, 4, 15, 19).mapCoefficients(Q, Q::mkNumerator)); Coder<UnivariatePolynomial<Rational<BigInteger>>, ?, ?> cfCoder = Coder.mkUnivariateCoder(field, "s"); MultivariateRing<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>> mRing = Rings.MultivariateRing(3, field); Coder<MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>>, ?, ?> coder = Coder.mkMultivariateCoder(mRing, cfCoder, "x", "y", "z"); MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> a = coder.parse("(1 - s + s*x^5 - s*y^5*z + (1 - s^6)*z^3*x) * ( 1 + s*x^2 + 12*x^5 + y)^5"); MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> b = coder.parse("(1 - s + s*x^5 - s*y^5*z + (1 - s^6)*z^3*x) * ( 14 - s*x + 2*s*x^17 + y - z)^5"); for (int i = 1; i < 10; ++i) { long start = System.nanoTime(); MultivariatePolynomial<UnivariatePolynomial<Rational<BigInteger>>> gcd = ZippelGCDInNumberFieldViaRationalReconstruction(a, b); System.out.println("Modular: " + nanosecondsToString(System.nanoTime() - start)); assertTrue(dividesQ(a, gcd)); assertTrue(dividesQ(b, gcd)); } } |
MultivariateInterpolation { @SuppressWarnings("unchecked") public static <E> MultivariatePolynomial<E> interpolateNewton(int variable, E[] points, MultivariatePolynomial<E>[] values) { checkInput(points, values); return new MultivariateInterpolation.Interpolation<>(variable, values[0]) .update(points, values) .getInterpolatingPolynomial(); } private MultivariateInterpolation(); @SuppressWarnings("unchecked") static MultivariatePolynomial<E> interpolateNewton(int variable, E[] points, MultivariatePolynomial<E>[] values); } | @Test @SuppressWarnings("unchecked") public void test1() throws Exception { String[] variables = {"a", "b"}; Ring<BigInteger> ring = new IntegersZp(17); MultivariatePolynomial<BigInteger> val1 = MultivariatePolynomial.parse("a^2 + a^3 + 1", ring, MonomialOrder.LEX, variables); MultivariatePolynomial<BigInteger> val2 = MultivariatePolynomial.parse("12*a^2 + 13*a^3 + 11", ring, MonomialOrder.LEX, variables); MultivariatePolynomial<BigInteger> val3 = MultivariatePolynomial.parse("2*a^2 + 3*a^3 + 1", ring, MonomialOrder.LEX, variables); BigInteger[] points = {BigInteger.valueOf(1), BigInteger.valueOf(2), BigInteger.valueOf(3)}; MultivariatePolynomial<BigInteger>[] values = new MultivariatePolynomial[]{val1, val2, val3}; MultivariatePolynomial<BigInteger> res = MultivariateInterpolation.interpolateNewton(1, points, values); assertInterpolation(1, res, points, values); }
@Test @SuppressWarnings("unchecked") public void test2() throws Exception { String[] variables = {"a", "b"}; Ring<BigInteger> ring = new IntegersZp(17); MultivariatePolynomial<BigInteger> val1 = MultivariatePolynomial.parse("a^2 + a^3 + 1", ring, MonomialOrder.LEX, variables); MultivariatePolynomial<BigInteger> val2 = MultivariatePolynomial.parse("12*a^2 + 13*a^3 + 11", ring, MonomialOrder.LEX, variables); MultivariatePolynomial<BigInteger> val3 = MultivariatePolynomial.parse("2*a^2 + 3*a^3 + 1", ring, MonomialOrder.LEX, variables); BigInteger[] points = {BigInteger.valueOf(1), BigInteger.valueOf(2), BigInteger.valueOf(3)}; MultivariatePolynomial<BigInteger>[] values = new MultivariatePolynomial[]{val1, val2, val3}; MultivariatePolynomial<BigInteger> res = MultivariateInterpolation.interpolateNewton(1, points, values); MultivariateInterpolation.Interpolation<BigInteger> interpolation = new MultivariateInterpolation.Interpolation<>(1, points[0], values[0]); interpolation.update(points[1], values[1]); interpolation.update(points[2], values[2]); assertInterpolation(1, res, points, values); assertInterpolation(interpolation); assertEquals(res, interpolation.getInterpolatingPolynomial()); }
@Test @SuppressWarnings("unchecked") public void test3() throws Exception { IntegersZp domain = new IntegersZp(197); String[] vars = {"a", "b", "c"}; MultivariatePolynomial<BigInteger> base = parse("15*b*c^2+47*b^4*c^4+144*a*b^5*c^5+150*a^5*b^4+62*a^5*b^4*c", domain, MonomialOrder.LEX); int var = 2; BigInteger[] points = { BigInteger.valueOf(1), BigInteger.valueOf(10), BigInteger.valueOf(20), BigInteger.valueOf(30), BigInteger.valueOf(40), BigInteger.valueOf(50) }; MultivariatePolynomial<BigInteger>[] values = base.evaluate(var, points); MultivariatePolynomial<BigInteger> interpolated = MultivariateInterpolation.interpolateNewton(var, points, values); assertInterpolation(var, interpolated, points, values); MultivariateInterpolation.Interpolation<BigInteger> interpolation = new MultivariateInterpolation.Interpolation<>(var, points[0], values[0]); for (int i = 1; i < points.length; i++) interpolation.update(points[i], values[i]); assertEquals(interpolated, interpolation.getInterpolatingPolynomial()); assertInterpolation(interpolation); }
@Test public void testRandom() throws Exception { RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = getRandomData(); int nIterations = its(500, 2000); for (int n = 0; n < nIterations; n++) { int nVars = rndd.nextInt(2, 4); IntegersZp domain = new IntegersZp(getModulusRandom(16)); MultivariatePolynomial<BigInteger> base = randomPolynomial(nVars, rndd.nextInt(3, 10), rndd.nextInt(5, 10), domain, MonomialOrder.LEX, rnd); int var = rndd.nextInt(0, nVars - 1); int degree = base.degrees()[var]; MultivariateInterpolation.Interpolation<BigInteger> interpolation = new MultivariateInterpolation.Interpolation<>(var, base); TIntHashSet seen = new TIntHashSet(); for (int i = 0; i <= degree + 2; i++) { int iPoint = rndd.nextInt(0, domain.modulus.intValue() - 1); if (seen.contains(iPoint)) continue; seen.add(iPoint); BigInteger point = BigInteger.valueOf(iPoint); MultivariatePolynomial<BigInteger> evaluated = base.evaluate(var, point); interpolation.update(point, evaluated); } BigInteger[] points = interpolation.getPoints().toArray(new BigInteger[0]); MultivariatePolynomial[] values = interpolation.getValues().toArray(new MultivariatePolynomial[0]); MultivariatePolynomial<BigInteger> res = MultivariateInterpolation.interpolateNewton(var, points, values); assertInterpolation(var, res, points, values); assertInterpolation(var, base, points, values); assertInterpolation(interpolation); assertEquals(base, interpolation.getInterpolatingPolynomial()); } } |
MultivariatePolynomialZp64 extends AMultivariatePolynomial<MonomialZp64, MultivariatePolynomialZp64> { public MultivariatePolynomialZp64 createLinear(int variable, long cc, long lc) { MonomialSet<MonomialZp64> data = new MonomialSet<>(ordering); lc = ring.modulus(lc); cc = ring.modulus(cc); if (cc != 0L) data.add(new MonomialZp64(nVariables, cc)); if (lc != 0L) { int[] lcDegreeVector = new int[nVariables]; lcDegreeVector[variable] = 1; data.add(new MonomialZp64(lcDegreeVector, 1, lc)); } return new MultivariatePolynomialZp64(nVariables, ring, ordering, data); } private MultivariatePolynomialZp64(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialSet<MonomialZp64> lMonomialTerms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialSet<MonomialZp64> terms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, Iterable<MonomialZp64> terms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialZp64... terms); static MultivariatePolynomialZp64 zero(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 one(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, String... variables); @Deprecated static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring); static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asMultivariate(UnivariatePolynomialZp64 poly, int nVariables, int variable, Comparator<DegreeVector> ordering); @Override UnivariatePolynomialZp64 asUnivariate(); @Override MultivariatePolynomial<UnivariatePolynomialZp64> asOverUnivariate(int variable); @Override MultivariatePolynomial<UnivariatePolynomialZp64> asOverUnivariateEliminate(int variable); @Override MultivariatePolynomial<MultivariatePolynomialZp64> asOverMultivariate(int... variables); @Override MultivariatePolynomial<MultivariatePolynomialZp64> asOverMultivariateEliminate(int[] variables, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asNormalMultivariate(MultivariatePolynomial<UnivariatePolynomialZp64> poly, int variable); static MultivariatePolynomialZp64 asNormalMultivariate(MultivariatePolynomial<MultivariatePolynomialZp64> poly); static MultivariatePolynomialZp64 asNormalMultivariate(
MultivariatePolynomial<MultivariatePolynomialZp64> poly,
int[] coefficientVariables, int[] mainVariables); MultivariatePolynomial<BigInteger> asPolyZSymmetric(); MultivariatePolynomial<BigInteger> asPolyZ(); MultivariatePolynomial<BigInteger> toBigPoly(); @Override MultivariatePolynomialZp64 contentAsPoly(); @Override MultivariatePolynomialZp64 lcAsPoly(); @Override MultivariatePolynomialZp64 lcAsPoly(Comparator<DegreeVector> ordering); @Override MultivariatePolynomialZp64 ccAsPoly(); @Override boolean isOverField(); @Override boolean isOverFiniteField(); @Override boolean isOverZ(); @Override BigInteger coefficientRingCardinality(); @Override BigInteger coefficientRingCharacteristic(); @Override boolean isOverPerfectPower(); @Override BigInteger coefficientRingPerfectPowerBase(); @Override BigInteger coefficientRingPerfectPowerExponent(); @Override @SuppressWarnings("unchecked") MultivariatePolynomialZp64[] createArray(int length); @Override MultivariatePolynomialZp64[][] createArray2d(int length); @Override MultivariatePolynomialZp64[][] createArray2d(int length1, int length2); @Override boolean sameCoefficientRingWith(MultivariatePolynomialZp64 oth); @Override MultivariatePolynomialZp64 setCoefficientRingFrom(MultivariatePolynomialZp64 lMonomialTerms); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 setRing(long newModulus); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 setRing(IntegersZp64 newDomain); @SuppressWarnings("unchecked") MultivariatePolynomial<E> setRing(Ring<E> newRing); MultivariatePolynomialZp64 setRingUnsafe(IntegersZp64 newDomain); MultivariatePolynomialZp64 createConstant(long val); @Override MultivariatePolynomialZp64 createConstantFromTerm(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 createZero(); @Override MultivariatePolynomialZp64 createOne(); MultivariatePolynomialZp64 createLinear(int variable, long cc, long lc); @Override boolean isMonic(); @Override int signumOfLC(); @Override boolean isOne(); @Override boolean isUnitCC(); @Override boolean isConstant(); long lc(); long lc(Comparator<DegreeVector> ordering); MultivariatePolynomialZp64 setLC(long val); long cc(); long content(); long[] coefficients(); @Override MultivariatePolynomialZp64 primitivePart(int variable); @Override UnivariatePolynomialZp64 contentUnivariate(int variable); @Override MultivariatePolynomialZp64 primitivePart(); @Override MultivariatePolynomialZp64 primitivePartSameSign(); @Override MultivariatePolynomialZp64 divideByLC(MultivariatePolynomialZp64 other); MultivariatePolynomialZp64 divide(long factor); @Override MultivariatePolynomialZp64 divideOrNull(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 monic(); @Override MultivariatePolynomialZp64 monic(Comparator<DegreeVector> ordering); MultivariatePolynomialZp64 monic(long factor); MultivariatePolynomialZp64 monic(Comparator<DegreeVector> ordering, long factor); @Override MultivariatePolynomialZp64 monicWithLC(MultivariatePolynomialZp64 other); @Override MultivariatePolynomialZp64 monicWithLC(Comparator<DegreeVector> ordering, MultivariatePolynomialZp64 other); IUnivariatePolynomial toDenseRecursiveForm(); static MultivariatePolynomialZp64 fromDenseRecursiveForm(IUnivariatePolynomial recForm,
Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 fromDenseRecursiveForm(IUnivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static long evaluateDenseRecursiveForm(IUnivariatePolynomial recForm, long[] values); AMultivariatePolynomial toSparseRecursiveForm(); static MultivariatePolynomialZp64 fromSparseRecursiveForm(AMultivariatePolynomial recForm,
Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 fromSparseRecursiveForm(AMultivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static long evaluateSparseRecursiveForm(AMultivariatePolynomial recForm, long[] values); @SuppressWarnings("unchecked") HornerFormZp64 getHornerForm(int[] evaluationVariables); MultivariatePolynomialZp64 evaluate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 evaluate(int[] variables, long[] values); @SuppressWarnings("unchecked") long evaluate(long... values); @SuppressWarnings("unchecked") MultivariatePolynomialZp64[] evaluate(int variable, long... values); MultivariatePolynomialZp64 eliminate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 eliminate(int[] variables, long[] values); lPrecomputedPowersHolder mkPrecomputedPowers(int variable, long value); lPrecomputedPowersHolder mkPrecomputedPowers(int[] variables, long[] values); static lPrecomputedPowersHolder mkPrecomputedPowers(int nVariables, IntegersZp64 ring, int[] variables, long[] values); lPrecomputedPowersHolder mkPrecomputedPowers(long[] values); MultivariatePolynomialZp64 substitute(int variable, MultivariatePolynomialZp64 poly); MultivariatePolynomialZp64 shift(int variable, long shift); MultivariatePolynomialZp64 shift(int[] variables, long[] shifts); MultivariatePolynomialZp64 add(long oth); MultivariatePolynomialZp64 subtract(long oth); @Override MultivariatePolynomialZp64 increment(); @Override MultivariatePolynomialZp64 decrement(); @Override MultivariatePolynomialZp64 multiply(long factor); @Override MultivariatePolynomialZp64 multiplyByLC(MultivariatePolynomialZp64 other); @Override MultivariatePolynomialZp64 multiplyByBigInteger(BigInteger factor); @Override MultivariatePolynomialZp64 multiply(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 multiply(MultivariatePolynomialZp64 oth); @Override MultivariatePolynomialZp64 square(); @Override MultivariatePolynomialZp64 evaluateAtRandom(int variable, RandomGenerator rnd); @Override MultivariatePolynomialZp64 evaluateAtRandomPreservingSkeleton(int variable, RandomGenerator rnd); @Override MultivariatePolynomialZp64 derivative(int variable, int order); @Override MultivariatePolynomialZp64 seriesCoefficient(int variable, int order); MultivariatePolynomial<T> mapTerms(Ring<T> newRing, Function<MonomialZp64, Monomial<T>> mapper); MultivariatePolynomialZp64 mapTerms(IntegersZp64 newRing, Function<MonomialZp64, MonomialZp64> mapper); MultivariatePolynomial<T> mapCoefficients(Ring<T> newRing, LongFunction<T> mapper); @Override MultivariatePolynomial<E> mapCoefficientsAsPolys(Ring<E> ring, Function<MultivariatePolynomialZp64, E> mapper); @Override int compareTo(MultivariatePolynomialZp64 oth); @Override @SuppressWarnings("unchecked") MultivariatePolynomialZp64 clone(); @Override @Deprecated MultivariatePolynomialZp64 parsePoly(String string); @Override String toString(IStringifier<MultivariatePolynomialZp64> stringifier); @Override String coefficientRingToString(IStringifier<MultivariatePolynomialZp64> stringifier); final IntegersZp64 ring; } | @Test public void testCreateLinear() throws Exception { MultivariatePolynomialZp64 p0 = MultivariatePolynomialZp64.zero(3, Integers, LEX); String[] vars = {"a", "b", "c"}; assertEquals(parse("-1+2*a", Integers, vars), p0.createLinear(0, -1, 2)); assertEquals(parse("-1+2*b", Integers, vars), p0.createLinear(1, -1, 2)); assertEquals(parse("-1+2*c", Integers, vars), p0.createLinear(2, -1, 2)); } |
MultivariatePolynomialZp64 extends AMultivariatePolynomial<MonomialZp64, MultivariatePolynomialZp64> { public MultivariatePolynomialZp64 eliminate(int variable, long value) { value = ring.modulus(value); MonomialSet<MonomialZp64> newData = new MonomialSet<>(ordering); lPrecomputedPowers powers = new lPrecomputedPowers(value, ring); for (MonomialZp64 el : terms) { long val = ring.multiply(el.coefficient, powers.pow(el.exponents[variable])); add(newData, el.without(variable).setCoefficient(val)); } return new MultivariatePolynomialZp64(nVariables - 1, ring, ordering, newData); } private MultivariatePolynomialZp64(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialSet<MonomialZp64> lMonomialTerms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialSet<MonomialZp64> terms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, Iterable<MonomialZp64> terms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialZp64... terms); static MultivariatePolynomialZp64 zero(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 one(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, String... variables); @Deprecated static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring); static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asMultivariate(UnivariatePolynomialZp64 poly, int nVariables, int variable, Comparator<DegreeVector> ordering); @Override UnivariatePolynomialZp64 asUnivariate(); @Override MultivariatePolynomial<UnivariatePolynomialZp64> asOverUnivariate(int variable); @Override MultivariatePolynomial<UnivariatePolynomialZp64> asOverUnivariateEliminate(int variable); @Override MultivariatePolynomial<MultivariatePolynomialZp64> asOverMultivariate(int... variables); @Override MultivariatePolynomial<MultivariatePolynomialZp64> asOverMultivariateEliminate(int[] variables, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asNormalMultivariate(MultivariatePolynomial<UnivariatePolynomialZp64> poly, int variable); static MultivariatePolynomialZp64 asNormalMultivariate(MultivariatePolynomial<MultivariatePolynomialZp64> poly); static MultivariatePolynomialZp64 asNormalMultivariate(
MultivariatePolynomial<MultivariatePolynomialZp64> poly,
int[] coefficientVariables, int[] mainVariables); MultivariatePolynomial<BigInteger> asPolyZSymmetric(); MultivariatePolynomial<BigInteger> asPolyZ(); MultivariatePolynomial<BigInteger> toBigPoly(); @Override MultivariatePolynomialZp64 contentAsPoly(); @Override MultivariatePolynomialZp64 lcAsPoly(); @Override MultivariatePolynomialZp64 lcAsPoly(Comparator<DegreeVector> ordering); @Override MultivariatePolynomialZp64 ccAsPoly(); @Override boolean isOverField(); @Override boolean isOverFiniteField(); @Override boolean isOverZ(); @Override BigInteger coefficientRingCardinality(); @Override BigInteger coefficientRingCharacteristic(); @Override boolean isOverPerfectPower(); @Override BigInteger coefficientRingPerfectPowerBase(); @Override BigInteger coefficientRingPerfectPowerExponent(); @Override @SuppressWarnings("unchecked") MultivariatePolynomialZp64[] createArray(int length); @Override MultivariatePolynomialZp64[][] createArray2d(int length); @Override MultivariatePolynomialZp64[][] createArray2d(int length1, int length2); @Override boolean sameCoefficientRingWith(MultivariatePolynomialZp64 oth); @Override MultivariatePolynomialZp64 setCoefficientRingFrom(MultivariatePolynomialZp64 lMonomialTerms); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 setRing(long newModulus); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 setRing(IntegersZp64 newDomain); @SuppressWarnings("unchecked") MultivariatePolynomial<E> setRing(Ring<E> newRing); MultivariatePolynomialZp64 setRingUnsafe(IntegersZp64 newDomain); MultivariatePolynomialZp64 createConstant(long val); @Override MultivariatePolynomialZp64 createConstantFromTerm(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 createZero(); @Override MultivariatePolynomialZp64 createOne(); MultivariatePolynomialZp64 createLinear(int variable, long cc, long lc); @Override boolean isMonic(); @Override int signumOfLC(); @Override boolean isOne(); @Override boolean isUnitCC(); @Override boolean isConstant(); long lc(); long lc(Comparator<DegreeVector> ordering); MultivariatePolynomialZp64 setLC(long val); long cc(); long content(); long[] coefficients(); @Override MultivariatePolynomialZp64 primitivePart(int variable); @Override UnivariatePolynomialZp64 contentUnivariate(int variable); @Override MultivariatePolynomialZp64 primitivePart(); @Override MultivariatePolynomialZp64 primitivePartSameSign(); @Override MultivariatePolynomialZp64 divideByLC(MultivariatePolynomialZp64 other); MultivariatePolynomialZp64 divide(long factor); @Override MultivariatePolynomialZp64 divideOrNull(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 monic(); @Override MultivariatePolynomialZp64 monic(Comparator<DegreeVector> ordering); MultivariatePolynomialZp64 monic(long factor); MultivariatePolynomialZp64 monic(Comparator<DegreeVector> ordering, long factor); @Override MultivariatePolynomialZp64 monicWithLC(MultivariatePolynomialZp64 other); @Override MultivariatePolynomialZp64 monicWithLC(Comparator<DegreeVector> ordering, MultivariatePolynomialZp64 other); IUnivariatePolynomial toDenseRecursiveForm(); static MultivariatePolynomialZp64 fromDenseRecursiveForm(IUnivariatePolynomial recForm,
Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 fromDenseRecursiveForm(IUnivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static long evaluateDenseRecursiveForm(IUnivariatePolynomial recForm, long[] values); AMultivariatePolynomial toSparseRecursiveForm(); static MultivariatePolynomialZp64 fromSparseRecursiveForm(AMultivariatePolynomial recForm,
Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 fromSparseRecursiveForm(AMultivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static long evaluateSparseRecursiveForm(AMultivariatePolynomial recForm, long[] values); @SuppressWarnings("unchecked") HornerFormZp64 getHornerForm(int[] evaluationVariables); MultivariatePolynomialZp64 evaluate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 evaluate(int[] variables, long[] values); @SuppressWarnings("unchecked") long evaluate(long... values); @SuppressWarnings("unchecked") MultivariatePolynomialZp64[] evaluate(int variable, long... values); MultivariatePolynomialZp64 eliminate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 eliminate(int[] variables, long[] values); lPrecomputedPowersHolder mkPrecomputedPowers(int variable, long value); lPrecomputedPowersHolder mkPrecomputedPowers(int[] variables, long[] values); static lPrecomputedPowersHolder mkPrecomputedPowers(int nVariables, IntegersZp64 ring, int[] variables, long[] values); lPrecomputedPowersHolder mkPrecomputedPowers(long[] values); MultivariatePolynomialZp64 substitute(int variable, MultivariatePolynomialZp64 poly); MultivariatePolynomialZp64 shift(int variable, long shift); MultivariatePolynomialZp64 shift(int[] variables, long[] shifts); MultivariatePolynomialZp64 add(long oth); MultivariatePolynomialZp64 subtract(long oth); @Override MultivariatePolynomialZp64 increment(); @Override MultivariatePolynomialZp64 decrement(); @Override MultivariatePolynomialZp64 multiply(long factor); @Override MultivariatePolynomialZp64 multiplyByLC(MultivariatePolynomialZp64 other); @Override MultivariatePolynomialZp64 multiplyByBigInteger(BigInteger factor); @Override MultivariatePolynomialZp64 multiply(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 multiply(MultivariatePolynomialZp64 oth); @Override MultivariatePolynomialZp64 square(); @Override MultivariatePolynomialZp64 evaluateAtRandom(int variable, RandomGenerator rnd); @Override MultivariatePolynomialZp64 evaluateAtRandomPreservingSkeleton(int variable, RandomGenerator rnd); @Override MultivariatePolynomialZp64 derivative(int variable, int order); @Override MultivariatePolynomialZp64 seriesCoefficient(int variable, int order); MultivariatePolynomial<T> mapTerms(Ring<T> newRing, Function<MonomialZp64, Monomial<T>> mapper); MultivariatePolynomialZp64 mapTerms(IntegersZp64 newRing, Function<MonomialZp64, MonomialZp64> mapper); MultivariatePolynomial<T> mapCoefficients(Ring<T> newRing, LongFunction<T> mapper); @Override MultivariatePolynomial<E> mapCoefficientsAsPolys(Ring<E> ring, Function<MultivariatePolynomialZp64, E> mapper); @Override int compareTo(MultivariatePolynomialZp64 oth); @Override @SuppressWarnings("unchecked") MultivariatePolynomialZp64 clone(); @Override @Deprecated MultivariatePolynomialZp64 parsePoly(String string); @Override String toString(IStringifier<MultivariatePolynomialZp64> stringifier); @Override String coefficientRingToString(IStringifier<MultivariatePolynomialZp64> stringifier); final IntegersZp64 ring; } | @Test public void testEliminate1() throws Exception { assertEquals(parse0("2^14*b"), parse0("a^14*b").eliminate(0, 2)); assertEquals(parse0("2*a^14"), parse0("a^14*b").eliminate(1, 2)); String str = "2^14*b - 7*2^9*b^4 + 19*2^9*b^4"; assertEquals(parse0(str), parse0(str.replace("2^", "a^"), "a", "b").eliminate(0, 2)); str = "-5*a^22*c*d^13 + 5*a^32*b^24*c*d + a^31*c*d^42 + c^66"; MultivariatePolynomialZp64 poly = parse0(str); assertEquals(parse0(str.replace("d", "3")), poly.eliminate(3, 3)); assertEquals(parse0(str.replace("c", "3"), "a", "b", "d"), poly.eliminate(2, 3)); assertEquals(parse0(str.replace("b", "3"), "a", "c", "d"), poly.eliminate(1, 3)); assertEquals(parse0(str.replace("a", "3"), "b", "c", "d"), poly.eliminate(0, 3)); } |
MultivariatePolynomialZp64 extends AMultivariatePolynomial<MonomialZp64, MultivariatePolynomialZp64> { public MultivariatePolynomialZp64 evaluate(int variable, long value) { value = ring.modulus(value); if (value == 0) return evaluateAtZero(variable); lPrecomputedPowers powers = new lPrecomputedPowers(value, ring); return evaluate(variable, powers); } private MultivariatePolynomialZp64(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialSet<MonomialZp64> lMonomialTerms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialSet<MonomialZp64> terms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, Iterable<MonomialZp64> terms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialZp64... terms); static MultivariatePolynomialZp64 zero(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 one(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, String... variables); @Deprecated static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring); static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asMultivariate(UnivariatePolynomialZp64 poly, int nVariables, int variable, Comparator<DegreeVector> ordering); @Override UnivariatePolynomialZp64 asUnivariate(); @Override MultivariatePolynomial<UnivariatePolynomialZp64> asOverUnivariate(int variable); @Override MultivariatePolynomial<UnivariatePolynomialZp64> asOverUnivariateEliminate(int variable); @Override MultivariatePolynomial<MultivariatePolynomialZp64> asOverMultivariate(int... variables); @Override MultivariatePolynomial<MultivariatePolynomialZp64> asOverMultivariateEliminate(int[] variables, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asNormalMultivariate(MultivariatePolynomial<UnivariatePolynomialZp64> poly, int variable); static MultivariatePolynomialZp64 asNormalMultivariate(MultivariatePolynomial<MultivariatePolynomialZp64> poly); static MultivariatePolynomialZp64 asNormalMultivariate(
MultivariatePolynomial<MultivariatePolynomialZp64> poly,
int[] coefficientVariables, int[] mainVariables); MultivariatePolynomial<BigInteger> asPolyZSymmetric(); MultivariatePolynomial<BigInteger> asPolyZ(); MultivariatePolynomial<BigInteger> toBigPoly(); @Override MultivariatePolynomialZp64 contentAsPoly(); @Override MultivariatePolynomialZp64 lcAsPoly(); @Override MultivariatePolynomialZp64 lcAsPoly(Comparator<DegreeVector> ordering); @Override MultivariatePolynomialZp64 ccAsPoly(); @Override boolean isOverField(); @Override boolean isOverFiniteField(); @Override boolean isOverZ(); @Override BigInteger coefficientRingCardinality(); @Override BigInteger coefficientRingCharacteristic(); @Override boolean isOverPerfectPower(); @Override BigInteger coefficientRingPerfectPowerBase(); @Override BigInteger coefficientRingPerfectPowerExponent(); @Override @SuppressWarnings("unchecked") MultivariatePolynomialZp64[] createArray(int length); @Override MultivariatePolynomialZp64[][] createArray2d(int length); @Override MultivariatePolynomialZp64[][] createArray2d(int length1, int length2); @Override boolean sameCoefficientRingWith(MultivariatePolynomialZp64 oth); @Override MultivariatePolynomialZp64 setCoefficientRingFrom(MultivariatePolynomialZp64 lMonomialTerms); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 setRing(long newModulus); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 setRing(IntegersZp64 newDomain); @SuppressWarnings("unchecked") MultivariatePolynomial<E> setRing(Ring<E> newRing); MultivariatePolynomialZp64 setRingUnsafe(IntegersZp64 newDomain); MultivariatePolynomialZp64 createConstant(long val); @Override MultivariatePolynomialZp64 createConstantFromTerm(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 createZero(); @Override MultivariatePolynomialZp64 createOne(); MultivariatePolynomialZp64 createLinear(int variable, long cc, long lc); @Override boolean isMonic(); @Override int signumOfLC(); @Override boolean isOne(); @Override boolean isUnitCC(); @Override boolean isConstant(); long lc(); long lc(Comparator<DegreeVector> ordering); MultivariatePolynomialZp64 setLC(long val); long cc(); long content(); long[] coefficients(); @Override MultivariatePolynomialZp64 primitivePart(int variable); @Override UnivariatePolynomialZp64 contentUnivariate(int variable); @Override MultivariatePolynomialZp64 primitivePart(); @Override MultivariatePolynomialZp64 primitivePartSameSign(); @Override MultivariatePolynomialZp64 divideByLC(MultivariatePolynomialZp64 other); MultivariatePolynomialZp64 divide(long factor); @Override MultivariatePolynomialZp64 divideOrNull(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 monic(); @Override MultivariatePolynomialZp64 monic(Comparator<DegreeVector> ordering); MultivariatePolynomialZp64 monic(long factor); MultivariatePolynomialZp64 monic(Comparator<DegreeVector> ordering, long factor); @Override MultivariatePolynomialZp64 monicWithLC(MultivariatePolynomialZp64 other); @Override MultivariatePolynomialZp64 monicWithLC(Comparator<DegreeVector> ordering, MultivariatePolynomialZp64 other); IUnivariatePolynomial toDenseRecursiveForm(); static MultivariatePolynomialZp64 fromDenseRecursiveForm(IUnivariatePolynomial recForm,
Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 fromDenseRecursiveForm(IUnivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static long evaluateDenseRecursiveForm(IUnivariatePolynomial recForm, long[] values); AMultivariatePolynomial toSparseRecursiveForm(); static MultivariatePolynomialZp64 fromSparseRecursiveForm(AMultivariatePolynomial recForm,
Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 fromSparseRecursiveForm(AMultivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static long evaluateSparseRecursiveForm(AMultivariatePolynomial recForm, long[] values); @SuppressWarnings("unchecked") HornerFormZp64 getHornerForm(int[] evaluationVariables); MultivariatePolynomialZp64 evaluate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 evaluate(int[] variables, long[] values); @SuppressWarnings("unchecked") long evaluate(long... values); @SuppressWarnings("unchecked") MultivariatePolynomialZp64[] evaluate(int variable, long... values); MultivariatePolynomialZp64 eliminate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 eliminate(int[] variables, long[] values); lPrecomputedPowersHolder mkPrecomputedPowers(int variable, long value); lPrecomputedPowersHolder mkPrecomputedPowers(int[] variables, long[] values); static lPrecomputedPowersHolder mkPrecomputedPowers(int nVariables, IntegersZp64 ring, int[] variables, long[] values); lPrecomputedPowersHolder mkPrecomputedPowers(long[] values); MultivariatePolynomialZp64 substitute(int variable, MultivariatePolynomialZp64 poly); MultivariatePolynomialZp64 shift(int variable, long shift); MultivariatePolynomialZp64 shift(int[] variables, long[] shifts); MultivariatePolynomialZp64 add(long oth); MultivariatePolynomialZp64 subtract(long oth); @Override MultivariatePolynomialZp64 increment(); @Override MultivariatePolynomialZp64 decrement(); @Override MultivariatePolynomialZp64 multiply(long factor); @Override MultivariatePolynomialZp64 multiplyByLC(MultivariatePolynomialZp64 other); @Override MultivariatePolynomialZp64 multiplyByBigInteger(BigInteger factor); @Override MultivariatePolynomialZp64 multiply(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 multiply(MultivariatePolynomialZp64 oth); @Override MultivariatePolynomialZp64 square(); @Override MultivariatePolynomialZp64 evaluateAtRandom(int variable, RandomGenerator rnd); @Override MultivariatePolynomialZp64 evaluateAtRandomPreservingSkeleton(int variable, RandomGenerator rnd); @Override MultivariatePolynomialZp64 derivative(int variable, int order); @Override MultivariatePolynomialZp64 seriesCoefficient(int variable, int order); MultivariatePolynomial<T> mapTerms(Ring<T> newRing, Function<MonomialZp64, Monomial<T>> mapper); MultivariatePolynomialZp64 mapTerms(IntegersZp64 newRing, Function<MonomialZp64, MonomialZp64> mapper); MultivariatePolynomial<T> mapCoefficients(Ring<T> newRing, LongFunction<T> mapper); @Override MultivariatePolynomial<E> mapCoefficientsAsPolys(Ring<E> ring, Function<MultivariatePolynomialZp64, E> mapper); @Override int compareTo(MultivariatePolynomialZp64 oth); @Override @SuppressWarnings("unchecked") MultivariatePolynomialZp64 clone(); @Override @Deprecated MultivariatePolynomialZp64 parsePoly(String string); @Override String toString(IStringifier<MultivariatePolynomialZp64> stringifier); @Override String coefficientRingToString(IStringifier<MultivariatePolynomialZp64> stringifier); final IntegersZp64 ring; } | @Test public void testEvaluate1() throws Exception { String[] vars = {"a", "b"}; assertEquals(parse0("2^14*b", vars), parse0("a^14*b", vars).evaluate(0, 2)); assertEquals(parse0("2*a^14", vars), parse0("a^14*b", vars).evaluate(1, 2)); String str = "2^14*b - 7*2^9*b^4 + 19*2^9*b^4"; assertEquals(parse0(str, vars), parse0(str.replace("2^", "a^"), vars).evaluate(0, 2)); str = "-5*a^22*c*d^13 + 5*a^32*b^24*c*d + a^31*c*d^42 + c^66"; vars = new String[]{"a", "b", "c", "d"}; MultivariatePolynomialZp64 poly = parse0(str, vars); assertEquals(parse0(str.replace("d", "3"), vars), poly.evaluate(3, 3)); assertEquals(parse0(str.replace("c", "3"), vars), poly.evaluate(2, 3)); assertEquals(parse0(str.replace("b", "3"), vars), poly.evaluate(1, 3)); assertEquals(parse0(str.replace("a", "3"), vars), poly.evaluate(0, 3)); } |
MultivariatePolynomialZp64 extends AMultivariatePolynomial<MonomialZp64, MultivariatePolynomialZp64> { static long seriesCoefficientFactor(int exponent, int order, IntegersZp64 ring) { IntegersZp64 baseDomain = ring.perfectPowerBaseDomain(); if (order < baseDomain.modulus) { long factor = 1; for (int i = 0; i < order; ++i) factor = ring.multiply(factor, exponent - i); factor = ring.divide(factor, ring.factorial(order)); return factor; } long numerator = 1, denominator = 1; int numZeros = 0, denZeros = 0; for (int i = 1; i <= order; ++i) { long num = exponent - i + 1, numMod = baseDomain.modulus(num); while (num > 1 && numMod == 0) { num = FastDivision.divideSignedFast(num, baseDomain.magic); numMod = baseDomain.modulus(num); ++numZeros; } if (numMod != 0) numerator = ring.multiply(numerator, ring == baseDomain ? numMod : ring.modulus(num)); long den = i, denMod = baseDomain.modulus(i); while (den > 1 && denMod == 0) { den = FastDivision.divideSignedFast(den, baseDomain.magic); denMod = baseDomain.modulus(den); ++denZeros; } if (denMod != 0) denominator = ring.multiply(denominator, ring == baseDomain ? denMod : ring.modulus(den)); } if (numZeros > denZeros) numerator = ring.multiply(numerator, ring.powMod(baseDomain.modulus, numZeros - denZeros)); else if (denZeros < numZeros) denominator = ring.multiply(denominator, ring.powMod(baseDomain.modulus, denZeros - numZeros)); if (numerator == 0) return numerator; return ring.divide(numerator, denominator); } private MultivariatePolynomialZp64(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialSet<MonomialZp64> lMonomialTerms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialSet<MonomialZp64> terms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, Iterable<MonomialZp64> terms); static MultivariatePolynomialZp64 create(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering, MonomialZp64... terms); static MultivariatePolynomialZp64 zero(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 one(int nVariables, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, String... variables); @Deprecated static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring); static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, Comparator<DegreeVector> ordering, String... variables); @Deprecated static MultivariatePolynomialZp64 parse(String string, IntegersZp64 ring, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asMultivariate(UnivariatePolynomialZp64 poly, int nVariables, int variable, Comparator<DegreeVector> ordering); @Override UnivariatePolynomialZp64 asUnivariate(); @Override MultivariatePolynomial<UnivariatePolynomialZp64> asOverUnivariate(int variable); @Override MultivariatePolynomial<UnivariatePolynomialZp64> asOverUnivariateEliminate(int variable); @Override MultivariatePolynomial<MultivariatePolynomialZp64> asOverMultivariate(int... variables); @Override MultivariatePolynomial<MultivariatePolynomialZp64> asOverMultivariateEliminate(int[] variables, Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 asNormalMultivariate(MultivariatePolynomial<UnivariatePolynomialZp64> poly, int variable); static MultivariatePolynomialZp64 asNormalMultivariate(MultivariatePolynomial<MultivariatePolynomialZp64> poly); static MultivariatePolynomialZp64 asNormalMultivariate(
MultivariatePolynomial<MultivariatePolynomialZp64> poly,
int[] coefficientVariables, int[] mainVariables); MultivariatePolynomial<BigInteger> asPolyZSymmetric(); MultivariatePolynomial<BigInteger> asPolyZ(); MultivariatePolynomial<BigInteger> toBigPoly(); @Override MultivariatePolynomialZp64 contentAsPoly(); @Override MultivariatePolynomialZp64 lcAsPoly(); @Override MultivariatePolynomialZp64 lcAsPoly(Comparator<DegreeVector> ordering); @Override MultivariatePolynomialZp64 ccAsPoly(); @Override boolean isOverField(); @Override boolean isOverFiniteField(); @Override boolean isOverZ(); @Override BigInteger coefficientRingCardinality(); @Override BigInteger coefficientRingCharacteristic(); @Override boolean isOverPerfectPower(); @Override BigInteger coefficientRingPerfectPowerBase(); @Override BigInteger coefficientRingPerfectPowerExponent(); @Override @SuppressWarnings("unchecked") MultivariatePolynomialZp64[] createArray(int length); @Override MultivariatePolynomialZp64[][] createArray2d(int length); @Override MultivariatePolynomialZp64[][] createArray2d(int length1, int length2); @Override boolean sameCoefficientRingWith(MultivariatePolynomialZp64 oth); @Override MultivariatePolynomialZp64 setCoefficientRingFrom(MultivariatePolynomialZp64 lMonomialTerms); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 setRing(long newModulus); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 setRing(IntegersZp64 newDomain); @SuppressWarnings("unchecked") MultivariatePolynomial<E> setRing(Ring<E> newRing); MultivariatePolynomialZp64 setRingUnsafe(IntegersZp64 newDomain); MultivariatePolynomialZp64 createConstant(long val); @Override MultivariatePolynomialZp64 createConstantFromTerm(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 createZero(); @Override MultivariatePolynomialZp64 createOne(); MultivariatePolynomialZp64 createLinear(int variable, long cc, long lc); @Override boolean isMonic(); @Override int signumOfLC(); @Override boolean isOne(); @Override boolean isUnitCC(); @Override boolean isConstant(); long lc(); long lc(Comparator<DegreeVector> ordering); MultivariatePolynomialZp64 setLC(long val); long cc(); long content(); long[] coefficients(); @Override MultivariatePolynomialZp64 primitivePart(int variable); @Override UnivariatePolynomialZp64 contentUnivariate(int variable); @Override MultivariatePolynomialZp64 primitivePart(); @Override MultivariatePolynomialZp64 primitivePartSameSign(); @Override MultivariatePolynomialZp64 divideByLC(MultivariatePolynomialZp64 other); MultivariatePolynomialZp64 divide(long factor); @Override MultivariatePolynomialZp64 divideOrNull(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 monic(); @Override MultivariatePolynomialZp64 monic(Comparator<DegreeVector> ordering); MultivariatePolynomialZp64 monic(long factor); MultivariatePolynomialZp64 monic(Comparator<DegreeVector> ordering, long factor); @Override MultivariatePolynomialZp64 monicWithLC(MultivariatePolynomialZp64 other); @Override MultivariatePolynomialZp64 monicWithLC(Comparator<DegreeVector> ordering, MultivariatePolynomialZp64 other); IUnivariatePolynomial toDenseRecursiveForm(); static MultivariatePolynomialZp64 fromDenseRecursiveForm(IUnivariatePolynomial recForm,
Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 fromDenseRecursiveForm(IUnivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static long evaluateDenseRecursiveForm(IUnivariatePolynomial recForm, long[] values); AMultivariatePolynomial toSparseRecursiveForm(); static MultivariatePolynomialZp64 fromSparseRecursiveForm(AMultivariatePolynomial recForm,
Comparator<DegreeVector> ordering); static MultivariatePolynomialZp64 fromSparseRecursiveForm(AMultivariatePolynomial recForm,
int nVariables,
Comparator<DegreeVector> ordering); @SuppressWarnings("unchecked") static long evaluateSparseRecursiveForm(AMultivariatePolynomial recForm, long[] values); @SuppressWarnings("unchecked") HornerFormZp64 getHornerForm(int[] evaluationVariables); MultivariatePolynomialZp64 evaluate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 evaluate(int[] variables, long[] values); @SuppressWarnings("unchecked") long evaluate(long... values); @SuppressWarnings("unchecked") MultivariatePolynomialZp64[] evaluate(int variable, long... values); MultivariatePolynomialZp64 eliminate(int variable, long value); @SuppressWarnings("unchecked") MultivariatePolynomialZp64 eliminate(int[] variables, long[] values); lPrecomputedPowersHolder mkPrecomputedPowers(int variable, long value); lPrecomputedPowersHolder mkPrecomputedPowers(int[] variables, long[] values); static lPrecomputedPowersHolder mkPrecomputedPowers(int nVariables, IntegersZp64 ring, int[] variables, long[] values); lPrecomputedPowersHolder mkPrecomputedPowers(long[] values); MultivariatePolynomialZp64 substitute(int variable, MultivariatePolynomialZp64 poly); MultivariatePolynomialZp64 shift(int variable, long shift); MultivariatePolynomialZp64 shift(int[] variables, long[] shifts); MultivariatePolynomialZp64 add(long oth); MultivariatePolynomialZp64 subtract(long oth); @Override MultivariatePolynomialZp64 increment(); @Override MultivariatePolynomialZp64 decrement(); @Override MultivariatePolynomialZp64 multiply(long factor); @Override MultivariatePolynomialZp64 multiplyByLC(MultivariatePolynomialZp64 other); @Override MultivariatePolynomialZp64 multiplyByBigInteger(BigInteger factor); @Override MultivariatePolynomialZp64 multiply(MonomialZp64 monomial); @Override MultivariatePolynomialZp64 multiply(MultivariatePolynomialZp64 oth); @Override MultivariatePolynomialZp64 square(); @Override MultivariatePolynomialZp64 evaluateAtRandom(int variable, RandomGenerator rnd); @Override MultivariatePolynomialZp64 evaluateAtRandomPreservingSkeleton(int variable, RandomGenerator rnd); @Override MultivariatePolynomialZp64 derivative(int variable, int order); @Override MultivariatePolynomialZp64 seriesCoefficient(int variable, int order); MultivariatePolynomial<T> mapTerms(Ring<T> newRing, Function<MonomialZp64, Monomial<T>> mapper); MultivariatePolynomialZp64 mapTerms(IntegersZp64 newRing, Function<MonomialZp64, MonomialZp64> mapper); MultivariatePolynomial<T> mapCoefficients(Ring<T> newRing, LongFunction<T> mapper); @Override MultivariatePolynomial<E> mapCoefficientsAsPolys(Ring<E> ring, Function<MultivariatePolynomialZp64, E> mapper); @Override int compareTo(MultivariatePolynomialZp64 oth); @Override @SuppressWarnings("unchecked") MultivariatePolynomialZp64 clone(); @Override @Deprecated MultivariatePolynomialZp64 parsePoly(String string); @Override String toString(IStringifier<MultivariatePolynomialZp64> stringifier); @Override String coefficientRingToString(IStringifier<MultivariatePolynomialZp64> stringifier); final IntegersZp64 ring; } | @Test public void testSeries1() throws Exception { int nIterations = its(1000, 1000); RandomGenerator rnd = getRandom(); RandomDataGenerator rndd = getRandomData(); for (int n = 0; n < nIterations; n++) { long modulus = getModulusRandom(rndd.nextInt(2, 4)); if (modulus < 10) { if (rnd.nextBoolean()) modulus = modulus * modulus; else if (rnd.nextBoolean() && rnd.nextBoolean()) modulus = modulus * modulus * modulus; else if (rnd.nextBoolean() && rnd.nextBoolean() && rnd.nextBoolean() && rnd.nextBoolean()) modulus = modulus * modulus * modulus * modulus; } int order = rndd.nextInt((int) modulus + 1, (int) (3 * modulus) + 1); int exponent = rndd.nextInt(order, 5 * order); assertEquals("" + exponent + " " + order + " " + modulus, combinatorialFactorExpected(exponent, order, modulus), MultivariatePolynomialZp64.seriesCoefficientFactor(exponent, order, new IntegersZp64(modulus))); } }
@Test public void testSeries2() throws Exception { long modulus = 9; int order = 18; int exponent = 21; assertEquals("" + exponent + " " + order + " " + modulus, combinatorialFactorExpected(exponent, order, modulus), MultivariatePolynomialZp64.seriesCoefficientFactor(exponent, order, new IntegersZp64(modulus))); } |
MultivariateSquareFreeFactorization { public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> PolynomialFactorDecomposition<Poly> SquareFreeFactorizationMusser(Poly poly) { if (poly.coefficientRingCharacteristic().isZero()) throw new IllegalArgumentException("Positive characteristic expected"); if (canConvertToZp64(poly)) return SquareFreeFactorizationMusser(asOverZp64(poly)).mapTo(Conversions64bit::convertFromZp64); if (poly.isEffectiveUnivariate()) return factorUnivariate(poly); poly = poly.clone(); Poly[] content = reduceContent(poly); Poly lc = poly.lcAsPoly(); PolynomialFactorDecomposition<Poly> fct = SquareFreeFactorizationMusser0(poly); addMonomial(fct, content[1]); return fct.addFactor(content[0], 1).addFactor(lc, 1); } private MultivariateSquareFreeFactorization(); static PolynomialFactorDecomposition<Poly> SquareFreeFactorization(Poly poly); static boolean isSquareFree(Poly poly); static Poly SquareFreePart(Poly poly); static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationYunZeroCharacteristics(Poly poly); static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationMusserZeroCharacteristics(Poly poly); static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationMusser(Poly poly); } | @Test public void test2() throws Exception { IntegersZp domain = new IntegersZp(7); MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("11 + x^7*y^14 + z^7*x^14 + y^7", domain), b = MultivariatePolynomial.parse("11 + 3*y^7*z^14 + 4*x^7*y^14 + 5*z^7", domain), c = MultivariatePolynomial.parse("z*y^2*x^2 - 2*y^3*x - 1234*z^7*x^12*y^13", domain), poly = a.square().multiply(b.square()).multiply(c.square()); MultivariatePolynomialZp64 lPoly = MultivariatePolynomial.asOverZp64(poly); for (int i = 0; i < its(1, 5); i++) { long start = System.nanoTime(); FactorDecompositionTest.assertFactorization(lPoly, MultivariateSquareFreeFactorization.SquareFreeFactorizationMusser(lPoly)); System.out.println(TimeUnits.nanosecondsToString(System.nanoTime() - start)); } }
@Test public void test3() throws Exception { IntegersZp domain = new IntegersZp(2); MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("11 + x^7*y^14 + z^7*x^14 + y^7", domain), b = MultivariatePolynomial.parse("11 + 3*y^7*z^14 + 4*x^7*y^14 + 5*z^7", domain), c = MultivariatePolynomial.parse("z*y^2*x^2 - 2*y^3*x - 1234*z^7*x^12*y^13", domain), poly = a.square().multiply(b.square()).multiply(c.square()); MultivariatePolynomialZp64 lPoly = MultivariatePolynomial.asOverZp64(poly); FactorDecompositionTest.assertFactorization(lPoly, MultivariateSquareFreeFactorization.SquareFreeFactorizationMusser(lPoly)); }
@Test public void test4() throws Exception { IntegersZp domain = new IntegersZp(17); MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("11 + x^7*y^14 + z^7*x^14 + y^7", domain), b = MultivariatePolynomial.parse("11 + 3*y^7*z^14 + 4*x^7*y^14 + 5*z^7", domain), c = MultivariatePolynomial.parse("z*y^2*x^2 - 2*y^3*x - 1234*z^7*x^12*y^13", domain), poly = a.square().multiply(b.square()).multiply(c.square()); MultivariatePolynomialZp64 lPoly = MultivariatePolynomial.asOverZp64(poly); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateSquareFreeFactorization.SquareFreeFactorizationMusser(lPoly); FactorDecompositionTest.assertFactorization(lPoly, decomposition); }
@Test public void test5() throws Exception { IntegersZp domain = new IntegersZp(2); MultivariatePolynomial<BigInteger> a = MultivariatePolynomial.parse("1 + a^6*b^14 + a^2*b^4 + a^7", domain), b = MultivariatePolynomial.parse("1 + a^3*b^4 + a + b", domain), poly = a.square().multiply(b.square()); MultivariatePolynomialZp64 lPoly = MultivariatePolynomial.asOverZp64(poly); PolynomialFactorDecomposition<MultivariatePolynomialZp64> decomposition = MultivariateSquareFreeFactorization.SquareFreeFactorizationMusser(lPoly); FactorDecompositionTest.assertFactorization(lPoly, decomposition); }
@Test public void test5_finiteField() throws Exception { long modulus = 2; FiniteField<UnivariatePolynomialZp64> field = new FiniteField<>(IrreduciblePolynomials.randomIrreduciblePolynomial(modulus, 4, AbstractTest.getRandom())); MultivariatePolynomial<UnivariatePolynomialZp64> a = MultivariatePolynomial.zero(3, field, MonomialOrder.LEX) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(1, 2, 3, 4, 5).modulus(modulus)), 1, 1, 3)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 1, 3, 2, 13).modulus(modulus)), 3, 2, 1)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 11, 13, 12, 13).modulus(modulus)), 0, 2, 1)), b = MultivariatePolynomial.zero(3, field, MonomialOrder.LEX) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(1, 1, 3, 4, 5).modulus(modulus)), 1, 1, 13)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 1, 1, 2, 13).modulus(modulus)), 2, 2, 1)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 11, 113, 112, 13).modulus(modulus)), 10, 2, 1)), c = MultivariatePolynomial.one(3, field, MonomialOrder.LEX) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(1, 1, 3, 4, 5, 12).modulus(modulus)), 11, 1, 13)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(11, 2, 1, 1, 2, 13).modulus(modulus)), 21, 2, 1)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 111, 113, 112, 13, 12).modulus(modulus)), 10, 12, 1)) .add(createMonomial(field.valueOf(UnivariatePolynomialZ64.create(2, 111, 113, 112, 13, 12).modulus(modulus)), 0, 0, 1)), poly = a.square().multiply(b.square()).multiply(c.square()); PolynomialFactorDecomposition<MultivariatePolynomial<UnivariatePolynomialZp64>> decomposition = MultivariateSquareFreeFactorization.SquareFreeFactorizationMusser(poly); FactorDecompositionTest.assertFactorization(poly, decomposition); } |
MultivariateSquareFreeFactorization { public static <Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>> PolynomialFactorDecomposition<Poly> SquareFreeFactorization(Poly poly) { if (poly.isOverFiniteField()) return SquareFreeFactorizationMusser(poly); else if (MultivariateGCD.isOverPolynomialRing(poly)) return MultivariateFactorization.tryNested(poly, MultivariateSquareFreeFactorization::SquareFreeFactorization); else if (poly.coefficientRingCharacteristic().isZero()) return SquareFreeFactorizationYunZeroCharacteristics(poly); else return SquareFreeFactorizationMusser(poly); } private MultivariateSquareFreeFactorization(); static PolynomialFactorDecomposition<Poly> SquareFreeFactorization(Poly poly); static boolean isSquareFree(Poly poly); static Poly SquareFreePart(Poly poly); static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationYunZeroCharacteristics(Poly poly); static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationMusserZeroCharacteristics(Poly poly); static PolynomialFactorDecomposition<Poly> SquareFreeFactorizationMusser(Poly poly); } | @Test public void test6() throws Exception { String[] vars = {"a", "b", "c", "d", "e", "f", "g", "h"}; for (Ring<BigInteger> ring : Arrays.<Ring<BigInteger>>asList(new IntegersZp(2), Rings.Z)) { MultivariatePolynomial<BigInteger> poly = MultivariatePolynomial.parse("a^2*b^4*c*e^5", ring, vars); PolynomialFactorDecomposition<MultivariatePolynomial<BigInteger>> expected = PolynomialFactorDecomposition.empty(poly); expected.addFactor(MultivariatePolynomial.parse("a", ring, vars), 2); expected.addFactor(MultivariatePolynomial.parse("b", ring, vars), 4); expected.addFactor(MultivariatePolynomial.parse("c", ring, vars), 1); expected.addFactor(MultivariatePolynomial.parse("e", ring, vars), 5); Assert.assertEquals(expected, MultivariateSquareFreeFactorization.SquareFreeFactorization(poly)); } } |
HenselLifting { static MultivariatePolynomialZp64 modImage(MultivariatePolynomialZp64 poly, int degree) { if (degree == 0) return poly.ccAsPoly(); Iterator<Map.Entry<DegreeVector, MonomialZp64>> it = poly.terms.entrySet().iterator(); while (it.hasNext()) { MonomialZp64 term = it.next().getValue(); if (ArraysUtil.sum(term.exponents, 1) >= degree) { it.remove(); poly.release(); } } poly.release(); return poly; } private HenselLifting(); @SuppressWarnings("unchecked") static void bivariateLiftNoLCCorrection0(Poly base, Poly[] factors,
IEvaluation<Term, Poly> evaluation, int degreeBound); @SuppressWarnings("unchecked") static UnivariatePolynomial<uPoly> seriesExpansionDense(Ring<uPoly> ring, Poly poly, int variable, IEvaluation<Term, Poly> evaluate); static void multivariateLiftAutomaticLC(Poly base,
Poly[] factors,
IEvaluation<Term, Poly> evaluation); static void multivariateLiftAutomaticLC(Poly base,
Poly[] factors,
IEvaluation<Term, Poly> evaluation,
int from); } | @Test public void testEvaluation1() throws Exception { IntegersZp64 domain = new IntegersZp64(97); String[] vars = {"a", "b", "c"}; MultivariatePolynomialZp64 poly = parse("b*a^2 + b + a^2 + 2 + a^3*b^4 - a^62*b + 3*b^55*a^55 + b^66 + 3*c^55 + c*a*b + 3", domain, vars); lEvaluation evaluation = new lEvaluation(poly.nVariables, new long[]{2, 3}, domain, poly.ordering); Assert.assertEquals(evaluation.evaluate(poly, 1), evaluation.modImage(poly, 1, 1)); Assert.assertEquals(parse("53 + a^2 + 49*a^3 + 22*a^55 + 2*b + a^2*b + 32*a^3*b + 84*a^55*b + 96*a^62*b + a*b*c + 3*c^55", domain, vars), evaluation.modImage(poly, 1, 2)); Assert.assertEquals(parse("31 + a^2 + 26*a^55 + 77*b + a^2*b + 93*a^55*b + 96*a^62*b + 96*b^2 + 60*a^55*b^2 + 52*b^3 + 4*a^55*b^3 + 6*b^4 + a^3*b^4 + 27*a^55*b^4 + 15*b^5 + 88*a^55*b^5 + 25*b^6 + 75*a^55*b^6 + a*b*c + 3*c^55", domain, vars), evaluation.modImage(poly, 1, 7)); Assert.assertEquals(parse("89 + a^2 + 22*a^55 + 33*b + a^2*b + 81*a^55*b + 96*a^62*b + 83*b^2 + 26*a^55*b^2 + 54*b^3 + 32*a^55*b^3 + 52*b^4 + a^3*b^4 + 89*a^55*b^4 + 14*b^5 + 56*a^55*b^5 + 19*b^6 + 8*a^55*b^6 + 58*b^7 + 9*a^55*b^7 + 32*b^8 + 23*a^55*b^8 + 57*b^9 + 42*a^55*b^9 + 58*b^10 + 90*a^55*b^10 + 56*b^11 + 53*a^55*b^11 + 24*b^12 + 4*a^55*b^12 + 86*b^13 + 92*a^55*b^13 + 33*b^14 + 64*a^55*b^14 + 71*b^15 + 71*a^55*b^15 + 44*b^16 + 42*a^55*b^16 + 49*b^17 + 92*a^55*b^17 + 26*b^18 + 94*a^55*b^18 + 77*b^19 + 78*a^55*b^19 + 76*b^20 + 24*a^55*b^20 + 37*b^21 + 76*a^55*b^21 + 3*b^22 + 64*a^55*b^22 + 80*b^23 + 71*a^55*b^23 + 77*b^24 + 89*a^55*b^24 + 71*b^25 + 7*a^55*b^25 + 92*b^26 + 87*a^55*b^26 + 65*b^27 + 49*a^55*b^27 + 25*b^28 + 60*a^55*b^28 + 30*b^29 + 19*a^55*b^29 + 95*b^30 + 16*a^55*b^30 + 32*b^31 + 3*a^55*b^31 + 85*b^32 + 62*a^55*b^32 + 24*b^33 + 91*a^55*b^33 + 32*b^34 + 55*a^55*b^34 + 79*b^35 + 58*a^55*b^35 + 57*b^36 + 82*a^55*b^36 + 30*b^37 + 62*a^55*b^37 + 44*b^38 + 64*a^55*b^38 + 61*b^39 + 95*a^55*b^39 + 68*b^40 + 17*a^55*b^40 + 57*b^41 + 35*a^55*b^41 + 76*b^42 + 96*a^55*b^42 + 2*b^43 + 29*a^55*b^43 + 83*b^44 + 37*a^55*b^44 + 42*b^45 + 92*a^55*b^45 + 3*b^46 + 42*a^55*b^46 + a*b*c + 3*c^55", domain, vars), evaluation.modImage(poly, 1, 47)); Assert.assertEquals(evaluation.evaluate(poly, 2), evaluation.modImage(poly, 2, 1)); Assert.assertEquals(parse("52 + a^2 + b + a^2*b + 96*a^62*b + a^3*b^4 + 3*a^55*b^55 + b^66 + 5*c + a*b*c", domain, vars), evaluation.modImage(poly, 2, 2)); Assert.assertEquals(parse("87 + a^2 + b + a^2*b + 96*a^62*b + a^3*b^4 + 3*a^55*b^55 + b^66 + 9*c + a*b*c + 7*c^2 + 93*c^3 + 79*c^4 + 4*c^5 + 64*c^6", domain, vars), evaluation.modImage(poly, 2, 7)); Assert.assertEquals(parse("52 + a^2 + b + a^2*b + 96*a^62*b + a^3*b^4 + 3*a^55*b^55 + b^66 + 36*c + a*b*c + 58*c^2 + 65*c^3 + 70*c^4 + 29*c^5 + 12*c^6 + 9*c^7 + 80*c^8 + 51*c^9 + 59*c^10 + 44*c^11 + 62*c^12 + 13*c^13 + 96*c^14 + 71*c^15 + 28*c^16 + 84*c^17 + 53*c^18 + 19*c^19 + 81*c^20 + 74*c^21 + 96*c^22 + 71*c^23 + 27*c^24 + 57*c^25 + 15*c^26 + 48*c^27 + 57*c^28 + 67*c^29 + 24*c^30 + 3*c^31 + 9*c^32 + 62*c^33 + 63*c^34 + 39*c^35 + 10*c^36 + 91*c^37 + 96*c^38 + 95*c^39 + 76*c^40 + 91*c^41 + 50*c^42 + 68*c^43 + 40*c^44 + 13*c^45 + 63*c^46", domain, vars), evaluation.modImage(poly, 2, 47)); }
@Test public void testEvaluation2() throws Exception { IntegersZp64 domain = new IntegersZp64(2); String[] vars = {"a", "b", "c"}; MultivariatePolynomialZp64 poly = parse("b*a^2 + b + a^2 + 2 + a^3*b^4 - a^62*b + 3*b^55*a^55 + b^66 + 3*c^55 + c*a*b + 3", domain, vars); lEvaluation evaluation = new lEvaluation(poly.nVariables, new long[]{1, 3}, domain, poly.ordering); Assert.assertEquals(evaluation.evaluate(poly, 1), evaluation.modImage(poly, 1, 1)); Assert.assertEquals(parse("a^2 + a^3 + b + a^2*b + a^55*b + a^62*b + a*b*c + c^55", domain, vars), evaluation.modImage(poly, 1, 2)); Assert.assertEquals(parse("1 + a^2 + a^55 + b + a^2*b + a^55*b + a^62*b + b^2 + a^55*b^2 + a^55*b^3 + a^3*b^4 + a^55*b^4 + a^55*b^5 + a^55*b^6 + a*b*c + c^55", domain, vars), evaluation.modImage(poly, 1, 7)); Assert.assertEquals(parse("1 + a^2 + b + a^2*b + a^62*b + b^2 + a^3*b^4 + a^55*b^7 + a^55*b^23 + a^55*b^39 + a*b*c + c^55", domain, vars), evaluation.modImage(poly, 1, 47)); Assert.assertEquals(evaluation.evaluate(poly, 2), evaluation.modImage(poly, 2, 1)); Assert.assertEquals(parse("1 + a^2 + b + a^2*b + a^62*b + a^3*b^4 + a^55*b^55 + b^66 + c + a*b*c", domain, vars), evaluation.modImage(poly, 2, 2)); Assert.assertEquals(parse("a^2 + b + a^2*b + a^62*b + a^3*b^4 + a^55*b^55 + b^66 + c + a*b*c + c^2 + c^3 + c^4 + c^5 + c^6", domain, vars), evaluation.modImage(poly, 2, 7)); Assert.assertEquals(parse("1 + a^2 + b + a^2*b + a^62*b + a^3*b^4 + a^55*b^55 + b^66 + a*b*c + c^7 + c^23 + c^39", domain, vars), evaluation.modImage(poly, 2, 47)); }
@Test public void testEvaluation3() throws Exception { IntegersZp domain = new IntegersZp(2); String[] vars = {"a", "b", "c"}; MultivariatePolynomial<BigInteger> poly = MultivariatePolynomial.parse("b*a^2 + b + a^2 + 2 + a^3*b^4 - a^62*b + 3*b^55*a^55 + b^66 + 3*c^55 + c*a*b + 3", domain, vars); Evaluation<BigInteger> evaluation = new Evaluation<>(poly.nVariables, new BigInteger[]{BigInteger.ONE, BigInteger.ONE}, domain, poly.ordering); Assert.assertEquals(evaluation.evaluate(poly, 1), evaluation.modImage(poly, 1, 1)); Assert.assertEquals(MultivariatePolynomial.parse("a^2 + a^3 + b + a^2*b + a^55*b + a^62*b + a*b*c + c^55", domain, vars), evaluation.modImage(poly, 1, 2)); Assert.assertEquals(MultivariatePolynomial.parse("1 + a^2 + a^55 + b + a^2*b + a^55*b + a^62*b + b^2 + a^55*b^2 + a^55*b^3 + a^3*b^4 + a^55*b^4 + a^55*b^5 + a^55*b^6 + a*b*c + c^55", domain, vars), evaluation.modImage(poly, 1, 7)); Assert.assertEquals(MultivariatePolynomial.parse("1 + a^2 + b + a^2*b + a^62*b + b^2 + a^3*b^4 + a^55*b^7 + a^55*b^23 + a^55*b^39 + a*b*c + c^55", domain, vars), evaluation.modImage(poly, 1, 47)); Assert.assertEquals(evaluation.evaluate(poly, 2), evaluation.modImage(poly, 2, 1)); Assert.assertEquals(MultivariatePolynomial.parse("1 + a^2 + b + a^2*b + a^62*b + a^3*b^4 + a^55*b^55 + b^66 + c + a*b*c", domain, vars), evaluation.modImage(poly, 2, 2)); Assert.assertEquals(MultivariatePolynomial.parse("a^2 + b + a^2*b + a^62*b + a^3*b^4 + a^55*b^55 + b^66 + c + a*b*c + c^2 + c^3 + c^4 + c^5 + c^6", domain, vars), evaluation.modImage(poly, 2, 7)); Assert.assertEquals(MultivariatePolynomial.parse("1 + a^2 + b + a^2*b + a^62*b + a^3*b^4 + a^55*b^55 + b^66 + a*b*c + c^7 + c^23 + c^39", domain, vars), evaluation.modImage(poly, 2, 47)); } |
HenselLifting { @SuppressWarnings("unchecked") static < Term extends AMonomial<Term>, Poly extends AMultivariatePolynomial<Term, Poly>, uPoly extends IUnivariatePolynomial<uPoly>> void bivariateLift0(Poly base, Poly[] factors, Poly[] factorsLC, IEvaluation<Term, Poly> evaluation, int degreeBound) { imposeLeadingCoefficients(factors, factorsLC); AllProductsCache<uPoly> uFactors = new AllProductsCache(asUnivariate(factors, evaluation)); UMultiDiophantineSolver<uPoly> uSolver = new UMultiDiophantineSolver<>(uFactors); Ring<uPoly> uRing = new UnivariateRing<>(uFactors.get(0)); UnivariatePolynomial<uPoly> baseSeries = seriesExpansionDense(uRing, base, 1, evaluation); UnivariatePolynomial<uPoly>[] solution = new UnivariatePolynomial[factors.length]; for (int i = 0; i < solution.length; i++) { solution[i] = seriesExpansionDense(uRing, factors[i], 1, evaluation); solution[i].ensureInternalCapacity(degreeBound + 1); } BernardinsTrick<uPoly> product = createBernardinsTrick(solution, degreeBound); for (int degree = 1; degree <= degreeBound; ++degree) { uPoly rhsDelta = baseSeries.get(degree).clone().subtract(product.fullProduct().get(degree)); uSolver.solve(rhsDelta); product.update(uSolver.solution); } for (int i = 0; i < solution.length; i++) factors[i].set(denseSeriesToPoly(base, solution[i], 1, evaluation)); } private HenselLifting(); @SuppressWarnings("unchecked") static void bivariateLiftNoLCCorrection0(Poly base, Poly[] factors,
IEvaluation<Term, Poly> evaluation, int degreeBound); @SuppressWarnings("unchecked") static UnivariatePolynomial<uPoly> seriesExpansionDense(Ring<uPoly> ring, Poly poly, int variable, IEvaluation<Term, Poly> evaluate); static void multivariateLiftAutomaticLC(Poly base,
Poly[] factors,
IEvaluation<Term, Poly> evaluation); static void multivariateLiftAutomaticLC(Poly base,
Poly[] factors,
IEvaluation<Term, Poly> evaluation,
int from); } | @Test public void testBivariateLiftingRandom1() throws Exception { MultivariateFactorizationTest.lSampleDecompositionSource baseSource = new MultivariateFactorizationTest.lSampleDecompositionSource( 3, 5, 2, 2, 2, 6, 1, 4); baseSource.minModulusBits = 15; baseSource.maxModulusBits = 30; FactorizationInput.SampleDecompositionSource<MultivariatePolynomialZp64> source = orderVarsByDegree( filterMonomialContent( filterNonSquareFree(baseSource))); testHenselLift(source, AbstractTest.its(500, 1000), lEvaluationLoop::new, ((base, factors, factorsLC, evaluation, degreeBounds, from) -> HenselLifting.bivariateLift0(base, factors, factorsLC, evaluation, degreeBounds[1])), true, 1); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.