TL;DR

A natural extension of Collatz conjecture which may be insufficiently known

I have possibly found a natural generalization of this conjecture, which I was not able to find on the web despite hours of researching.
There is, actually, an article by Carnielli ("Some Natural Generalizations Of The Collatz Problem"), that deals with the same type of transformations, but the following conjecture does not seem to be enunciated there:

Let ##a## be a fixed natural number. For every ##n\in \mathbb N^*##, define the following sequence:
$$n_0 = n, \quad {\rm and}$$
$$n_{i+1} = \cases{\displaystyle{n_i \over a}, & if $a | n_i$,\cr
\displaystyle{(a + 1)n_i + a - r\over a}, & if $a$ does not divide $n_i$,
}$$ where ##r## is the Euclidean remainder of the division of ##n_i## by ##a##.
Then for every ##a## in a certain set S of integers, whose first values are
$$\{2, 5, 7, 8, 13, 14, 18, 19, 21, 22, 25, 26, 28, 30, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 49, 50, 51, 52, 53, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 95, 96, 97, 98, 99\},$$
the sequence ##n_i## will eventually reach ##1## for every ##n## (and then cycle over the sequence ##1,2,3,... a-1##)

Substituting ##a = 2## in the above bring us back to the Collatz conjecture.

What is surprising is that Carnielli who has studied these transformations didn't hit at all the most striking fact, that makes this conjecture different from the other extensions found in the past: What I say here is that for many numbers n, the Collatz type transformations above will always lead to the number 1, exactly like the genuine Collatz conjecture. No cycle here! Of course, for the other numbers, Carnielli already conjectured that the sequence cycle at some stage. But the main point is that this conjecture is very, very like the original conjecture. In other words, the "3" in the ##3n + 1## has nothing particular. In fact, it turns out that "most" numbers ##a## are likely to satisfy the conjecture, as I was able to check with a program: I tested for all ##a < 1000##, ##n < 5000## and a maximal cycle length of 10000.
The numbers ##a## for which the procedure didn't ended at 1 for some n < 5000 are summarized in the following table, and there are only about 30 such numbers smaller than 1000:

a: 3 n: 5 cycle head: 7
a: 4 n: 11 cycle head: 23
a: 6 n: 7 cycle head: 23
a: 9 n: 31 cycle head: 35
a: 10 n: 34 cycle head: 42
a: 11 n: 588 cycle head: 642
a: 12 n: 767 cycle head: 1348
a: 15 n: 49 cycle head: 53
a: 16 n: 35 cycle head: 178
a: 17 n: 19 cycle head: 79
a: 20 n: 63 cycle head: 71
a: 23 n: 49 cycle head: 82
a: 24 n: 201 cycle head: 335
a: 25 n: 2341 cycle head: 4064
a: 27 n: 196 cycle head: 545
a: 29 n: 91 cycle head: 111
a: 31 n: 352 cycle head: 389
a: 48 n: 49 cycle head: 136
a: 54 n: 825 cycle head: 3406
a: 57 n: 2089 cycle head: 3416
a: 78 n: 712 cycle head: 1494
a: 85 n: 1979 cycle head: 4435
a: 94 n: 475 cycle head: 1308
a: 111 n: 1792 cycle head: 2838
a: 123 n: 125 cycle head: 195
a: 134 n: 1351 cycle head: 1871
a: 136 n: 822 cycle head: 1356
a: 172 n: 693 cycle head: 887
a: 225 n: 3390 cycle head: 4773
a: 368 n: 1476 cycle head: 3805
a: 419 n: 3361 cycle head: 5785
a: 540 n: 1623 cycle head: 3292

Here is a the Python code that may help to figure out the above conjecture:
Mentor note: Code tags added to retain original indentation.

cycle_length_threshold = 10000

check_for_n_up_to = 1000


def procedure_1(n, p,
                cycle_length_threshold,
                verbose=False,
                check_cycle=False):
    count = 0
    cycle_buffer = set()
    while count < cycle_length_threshold:
        old_n = n
        rem = n % p
        if rem == 0:
            if verbose:
                print(n, 'divisible by p')
            cycle_buffer.add(n)
            n = n//p
            if n == 1:
                if verbose:
                    print(n)
                return 0
        else:
            if verbose:
                print(n, 'performing transformation:')
            if n in cycle_buffer:
                if verbose:
                    print('cycle found. Cycle head: ', n)
                return n
            else:
                cycle_buffer.add(n)
             
            n = (n * (p+1) + p - rem) // p
            if n == old_n:  # stable state has been reached
                if verbose:
                    print('stable state has been reached: ', n)
                return n
            elif n == 1:
                if verbose:
                    print(n)
                return 0
        count += 1
    if verbose:
        print('Maximal cycle length has been reached - aborting.') 
    return -1

integer_list = []

for p in range (2, 1000):
    flag = True
    for n in range(1, 5000):
        ret = procedure_1(n, p, cycle_length_threshold)
        print(ret, end="")     
        if ret != 0:
            flag = False
            if ret != -1:
                print('a: ', f"{p:<7}", '\tn: ', f"{n:<7}", '\tcycle head: ', ret)
            else:
                print('a: ', f"{p:<7}", '\tn: ', f"{n:<7}", '\t(max cycle length reached)')             
            break
    if flag:
        integer_list.append(p)
    
print('Integer list: ', integer_list)

The better approach would have been to publish it in a mathematical journal.

---

This happens a lot in patents, too. An exuberant inventor talks about his patent idea before he gets his patent. It either gets rejected because the examiner found his comments or because later in a trial of patent royalties and defendant claims the patent is invalid because the inventor divulged the patent idea to the public.

IBM routinely published its employees' patent ideas, not to gain credit for them but to prevent other companies from patenting the ideas and demanding royalties from IBM.

---

I don't know how this works in academia, where one mathematician happens to see the posted idea and publishes a paper on it before the originator can get his paper published. The originater gets scooped.

I play with it on and off and have discovered an interesting feature. Given a starting number, once a Collatz sequence falls below it, its trajectory is known.

Here’s the caveat: I started with 1, 2, 3, 4, 5…
And asked myself whether there were any gaps between my starting number and 1. So I computed the collatz sequences from 1 to N and found there were no numbers that hadn’t been touched.

It seemed this approach might lend itself to an induction proof. But alas I hit a dead end, one of many.

—-

Collatz is like that running joke about a farmer who notices a squirrel disappear into a massive strong oak tree standing next to his home. Upon investigation he is shocked find a massive hole in the tree meaning its not as solid as he once thought and could come down at any moment.

When asked, the farmer said I wish I never saw that darn squirrel.

—-

It's s a metaphor for life. Feeling perfectly healthy and on top of the world until that darn squirrel shows up with your doctor who delivers devastating news.

Collatz can be like that but its still fun to try. Theres always hope that you find something tens of thousands of people have missed since Collatz introduced his conjecture.