snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/raytracing/additional_len_spec_choices.py

@@ -0,0 +1,63 @@
+"""
+from snappy import *; from snappy.raytracing.additional_len_spec_choices import *
+
+M=Manifold("t10879")
+M=CubicalOrientableCuspedCensus[0]
+v = M.inside_view()
+a=AdditionalLenSpecChoices(M)
+v.view.widget.additional_structures['lenSpec'] = a; v.view.widget._update_shader()
+
+"""
+
+from ..len_spec import mcomplex_for_len_spec
+
+from .pack import pack_tet_data
+from .upper_halfspace_utilities import add_coordinate_transform_to_mcomplex
+from ..snap.t3mlite import simplex
+
+class AdditionalLenSpecChoices:
+    def __init__(self, manifold):
+
+        self.mcomplex = mcomplex_for_len_spec(
+            manifold, bits_prec = 53, verified = False)
+        add_coordinate_transform_to_mcomplex(self.mcomplex)
+
+        self._num = 0
+
+        self.compute_bindings()
+
+    def get_compile_time_defs(self):
+        if self._num > 0:
+            num = max(100, self._num)
+        else:
+            num = 0
+
+        return { 'num_additional_horospheres' : num,
+                 'has_edge_midpoints' : 1}
+
+    def get_uniform_bindings(self):
+        return self._uniform_bindings
+
+    def compute_bindings(self):
+        self._uniform_bindings, self._num = pack_tet_data(
+            'additionalHorospheres.horosphere',
+            self._get_data())
+        self._uniform_bindings['edgeMidpoints.edgeMidpointVec'] = (
+            'vec4[]', [ tet.to_coordinates_in_symmetric_tet * tet.spine_points[e]
+                        for tet in self.mcomplex.Tetrahedra
+                        for e in simplex.OneSubsimplices ])
+        self._uniform_bindings['edgeMidpointRadiusParam'] = (
+            'float', 1.002)
+
+    def _get_data(self):
+        return [ [ _data_for_vert(tet, v) for v in simplex.ZeroSubsimplices ]
+                 for tet in self.mcomplex.Tetrahedra ]
+
+def _data_for_vert(tet, v):
+    return {
+        'Vec' :(
+            'vec4',
+            tet.to_coordinates_in_symmetric_tet * tet.R13_vertices[v]),
+        'CuspIndex' : (
+            'int',
+            tet.Class[v].Index) }

snappy/raytracing/cohomology_fractal.py

