finding a minimum residue-class-id per order, related to the Collatz conjecture

["Ruud H.G. van Tol" <rvtol@isolution.nl>]

I'm looking for a way to derive the minimum residue-class-id per order.
This order is the hammingweight of a parity-vector.
More details in https://oeis.org/A100982/a100982.txt

Any admissible parity-vector (see A100982) represents a set of 
operations to transform a start-value to its first value lower than the 
starting-value, or in case of 1: to 1.

Some examples of parity-vectors, formatted as binary numbers:
{0}, {10}, {1100}, {11010, 11100}, {1101100, 1110100, 1111000}.

A 0-digit represents the transformation x -> x/2, further called a 
halving, or an even operation.
A 1-digit represents the transformation x -> (3*x +1)/2, further called 
a tripling, or an odd operation.


For all even start-values, the parity-vector "0" applies, as they only 
need a single halving: 2 -> 1, 4 -> 2, 6 -> 3.
Any even starting-value x is transformed to x/2.
Their dropping-formula: 2 + i * 2^1  ->  1 + i * 3^0.
The exponent one inside the "2^1" is always the length of the 
parity-vector: in this case one 0-digit.


The trajectory for 1 is {2, 1}, for 5 is {8, 4}, and for 9 is {14, 7}. 
The parity-vector for any starting-value congruent to 1 (mod 2^2) is 
"10", meaning one tripling followed by one halving, and which is of order 1.
Any such odd starting-value x is transformed to (3*x+1)/2/2 = (3*x+1)/4.
Their dropping-formula: 1 + i * 2^2  ->  1 + i * 3^1.
The exponent 2 inside the "2^2" is always the length of the 
parity-vector, which is the same as the count of implicit and explicit 
halvings.

The number of triplings (or 1-digits) is logint(2^length, 3), which is 
the order of the parity-vector. At each position in the parity-vector 
but the final position, the intermediate value divided by the starting 
value is still above 1. Only a the last position, which is always a 
halving, the ratio becomes < 1, or in case of starting-value 1: equal to 1.


The next starting-value is 3. Its trajectory is {(3*3+1)/2, 
(3*(3*3+1)/2+1)/2, (3*(3*3+1)/2+1)/2/2, (3*(3*3+1)/2+1)/2/2/2},
which is {5, 8, 4, 2}, so its parity-vector is "1100", which is of order 
2. So this applies to any starting value that is congruent to 3 mod 2^4.
Their dropping-formula: 3 + i * 2^4  ->  2 + i * 3^2.
Example for i=1: 19 -> 11, the trajectory is {29, 44, 22, 11}.
Example for i=2: 35 -> 20, the trajectory is {53, 80, 40, 20}.


The next starting-value is 7, which has trajectory {11, 17, 26, 13, 20, 
10, 5}, so its parity-vector is "1110100", so is of order 4.

Notice that the parity-vector starts with the trailing 1-bits of the 
start-value, followed by a 0-bit. This can be used to do a 
multi-tripling operation with a single closed formula, which is 
efficient, but not relevant to this story.


The parity vector for start-value 7 is the second parity-vector for 
order 4. So 7 is the minimal starting value, or minimal 
residue-class-id, for order 4.


Next start-value is 11, it has trajectory {17, 26, 13, 20, 10}. Notice 
how that is part of the trajectory of start-value 7. The parity-vector 
is "11010", which is the first one of order 3.


Next start-value is 15, it has trajectory {23, 35, 53, 80, 40, 20, 10}.
Its parity-vector is "1111000", which is the last one of order 4.
Notice that 35 was mentioned as an example for starting-value 3.


Next start-value is 23, it has trajectory {35, 53, 80, 40, 20}. Notice 
how that is part of the trajectory of start-value 15. The parity-vector 
is "11100", which is the last one of order 3.
Its parity-vector is "1111000", which is the last one of order 4.

The next start-values are 27, 31, and we'll skip those, as they have 
long trajectories, so long parity-vectors of high orders.


To generate a parity-vector, start with one or more triplings. A single 
tripling leads to parity-vector "10". Two triplings can either be 
followed by two halving, see start value 3, or by one halving and then 
one or more further triplings, increasing the order it will finally 
belong to.

In the end, the number of 1-digits t (for triplings, which is also the 
order) and the number of explicit halvings h, are related as:
h == logint(3^t,2)+1 - t, and t == logint(2^(t+h), 3). So for 
intermediate, or non-final, 0-bits, the total number of 0 bits is 
limited by the number of 1-bits used so far.
See https://oeis.org/A100982/a100982.svg for a lattice-picture.

- - - - - - - -

Now comes the challenge: which parity-vector in the set of 
parity-vectors for an order, represents the lowest start-value for that 
order.
Is there a number-theoretical way to derive it, or is (near) brute-force 
the only way to find it? Equivalently: what is the order of the 
parity-vectors for an order, when sorted by residue-class-id?

Any ideas are welcome! I already threw some AI at this problem, but it 
gave up. It did create loads of nice Lean-code about it.

Mind that this will NOT prove the Collatz-conjecture. Each parity-vector 
in the set for an order, is related to its own residue-class-id, which 
is the minimal starting-value for that parity-vector.
Maybe call those the Collatz-primes?

They are listed in several OEIS-sequences, in different orders.
Example: https://oeis.org/A243115, which is cheap to generate, so looks 
hard to beat. I added some overly clever bit-oriented memoizing to its 
code, and could only make it go 10% faster.

-- Greetings, Ruud

P.S. Feel free to use the above in any way you like. There is nothing 
new in it, all of this has also been explored already in the 70s of the 
previous century.
Example: https://doi.org/10.4064/aa-30-3-241-252 from Riho Terras.