Many types of encryption can be generalized as using a message $m$ and a key $k$ as input of an encryption function $f$ with a cipher $c$ as output.
$$f(m,k)=c$$
As a node graph this could look like this:
Given node $m$ it has one edge of progression. If an inverse function $f{^{-1}}$ exists we could use it as a 2nd edge at $m$. With this node $m$ would have 2 edges of progression. At node $c$ we can also add $f{^{-1}}$ back to $m$ and if $f$ is length preserving we can add $f$ to a new node $c'=f(c,\cdot)$. Reaping this over and over again we will end up in a node we already visited before (not all end up at $m$ again.)
My question is now if there are any type of encryption (or related) which provide message node $m$ more than two edges of progression. E.g. like this:
Here node $m$ has 3 edges of progression (or if we include not-drawn $f{^{-1}}$ it would be 4). This is only a sub-graph presenting some edges of progression for node $m$. To be complete the inverse of each progression function and many nodes with their related functions had to be added (the related function parameter $k$ as well). However connections don't need to exist like in between $b$ and $c$.
An (easy to break) encryption could be $g^{-1}(f(f(g(m))))=c$
This can be seen as a generalization of a cyclic group with an order of prime factors and that many related generators.
On target use case the security would rely at the number of edge progressions/functions needed in between two nodes.
Furthermore it need to be representable in 3D euclidean space with around equal note density. So with this the $n-$neighborhood of a node is limited to $24 n^2+1$ nodes (in mean, same as adjacent numbers in a $\mathbb{Z}^3$ space). Similar as above progression in one direction will result in node $m$ again after $D$ steps. Other than above this can be done in 3 orthogonal directions in $D_1, D_2, D_3$ steps of progression (in between start and end not 100% orthogonal needed). The total node number $N \ge D_1\cdot D_2\cdot D_3$ should be $< 2^{200}$ but finding the edge progression in between two random nodes should take in mean $>O(2^{100})$ progression steps. The random nodes need to be generated without leaking security related information. The progression functions and their inverses need to take about the same computation time. The adversary can run the program code, so with this the same node structure need to be iteratively created out of any given starting node. A small set $<\approx 10$ of disjoint networks of same structure would also be sufficient (resulting net would relate to starting node).
That's a lot of asking for. I'm also thankfully about something similar which might work out with some tweaking.
(I do not look for something like a Feistel network. Those are just in between two nodes. They only serve as (part) of a edge progression function. I'm looking for a network in between a set of nodes)
