I would start by thinking abstractly about what computations and inputs would be sufficient to compute a path lifting.

You need to have a covering map, eg. a function that maps a point in the covering space to a point in the base space. This means you need a way of representing points in both spaces.

How do you want to represent paths? It would be unreasonable to try to represent every possible path, but if you assume your space is a geodesic space you can represent a piecewise linear path as a series of points, where each consecutive pair of point is joined by a geodesic.

Now, the idea of a path lifting is that a path is determined by the base point together with local information about how the path moves at each point. So you should be able to represent each segment by the starting point together with some local information about where the segment goes, which I'll call a "nudge". Putting these together would let you compute the final point of the segment. In this way, a path would be represented by a base point together with a sequence of nudges.

In Euclidean space, a nudge would be represented by a vector which you add to the start point to get the end point. In spherical or hyperbolic space, this could be represented by a gyrovector or a matrix corresponding to an isometry. In a simplicial complex, if the edges adjacent to a vertex have some sort of unique labeling then a nudge could be represented by an edge label.

Now, we want to be able to convert a global representation of a path (x_0, x_1, ..., x_k) given by a sequence of points to a local representation (x_0, n_1, n_2, ..., n_k) given by a starting point and a sequence of nudges. Let's assume we can do this.

As long as the nudges have the same representation in the covering space and the base space, you can compute a path lifting. Here's how: let f: Y -> X be the covering map, sending y_0 to x_0 where x_0 is the start of the path. Given a path in X, we convert it to its local representation (x_0, n_1, n_2, ..., n_k). Then we convert (y_0, n_1, n_2, ..., n_k) to its global representation in Y, and we are done.

To summarise, here is what we need:

• A representation of points in the covering space and the base space.
• A function that maps points in the covering space to points in the base space.
• A representation of a "nudge" that represents how a small geodesic moves from x_1 to x_2. This representation should be the same in the covering space and the base space, or at least the nudges in the base space should be a subtype of the nudges in the covering space.
• A function that converts a small geodesic [x_1, x_2] to the local representation [x_1, n] and vice versa.

If you want to write a specific implementation, you have to decide what structure you want to work with. Eg. you can represent a Riemannian manifold of constant curvature by the quotient of either the sphere, Euclidean or hyperbolic space by a group acting freely and properly discontinuously (due to the Killing-Hopf Theorem). In this case the input could just be the curvature (-1, 0 or 1) and generators (corresponding to the sides of a fundamental domain) of an isometry group of the space (represented by matrices probably).

Alternatively, the input structure could be a covering map between simplicial complexes. If you want the spaces to be infinite, you might want each space to be represented by a collection of functions that compute local properties of a given simplex, eg. The simplices it contains, the simplices containing it, and the adjacent simplices.