@@ -0,0 +1,197 @@
+from snappy.ptolemy.homology import homology_basis_representatives_with_orders
+
+"""
+Helpers to compute weights for faces corresponding to a 2-cocycle. Used to
+visualize cohomology fractals.
+
+The weights for the faces are stored in the order
+[face 0 tet 0, face 1 tet 0, ... face 3 tet 0, face 0, tet 1, ...].
+
+Note that we also use face classes (consisting each of two
+faces). Some helpers convert weights stored per face class to weights
+stored per face per tetrahedron.
+"""
+
+
+def face_var_name_to_index(var_name):
+    """
+    Convert variable name to index in array of weights.
+
+        >>> face_var_name_to_index('s_2_5')
+        22
+
+    """
+
+    name, face_index, tet_index = var_name.split('_')
+    if name != 's':
+        raise AssertionError(
+            "Variable name '%s' for face class invalid" % var_name)
+    return 4 * int(tet_index) + int(face_index)
+
+
+def value_for_face_class(weights, face_class):
+    """
+    Given weights per face per tetrahedron and a face_class as encoded
+    by the ptolemy module, extract the weight for that face_class and
+    perform consistency check.
+    """
+
+    sgn, power, repr0, repr1 = face_class
+
+    # Weight for one representative of face class
+    val0 = weights[face_var_name_to_index(repr0)]
+    # Weight for other representative of face class
+    val1 = weights[face_var_name_to_index(repr1)]
+
+    # Check weights match
+    if abs(val0 - sgn * val1) > 1e-6:
+        raise ValueError("Weights for identified faces do not match")
+
+    return val0
+
+
+def check_weights_valid(trig, weights):
+    """
+    Given a SnapPy triangulation and weights per face per tetrahedron,
+    check they are consistent across glued faces and form a 2-cocycle.
+
+        >>> check_weights_valid(Manifold("m015"), [1, 0, 0, 0, -1, 0, 0, 1, -1, 0, 0, 0])
+        >>> check_weights_valid(Manifold("m004"), [0, 1, 0, 1, 0, 0, -1, -2])
+        Traceback (most recent call last):
+           ...
+        ValueError: Weights for identified faces do not match
+        >>> check_weights_valid(Manifold("m003"), [1, 0, 0, 2, -1, 0, 0, -2])
+        Traceback (most recent call last):
+           ...
+        ValueError: Weights are not a 2-cocycle.
+
+    """
+
+    face_classes = trig._ptolemy_equations_identified_face_classes()
+
+    check_face_class_weights_valid(
+        trig,
+        [ value_for_face_class(weights, face_class)
+          for face_class in face_classes ])
+
+
+def check_face_class_weights_valid(trig, weights):
+    """
+    Given a SnapPy triangulation and weights per face class, check they
+    form a 2-cocycle.
+    """
+    matrix, edge_labels, face_labels = (
+        trig._ptolemy_equations_boundary_map_2())
+    for row in matrix:
+        total = sum(entry * weight for entry, weight in zip(row, weights))
+        if abs(total) > 1e-6:
+            raise ValueError("Weights are not a 2-cocycle.")
+
+
+def compute_signs_and_face_class_indices(trig):
+    """
+    An array helpful to convert weights per face class to weights per
+    face per tetrahedron. The entries are per face per tetrahedron and
+    are a pair (sign adjustment, face class index).
+    """
+
+    result = (4 * trig.num_tetrahedra()) * [ None ]
+    face_classes = trig._ptolemy_equations_identified_face_classes()
+    for i, face_class in enumerate(face_classes):
+        sgn, power, repr0, repr1 = face_class
+        result[face_var_name_to_index(repr0)] = ( +1, i)
+        result[face_var_name_to_index(repr1)] = (sgn, i)
+    return result
+
+
+def rational_cohomology_basis(trig):
+    """
+    Given a SnapPy triangulation, give 2-cocycles encoded as weights
+    per face per tetrahedron that generate the second rational cohomology
+    group.
+
+        >>> rational_cohomology_basis(Manifold("m125"))
+        [[-1, -4, -2, 0, 1, 0, 0, 0, 0, 4, 1, 2, -1, 0, 0, 0], [0, 5, 2, 0, 0, 0, 0, 1, 0, -5, 0, -2, 0, 0, 0, -1]]
+
+    """
+
+    signs_and_face_class_indices = compute_signs_and_face_class_indices(
+        trig)
+
+    matrix2, edge_labels, face_labels = (
+        trig._ptolemy_equations_boundary_map_2())
+    matrix3, face_labels, tet_labels = (
+        trig._ptolemy_equations_boundary_map_3())
+
+    two_cocycles_and_orders = (
+        homology_basis_representatives_with_orders(
+            matrix2, matrix3, 0))
+
+    rational_two_cocycles = [
+        two_cocycle
+        for two_cocycle, order in two_cocycles_and_orders
+        if order == 0 ]
+
+    # Expand two cocycles which assign a weight to each face class
+    # to weights per face per tetrahedron
+    return [
+        [ sgn * two_cocycle[index]
+          for sgn, index in signs_and_face_class_indices ]
+        for two_cocycle in rational_two_cocycles ]
+
+
+def compute_weights_basis_class(trig, cohomology_class):
+    """
+    Convenience method to quickly access cohomology classes for
+    M.inside_view().
+
+        >>> compute_weights_basis_class(Manifold("m004"), None)
+        (None, None, None)
+        >>> compute_weights_basis_class(Manifold("m003"), [1, 0, 0, 1, -1, 0, 0, -1])
+        ([1, 0, 0, 1, -1, 0, 0, -1], None, None)
+        >>> compute_weights_basis_class(Manifold("m003"), 0)
+        (None, [[1, 0, 0, 1, -1, 0, 0, -1]], [1.0])
+        >>> compute_weights_basis_class(Manifold("m125"), 0)
+        (None, [[-1, -4, -2, 0, 1, 0, 0, 0, 0, 4, 1, 2, -1, 0, 0, 0], [0, 5, 2, 0, 0, 0, 0, 1, 0, -5, 0, -2, 0, 0, 0, -1]], [1.0, 0.0])
+        >>> compute_weights_basis_class(Manifold("m125"), 1)
+        (None, [[-1, -4, -2, 0, 1, 0, 0, 0, 0, 4, 1, 2, -1, 0, 0, 0], [0, 5, 2, 0, 0, 0, 0, 1, 0, -5, 0, -2, 0, 0, 0, -1]], [0.0, 1.0])
+        >>> compute_weights_basis_class(Manifold("m125"), [0.5, 0.5])
+        (None, [[-1, -4, -2, 0, 1, 0, 0, 0, 0, 4, 1, 2, -1, 0, 0, 0], [0, 5, 2, 0, 0, 0, 0, 1, 0, -5, 0, -2, 0, 0, 0, -1]], [0.5, 0.5])
+
+    """
+
+    # If no cohomology_class specified, just return None
+    if cohomology_class is None:
+        return None, None, None
+
+    try:
+        as_list = list(cohomology_class)
+    except TypeError:
+        as_list = None
+
+    if as_list:
+        # User can give a weight for each tetrahedron
+        if len(as_list) == 4 * trig.num_tetrahedra():
+            check_weights_valid(trig, as_list)
+            return as_list, None, None
+
+        # User can specify super position of basis two-cocycles,
+        # that is a number for each element in the basis.
+        basis = rational_cohomology_basis(trig)
+        if len(as_list) == len(basis):
+            return None, basis, as_list
+
+        raise ValueError(
+            ("Expected array of length %d or %d either assigning one number "
+             "for each basis vector of the second rational cohomology group "
+             "or one weight per face "
+             "and tetrahedron.") % (len(basis), 4 * trig.num_tetrahedra()))
+    else:
+        # User can just specify an integer to pick one of the basis
+        # two-cocycles generating the cohomology.
+        basis = rational_cohomology_basis(trig)
+
+        c = range(len(basis))[cohomology_class]
+
+        return None, basis, [ 1.0 if i == c else 0.0
+                              for i in range(len(basis)) ]

