\hXb#SSKJr SSKJr SSKJrJrJr SSK J r SSK J r J r Jr SSKJr \R"r"SS\5rS r\"\"SS S S 5\"\"SS S 5\"SS S 5\"SS S 5\"S S S 55\"\"S S S 5\"S 5"SS S 5\"SS S 5\"SS S 5\"SS 5"S S 5\"SS 5"S S 5\"SS 5"S S 555r\"\"SS S S S SSS5\"\"SS S S 5\"SS SS 5\"S S SS5\"S S SS5\"SS SS 5\"S SSS55\"\"SS S S 5"S SSS5\"SS SS 5"S S SS5\"SS SS 5"S SSS 5\"SS 5"S S 5"S S5"SS5\"SS5"S S 5"S S5"S S5\"SS5"S S5"S S 5"S S5\"SS 5"S S5"S S 5"SS5\"SS 5"S S5"S S5"S S5\"SS5"S S5"S S 5"S S5\"S S S 5"S SS5\"S5"SSS 5"S S S5\"SSS5"S SS 5\"SSS 5"S S S55 5r\"\"SS S S S S5\"\"SS S 5\"SS S 5\"SS S 5\"SS S 5\"S S S5\"S S S5\"S S S5\"S S S55\"\"S5"S S S S 5\"SS SS 5\"SS SS 5\"SS 5"S S 5"S S5\"SS 5"S S 5"S S5\"SS 5"S S5"S S 5\"SS 5"S S 5"S S5\"SS5"S S 5"S S 5\"SS5"S S 5"S S 5\"SS S 5"S S S5\"SS S 5"S S S5\"SS S 5"S SS 5\"SS S 5"S SS 55 5r\"\"SS S S S SSSSSSSSSSSSSSS5\"\"SS S S S 5\"SS SSS5\"S S SSS5\"S S SSS5\"S S SSS5\"SS SSS5\"SSSSS5\"SSSSS5\"SSSSS5\"SSSSS5\"SSSSS5\"SSSSS55 \"/\"SS S S S 5"SSSSS5"SSSSS5"SSSSS5P\"SSSSS 5"S S SSS5"S SSSS5"SSSSS5P\"SSSSS 5"S SSSS 5"S SSSS5"SSSSS5P\"SSSSS5"S SSSS 5"S SSSS 5"SSSSS5P\"SS SSS5"S SSSS5"S SSSS 5"SSSSS5P\"SS SSS5"S S SSS5"S SSSS5"SSSSS5P\"SS 5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S 5"S S5"S S5"SS5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S 5"S S5"SS5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S 5"SS5"SS5"SS5"SS5"SS5"SS5P\"SS 5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5"SS5"SS5"SS5"SS5P\"S S S5"S SS5"S SS5"SSS5"SSS5"SSS5P\"S5"SSS 5"S SS5"S SS5"SSS5"SSS5"SSS5P\"SSS5"S SS 5"S SS5"SSS5"SSS5"SSS5P\"SSS5"S SS5"S SS 5"SSS5"SSS5"SSS5P\"SS S5"S SS5"S SS5"SSS5"SSS5"SSS5P\"SSS5"S SS5"S SS5"S SS5"S SS5"SSS5P\"SSS5"S SS5"S SS5"S SS5"S SS5"SSS5P\"SSS5"S SS5"S SS5"S SS5"S SS5"SSS5P\"SSS5"S SS5"S SS5"S SS5"S SS5"SSS5P\"SSS5"S SS5"S SS5"S SS5"S SS5"SSS5P765r\"\"SS S S S SSSSSSS5 \"\"SS S 5\"SS S 5\"SS S 5\"SS S5\"SS S5\"S SS5\"S S S5\"S SS5\"S S S5\"S SS5\"S S S5\"S SS5\"S SS5\"SSS5\"S SS5\"SSS5\"SSS5\"SSS5\"SSS5\"SSS55\"/\"S5"S S S S S5"SSSSS5P\"SSSSS 5"S S SSS5P\"SS SSS 5"S SSSS5P\"SS SSS 5"S SSSS5P\"SS SSS5"S S SSS5P\"SS SSS 5"S S SSS5P\"SS 5"S S5"S S5"S S5"SS5"SS5P\"SS 5"S S 5"S S5"SS5"SS5"SS5P\"SS 5"S S5"S S 5"SS5"SS5"SS5P\"SS 5"S S5"S S5"S S5"SS5"SS5P\"SS5"S S 5"S S5"S S5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5P\"SS5"S S 5"S S5"S S5"SS5"SS5P\"SS5"S S5"S S 5"S S5"SS5"SS5P\"SS5"S S5"S S5"S S 5"SS5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5P\"SS5"S S5"S S5"S S5"S S5"SS5P\"SSS 5"S S S5"S SS5"SSS5P\"SS S 5"S SS5"S SS5"SSS5P\"SS S 5"S SS 5"SSS5"SSS5P\"SS S 5"S SS5"S SS5"SSS5P\"SS S5"S S S5"S SS5"SSS5P\"SSS5"S SS5"S S S5"S SS5P\"SSS5"S SS 5"S SS5"S SS5P\"SSS5"S SS 5"S SS 5"SSS5P\"SSS5"S SS5"S SS5"S SS 5P\"SSS5"S S S5"S SS5"S SS5P765r\R2Vs/sH n\"U5PM snr\R2Vs/sH n\"U5PM snr\R2Vs/sH n\"U5PM snr\R2Vs/sH n\"U5PM snr\R2Vs/sH n\"U5PM snrgs snfs snfs snfs snfs snf)) Permutation)PermutationGroup)BasicTupledefault_sort_key) FiniteSet)minlex unflattenflatten)as_intc\rSrSrSrSrSSjr\S5r\r \S5r \S5r \S5r \S 5r \S 5r\S 5rS rS rSrg) Polyhedron a Represents the polyhedral symmetry group (PSG). Explanation =========== The PSG is one of the symmetry groups of the Platonic solids. There are three polyhedral groups: the tetrahedral group of order 12, the octahedral group of order 24, and the icosahedral group of order 60. All doctests have been given in the docstring of the constructor of the object. References ========== .. [1] https://mathworld.wolfram.com/PolyhedralGroup.html Nc UVs/sHn[US[S9PM nnXU4Vs/sH n[U6PM sn=upp6[R"U/UQ76n[ U5Ul[U6UlU(a'USR[U5:wa [S5e[U=(d [[[U555/5UlU$s snfs snf)aw) The constructor of the Polyhedron group object. Explanation =========== It takes up to three parameters: the corners, faces, and allowed transformations. The corners/vertices are entered as a list of arbitrary expressions that are used to identify each vertex. The faces are entered as a list of tuples of indices; a tuple of indices identifies the vertices which define the face. They should be entered in a cw or ccw order; they will be standardized by reversal and rotation to be give the lowest lexical ordering. If no faces are given then no edges will be computed. >>> from sympy.combinatorics.polyhedron import Polyhedron >>> Polyhedron(list('abc'), [(1, 2, 0)]).faces {(0, 1, 2)} >>> Polyhedron(list('abc'), [(1, 0, 2)]).faces {(0, 1, 2)} The allowed transformations are entered as allowable permutations of the vertices for the polyhedron. Instance of Permutations (as with faces) should refer to the supplied vertices by index. These permutation are stored as a PermutationGroup. Examples ======== >>> from sympy.combinatorics.permutations import Permutation >>> from sympy import init_printing >>> from sympy.abc import w, x, y, z >>> init_printing(pretty_print=False, perm_cyclic=False) Here we construct the Polyhedron object for a tetrahedron. >>> corners = [w, x, y, z] >>> faces = [(0, 1, 2), (0, 2, 3), (0, 3, 1), (1, 2, 3)] Next, allowed transformations of the polyhedron must be given. This is given as permutations of vertices. Although the vertices of a tetrahedron can be numbered in 24 (4!) different ways, there are only 12 different orientations for a physical tetrahedron. The following permutations, applied once or twice, will generate all 12 of the orientations. (The identity permutation, Permutation(range(4)), is not included since it does not change the orientation of the vertices.) >>> pgroup = [Permutation([[0, 1, 2], [3]]), Permutation([[0, 1, 3], [2]]), Permutation([[0, 2, 3], [1]]), Permutation([[1, 2, 3], [0]]), Permutation([[0, 1], [2, 3]]), Permutation([[0, 2], [1, 3]]), Permutation([[0, 3], [1, 2]])] The Polyhedron is now constructed and demonstrated: >>> tetra = Polyhedron(corners, faces, pgroup) >>> tetra.size 4 >>> tetra.edges {(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)} >>> tetra.corners (w, x, y, z) It can be rotated with an arbitrary permutation of vertices, e.g. the following permutation is not in the pgroup: >>> tetra.rotate(Permutation([0, 1, 3, 2])) >>> tetra.corners (w, x, z, y) An allowed permutation of the vertices can be constructed by repeatedly applying permutations from the pgroup to the vertices. Here is a demonstration that applying p and p**2 for every p in pgroup generates all the orientations of a tetrahedron and no others: >>> all = ( (w, x, y, z), (x, y, w, z), (y, w, x, z), (w, z, x, y), (z, w, y, x), (w, y, z, x), (y, z, w, x), (x, z, y, w), (z, y, x, w), (y, x, z, w), (x, w, z, y), (z, x, w, y) ) >>> got = [] >>> for p in (pgroup + [p**2 for p in pgroup]): ... h = Polyhedron(corners) ... h.rotate(p) ... got.append(h.corners) ... >>> set(got) == set(all) True The make_perm method of a PermutationGroup will randomly pick permutations, multiply them together, and return the permutation that can be applied to the polyhedron to give the orientation produced by those individual permutations. Here, 3 permutations are used: >>> tetra.pgroup.make_perm(3) # doctest: +SKIP Permutation([0, 3, 1, 2]) To select the permutations that should be used, supply a list of indices to the permutations in pgroup in the order they should be applied: >>> use = [0, 0, 2] >>> p002 = tetra.pgroup.make_perm(3, use) >>> p002 Permutation([1, 0, 3, 2]) Apply them one at a time: >>> tetra.reset() >>> for i in use: ... tetra.rotate(pgroup[i]) ... >>> tetra.vertices (x, w, z, y) >>> sequentially = tetra.vertices Apply the composite permutation: >>> tetra.reset() >>> tetra.rotate(p002) >>> tetra.corners (x, w, z, y) >>> tetra.corners in all and tetra.corners == sequentially True Notes ===== Defining permutation groups --------------------------- It is not necessary to enter any permutations, nor is necessary to enter a complete set of transformations. In fact, for a polyhedron, all configurations can be constructed from just two permutations. For example, the orientations of a tetrahedron can be generated from an axis passing through a vertex and face and another axis passing through a different vertex or from an axis passing through the midpoints of two edges opposite of each other. For simplicity of presentation, consider a square -- not a cube -- with vertices 1, 2, 3, and 4: 1-----2 We could think of axes of rotation being: | | 1) through the face | | 2) from midpoint 1-2 to 3-4 or 1-3 to 2-4 3-----4 3) lines 1-4 or 2-3 To determine how to write the permutations, imagine 4 cameras, one at each corner, labeled A-D: A B A B 1-----2 1-----3 vertex index: | | | | 1 0 | | | | 2 1 3-----4 2-----4 3 2 C D C D 4 3 original after rotation along 1-4 A diagonal and a face axis will be chosen for the "permutation group" from which any orientation can be constructed. >>> pgroup = [] Imagine a clockwise rotation when viewing 1-4 from camera A. The new orientation is (in camera-order): 1, 3, 2, 4 so the permutation is given using the *indices* of the vertices as: >>> pgroup.append(Permutation((0, 2, 1, 3))) Now imagine rotating clockwise when looking down an axis entering the center of the square as viewed. The new camera-order would be 3, 1, 4, 2 so the permutation is (using indices): >>> pgroup.append(Permutation((2, 0, 3, 1))) The square can now be constructed: ** use real-world labels for the vertices, entering them in camera order ** for the faces we use zero-based indices of the vertices in *edge-order* as the face is traversed; neither the direction nor the starting point matter -- the faces are only used to define edges (if so desired). >>> square = Polyhedron((1, 2, 3, 4), [(0, 1, 3, 2)], pgroup) To rotate the square with a single permutation we can do: >>> square.rotate(square.pgroup[0]) >>> square.corners (1, 3, 2, 4) To use more than one permutation (or to use one permutation more than once) it is more convenient to use the make_perm method: >>> p011 = square.pgroup.make_perm([0, 1, 1]) # diag flip + 2 rotations >>> square.reset() # return to initial orientation >>> square.rotate(p011) >>> square.corners (4, 2, 3, 1) Thinking outside the box ------------------------ Although the Polyhedron object has a direct physical meaning, it actually has broader application. In the most general sense it is just a decorated PermutationGroup, allowing one to connect the permutations to something physical. For example, a Rubik's cube is not a proper polyhedron, but the Polyhedron class can be used to represent it in a way that helps to visualize the Rubik's cube. >>> from sympy import flatten, unflatten, symbols >>> from sympy.combinatorics import RubikGroup >>> facelets = flatten([symbols(s+'1:5') for s in 'UFRBLD']) >>> def show(): ... pairs = unflatten(r2.corners, 2) ... print(pairs[::2]) ... print(pairs[1::2]) ... >>> r2 = Polyhedron(facelets, pgroup=RubikGroup(2)) >>> show() [(U1, U2), (F1, F2), (R1, R2), (B1, B2), (L1, L2), (D1, D2)] [(U3, U4), (F3, F4), (R3, R4), (B3, B4), (L3, L4), (D3, D4)] >>> r2.rotate(0) # cw rotation of F >>> show() [(U1, U2), (F3, F1), (U3, R2), (B1, B2), (L1, D1), (R3, R1)] [(L4, L2), (F4, F2), (U4, R4), (B3, B4), (L3, D2), (D3, D4)] Predefined Polyhedra ==================== For convenience, the vertices and faces are defined for the following standard solids along with a permutation group for transformations. When the polyhedron is oriented as indicated below, the vertices in a given horizontal plane are numbered in ccw direction, starting from the vertex that will give the lowest indices in a given face. (In the net of the vertices, indices preceded by "-" indicate replication of the lhs index in the net.) tetrahedron, tetrahedron_faces ------------------------------ 4 vertices (vertex up) net: 0 0-0 1 2 3-1 4 faces: (0, 1, 2) (0, 2, 3) (0, 3, 1) (1, 2, 3) cube, cube_faces ---------------- 8 vertices (face up) net: 0 1 2 3-0 4 5 6 7-4 6 faces: (0, 1, 2, 3) (0, 1, 5, 4) (1, 2, 6, 5) (2, 3, 7, 6) (0, 3, 7, 4) (4, 5, 6, 7) octahedron, octahedron_faces ---------------------------- 6 vertices (vertex up) net: 0 0 0-0 1 2 3 4-1 5 5 5-5 8 faces: (0, 1, 2) (0, 2, 3) (0, 3, 4) (0, 1, 4) (1, 2, 5) (2, 3, 5) (3, 4, 5) (1, 4, 5) dodecahedron, dodecahedron_faces -------------------------------- 20 vertices (vertex up) net: 0 1 2 3 4 -0 5 6 7 8 9 -5 14 10 11 12 13-14 15 16 17 18 19-15 12 faces: (0, 1, 2, 3, 4) (0, 1, 6, 10, 5) (1, 2, 7, 11, 6) (2, 3, 8, 12, 7) (3, 4, 9, 13, 8) (0, 4, 9, 14, 5) (5, 10, 16, 15, 14) (6, 10, 16, 17, 11) (7, 11, 17, 18, 12) (8, 12, 18, 19, 13) (9, 13, 19, 15, 14)(15, 16, 17, 18, 19) icosahedron, icosahedron_faces ------------------------------ 12 vertices (face up) net: 0 0 0 0 -0 1 2 3 4 5 -1 6 7 8 9 10 -6 11 11 11 11 -11 20 faces: (0, 1, 2) (0, 2, 3) (0, 3, 4) (0, 4, 5) (0, 1, 5) (1, 2, 6) (2, 3, 7) (3, 4, 8) (4, 5, 9) (1, 5, 10) (2, 6, 7) (3, 7, 8) (4, 8, 9) (5, 9, 10) (1, 6, 10) (6, 7, 11) (7, 8, 11) (8, 9, 11) (9, 10, 11) (6, 10, 11) >>> from sympy.combinatorics.polyhedron import cube >>> cube.edges {(0, 1), (0, 3), (0, 4), (1, 2), (1, 5), (2, 3), (2, 6), (3, 7), (4, 5), (4, 7), (5, 6), (6, 7)} If you want to use letters or other names for the corners you can still use the pre-calculated faces: >>> corners = list('abcdefgh') >>> Polyhedron(corners, cube.faces).corners (a, b, c, d, e, f, g, h) References ========== .. [1] www.ocf.berkeley.edu/~wwu/articles/platonicsolids.pdf F)directedkeyrz.Permutation size unequal to number of corners.)r rrr__new__tuple_cornersr_facessizelen ValueErrorrPermrange_pgroup)clscornersfacespgroupfaargsobjs V/var/www/auris/envauris/lib/python3.13/site-packages/sympy/combinatorics/polyhedron.pyrPolyhedron.__new__"sD KPP%QE/?@%P!( 8 9 81UAY 8 9 :mmC'$'W~ & fQinnG 4MN N&  1tE#g,/014  Q 9s CCcUR$)a@ Get the corners of the Polyhedron. The method ``vertices`` is an alias for ``corners``. Examples ======== >>> from sympy.combinatorics import Polyhedron >>> from sympy.abc import a, b, c, d >>> p = Polyhedron(list('abcd')) >>> p.corners == p.vertices == (a, b, c, d) True See Also ======== array_form, cyclic_form )rselfs r%rPolyhedron.cornerss*}}c[URS5nURVs/sHo!RU5PM sn$s snf)aReturn the indices of the corners. The indices are given relative to the original position of corners. Examples ======== >>> from sympy.combinatorics.polyhedron import tetrahedron >>> tetrahedron = tetrahedron.copy() >>> tetrahedron.array_form [0, 1, 2, 3] >>> tetrahedron.rotate(0) >>> tetrahedron.array_form [0, 2, 3, 1] >>> tetrahedron.pgroup[0].array_form [0, 2, 3, 1] See Also ======== corners, cyclic_form r)listr#rindex)r)rcs r% array_formPolyhedron.array_forms92tyy|$*.,,7,Q a ,777sAcV[R"UR5R$)zReturn the indices of the corners in cyclic notation. The indices are given relative to the original position of corners. See Also ======== corners, array_form )r_af_newr0 cyclic_formr(s r%r4Polyhedron.cyclic_forms||DOO,888r+c,[UR5$)z. Get the number of corners of the Polyhedron. )rrr(s r%rPolyhedron.sizes 4==!!r+cUR$)z" Get the faces of the Polyhedron. )rr(s r%rPolyhedron.facess {{r+cUR$)z) Get the permutations of the Polyhedron. )rr(s r%r Polyhedron.pgroups ||r+c URcs[5nURHLn[[ U55H1n[ [ X#X#S- /55nURU5 M3 MN [U6UlUR$)a  Given the faces of the polyhedra we can get the edges. Examples ======== >>> from sympy.combinatorics import Polyhedron >>> from sympy.abc import a, b, c >>> corners = (a, b, c) >>> faces = [(0, 1, 2)] >>> Polyhedron(corners, faces).edges {(0, 1), (0, 2), (1, 2)} ) _edgessetrrrrsortedaddr)r)outputfaceiedges r%edgesPolyhedron.edgessv ;; UF s4y)A $1u+(>!?@DJJt$*#$V,DK{{r+cR[U[5(dURUnO%URUR:wa [ S5eUR n[ [UR55Vs/sHo0RX#PM nn[U5Ul gs snf)ae Apply a permutation to the polyhedron *in place*. The permutation may be given as a Permutation instance or an integer indicating which permutation from pgroup of the Polyhedron should be applied. This is an operation that is analogous to rotation about an axis by a fixed increment. Notes ===== When a Permutation is applied, no check is done to see if that is a valid permutation for the Polyhedron. For example, a cube could be given a permutation which effectively swaps only 2 vertices. A valid permutation (that rotates the object in a physical way) will be obtained if one only uses permutations from the ``pgroup`` of the Polyhedron. On the other hand, allowing arbitrary rotations (applications of permutations) gives a way to follow named elements rather than indices since Polyhedron allows vertices to be named while Permutation works only with indices. Examples ======== >>> from sympy.combinatorics import Polyhedron, Permutation >>> from sympy.combinatorics.polyhedron import cube >>> cube = cube.copy() >>> cube.corners (0, 1, 2, 3, 4, 5, 6, 7) >>> cube.rotate(0) >>> cube.corners (1, 2, 3, 0, 5, 6, 7, 4) A non-physical "rotation" that is not prohibited by this method: >>> cube.reset() >>> cube.rotate(Permutation([[1, 2]], size=8)) >>> cube.corners (0, 2, 1, 3, 4, 5, 6, 7) Polyhedron can be used to follow elements of set that are identified by letters instead of integers: >>> shadow = h5 = Polyhedron(list('abcde')) >>> p = Permutation([3, 0, 1, 2, 4]) >>> h5.rotate(p) >>> h5.corners (d, a, b, c, e) >>> _ == shadow.corners True >>> copy = h5.copy() >>> h5.rotate(p) >>> h5.corners == copy.corners False z(Polyhedron and Permutation sizes differ.N) isinstancerr rrr0rrrrr)r)permr"rDrs r%rotatePolyhedron.rotatest$%%;;t$DyyDII% !KLL OO/4S5F/GH/G!<<%/GHg Is7B$c,URSUlg)aReturn corners to their original positions. Examples ======== >>> from sympy.combinatorics.polyhedron import tetrahedron as T >>> T = T.copy() >>> T.corners (0, 1, 2, 3) >>> T.rotate(0) >>> T.corners (0, 2, 3, 1) >>> T.reset() >>> T.corners (0, 1, 2, 3) rN)r#rr(s r%resetPolyhedron.resetDs" !  r+)rr>)rP)__name__ __module__ __qualname____firstlineno____doc__r>rpropertyrverticesr0r4rrr rFrKrN__static_attributes__rPr+r%rr s(Fm^ *H 886 9 9""   0B'H%r+rcd^^Sn/SQn[/SQS//5[/SQS//5[/SQS//5[/S QS //5[SS/S S//5[SS /SS//5[SS/SS //5/n[[S 5UU5n/S Qn/S Q/SQ/SQ/SQ/SQ/SQ/SQ/SQ/SQ/SQ/SQ/SQ/SQ4 Vs/sHn[U5PM nn[[S5UU5n/SQn[[S5UU"XtU55n /SQn UU4Sjn [/SQ5m[/S Q5mTT/S!R5R 5V s/sH o"U 5PM sn -n [[S"5U U 5n/S#Qn[[S$5UU"XU 55nX7XUXUX4 $s snfs sn f)%a Return the permutation groups for each of the polyhedra and the face definitions: tetrahedron, cube, octahedron, dodecahedron, icosahedron, tetrahedron_faces, cube_faces, octahedron_faces, dodecahedron_faces, icosahedron_faces Explanation =========== (This author did not find and did not know of a better way to do it though there likely is such a way.) Although only 2 permutations are needed for a polyhedron in order to generate all the possible orientations, a group of permutations is provided instead. A set of permutations is called a "group" if:: a*b = c (for any pair of permutations in the group, a and b, their product, c, is in the group) a*(b*c) = (a*b)*c (for any 3 permutations in the group associativity holds) there is an identity permutation, I, such that I*a = a*I for all elements in the group a*b = I (the inverse of each permutation is also in the group) None of the polyhedron groups defined follow these definitions of a group. Instead, they are selected to contain those permutations whose powers alone will construct all orientations of the polyhedron, i.e. for permutations ``a``, ``b``, etc... in the group, ``a, a**2, ..., a**o_a``, ``b, b**2, ..., b**o_b``, etc... (where ``o_i`` is the order of permutation ``i``) generate all permutations of the polyhedron instead of mixed products like ``a*b``, ``a*b**2``, etc.... Note that for a polyhedron with n vertices, the valid permutations of the vertices exclude those that do not maintain its faces. e.g. the permutation BCDE of a square's four corners, ABCD, is a valid permutation while CBDE is not (because this would twist the square). Examples ======== The is_group checks for: closure, the presence of the Identity permutation, and the presence of the inverse for each of the elements in the group. This confirms that none of the polyhedra are true groups: >>> from sympy.combinatorics.polyhedron import ( ... tetrahedron, cube, octahedron, dodecahedron, icosahedron) ... >>> polyhedra = (tetrahedron, cube, octahedron, dodecahedron, icosahedron) >>> [h.pgroup.is_group for h in polyhedra] ... [True, True, True, True, True] Although tests in polyhedron's test suite check that powers of the permutations in the groups generate all permutations of the vertices of the polyhedron, here we also demonstrate the powers of the given permutations create a complete group for the tetrahedron: >>> from sympy.combinatorics import Permutation, PermutationGroup >>> for h in polyhedra[:1]: ... G = h.pgroup ... perms = set() ... for g in G: ... for e in range(g.order()): ... p = tuple((g**e).array_form) ... perms.add(p) ... ... perms = [Permutation(p) for p in perms] ... assert PermutationGroup(perms).is_group In addition to doing the above, the tests in the suite confirm that the faces are all present after the application of each permutation. References ========== .. [1] https://dogschool.tripod.com/trianglegroup.html c[US5n[[U[[U5555n[ U5n/nUHnUR 5nUR U5 URn [UV s/sHoU PM sn U5n U V s/sH$n [[[[U SS955PM& n n UR[U V s/sHoU PM sn 55 M U$s sn fs sn fs sn f)NrF)r)rdictziprr copyrKrr rmapr r appendr) polyh ordered_facesr nfmap flat_faces new_pgroupphr/jreorderr!s r%_pgroup_of_double(_pgroup_calcs.._pgroup_of_doubles  a ! C c-0134]+  A A HHQK A z :z!1z :A>G!() '1Sa%023 ' )   dW#=WGW#=> ?!;) $>s>C8 +C=D)rr=rrmrror=r=rmrorqrrlro)rrormr=rprm))rr=rmro)rr=rr)r=rmrs)rmrort)rrorurr)rrrsrtru)r=rmrorrsrtrurr)rrrrorursr=rmrt)rrrsr=rrurtrmro)r=rrrrsrmrorurt)rtrmr=rsrurorrr)rtrurormrsrrrr=)rorurrrrmrtrsr=)rrrurtrsrrormr=)rtrsrrrurmr=rro)rrorurrr=rmrtrs)rsr=rrrrtrmroru)rsrtrmr=rrruror)rurrrrortrsr=rm)rlrnrrorr)rr=rr)r=rmrs)rmrors)rorrrs)r=rrrsrt) )rr=rmrorr)rr=rt rs)r=rmrurrt)rmrorv ru)rorr rv)rrrrzrs)rsrxr|)rtrxr}r)rurrry)rvryrr{)rzr{rr~r|)r~r}rrrc>[[S55/nSnUH@nUS;a[U5S- nOSnUS:XaTnOUS:XaTnURU/U-5 MB [R"U6$)N01r=01)rrintextendrmul)srvrfsicount_f0_f1s r%_string_to_perm&_pgroup_calcs.._string_to_perm su59o  B~B! 9A3YA IIqc%i yy"~r+)r=rmrorrrrtrurvrzrsrryr{r|rxr}rrrr~)rsrrrrzr|rxr=ror{r~rtrmrvrr}rrruryrz 0104 140 014 0410 010 1403 03104 04103 102 120 1304 01303 021302 03130 0412041 041204103 04120410 041204104 041204102 10 01 1402 0140 04102 0412 1204 1302 0130 03120r)rlrnrw)rrrrs)rr=rs)r=rtru)r=rmru)rmrurv)rmrorv)rorvrz)rorrrz)rrrzrx)rrrsrx)rsrtrx)r=rsrt)rtrur)rurvr)rvrzr)rzrxr)rtrxrry)rrrstripsplit)rjtetrahedron_faces _t_pgroup tetrahedron cube_facesrf _c_pgroupcubeoctahedron_faces octahedrondodecahedron_facesrr_dodeca_pgroup dodecahedronicosahedron_faces icosahedronrrs @@r% _pgroup_calcsrXs7`4 i!  i!  i!  i!  q!fq!f  q!fq!f  q!fq!f I aK J !               a  &  a D   a$I68J   , -C , -C 3Z@7 8=uwuuw @G#H@G!?1#5@G#HHN b L F  b  n >?K z'7 //} L#Hs =F(F-r=rmrorrrsrtrurvrzrxrryr{r|r~r}rrrN) sympy.combinatoricsrrsympy.combinatorics.perm_groupsr sympy.corerrr sympy.setsrsympy.utilities.iterablesr r r sympy.utilities.miscr rrrrrrrrrrrrrrr)args0r%rs3<55 BB' yyJ %J %Zg/` !Q1  aA aA aA aA    Q1  Q1a Q1  Q1  Q 1a Q 1a Q 1a " !Q1aAq!  aAq aAq aAq aAq aAq aAq   Q1aAq!$ Q1aAq!$ Q1aAq!$ Q 1aAq!$ Q 1aAq!$ Q 1aAq!$ Q 1aAq!$ Q 1aAq!$ Q 1aAq!$ Q1 aA Q1aAq! Q1 aA Q1 aA  !0 !Q1a  aA aA aA aA aA aA aA aA  Q1a Q1a Q1a Q 1aA Q 1aA Q 1aA Q 1aA Q 1aA Q 1aA Q1 aA Q1 aA Q1 aA Q1 aA  ! 4 !Q1aAq!QBBBBBO  aAq! aAr1 aAr1 aAr1 aAr1 aAr1 aRR  aRR  aRR  aRR  aRR  b"b"b! # M Q1aAq!Q*2r2r2>r2r2rRM Q2q!Q2r2.q!RQ?2r2rRM QBAq!RA.q!RQ?2r2rRM Q2r1aRQ/1b!Q?2r2rR M Q2r2q!RQ/1b!Q?2r2rR M Q1b!Q2r2.q!RQ?2r2rR M Q 1aB1%a,Q3Ar:2rB2rJ2rRM Q 1aAq"%a,Q3Ar:2rB2rJ2rRM Q Aq!Q1%a,Q3Ar:2rB2rJ2rRM Q 1b!Q1%a,Q3Ar:2rB2rJ2rRM Q 1aB1%a,Q3Ar:2rB2rJ2rRM Q 1b!R B'2.q!4Q;ArB2rJ2rRM Q Aq!R B'2.q!4Q;ArB2rJ2rRM Q Ar1a B'2.q"5a;ArB2rJ2rRM Q Ar1b!!Q'2.q"5a Q2q"b!!R,QA6q"bA!QK?M.N ` !Q1aAq!QB/  aA aA aA aA aA aA aA aA aA aA aA aB aB aB aA aB aB aB aR aR)* 4 RAq!Q1aB/4 Q1aAq"b!,4 Q1aAq!R+4 Q1aAq"b!, 4 Q1b!Q1b!, 4 Q2q!Q1b!, 4 Q 1aAq!$Q+Ar24 Q 1aAq!$Q*2r24 Q 1aAq!$Q+Ar24 Q 1aB1%a+Ar24 Q 1aB1%a+Ar24 Q 1aB2&q!,Q24 Q 1aAq"%a+Ar24 Q 1aAq!$Q+Ar24 Q 1b!R A&q!,Q24 Q Aq!R A&q!,Q2!4" Q Aq!R A&q!,Q2#4$ Q Aq!Q1%a,Q2%4& Q Ar1a A&q!,Q2'4( Q Aq!Q2&q!,Q2)4* Q Aq!Q1%a+Ar2+4, Q1 aAq"a(Ar2-4. Q1 aAq!Q'2r2/40 Q1 aAq!Q'2r2142 Q1 aB1a(Ar2344 Q1 aB1a(Ar2546 QAq!Q1b)!Q2748 Q1 aAq!R(B294: Q1 aQ1a(Ar2;4< Q2q!Q2q)!Q2=4> Q1 aB1a(B2?4/65 p,7+<+<=+,>?,>SeCj,>?+6+<+<=+ /;?=s(C6AFDAFD<AF"EAF'FAF,