If you are trying to find relationships between two structures, at the beginning the algorithm itself is not important. What really matters is the function f and how this function can map objects from one structure to other one, while the relationships between objects (that you have defined before) are guaranteed. Once you have proved that f performs the map that you are looking for (injection, surjection, bijection, etc.), you have to prove that the algorithm that you are proposing is an implementation of the function f. As you say, the simplicity of the function is a good way to show that both structures are similars, but it would be more important to show that you can solve the same (or equivalent) problems in the resulting structure easier than in the original one. In other words, a good metric to verify for the quality of your function is by showing that the complexity (time/space) of solving equivalent problems in the original structure is bigger than the complexity of the mapping function itself + complexity of solving the equivalent problem in the resulting structure.

I'm assuming you aren't looking at "efficient" algorithms.  Several things come to mind:

1)  How can you encode or describe a mathematical object?  For example graphs can be described in numerous ways.  

2)  Does the object involve numbers?  If a description isn't a simple "one-to-one" encoding/decoding, it sometimes works for or against you.  Some algorithms can be build upon reductions that will preserve objects sitting within your entire set (of the structure) but you have to include additional feasibility checks.  For example, if your problem has anything to do with 0-1 Knapsack, try to exploit its Dynamic Programming algorithm.  If not, one common trick is to turn it into a graph or design, if possible.

3)  From experience and what I normally see in generation algorithms or enumeration algorithms (as this is used all the time there) is that a correspondence is found (you want an IFF relationship usually).  Sometimes (2) can throw a wrench in this step.

4)  The algorithm exploits (3).  People like myself that do research in this area will try to come up with new ways to do (3), or ways to exploit (1).  If you can do (1) well, your algorithm may be very efficient.  A class of algorithms I want to point out are loopless algorithms.  Take O(n) steps to construct the first object, then O(1) for each consecutive object.  So the running time (if exponential in size) will depend on the size of the set typically---which is pretty efficient if you want the whole object.  There are trade-offs even with this approach.

Keep in mind the intuition involved with finding the mapping does not always come in the order I gave.  Personally when it comes to attributes, some of the points I made in (4) are relevant, but fundamentally I am not sure if you are talking about properties problems have, or attributes as in a subjective construct that I can't prove something about.  I had a bit of trouble interpreting your question as it was not as concrete as we could make this (entire areas of Combinatorics and Theoretical Computer Science work in this area), but I hope this helps. 

In closing, here are two handy references that may help you some more.  They cover most concepts ranging from brute-force-and-ignorance to many loopless algorithms:

1)  (my favourite, very straight to the point and lays out a lot of common and classic techniques these days, a bit harder to get your hands on though) Combinatorial Algorithms,  Reingold et al., 1977.

2) (a standard text in the area of combinatorial algorithms, very accessible) Combinatorial Algorithms: Generation, Enumeration & Search, Kreher and Stinson, 1998. 

If you want to reduce a structure A to a structure B thru some procedure P, the first question is: Is P a polynomial time procedure? I.e. can you transform A to B using P in polynomial time (or, the time you need it to be), and vice versa: Is B reducible to A using P, in polynomial time. If the answer is YES, than you know that A, and B are in the same class of complexity, i.e. both are polynomial.

Now, if you know the "natural" structure B only partially, than you may start identifying elements of B with respect to A using fixed points algorithm.

Hope it will be helpful.