snappy/raytracing/eyeball.py

@@ -0,0 +1,124 @@
+from ..hyperboloid import o13_inverse
+from ..hyperboloid.point import R13Point
+
+from ..tiling.tile import compute_tiles
+from ..tiling.lifted_tetrahedron import LiftedTetrahedron
+from ..tiling.lifted_tetrahedron_set import (LiftedTetrahedronSet,
+                                             get_lifted_tetrahedron_set)
+from ..tiling.triangle import add_triangles_to_tetrahedra
+
+from ..matrix import make_matrix, make_vector
+
+from ..matrix import matrix
+
+import math
+
+eyeball_type_none = 0
+eyeball_type_paper_plane = 1
+eyeball_type_eyeball = 2
+
+_max_num_eyeballs = 40
+
+class Eyeball:
+    def __init__(self, raytracing_view):
+        self.raytracing_view = raytracing_view
+
+        self.mcomplex = self.raytracing_view.raytracing_data.mcomplex
+        self.num_tetrahedra = len(self.mcomplex.Tetrahedra)
+
+        self._added_triangles = False
+
+    def _enabled(self):
+        return (
+            self.raytracing_view.ui_parameter_dict['eyeballSize'][1] > 0 and
+            self.raytracing_view.ui_parameter_dict['eyeballType'][1] > eyeball_type_none)
+
+    def get_compile_time_defs(self):
+        if not self._enabled():
+            return {}
+
+        d = { 'num_eyeballs' : _max_num_eyeballs,
+              'eyeball_type' : self.raytracing_view.ui_parameter_dict['eyeballType'][1]}
+
+        return d
+
+    def get_uniform_bindings(self):
+        if not self._enabled():
+            return {}
+
+        if not self._added_triangles:
+            add_triangles_to_tetrahedra(self.mcomplex)
+            self._added_triangles = True
+
+        view_state = self.raytracing_view.ui_parameter_dict.get('eyeballViewState')
+        if not view_state or (
+                not self.raytracing_view.ui_parameter_dict['freezeEyeball'][1]):
+            self.raytracing_view.ui_parameter_dict['eyeballViewState'] = (
+                'viewState', self.raytracing_view.view_state)
+
+        boost, tet_num, current_weight = (
+            self.raytracing_view.ui_parameter_dict['eyeballViewState'][1])
+
+        RF = self.raytracing_view.raytracing_data.RF
+        
+        boost = make_matrix(boost, ring=RF)
+
+        base_point = make_vector([b[0] for b in boost])
+
+        eyeballRadius = self.raytracing_view.ui_parameter_dict['eyeballSize'][1]
+        if self.raytracing_view.ui_parameter_dict['eyeballType'][1] == eyeball_type_eyeball:
+            eyeballRadius = eyeballRadius / 2.0
+        tets_to_data = [ [] for i in range(self.num_tetrahedra) ]
+
+        initial_lifted_tetrahedron = LiftedTetrahedron(
+            self.mcomplex.Tetrahedra[tet_num], matrix.identity(RF, 4))
+
+        cut_off = RF(1.0 + 1e-5)
+
+        lifted_tetrahedron_set : LiftedTetrahedronSet = (
+            get_lifted_tetrahedron_set(
+                base_point=base_point,
+                act_on_base_point_by_inverse=True,
+                max_neg_prod_equal=cut_off,
+                min_neg_prod_distinct=cut_off,
+                canonical_representatives_function=None,
+                verified=False))
+
+        for i, tile in enumerate(
+                compute_tiles(
+                    geometric_object=R13Point(base_point),
+                    visited_lifted_tetrahedra=lifted_tetrahedron_set,
+                    initial_lifted_tetrahedra=[ initial_lifted_tetrahedron ],
+                    verified=False)):
+
+            if i == _max_num_eyeballs:
+                break
+            if tile.lower_bound_distance > eyeballRadius:
+                break
+
+            m = o13_inverse(boost) * tile.lifted_tetrahedron.o13_matrix
+
+            tets_to_data[tile.lifted_tetrahedron.tet.Index].append((
+                tile.inverse_lifted_geometric_object.point,
+                m,
+                o13_inverse(m)))
+        
+        eyeballPositions = []
+        eyeballInvEmbeddings = []
+        eyeballEmbeddings = []
+        eyeballOffsets = []
+
+        for data in tets_to_data:
+            eyeballOffsets.append(len(eyeballPositions))
+            for eyeballPosition, eyeballInvEmbedding, eyeballEmbedding in data:
+                eyeballPositions.append(eyeballPosition)
+                eyeballInvEmbeddings.append(eyeballInvEmbedding)
+                eyeballEmbeddings.append(eyeballEmbedding)
+        eyeballOffsets.append(len(eyeballPositions))
+
+        return {
+            'eyeballRadius' : ('float', eyeballRadius),
+            'eyeballs.eyeballPositions' : ('vec4[]', eyeballPositions),
+            'eyeballs.eyeballInvEmbeddings' : ('mat4[]', eyeballInvEmbeddings),
+            'eyeballs.eyeballEmbeddings' : ('mat4[]', eyeballEmbeddings),
+            'eyeballs.eyeballOffsets' : ('int[]', eyeballOffsets) }

