There are previous posts, such as Delete duplicates from list of lists as if on a necklace, that give a way to find all necklaces from a set of lists. The methods presented there work well for a small list dimension N.
For example, if N = 3 and if I work with two elements, 0 and 1, then I technically create the set: $$\{\{0, 0, 0\}, \{0, 0, 1\}, \{0, 1, 0\}, \{0, 1, 1\}, \{1, 0, 0\}, \{1, 0, 1\}, \{1, 1, 0\}, \{1, 1, 1\}\}$$ and then select only those that are inequivalent under rotations: $$\{\{0, 0, 0 \}, \{0, 0, 1\}, \{0, 1, 1 \}, \{1, 1, 1\}\}$$
My goal is to be able to construct this set without constructing the full list of possible states.
If my understading is correct, even the faster methods presented in that question rely on the construction of the full set of states first and, then, they manipulate it to arrive to the desired result. In essence they don't use Savage's algorithm or any update of it.
My questions are:
Is the parallelized and compiled code of Delete duplicates from list of lists as if on a necklace comparable in performance with an optimized algorithm that constructs only the necklaces? (My understanding is that the answer is no...)
How would I be able to get only the necklaces for a given N? Is there any implementation of Savage's algorithm or any other more efficient algorithm in Mathematica?
Then, I want to go to 2D. Let's consider the following scenario: $$(N_x, N_y) = (3, 3)$$ I want to construct all the 2D necklaces. I assume that my 2D list is periodic across the x- and the y-dimension. This means that $$\begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 1 \end{pmatrix}, \begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 1 & 0 \end{pmatrix}, \begin{pmatrix} 0 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 0 \end{pmatrix} $$ are for example equivalent (among 9 matrices with a single 1 and 8 zeros that are equivalent).
However, the following two matrices are inequivalent: $$\begin{pmatrix} 0 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 1 & 0 \end{pmatrix}, \begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 1 \\ 0 & 1 & 0 \end{pmatrix} $$
As in 1D, how would I construct all 2D necklaces for a given $(N_x, N_y)$?
Comment: I wanted to clearly state that the whole concept of needing to resort to the necklaces is a problem of performance... Calculating the whole tuple-set in 1D scales terribly. Calculating the necklaces however (in any problem that the only thing that matters are circularly symmetric lists) might help. This way, for example, for $N=6$ in 1D you calculate 14 necklaces instead of $2^6$ configurations. At the end, the number of necklaces scales badly too but allows for access to higher N's. The same is the goal in 2D. To be able to access system sizes that are differently not accessible via a simple calculation with Tuples.
Edit: Because it seems to be unclear what it is meant by necklaces, I will give some examples here.
For $N = 4$, the necklaces (distinct lists under rotations) are
$$\{0, 0, 0, 0\}, \{0, 0, 0, 1\}, \{0, 0, 1, 1\}, \{0, 1, 0, 1\}, \{0, 1, 1, 1\}, \{1, 1, 1, 1\}$$
For $N = 5$, the necklaces are
$$\{0, 0, 0, 0, 0\}, \{0, 0, 0, 0, 1\}, \{0, 0, 0, 1, 1\}, \{0, 0, 1, 0, 1\}, \{0, 0, 1, 1, 1\}, \{0, 1, 0, 1, 1\}, \{0, 1, 1, 1, 1\}, \{1, 1, 1, 1, 1\}$$
For N = 6, the necklaces are
$$\{0, 0, 0, 0, 0, 0\}, \{0, 0, 0, 0, 0, 1\}, \{0, 0, 0, 0, 1, 1\}, \{0, 0, 0, 1, 0, 1\}, \{0, 0, 1, 0, 0, 1\}, \{0, 0, 0, 1, 1, 1\}, \{0, 0, 1, 0, 1, 1\}, \{0, 1, 0, 1, 0, 1\}, \{0, 0, 1, 1, 0, 1\}, \{0, 0, 1, 1, 1, 1\}, \{0, 1, 0, 1, 1, 1\}, \{0, 1, 1, 0, 1, 1\}, \{0, 1, 1, 1, 1, 1\}, \{1, 1, 1, 1, 1, 1\}$$
The intuitive (initial) algorithm to get the necklaces for any N is described in the paper by Frank Ruskey and Carla Savage, Generating Necklaces, https://people.engr.ncsu.edu/savage/AVAILABLE_FOR_MAILING/necklace_fkm.pdf