@Override public boolean test(Permutation permutation, int level) { if (level < from.length) return permutation.newIndexOf(from[level]) == to[level]; return true; }
@Override public boolean test(Permutation permutation, int level) { return level == 0 ? larger.get(level).belongsToOrbit( wordReference[level].newIndexOf(base[level])) : larger.get(level).belongsToOrbit( intersectionWord[level - 1].newIndexOfUnderInverse( wordReference[level].newIndexOf(base[level]))); }
private static boolean checkNonPermutingPositions(Permutation permutation, int[] nonPermutablePositions) { for (int i : nonPermutablePositions) if (permutation.newIndexOf(i) != i) return false; return true; }
@Override public void beforeLevelIncrement(int level) { int image = wordReference[level].newIndexOf(base[level]); if (level == 0) intersectionWord[level] = larger.get(level).getTransversalOf(image); else intersectionWord[level] = larger.get(level).getTransversalOf(intersectionWord[level - 1] .newIndexOfUnderInverse(image)).composition(intersectionWord[level - 1]); }
private static boolean assertPartialBaseImage(final int level, final Permutation[] word, final int[] base, final ArrayList<? extends BSGSElement> subgroup_rebase) { for (int i = 0; i <= level; ++i) if (subgroup_rebase.get(i).basePoint != word[i].newIndexOf(base[i])) return false; return true; } }
@Override public boolean is(Permutation p) { for (int s : set) if (Arrays.binarySearch(set, p.newIndexOf(s)) < 0) return false; return true; } }
@Override public boolean test(Permutation permutation, int level) { if (level < set.length) { assert Arrays.binarySearch(set, base[level]) >= 0; return Arrays.binarySearch(set, permutation.newIndexOf(base[level])) >= 0; } else return Arrays.binarySearch(set, permutation.newIndexOf(base[level])) < 0; }
/** * Returns a subset of {@code stabilizerGenerators} that fix this base point. * * @return a subset of {@code stabilizerGenerators} that fix this base point */ public List<Permutation> getStabilizersOfThisBasePoint() { ArrayList<Permutation> basePointStabilizers = new ArrayList<>(); for (Permutation previousPointsStabilizer : stabilizerGenerators) if (previousPointsStabilizer.newIndexOf(basePoint) == basePoint) basePointStabilizers.add(previousPointsStabilizer); return basePointStabilizers; }
@Override public int compare(Permutation a, Permutation b) { int compare; for (int i : base) if ((compare = inducedOrdering.compare(a.newIndexOf(i), b.newIndexOf(i))) != 0) return compare; return 0; } }
@Override public boolean test(Permutation permutation, int level) { if (level == 0) return true; //find previous base point that lies in same orbit of subgroup if (subgroup.internalDegree < group_base[level - 1]) if (group_base[level - 1] != group_base[level]) return true; if (subgroup.indexOfOrbit(group_base[level - 1]) != subgroup.indexOfOrbit(group_base[level])) return true; Permutation mapping = mappings[level - 1]; int expected = mapping.newIndexOf(permutation.newIndexOf(group_base[level - 1])); return permutation.newIndexOf(group_base[level]) == expected; }
public static List<Permutation> getIndicesSymmetriesForIndicesWithSameStates(final int[] indices, Tensor tensor) { List<Permutation> total = findIndicesSymmetries(indices, tensor); List<Permutation> symmetries = new ArrayList<>(); int i; OUT: for (Permutation s : total) { for (i = 0; i < indices.length; ++i) if (IndicesUtils.getRawStateInt(indices[i]) != IndicesUtils.getRawStateInt(indices[s.newIndexOf(i)])) continue OUT; symmetries.add(s); } return symmetries; }
/** * Calculates the transversal of specified point (u<sub>β</sub>), i.e. the element * u<sub>β</sub> such that β<sub>i</sub><sup>u<sub>β</sub></sup> = β. * * @param point point * @return element that maps this base point to the specified point. * @see #getInverseTransversalOf(int) */ public Permutation getTransversalOf(int point) { Permutation transversal = getInverseTransversalOf(point).inverse(); assert transversal.newIndexOf(basePoint) == point; return transversal; }
@Override public int compareTo(Permutation t) { final int max = Math.max(degree(), t.degree()); if (antisymmetry != t.antisymmetry()) return antisymmetry ? -1 : 1; for (int i = 0; i < max; ++i) if (newIndexOf(i) < t.newIndexOf(i)) return -1; else if (newIndexOf(i) > t.newIndexOf(i)) return 1; return 0; } }
@Override public int compareTo(Permutation t) { final int max = Math.max(degree(), t.degree()); if (antisymmetry != t.antisymmetry()) return antisymmetry ? -1 : 1; for (int i = 0; i < max; ++i) if (newIndexOf(i) < t.newIndexOf(i)) return -1; else if (newIndexOf(i) > t.newIndexOf(i)) return 1; return 0; } }
@Override public int compareTo(Permutation t) { final int max = Math.max(degree(), t.degree()); if (antisymmetry != t.antisymmetry()) return antisymmetry ? -1 : 1; for (int i = 0; i < max; ++i) if (newIndexOf(i) < t.newIndexOf(i)) return -1; else if (newIndexOf(i) > t.newIndexOf(i)) return 1; return 0; } }
@Override public int compareTo(Permutation t) { int c = Integer.compare(degree(), t.degree()); if (c != 0) return c; if (antisymmetry != t.antisymmetry()) return antisymmetry ? -1 : 1; for (int i = 0; i < degree(); ++i) if (newIndexOf(i) < t.newIndexOf(i)) return -1; else if (newIndexOf(i) > t.newIndexOf(i)) return 1; return 0; } }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || !(o instanceof Permutation)) return false; Permutation that = (Permutation) o; if (antisymmetry != that.antisymmetry()) return false; if (internalDegree != that.degree()) return false; for (int i = 0; i < internalDegree; ++i) if (newIndexOf(i) != that.newIndexOf(i)) return false; return true; }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || !(o instanceof Permutation)) return false; Permutation that = (Permutation) o; if (antisymmetry != that.antisymmetry()) return false; if (internalDegree != that.degree()) return false; for (int i = 0; i < internalDegree; ++i) if (newIndexOf(i) != that.newIndexOf(i)) return false; return true; }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || !(o instanceof Permutation)) return false; Permutation that = (Permutation) o; if (antisymmetry != that.antisymmetry()) return false; if (internalDegree != that.degree()) return false; for (int i = 0; i < internalDegree; ++i) if (newIndexOf(i) != that.newIndexOf(i)) return false; return true; }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || !(o instanceof Permutation)) return false; Permutation that = (Permutation) o; if (antisymmetry != that.antisymmetry()) return false; if (degree() != that.degree()) return false; for (int i = 0; i < degree(); ++i) if (newIndexOf(i) != that.newIndexOf(i)) return false; return true; }