snappy/raytracing/finite_raytracing_data.py

@@ -0,0 +1,237 @@
+from snappy.snap import t3mlite as t3m
+from snappy import Triangulation
+
+from ..matrix import make_matrix, make_vector
+
+from ..upper_halfspace import pgl2c_to_o13
+
+# We could use
+#
+# from ..sage_helper import _within_sage
+#
+# but then dev/GLSLFiniteInsideView.py cannot be used for
+# debugging anymore.
+
+try:
+    import sage.all
+    _within_sage = True
+except ImportError:
+    _within_sage = False
+    import decorator
+
+if _within_sage:
+    from snappy.dev.vericlosed import compute_approx_hyperbolic_structure_orb
+    from snappy.dev.vericlosed.polishApproxHyperbolicStructure import *
+
+    from snappy.dev.vericlosed.truncatedComplex import *
+
+from .hyperboloid_utilities import *
+
+from .raytracing_data import *
+
+__all__ = ['FiniteRaytracingData']
+
+
+class FiniteRaytracingData(RaytracingData):
+    @staticmethod
+    def from_triangulation(triangulation, weights=None):
+
+        if not _within_sage:
+            raise Exception("Only supported within SageMath :(")
+
+        hyperbolic_structure = compute_approx_hyperbolic_structure_orb(triangulation)
+        hyperbolic_structure.pick_exact_and_var_edges()
+        hyperbolic_structure = polish_approx_hyperbolic_structure(
+            hyperbolic_structure, bits_prec=212)
+
+        r = FiniteRaytracingData(hyperbolic_structure)
+
+        r.RF = hyperbolic_structure.edge_lengths[0].parent()
+
+        r._compute_matrices(hyperbolic_structure)
+
+        r._compute_tet_vertices()
+        r._compute_edge_ends()
+        r._compute_planes()
+        r._compute_face_pairings()
+
+        r.add_weights(weights)
+
+        return r
+
+    def __init__(self, hyperbolic_structure):
+        super().__init__(
+            hyperbolic_structure.mcomplex)
+
+    def _compute_matrices(self, hyperbolic_structure):
+        for tet in self.mcomplex.Tetrahedra:
+            tet.permutahedron_matrices = _matrices_for_tet(
+                hyperbolic_structure, tet.Index)
+
+    def _compute_tet_vertices(self):
+        c = make_vector([1, 0, 0, 0], ring=self.RF)
+
+        def _compute_vertex(tet, perm):
+            m = tet.permutahedron_matrices[perm]
+            return pgl2c_to_o13(_adjoint(m)) * c
+
+        for tet in self.mcomplex.Tetrahedra:
+            tet.R13_vertices = {
+                t3m.V0 : _compute_vertex(tet, (0,1,3,2)),
+                t3m.V1 : _compute_vertex(tet, (1,0,2,3)),
+                t3m.V2 : _compute_vertex(tet, (2,0,3,1)),
+                t3m.V3 : _compute_vertex(tet, (3,0,1,2)) }
+
+    def _compute_edge_ends(self):
+        cs = [ make_vector([1,  1, 0, 0], ring=self.RF),
+               make_vector([1, -1, 0, 0], ring=self.RF) ]
+
+        def _compute_edge_ends(tet, perm):
+            m = tet.permutahedron_matrices[perm]
+            return [ pgl2c_to_o13(_adjoint(m)) * c for c in cs ]
+
+        for tet in self.mcomplex.Tetrahedra:
+            tet.R13_edge_ends = {
+                t3m.E01 : _compute_edge_ends(tet, (0,1,2,3)),
+                t3m.E02 : _compute_edge_ends(tet, (0,2,1,3)),
+                t3m.E12 : _compute_edge_ends(tet, (2,1,0,3)),
+                t3m.E03 : _compute_edge_ends(tet, (0,3,1,2)),
+                t3m.E13 : _compute_edge_ends(tet, (1,3,0,2)),
+                t3m.E23 : _compute_edge_ends(tet, (2,3,0,1)) }
+
+    def _compute_planes(self):
+        c = make_vector([0.0, 0.0, 0.0, -1.0], ring=self.RF)
+
+        def _compute_plane(tet, perm):
+            m = tet.permutahedron_matrices[perm]
+            v = c * pgl2c_to_o13(m)
+            return make_vector([-v[0], v[1], v[2], v[3]])
+
+        for tet in self.mcomplex.Tetrahedra:
+            tet.R13_planes = {
+                t3m.F0 : _compute_plane(tet, (2,3,1,0)),
+                t3m.F1 : _compute_plane(tet, (0,3,2,1)),
+                t3m.F2 : _compute_plane(tet, (0,1,3,2)),
+                t3m.F3 : _compute_plane(tet, (0,2,1,3)) }
+
+    def _compute_face_pairings(self):
+        for tet in self.mcomplex.Tetrahedra:
+            tet.O13_matrices = {
+                F : _compute_face_pairing(tet, F)
+                for F in t3m.TwoSubsimplices }
+
+    def _check_consistency(self):
+        for tet in self.mcomplex.Tetrahedra:
+            for F in t3m.TwoSubsimplices:
+                for V in t3m.ZeroSubsimplices:
+                    if V & F:
+                        v0 = tet.O13_matrices[F] * make_vector(tet.R13_vertices[V])
+                        v1 = tet.Neighbor[F].R13_vertices[tet.Gluing[F].image(V)]
+
+                        if abs(r13_dot(v0, v1) - (-1.0)) > 1e-6:
+                            print("Inconsistency ", tet.Index, F)
+                            print(v0)
+                            print(v1)
+
+    def get_uniform_bindings(self):
+        # self._check_consistency()
+
+        d = super().get_uniform_bindings()
+        d['TetrahedraEdges.R13EdgeEnds'] = (
+            'vec4[]',
+            [ edge_end
+              for tet in self.mcomplex.Tetrahedra
+              for E in t3m.OneSubsimplices
+              for edge_end in tet.R13_edge_ends[E] ])
+        d['isNonGeometric'] = (
+            'bool',
+            False)
+        d['nonGeometricTexture'] = (
+            'int',
+            0)
+
+        return d
+
+    def get_compile_time_constants(self):
+        d = super().get_compile_time_constants()
+        d[b'##finiteTrig##'] = 1
+        return d
+
+    def initial_view_state(self):
+        boost = make_matrix([[1.0,0.0,0.0,0.0],
+                             [0.0,1.0,0.0,0.0],
+                             [0.0,0.0,1.0,0.0],
+                             [0.0,0.0,0.0,1.0]])
+        tet_num = 0
+        weight = 0.0
+        return (boost, tet_num, weight)
+
+# 3
+#
+# Helpers
+#
+
+
+_face_to_perm = {
+    t3m.F0: t3m.Perm4((1,3,2,0)),
+    t3m.F1: t3m.Perm4((0,2,3,1)),
+    t3m.F2: t3m.Perm4((0,3,1,2)),
+    t3m.F3: t3m.Perm4((0,1,2,3))}
+
+
+def _compute_face_pairing(tet, F):
+    tet_perm = _face_to_perm[F]
+    m = tet.permutahedron_matrices[tet_perm.tuple()]
+
+    other_tet_perm = tet.Gluing[F] * tet_perm
+    other_tet = tet.Neighbor[F]
+    other_m = other_tet.permutahedron_matrices[other_tet_perm.tuple()]
+
+    return pgl2c_to_o13(_adjoint(other_m) * m)
+
+
+def _adjoint(m):
+    return make_matrix([[ m[1,1],-m[0,1]],
+                        [-m[1,0], m[0,0]]])
+
+
+_new_perm_edge_type_old_perm = [
+    ((1, 0, 2, 3), 'alpha', t3m.Perm4((0, 1, 2, 3))),
+    ((0, 2, 1, 3), 'beta', t3m.Perm4((0, 1, 2, 3))),
+    ((0, 1, 3, 2), 'gamma', t3m.Perm4((0, 1, 2, 3))),
+    ((1, 2, 0, 3), 'beta', t3m.Perm4((1, 0, 2, 3))),
+    ((1, 0, 3, 2), 'gamma', t3m.Perm4((1, 0, 2, 3))),
+    ((2, 0, 1, 3), 'alpha', t3m.Perm4((0, 2, 1, 3))),
+    ((0, 2, 3, 1), 'gamma', t3m.Perm4((0, 2, 1, 3))),
+    ((0, 3, 1, 2), 'beta', t3m.Perm4((0, 1, 3, 2))),
+    ((2, 1, 0, 3), 'alpha', t3m.Perm4((1, 2, 0, 3))),
+    ((1, 2, 3, 0), 'gamma', t3m.Perm4((1, 2, 0, 3))),
+    ((1, 3, 0, 2), 'beta', t3m.Perm4((1, 0, 3, 2))),
+    ((2, 0, 3, 1), 'gamma', t3m.Perm4((2, 0, 1, 3))),
+    ((0, 3, 2, 1), 'beta', t3m.Perm4((0, 2, 3, 1))),
+    ((3, 0, 1, 2), 'alpha', t3m.Perm4((0, 3, 1, 2))),
+    ((2, 1, 3, 0), 'gamma', t3m.Perm4((2, 1, 0, 3))),
+    ((1, 3, 2, 0), 'beta', t3m.Perm4((1, 2, 3, 0))),
+    ((3, 1, 0, 2), 'alpha', t3m.Perm4((1, 3, 0, 2))),
+    ((2, 3, 0, 1), 'beta', t3m.Perm4((2, 0, 3, 1))),
+    ((3, 0, 2, 1), 'alpha', t3m.Perm4((0, 3, 2, 1))),
+    ((2, 3, 1, 0), 'beta', t3m.Perm4((2, 1, 3, 0))),
+    ((3, 1, 2, 0), 'alpha', t3m.Perm4((1, 3, 2, 0))),
+    ((3, 2, 0, 1), 'alpha', t3m.Perm4((2, 3, 0, 1))),
+    ((3, 2, 1, 0), 'alpha', t3m.Perm4((2, 3, 1, 0))) ]
+
+
+def _matrices_for_tet(hyperbolic_structure, tet_num):
+    RF = hyperbolic_structure.vertex_gram_matrices[0].base_ring()
+    CF = RF.complex_field()
+
+    matrices = { (0, 1, 2, 3) : matrix.identity(CF, 2) }
+
+    for new_perm, edge_type, old_perm in _new_perm_edge_type_old_perm:
+        tet_edge = TruncatedComplex.Edge(edge_type, (tet_num, old_perm))
+
+        m = hyperbolic_structure.pgl2_matrix_for_edge(tet_edge)
+
+        matrices[new_perm] = m * matrices[old_perm.tuple()]
+
+    return matrices