21.08.2022 18:25
moonbase-delta 26 2600 Источник

0

Мне кажется всем и так понятно что это (кто всё же не знает - вперёд в вики), поэтому попробую просто пройтись по наработкам.

Картинок немного, начинаются с пункта 5. Ближе к концу статьи есть питонный код на случай если хочется быстро посмотреть много чисел. Качество приведённого кода мне самому не нравится. Оно соответствует подходу "у меня есть такие-то затеи и записи, надо быстро запрототипировать и посмотреть результаты", а не является результатом вытачивания готовой задачи по заранее установленным лекалам. Код несёт вспомогательную функцию к статье, основная мысль даётся текстом и формулами.

1

Для начала заметим, что можно спокойно отбрасывать чётные числа - они по определению функции переходят в нечётные.

1, 2, 3, 4, ... \rightarrow 1, 3, 5, 7, ...

Также мы можем несколько модифицировать верхнюю ветку функции, заменив 3n + 1 на 1.5n + \frac 1 2.

Соответственно:

cltz(n) = \begin{cases} 1.5n + \frac 1 2, & n\equiv 1\pmod 2 \\ n / 2 , & n\equiv 0\pmod 2 \end{cases}

Далее, актуальная проблема аналогична классической - доказать, что

cltz^k(n) = 1, \ k \gt 0

2

Посмотрим, как поведут себя нечётные числа при применении этой функции:

\begin{align} 1 & \rightarrow & 2 \\ 3 & \rightarrow & 5 \\ 5 & \rightarrow & 8 \\ 7 & \rightarrow & 11 \\ & ... \end{align}

Чуть модифицируем этот список, указав порядковый номер нечётного числа и пропишем также альтернативную запись получающегося результата, и следующий шаг применения cltz(n) если получаются чётные:

\begin{align}& [1] & 1 & \rightarrow 1 + 1 & \Rightarrow & \, 2 & \rightarrow 1 \\& [2] & 3 & \rightarrow 3 + 2 & \Rightarrow & \, 5 \\& [3] & 5 & \rightarrow 5 + 3 & \Rightarrow & \ 8 & \Rightarrow 1 \\& [4] & 7 & \rightarrow 7 + 4 & \Rightarrow & \, 11 \\& [5] & 9 & \rightarrow 9 + 5 & \Rightarrow & \, 14 & \rightarrow 7\\& ...\end{align}

Здесь явно виден следующий паттерн:

[m_{i}] \, n_{i} \rightarrow n_{i} + m_{i} \Rightarrow n_{i+1}

Номера [m] чисел n в полученном ряду получаются по формуле:[m] \iff (n + 1) / 2

Это справедливо также и для чётных чисел, они будут принимать вид [m.5], например - [5.5] \iff 10 .

Посмотрим как данная система поведёт себя на числе 25 проводя пошаговое применение cltz(n) доводя до единицы. Также будем записывать изменение порядкового номера.

Пошаговая раскадровка действий от числа 25
\begin{align}& [13] & 25 & \rightarrow 25 + 13 & \Rightarrow & \, 38 \\ \rightarrow + 6.5 & \\ & [19.5] & 38 & \rightarrow /2 & \Rightarrow & \, 19 \\ \rightarrow - 9.5 & \\ & [10] & 19 & \rightarrow 19 + 10 & \Rightarrow & \, 29 \\ \rightarrow + 5 & \\ & [15] & 29 & \rightarrow 29 + 15 & \Rightarrow & \, 44 \\ \rightarrow + 7.5 & \\ & [22.5] & 44 & \rightarrow /2 & \Rightarrow & \, 22 \\ \rightarrow - 11 & \\ & [11.5] & 22 & \rightarrow /2 & \Rightarrow & \, 11 \\ \rightarrow - 5.5 & \\& [6] & 11 & \rightarrow 11 + 6 & \Rightarrow & \, 17 \\ \rightarrow + 3 & \\ & [9] & 17 & \rightarrow 17 + 9 & \Rightarrow & \, 26 \\ \rightarrow + 4.5 & \\ & [13.5] & 26 & \rightarrow /2 & \Rightarrow & \, 13 \\ \rightarrow - 6.5 & \\ & [7] & 13 & \rightarrow 13 + 7 & \Rightarrow & \, 20 \\ \rightarrow + 3.5 & \\ & [10.5] & 20 & \rightarrow /2 & \Rightarrow & \, 10 \\ \rightarrow - 5 & \\ & [5.5] & 10 & \rightarrow /2 & \Rightarrow & \, 5 \\ \rightarrow - 2.5 & \\ & [3] & 5 & \rightarrow 5 + 3 & \Rightarrow & \, 8 \\ \rightarrow + 1.5 & \\ & [4.5] & 8 & \rightarrow /2 & \Rightarrow & \, 4 \\ \rightarrow - 2 & \\ & [2.5] & 4 & \rightarrow /2 & \Rightarrow & \, 2 \\ \rightarrow - 1 & \\ & [1.5] & 2 & \rightarrow /2 & \Rightarrow & \, 1 \\ \rightarrow - 0.5 & \\ & [1] & 1 & . \\ \end{align}

Здесь мы можем заметить, что ситуация на самом деле не требует самих чисел, достаточно одних лишь порядковых номеров и их изменений.

Те же действия но уже только с порядковыми номерами
\begin{align} & [13] \\ \rightarrow + 6.5 & \\ & [19.5] \\ & \;\;\;\;\;\; - 9.5 \leftarrow \\ & [10] \\ \rightarrow + 5 & \\ & [15] \\ \rightarrow + 7.5 & \\ & [22.5] \\ & \;\;\;\;\;\; - 11 \leftarrow \\ & [11.5] \\ & \;\;\;\;\;\; - 5.5 \leftarrow \\ & [6] \\ \rightarrow + 3 & \\ & [9] \\ \rightarrow + 4.5 & \\ & [13.5] \\ & \;\;\;\;\;\; - 6.5 \leftarrow \\ & [7] \\ \rightarrow + 3.5 & \\ & [10.5] \\ & \;\;\;\;\;\; - 5 \leftarrow \\ & [5.5] \\ & \;\;\;\;\;\; - 2.5 \leftarrow \\ & [3] \\ \rightarrow + 1.5 & \\ & [4.5] \\ & \;\;\;\;\;\; - 2 \leftarrow \\ & [2.5] \\ & \;\;\;\;\;\; - 1 \leftarrow \\ & [1.5] \\ & \;\;\;\;\;\; - 0.5 \leftarrow \\ & [1]. \end{align}

3

На основе полученной схемы можно вывести следующие закономерности:

  1. m_i является числом вида [N]:

\begin{align} & [m_i] \\ \rightarrow + {\frac {m_i} 2} & \\ & [m_{i-1}] \\ \end{align}

  1. m_iимеет вид [N.5]:

\begin{align} & [m_i] \\ & \;\;\;\;\;\; - \frac {m_i - 0.5} 2 \leftarrow \\ & [m_{i-1}] \\ \end{align}

В обоих случаях m_{i-1} может иметь вид как [N.5] так и[N] .

Оба паттерна при этом справедливы как для "движения вниз" по последовательности, так и при "движении наверх" т.е от [m_{i+1}] к [m_{i}]. Выпишем "плюсовые" и "минусовые" действия:

  1. +, движение от m_i к m_{i+1}:

\frac {2m_i} 3 = m_{i+1}

  1. -, движение от m_i к m_{i+1}:

m_i + m_i - 0.5 = m_{i+1}

  1. +, обратное движение, от m_{i+1} к m_i:

\frac {3m_i} 2 = m_{i-1}

  1. -, обратное движение, от m_{i+1} к m_i:

m_i - \frac {m_i - 0.5} 2 = m_{i-1}
Примеры от 1) к 4),
\begin{align} \frac {2 * 4.5} 3 & = \ 3 \\ 5.5 + 5.5 - 0.5 & = \ 10.5 \\ \frac {13 * 3} 2 & = \ 19.5 \\ 22.5 - \frac {22.5 - 0.5} 2 & = \ 11.5 \\ \end{align}

4

Теперь на основе данных операций и номеров можно создать орграф.

Данный граф будет иметь следующие особенности:

  1. Переходы определены для всех [N] и [N.5] начиная с [1].

  1. В каждую вершину графа может быть лишь одна точка входа.

Это достигается за счёт невозможности ввести войти в одну вершину одновременно и через "плюсовое" и через "минусовое" движение, что можно проверить через уравнение:

\begin{align}& \frac {2x_i} 3 & = & \ 2x_j - 0.5 \\ & ... \\& x_i & = & \ 3 x_j - \frac 3 4 \\ & x_j & = & \ \frac {x_i} 3 + \frac 1 4 \\ \end{align}

И [ x_i ] и [ x_j ] однако не относятся ни к [N] ни к [N.5] и соответственно, не принадлежат базовому графу.

  1. В качестве исходной вершины будет положена [1], т.к она является наименьшей в графе.

  1. Граф содержит единственный цикл между двумя соседними вершинами: [1] \leftrightarrow [1.5]. Для удобства дальнейшего рассмотрения мы можем игнорировать "плюсовой" переход [1.5] \rightarrow [1], т.к цикл не влияет на последующую структуру графа. Таким образом, [1] будет также единственной вершиной без точки входа.

+ назад, - вперёд:

\begin{align}& \frac {3x_i} 2 & = & \ 2x_i - 0.5 \\& ... \\& x_i & = & \ 1 \\\end{align}

+ вперёд, - назад:

\begin{align}& \frac {2x_j} 3 & = & \ x_j - \frac {x_j - 0.5} 2 \\& ... \\& x_j & = & \ 1.5 \\\end{align}

  1. При продолжительном движении назад по переходам [N.5] переходит в [N]. Количество шагов тут будет равным степени двойки в оригинальном числе, например, для 24 потребуется 3 шага.

  2. В случае когда [N] является чётным, то при обратных оно будет двигаться по другим номерам вида [N] пока не достигнет нечётного номера. Количество шагов до достижения нечётного номера аналогично 5) также равно степени двойки, только на этот раз присутствующей в [N].

  3. Нечётное [N] при обратном переходе отображается в [N.5], кроме особого случая [1], см. 4).

Свойства 5)-7) будут более наглядны при визуальном построении.

Заметим, что данный граф является несбалансированным бинарным деревом.

Соответственно, мы можем пронумеровать его вершины идя по уровням вниз, и считая слева направо. Левая ветка отображает - переход, правая - +.

Таким образом, мы получаем полное отображение натуральных чисел на структуру cltz(n).

Здесь же стоит отметить, что уникальными являются как значения вершин графа, так и значения рёбер. Значение вершины однозначно определяет родительскую вершину а также одну или две дочерние вершины, а значение ребра - обе вершины которые оно соединяет.

5

Теперь мы можем визуализировать основной граф с вершинами разложенными по координатной сетке таким образом, что [ N.5 ] находятся друг над другом в зависимости от кол-ва перехов, а [ N ] располагаются справа друг к другу в порядке возрастания. [ 1 ] располагается в левом нижнем углу изображения.

Выведем граф на момент полного заполнения шага 15 (левые верхние колонки не показывается полностью чтобы не занимать слишком много места, также столбцы справа визуально подвинуты для более понятного внешнего вида):

Помимо всего прочего, отдельно интересно что столбцы с основаниями [ N ] \equiv 2\pmod 3 не порождают новых оснований, а лишь растут вверх.

Прометим теперь движение по графу от числа 13 к единице:

От числа 38 к единице:

6

Как можно видеть, структура вполне однозначна: граф по мере заполнения уровней вбирает в себя всё больше чисел, а запуск поиска обратного пути для любого натурального числа единственным образом приводит нас к [ 1 ].

Тем не менее, для соответствия описанной схемы классической Гипотезе Коллатца необходимо чтобы при поиске обратного пути при "плюсовых переходах" был добавлен заход в промежуточную вершину вида [ N.5 ].
Для сравнения, на число 13.

  1. Текущий обратный ход:

\begin{align}& [7] & 13 \\& [10.5] & 20.0 \\& [5.5] & 10.0 \\& [3.0] & 5.0 \\& [4.5] & 8.0 \\& [2.5] & 4.0 \\& [1.5] & 2.0 \\& [1.] & 1 \\\end{align}

  1. Классическая Гипотеза Коллатца:

\begin{align}& [7] & 13 \\& [20.5] & 40.0 \\& [10.5] & 20.0 \\& [5.5] & 10.0 \\& [3.0] & 5.0 \\& [8.5] & 16.0 \\& [4.5] & 8.0 \\& [2.5] & 4.0 \\& [1.5] & 2.0 \\& [1.] & 1 \\\end{align}

Модификация поиска обратного пути выглядит довольно очевидным образом, поэтому мы легко можем подготовить модифицированную версию. Важно отметить, что такая модицикация не затрагивает структуру и свойства графа - это всего лишь функция сбора вершин при поиске обратного пути. Аналогичным образом мы могли бы подставлять не одну промежуточную вершину [ N.5 ], а две или более.

Для сравнения посмотрим как изменились отмеченные вершины в случае с числом 13:

Таким образом, можно утверждать эквивалентность данного построения и классической Гипотезы Коллатца.

7

В целом вышеизложенного достаточно чтобы сделать следующие выводы о Гипотезе Коллатца:

  1. Из натуральных чисел единственной исходной точкой может быть только число 1.

  2. Т.к в самом графе отсутствуют циклы кроме [1.5] \rightarrow [1], а операция противохода от заданного числа однозначно определена как в основной версии, так и в модифицированных, то для любых натуральных чисел Гипотеза Коллатца не может породить циклические переходы чисел.

  3. Условиям достижимости внутри графа соответствуют все натуральные числа. Соответственно, невозможна структура бесконечно возрастающих переходов натуральных чисел не имеющая в своём основании натуральное число принадлежащее графу.

Гипотеза доказана. _{\blacksquare}

Почему по-другому так проблемно и тяжело?

Напоследок рассмотрим проблемы иной интерпретации функции противохода по графу, используя для этого построение того же графа но в виде бинарного дерева. Листья с "null" обозначают что данная операция невозможна по условиям построения графа.

Бинарное дерево c поиском числа 18:

Теперь посмотрим на модифицированную версию:


Если снять предположение что дополнительные переходы являются лишь особенностью функции поиска пути, то ацикличность уже требует отдельного доказательства - мы получаем уже структуру где у каждой вершины три выходных пути и 1-2 входных.
Ещё более интересная ситуация случается, если снять запрет на присутствие в графе чисел отличных от натуральных.

Сравним порождающие структуры для окрестностей текущей вершины:

  1. Описанный в данной работе граф:

Eсли вершина не является натуральным числом то она не добавляется. Родительская вершина всего одна и может быть только натуральным числом.

  1. Модифицированный граф позволяющий как несколько входных точек, так и рациональные числа:

Второй случай очевидным образом порождает структуры уже кардинально отличные от первого. Сами функции перехода и их отношения становятся более сложными. Помимо цикличности здесь мы также не можем гарантировать уникальность включения какого-либо числа без отдельного исследования.
Если локально высчитывать i для вершины каждой тройки из 1) или центральной вершины из 2), то мы также получим ситуацию где граф сохраняет в себе различные значения i являющиеся рациональными дробями.

Любопытной может быть также вариация основного бинарного дерева, где вместо [ N.5 ] разрешаются номера вида [ N.\frac 1 3 ] и [ N.\frac 2 3 ].

Немного кода, немного бинарных деревьев

Код скромный и сделан в сугубо демонстративных целях.

Для визуализации тут используется библиотека binarytree, для рендеринга ей требуется также установленный для Питона пакет graphviz.

from binarytree import Node
from decimal import Decimal


def try_right_move(n):
    return Decimal(n) / 3 * 2

def make_left_move(n):
    return Decimal(n)  * 2 - Decimal('0.5')


def translate_from_cltz_ordinal(n):
    return Decimal(n) * 2 - 1



def gen_n_levels_deep(base_ord, n):
    tree = Node(base_ord)
    k = n - 1
    while k > 0:
        nodes_to_try = tree.levels[-1]
        for i in nodes_to_try:
            i.left  = Node(str(make_left_move(Decimal(i.value))))

            # на случай вывода только N-вершин
            #if Decimal(i.value) % 3 != 2:
            #    i.left  = Node(str(make_left_move(Decimal(i.value))))
                
            if str(i.value) != '1.5':
                right_val_cand = try_right_move(Decimal(i.value))
                if str(right_val_cand)[-2:] in ['.5', '.0'] or ( '.' not in str(right_val_cand)):
                    i.right = Node(str(right_val_cand))
        k -= 1
    
    return tree
  
# генерируем дерево от корня '1.0' на 8 шагов вглубину
r = gen_n_levels_deep(str(Decimal('1.0')), 8 )

# отображаем целые числа без нуля-с-точкой на конце
for i in r:
    if i.value[-2:] in ['.0']:
        i.value = i.value[:-2]
        
# на случай вывода только N-вершин
#for i in r:
#    if str(i.value)[-2:] in ['.5']:
#        i.value = ''
  
# на случай когда нужен вывод не порядковых номеров, а самих чисел
#for i in r: i.value = int(translate_from_cltz_ordinal(i.value))

r.graphviz().render(filename="binary_tree.gv", format='png')
Полученное дерево на 8 шагов

Оно же, но с отображением оригинальных чисел

Можно также убрать показ значений [N.5] вершин и не просчитывать их для [N]вершин с номерами дающими остаток 2 при делении на тройку, т.к начиная с этих вершин не создаются новые вершины с целочисленными номерами.

Вывод только целочисленных вершин на шаге 14

Регулярность расположения [N] вершин указывает на то, что при доработке алгоритма возможно создавать древовидные структуры и на сугубо целочисленных порядковых номерах, что в свою очередь будет являться графом последовательно создающим исключительно нечётные числа по мере их появления в последовательности Коллатца.

Заход на исключительно нечётные числа в последовательности Коллатца

Для начала введём дополнительную типизацию для номеров вида [N]:

\begin{align} [N] \equiv 0 \pmod 3 & \rightarrow & [ N.\frac 0 3 ] \\ [N] \equiv 1 \pmod 3 & \rightarrow & [ N.\frac 1 3 ] \\ [N] \equiv 2 \pmod 3 & \rightarrow & [ N.\frac 2 3 ] \\ \end{align}

Наблюдая структуру графа в пункте 5 мы можем заметить, что новые нечётные числа появляются лишь в столбцах чьи порядковые номера отличны от[ N.\frac 2 3 ].

Далее объявим три случая появления в графе новых нечётных чисел:

1) Число появляется из вершины в столбце роста чёрных чисел начиная с первой такой "генерирующей вершины" находящейся на 1-2 шага выше основания столбца. Если рассматривать все первые "боковые" относительно рассматриваемого столбца вершины с нечётными числами, то переход между ними происходит таким образом:

4 m_{i} - 1= m_{i+1}

2) Та самая первая "генерирующая вершина". В данном случае возможны два случая - это вершина находящая сразу над основанием столбца, либо через одну над ним. Появление обоих полностью детерминировано типом основания столбца.

\begin{align} [ N.\frac 0 3 ] & \rightarrow & \frac {8m_i} 3 - 1 = m_{i+1} \\ [ N.\frac 1 3 ] & \rightarrow & \frac {4m_i - 1} 3 = m_{i+1}\\ \end{align}

3) Число появляется от самого основания столбца, если порядковый номер последнего имеет вид [ N.\frac 0 3 ] . Осуществляется этот переход по уже известной формуле:

\frac {2m_i} 3 = m_{i+1}

Такая структура сохраняет основные свойства оригинала, только в этот раз количество выходных вершин варьируется от 0 до 3.

Применяя это мы можем построить граф уже сугубо нечётных чисел, в данном случае на 9м шаге алгоритма:

Используемый тут код
import collections
from decimal import Decimal
from typing import Any

from attr import dataclass
from graphviz import Source



def translate_from_cltz_ordinal(n):
    return Decimal(n) * 2 - 1




INTNODE_TYPE   = 'N'
ONETHIRD_TYPE  = 'N.1/3'
TWOTHIRDS_TYPE = 'N.2/3'

def determine_type_of_cltz_node(n):

    if n.cltz_ordinal % 3 == 0:
        return INTNODE_TYPE
    elif n.cltz_ordinal % 3 == 1:
        return ONETHIRD_TYPE
    elif n.cltz_ordinal % 3 == 2:
        return TWOTHIRDS_TYPE



@dataclass
class Cltz_node():

    cltz_ordinal:   int = 1
    actual_value:   int = 1  
    lvl: int = 0 

    cltz_type  :  str = INTNODE_TYPE
    parent_node:           int = None # Cltz_node.cltz_ordinal
    parent_node_cltz_ordinal: int = None # Cltz_node.cltz_ordinal
    parent_node_actual_value: int = None # Cltz_node.cltz_ordinal
    created_by_action:     str = 'first' # first\left\right\center
 
    left_child:    Any = None # Cltz_node.cltz_ordinal
    center_child:  Any = None # Cltz_node.cltz_ordinal
    right_child:   Any = None # Cltz_node.cltz_ordinal
 

    def try_add_child_nodes(self):
        self.try_add_left_child()
        self.try_add_center_child()
        self.try_add_right_child()

    def try_add_left_child(self):

        if self.created_by_action == 'left' or self.cltz_type != TWOTHIRDS_TYPE and self.created_by_action != 'right':

            new_node = Cltz_node(
                cltz_ordinal = self.cltz_ordinal * 4 - 1,
                parent_node_cltz_ordinal = self.cltz_ordinal,
                parent_node_actual_value = self.actual_value,
                created_by_action        = 'left',
                lvl         = self.lvl + 1
            )
            new_node.cltz_type    = determine_type_of_cltz_node(new_node)
            new_node.actual_value = translate_from_cltz_ordinal(new_node.cltz_ordinal)
            self.left_child = new_node


    def try_add_center_child(self):
        if self.cltz_ordinal != 1 and self.cltz_type == INTNODE_TYPE:

            new_node = Cltz_node(
                cltz_ordinal             = int(self.cltz_ordinal * 8 / 3 - 1),
                parent_node_cltz_ordinal = self.cltz_ordinal,
                parent_node_actual_value = self.actual_value,
                created_by_action        = 'center',
                lvl         = self.lvl + 1
            )
            new_node.cltz_type    = determine_type_of_cltz_node(new_node)
            new_node.actual_value = translate_from_cltz_ordinal(new_node.cltz_ordinal)
            self.center_child = new_node

        elif self.cltz_ordinal != 1 and self.cltz_type == ONETHIRD_TYPE:

            new_node = Cltz_node(
                cltz_ordinal             = int( (self.cltz_ordinal * 4 - 1 ) / 3 ),
                parent_node_cltz_ordinal = self.cltz_ordinal,
                parent_node_actual_value = self.actual_value,
                created_by_action        = 'center',
                lvl         = self.lvl + 1
            )
            new_node.cltz_type    = determine_type_of_cltz_node(new_node)
            new_node.actual_value = translate_from_cltz_ordinal(new_node.cltz_ordinal)
            self.center_child = new_node

    def try_add_right_child(self):
        if self.cltz_ordinal != 1 and self.cltz_type == INTNODE_TYPE:

            new_node = Cltz_node(
                cltz_ordinal             = int(self.cltz_ordinal / 3 * 2),
                parent_node_cltz_ordinal = self.cltz_ordinal,
                parent_node_actual_value = self.actual_value,
                created_by_action        = 'right',
                lvl         = self.lvl + 1
            )
            new_node.cltz_type    = determine_type_of_cltz_node(new_node)
            new_node.actual_value = translate_from_cltz_ordinal(new_node.cltz_ordinal)
            self.right_child = new_node

    def get_child_nodes(self):
        ret = []

        if self.left_child:
            ret.append(self.left_child)
        if self.center_child:
            ret.append(self.center_child)
        if self.right_child:
            ret.append(self.right_child)


        return ret

 


def gen_n_levels_deep(n):
    root = Cltz_node(cltz_ordinal=1)

    k = n - 1
    root.try_add_child_nodes()
    nodes_next = root.get_child_nodes()


    while k > 0:
        nodes_to_try = nodes_next
        nodes_next   = []
        for i in nodes_to_try:
            i.try_add_child_nodes()
            for nn in i.get_child_nodes():
                nodes_next.append(nn)
        k -= 1
    return root


def cltz_odd_tree_to_graph(root):
    ans = []

    if root is None: return ans

    queue = collections.deque()
    queue.append(root)

    while queue:
        currSize = len(queue)
        currList = []

        while currSize > 0:
            currNode = queue.popleft()

            if currNode.cltz_ordinal != 1:
                currList.append(f'{currNode.actual_value} [label="{currNode.actual_value}"]\n')

                if currNode.created_by_action == 'left':
                    currList.append(f'{currNode.parent_node_actual_value} -> {currNode.actual_value} \n')
                elif currNode.created_by_action == 'center':
                    currList.append(f'{currNode.parent_node_actual_value} -> {currNode.actual_value} [color="red", arrowhead=normal, dir=both, arrowtail=dot]\n')
                elif currNode.created_by_action == 'right':
                    currList.append(f'{currNode.parent_node_actual_value} -> {currNode.actual_value} [color="blue", arrowhead=normal]\n')
            else:
                currList.append(f'{currNode.actual_value} [label="{currNode.actual_value}", color="darkblue"]\n')

            currSize -= 1

            if currNode.left_child is not None:
                queue.append(currNode.left_child)
            if currNode.center_child is not None:
                queue.append(currNode.center_child)
            if currNode.right_child is not None:
                queue.append(currNode.right_child)
        ans.append(currList)

    flat_list = [item for sublist in ans for item in sublist]
    return flat_list
 
cltz_root = gen_n_levels_deep(9)
 
# левый - через степени двойки
# средний - через прокидывание новых нод от соответствующей двойки
# правый - деление порядковых на три 

stuff = cltz_odd_tree_to_graph(cltz_root)
nodes_n_edges = ''.join(stuff)
cltz_graph_gv = """
digraph G{
    splines=curved
edge [dir="both", arrowtail="dot", arrowhead="normal", arrowsize=0.75,fontsize=9]
node [shape="doublecircle", color="lightblue2", style="filled",fontsize=12,fontnames="bold"]

%s
}
""" % nodes_n_edges
cltz_graph = Source(cltz_graph_gv,
    engine="neato",
    filename="cltz_odds_graph.gv", format="png")
cltz_graph.unflatten(stagger=3).view()

Теперь, зная всё это мы можем построить функцию обратного хода от произвольного нечётного числа к единице сугубо по нечётным числам.

Для этого достаточно прописать обратные функции к функциям переходов использованных для построения графа.

\begin{align} f_l(n) & \rightarrow & \frac {n + 1} 4 \\ f_{с_0}(n) & \rightarrow & \frac {3(n + 1)} 8 \\ f_{с_1}(n) & \rightarrow & \frac {3n + 1} 4 \\ f_r(n) & \rightarrow & \frac {3n} 2 \\ & ... \end{align}

Тут можно обойтись даже без использования типизации вершин, т.к целое число за раз почти всегда получается лишь на одной из четырёх из них (напомню, для случая 2 - перехода через первую "генерирующую вершину" - используется две разные функции).

Двойной ответ может происходить при одновременном срабатывании f_l(n) и f_{c_{0,1}}(n) , в таком случае приоритет имеют переходы f_{c_{0,1}}(n).

from decimal import Decimal


def translate_from_cltz_ordinal(n):
    return Decimal(n) * 2 - 1 
def translate_to_cltz_ordinal(n):
    return int( (Decimal(n) + 1) / 2 )

def f_l(n):
    return (n+1)/4
def f_c0(n):
    return (n+1)*3/8
def f_c1(n):
    return (n*3+1)/4
def f_r(n):
    return n * 3 / 2


def calc(n):
    return [f_l(n), f_c0(n), f_c1(n), f_r(n)]



def choose_num(lst):
    ans = -1

    # [27.0, 40.5, 80.5, 123.0,160.5] 
    ans_lst = [ str(i)[-2:] in ['.0'] for i in lst ]
    # [0, 3]
    ans_ind = [i for i, val in enumerate(ans_lst) if val] 

    return lst[ans_ind[-1]]

  
def backward_run_odds(n):

    m = n
    ret = [m]
    while m != 1:
        now_ans = calc(m)
        m = choose_num(now_ans)
        ret.append(m)

    return ret


  
num = translate_to_cltz_ordinal(
    12345
)

l = backward_run_odds(num)
print(l)
print([ int(translate_from_cltz_ordinal(i)) for i in l ])

При каноничном вызове от числа 12345 мы получаем такие результаты:

[6173, 4630.0, 6945.0, 5209.0, 3907.0, 
 977.0, 733.0, 550.0, 825.0, 619.0, 155.0, 
 39.0, 15.0, 6.0, 9.0, 7.0, 3.0, 1.0]

[12345, 9259, 13889, 10417, 7813, 1953, 1465, 1099, 
 1649, 1237, 309, 77, 29, 11, 17, 13, 5, 1]

Сравнивая с каноничным случаем оригинальной последовательности мы явно видим здесь лишние числа. Это возникает из-за особенностей графа по которому строится алгоритм поиска.

Модификация возможна, но для этого надо обратить внимание на структуру графа нечётных чисел в сравнении с исходным графом последовательности Коллатца. Переход по "чёрным" рёбрам в оригинальном графе приводит в вершины вида [N.5], в текущем же случае мы используем вместо них промежуточные "боковые" остановки.

Собственно, всё что нам теперь нужно - это вести учёт "цветов" рёбер по которым выстраивается движение к единице, после чего выбросить промежуточные "чёрные" переходы.

...

def choose_num_with_edge_types(lst):
    ans = -1

    # [27.0, 40.5, 80.5, 123.0,160.5] 
    ans_lst = [ str(i)[-2:] in ['.0'] for i in lst ]
    # [0, 3]
    ans_ind = [i for i, val in enumerate(ans_lst) if val] 

    ans = ans_ind[-1]
    if ans == 0:
        ret = ('left-black', lst[ans])
    elif ans == 1 or ans == 2:
        ret = ('center-red', lst[ans])
    elif ans == 3:
        ret = ('right-blue', lst[ans])

    return ret
 

def backward_run_odds_with_edge_types(n):

    m = ('first', n)
    ret = [m]
    while m[1] != 1:
        now_ans = calc(m[1]) 
        m = choose_num_with_edge_types(now_ans)
        ret.append(m)

    return ret


def make_repaired_odds_list(l):
    l2 = [(i[0], i[1], translate_from_cltz_ordinal(i[1])) for i in l] 
    l3 = [i for i in l2 if (i[0] != 'left-black') ]
    l3.append(l2[-1])
    return l3
  
...

l = backward_run_odds_with_edge_types(num) 
l2 = make_repaired_odds_list(l)
print([int(i[2]) for i in l2])

В данном случае вывод будет уже идентичен каноничному:

[12345, 9259, 13889, 10417, 7813, 1465, 1099, 
 1649, 1237, 29, 11, 17, 13, 5, 1]

Исходя из вышеизложенного, можно утверждать, что сей алгоритм корректным образом выводит список заходов последовательности Коллатца в нечётные числа без промежуточного использования чётных.

Пожалуй, здесь уже можно остановиться и далее рихтовать лишь косметические моменты.

Комментарии (26)


  1. orion24
    21.08.2022 20:17
    #24651594

    Какова практическая цель данных исследований?


  1. Politura
    21.08.2022 20:32
    #24651620
    +6

    Здесь явно виден следующий паттерн:

    [m_{i}] \, n_{i} \rightarrow n_{i} + m_{i} \Rightarrow n_{i+1}

    Мне не виден, первая же строчка: [1]1 -> 1 + 1 => 2, однако во второй строке n равен 3, а не 2.

    В целом, вы рассматриваете какие-то отдельные числа, из ограниченного диапазона, и выводите из них какие-то закономерности, но нигде не доказываете справедливость оных закономерностей для любых чисел. Просто постулируете их. Я не думаю, что это является доказательством чего-либо.


    1. moonbase-delta Автор
      22.08.2022 03:02
      #24652214

      Так ведь рассматриваются нечётные числа. Результаты применения функции одной строки там не связаны со следующей.

      Применимость же переходов графа для любых натуральных чисел, по-моему, является очевидной. Это можно более строго расписать, но идея статьи - показать всё в русле конструктивного доказательства через прямые примеры. Вставлять в текст раскадровки для более больших чисел скорее накладно для вёртки и чтения. Возможно, стоит начальные разделы также разбавить кодом.


  1. Milliard
    21.08.2022 22:59
    #24651948

    Задавал этот вопрос в другом посте, повторюсь.
    Как ваше доказательство справится, если правило слегка модифицировать? Например 3n-1 сходится к следующим последовательностям:
    2, 1
    5, 14, 7, 20, 10
    25, 74, 37, 110, 55, 164, 82, 41, 122, 61, 182, 91, 272, 136, 68, 34, 17, 50


    1. moonbase-delta Автор
      22.08.2022 03:35
      #24652238
      +1

      Не рассматривал этот случай, да и в целом не планировал заход на обобщение этих проблем.

      Если навскидку, то вообще не факт что к произвольной kn+a повезёт найти удобно вычислимые переходы между вершинами. В случае 3n-1, думаю, какой-то инсайт может получиться если попробовать заменять числа не на [ (n+1)/2 ] а на [ (n-1)/2 ]. По приведённым циклам что характерно паттерн таки объявляется:

      >>>def f(n): return (n - 1) / 2

      >>>a = [25, 74, 37, 110, 55, 164, 82, 41, 122, 61, 182, 91, 272, 136, 68, 34, 17, 50]

      >>>b = [5,14,7,20,10]

      >>>c = [2,1]

      >>>[f(i) for i in a]
      [12.0, 36.5, 18.0, 54.5, 27.0, 81.5, 40.5, 20.0, 60.5, 30.0, 90.5, 45.0, 135.5, 67.5, 33.5, 16.5, 8.0, 24.5]
      >>>[f(i) for i in b]
      [2.0, 6.5, 3.0, 9.5, 4.5]
      >>>[f(i) for i in с]
      [0.5, 0.0]

      Но чтобы это куда-то доказалось придётся отдельно рассматривать что происходит в структуре которая будет порождаться новыми правилами. Мне кажется, для любой конкретной kn+a проблемы графы могут вести себя очень по-разному и то что для 3n+1 там объявилось бинарное дерево не значит что у схожих формулировок граф тоже окажется бинарным деревом.


      1. Milliard
        22.08.2022 20:01
        #24654396

        Хорошо, тогда давайте рассмотрим случай 3n+1 для отрицательных чисел. Сводится к циклам:
        -2,-1;
        -5,-14,-7,-20,-10;
        -25,-74,-37,-110,-55,-164,-82,-41,-122,-61,-182,-91,-272,-136,-68,-34,-17,-50.


        1. moonbase-delta Автор
          23.08.2022 06:45
          #24655166

          Так ведь оно буквально является зеркальным отражением 3n-1:

          -n \rightarrow 3n+1 = -3n + 1 = (-1)(3n-1)

          С той же самой особенностью что ноль остаётся недостижимым и переход через него соответственно невозможен.

          Опять же, тут дело происходит уже с другой структурой, нежели описанная в статье.


  1. emaxx
    22.08.2022 02:30
    #24652202
    +3

    Прекрасно, вы изобрели универсальную отмычку к любой математической задаче!

    Рецепт: переформулировать условие исходя из тривиальных умозаключений, рассмотреть пару примеров, из этих примеров бездоказательно постулировать универсальные правила, вернуться к исходной задаче для завершения "решения".


    1. moonbase-delta Автор
      22.08.2022 03:55
      #24652246

      Ну вообще-то построенные графовые структуры априори включают в себя множество случаев. Обобщение же ситуации до обратного поиска пути по нечётным и вовсе не может произойти без изучения множества примеров.

      Насчёт "бездоказательно постулировать универсальные правила", тут по-моему весь аппарат уже отлично проработан в базовой теории графов из любого курса дискретки. Чтобы утверждать что мы имеем дело с деревом нужно было показать что функции переходов не могут одновременно приводить в одно и тоже число, а также уникальность цикла [1]<->[1.5]. Обе эти ситуации в тексте рассмотрены в 4.2 и 4.4 соответственно.


  1. Refridgerator
    22.08.2022 06:14
    #24652302
    +3

    Алгоритмические пути в математике не являются доказательством, поскольку нельзя аксиоматически проверить корректность алгоритма. Доказательств подобного рода в интернете — вагон. Операция MOD явным образом в математике отсутствует — нужно переходить либо в модулярную либо в комплексную арифметику, где цикличность значений строго обоснована. Сама по себе гипотеза Коллатца ценности не имеет — поскольку очевидно является всего лишь частным случаем определённого класса задач. Корректному доказательству должен предшествовать новый математический аппарат, позволяющий, в том числе, сводить другие задачи к этой.


  1. Akela_wolf
    22.08.2022 11:15
    #24652732
    +2

    В пункте 3 вы рассматриваете два случая: m - четное и m - дробное. Но случай с нечетным m не рассмотрен.

    Дальше вы демонстрируете граф и утрвеждаете что в нем есть единственный цикл между 1 и 1.5. Но это недоказанное утверждение. Например, в графе у вас нет чисел 13 и 14 и вы не доказали что все натуральные числа присутствуют в этом графе. Если же допустить, что 13 отсутствует в графе, то это означает что число с порядковым номером 13 образует свой собственный граф (то есть цикл). Таким образом, доказательство нельзя считать строгим.


    1. moonbase-delta Автор
      22.08.2022 12:28
      #24653038

      Спасибо за уточнение по пункту 3, там правка нужна - должно быть не чётное, а "делится надвое с результатом вида [N.5]", т.е что число целое.

      Относительно 13 и 14 - они присутствуют в графе как в обычном случае, так и в случае когда это порядковые. Чтобы число отсутствовало в графе у него не должно быть точки входа, однако у всех положительных целых чисел начиная с 1 и соответствующих им порядковым номерам эта точка есть и она единственная.

      Чтобы появилось некое число которое не встроено в граф, ему нужно иметь форму отличную от [N] и [N.5], однако построенное от него дерево либо не будет связано с тем что было здесь описано, либо при пересечении породит новую более комплексную структуру. Но во втором случае мы автоматом получим дополнительные переходы которые нужно учитывать и при построении основного графа, и собственно изменит составляющие его числа.

      Цикл между 1 и 1.5 единственный для случая двух соседних вершин. Можно расписать таблицу комбинаций входных и выходных переходов на случай собственно двух соседних вершин, но это добавит условных полторы страницы довольно однообразного текста.

      А для более длинных циклов уже требуется чтобы был возможен более чем один заход в вершину, чего однако не происходит за счёт невозможности прийти в одну вершину обоими переходами сразу.


      1. Akela_wolf
        22.08.2022 13:40
        #24653278
        +3

        А для более длинных циклов уже требуется чтобы был возможен более чем
        один заход в вершину, чего однако не происходит за счёт невозможности
        прийти в одну вершину обоими переходами сразу.

        Почему это требует возможности зайти в вершину двумя путями?
        Как вы доказываете несуществование несвязанного графа?

        Я имею в виду, что может существовать такое множество чисел P, ни в одно число которого невозможно попасть из вашего графа (начинающегося с единицы). И внутри этого графа P вполне может существовать длинный цикл A -> B -> C -> .... -> A

        Пока я не вижу доказательства что продемонстрированный вами граф содержит все полуцелые числа больше или равные единице.


        1. moonbase-delta Автор
          22.08.2022 17:11
          #24653968

          Отличный тейк, пришлось поразмыслить над тотальностью полученного графа.

          Что имеем,

          Если смотреть на "квадратное отображение", то то во второй строке снизу (1.5, 3.5, ...) мы имеем последовательность нечётных чисел к которым добавлена в общем-то литера ".5". Более верхние строки являются домножением целой части этой строки на степень двойки (например [11.5] -> [22.5] -> [44.5] -> ... ). Т.к первая строка образуется всеми нечётными числами, то последующие строки [N.5] постолбчато состоят из некоторой степени двойки и перемножения простых чисел не равных двойке:

          2^r \prod p_i , \; r \ge 0, \; p_i \neq 2

          Соответственно, взяв любое [N.5] и мы можем факторизировать из него степени двойки и получить столбец к которому оно относится.

          При этом, кстати, число [N.5] в первой строке любого столбца своей целой частью равно оригинальному нечётному числу являющемуся основанием столбца. Так "[3] 5" переходит в "[5.5] 10".

          Но таким образом мы однако обосновываем лишь принадлежность всех [N.5] неким столбцам с основаниями [N].

          Далее уже надо обосновать что все [N] принадлежат к графу. И тут, пожалуй, происходит получается самое любопытное - из-за того что у нас есть заранее заданная операцией "плюсового перехода" от [N] к [N] влево по диаграмме, то могут возникнуть подозрения что эти переходы в сочетании с переходами от [N.5] к [N] вправо могут породить замкнутый цикл не связанный с исходной вершиной.

          Где-то тут, мне кажется, пролегает разделение подходов между дискретными структурами и логическими утверждениями. В случае дерева мы можем спокойно предполагать что оно строится уровень-за-уровнем целиком и в таком случае ситуации с "A -> B -> C -> .... -> A" возникнуть не сможет: каждый шаг будет подразумевать приращение уровня глубины графа с закрытием всех входных путей в новые вершин, а переход на новый уровень при этом возможен лишь с от уровня m к уровню m+1. Соответственно, "A lvl (m) -> B lvl (m+1) -> C lvl (m+2) -> .... -> A lvl (m) " попросту не может случиться.

          Если же вместо этого опираться на теоретико-множественный и логистический подход, то пожалуй надо утверждать что выше в этом посте мною обосновано разбиение множества всех валидных [N.5] чисел на классы соответствующие основаниям столбцов, которые можно обозначить например через <[N]>.

          И вот тут начинается ад возвращающий нас обратно к стандартной проблеме: относительно <[N]> мы можем сходу утверждать лишь их частичную упорядоченность в случае с цепочками "размена степеней тройки на степени двойки" в [N] (имею в виду движение по типу [9] -> [6] -> [4]).

          (минутка философии) Учитывая, что таким образом мы вроде как теряем упорядоченность чисел уже гарантированную нам бинарным деревом, то могу предположить что тут мы либо перескакиваем на иное доказательство того же вопроса, либо из такого перехода следует что построенное дерево само по себе и не отвечало на вопрос о присутствии в нём всех натуральных чисел.

          Попробуем теперь всё же атаковать уже эту ситуацию, полагаю что для этого всё в наличии. Но всё-таки,

          \отступление

          Ради интереса замечу отдельно, что <[N]> для того чтобы не включаться в основной граф должен быть частью цикла вида "<[N]> -> ... -> <[M]> -> <[N]>", при этом для того чтобы цикл замкнулся надо чтобы хотя бы один [N] в нём имел число N делящееся на 3 с остатком 2 чтобы быть столбцом порождающим переходы вправо сверху вниз. И это приведёт нас к ситуации где цикл хотя бы одним своим столбцом порождает бесконечное число дополнительных столбцов. Из который в свою очередь некая часть тоже может порождать новые столбцы, и так далее. Естественно после этого можно начать уже жёсткие фокусы заметив прежде всего что ничто не указывает на уникальность такого цикла, а значит их может быть сколько угодно, потом подготовить ранжирование таких циклов по возможной длине. Итд, итд. Ситуация однозначно жуткая.

          Чтобы напрямую побороть эту спекуляцию в таком изложении, мне кажется, может помочь как раз-таки заход на через изучение поведения тут чисел отличных от [N.5] и [N] с дальнейшим сведением ситуации к абсурду через наличие таким образом принципиально разных множеств якобы натуральных чисел. Но для этого, на мой опять же взгляд, к <[N]> должны идти в комплекте операции помогающие соорудить нечто вроде линейных комбинаций.

          \конец-отступления

          Продолжаю,

          Я таки не думал что части статьи статьи после пронумерованных могут быть сколько-то полезные для основного рассуждения, однако теперь мы можем всё же обратиться к дереву нечётных чисел.

          Оно опирается на свойства и наполнение основного бинарного дерева, да. Однако за счёт того что там мы задействуем промежуточные вершины, являющиеся побочными для столбцов в основном графе, то в графе нечётных мы имеем уже фиксированные пределы количества дочерних вершин. Благодаря этому тернарное дерево уже может спокойно задавать полную упорядоченность классов <[N]> на множестве нечётных чисел.

          И так как в данном случае уже нельзя апеллировать к бесконечному числу порождаемых дочерних <[N]> и переходы в визуальном плане все однонаправленные, то я не представляю каким образом там может получиться цикл.

          Дополнительно тут выделю, что функция противохода для нечётных вряд ли возможна без подобной упорядоченности. При этом функция при всей своей лаконичности выдаёт корректные результаты, чего я как-то не встречал ранее. Сама функция тут естественно не является доказательством чего-либо, но я бы отнёс её к сильным аргументам о том что тернарное дерево задаёт упорядоченность <[N]>.

          То что тернарное дерево является естественным следствием расположения чисел в бинарном, думаю, дополнительно доказывать не нужно.


          1. moonbase-delta Автор
            23.08.2022 08:31
            #24655274

            А меж тем кажется сложилась аргументация насчёт циклов, вечером (нахожусь во Владивостоке) постараюсь расписать.


        1. moonbase-delta Автор
          24.08.2022 16:24
          #24660098

          По циклам,

          Тут ключевой момент, пожалуй, будет в том как именно мы относимся к переходам между вершинами. По всей логике наблюдаемой ситуации переходы задают упорядоченность всем вершинам графа.

          Отношение /

          Из-за того что в вершину доступен лишь один вход, а число переходов из неё 1-2, то


    1. moonbase-delta Автор
      22.08.2022 13:13
      #24653166

      Поправил пункт 3


  1. Akela_wolf
    22.08.2022 11:41
    #24652854
    +2

    Переходы определены для всех [N] и [N.5] начиная с [1].

    "Входящий" переход соответствует шагу в гипотезе Коллаца (то есть применению операции 3n+1 или n/2 в зависимости от того четное это число или нет). Соответственно у любого числе действительно есть входящее ребро и оно единственное (так как шаг однозначен). Так у числа 8 [3.5] входящее ребро из числа 4 [m=1.5], у числа 15 [7] входящее ребро из числа 46 [22.5]

    Исходящий переход, соответственно - числам, которые являются "предками" данного числа. Для любого числа n есть как минимум число 2n, являющееся очевидным "предком". А также может существовать число (n-1)/3, в случае если оно является целым, то есть у нас от 1 до 2 исходящих ребер.

    В каждую вершину графа может быть лишь одна точка входа.

    Следует из определения входящего ребра - это ребро от предка к потомку, у нас по определению не может быть двух потомков.

    В качестве исходной вершины будет положена [1], т.к она является наименьшей в графе.

    Очевидно.

    Граф содержит единственный цикл между двумя соседними вершинами: [1] \leftrightarrow [1.5]

    Требует доказательства, так как вы на этом утверждении основываете все остальное.

    При продолжительном движении назад по переходам [N.5] переходит в [N]

    Тривиально. Как следуюет из определения входящего ребра, это отношение "предок-потомок", соответствено "обратное движение" по таким ребрам - это "прямое движение" по последовательности чисел. [N.5] является четным числом, соответственно прямое движение будет заключаться в делении на 2, пока мы не получим нечетное [N]

    Здесь же стоит отметить, что уникальными являются как значения вершин
    графа, так и значения рёбер. Значение вершины однозначно определяет
    родительскую вершину а также одну или две дочерние вершины, а значение
    ребра - обе вершины которые оно соединяет.

    Про вершины понятно - это следует из первого абзаца моего комментария. А вот про значения ребер - требует доказательства.


    1. moonbase-delta Автор
      22.08.2022 13:05
      #24653148

      Насчёт 1 и 1.5 ответил к посту выше.

      По значениям рёбер, не посчитал нужным углубляться, т.к далее не используется. Но там всё также упирается в определение переходов между вершинами.

      К примеру, в случае [22.5] по изложенному алгоритму мы всё же имеем от него переход вперёд в [15] с разницей +7.5 (здесь плюс для маркировки вида перехода), и переход назад в [11.5] со значением ребра в -11. Т.к мы сохраняем знак, то каждое из чисел мы лишь единожды проверяем на переходах в начале пункта 3, оба из которых легко строятся в обратную сторону. Получаем таким образом, тот же [22.5] через 11*2+0.5 ни одно другое число [11] тут породить просто не сможет.

      Вот что было бы интересно доказать отдельно - это наличие в рёбрах графа всех чисел от 0.5 и далее с шагом по 0.5 с обоими знаками, после чего описать альтернативную визуализацию где в вертикальных столбцах получатся останутся уже только числа вида [N] расставленные по значению входящего перехода (связанные с ними рёбра при этом будут иметь крайне хаотичную структуру).


  1. karambaso
    22.08.2022 14:58
    #24653556
    +1

    В пункте №2 своего "доказательства" автор заявляет:

    Это справедливо также и для чётных чисел

    Но это не так. Точнее, автор применил подход, который применим к нечётным числам, к числам чётным. Сам по себе подход применять можно хоть к чему, но только такое применение никак не связывает его с рассматриваемой гипотезой.

    В случае с гипотезой имеем предложение автора, предлагающее определить i+1 член последовательности через формулу из двух вариантов:

    n[i+1]=1.5*n[i]+0.5

    n[i+1]=n[i]/2

    Далее автор рассуждает про какие-то конкретные числа, на примере которых он и заключает, что

    Это справедливо также и для чётных чисел

    Но если бы автор не рассуждал о конкретных числах, а вывел бы простейшую формулу, то всё бы оказалось совсем по другому. Формула такая:

    n[i]=2i-1

    Из неё, подставляя 2i-1 вместо n[i], получаем:

    n[i+1]=3i-1=2i-1+i=n[i]+i

    n[i+1]=i-0.5=(2i-1)/2=n[i]/2

    То есть для нечётных чисел всё красиво, но вот для чётных, утверждение "Это справедливо также и для чётных чисел" означает, что 3i-1=i-0.5. Немного преобразуем и получим: 2i-0.5=0

    После такого очевидного ухода в дебри далее читать данного автора не стоит.

    PS

    Не смотря на смелое манипулирование математической терминологией автор так и не осилил даже переход к показанной выше очень простой формуле. Поэтому и результат такой.


    1. moonbase-delta Автор
      22.08.2022 17:37
      #24654034

      Про "справедливо также и для чётных чисел" речь шла исключительно о преобразовании чисел в порядковые номера.

      Быть может я чего-то совсем уж путаю, но вроде нигде в тексте/коде "нечётная" ветка cltz(n) не использована для чётных чисел. Постоянно однако идут указания на разницу поведения в графе числе [N.5] и [N].


      1. karambaso
        23.08.2022 22:24
        #24657766

        Ваша проблема состоит в неумении подать материал. Вам, возможно, какие-то выводы кажутся очевидными, но для остальных это не так. Поэтому перепишите статью полностью. Да, с нуля и не пропуская ни одного доказательства. Кажется слишком тяжёлым трудом? Ну что-ж, оставайтесь с тем, что есть - с игнорированием вас всеми остальными.

        По доказательствам подскажу - формулы выше сводят несколько страниц вашего текста к короткому описанию использованных в формулах переменных. То есть на самом деле писать нужно намного меньше, чем написали вы. Только писать нужно по другому. Именно поэтому нужно переписать с нуля.

        Вообще, умение строить логические цепочки отличает человека от робота. Вы же выдаёте некий поток уровня GPT-3, но у последнего обычно части текста бессвязны и сразу видно отсутствие логики у писателя, у вас же связи между фрагментами вроде есть, но в целом получается что-то совершенно неудобоваримое. Возможно, так выглядят тексты GPT-4. Не будьте похожим на робота. Сделайте работу по человечески.


        1. moonbase-delta Автор
          24.08.2022 06:22
          #24658232

          Статья получилась сырая, тут уже однозначно согласен, многое хочется переоформить. Во многом это связано с тем, что я ещё банально не чувствую хаброаудиторию, ну да ладно.

          В дальнейшем, полагаю, переделанная версия ещё будет, но это явно не пары дней процесс.

          ----

          А насчёт логических-цепочек-и-роботов решительно не соглашусь. У нейронок и компьютеров не с логикой беды, а с семантикой.


  1. andyudol
    22.08.2022 16:47
    #24653906

    Интересно, что существует подмножество чисел, для которого гипотеза доказывается почти так же просто, как для степеней двойки.

    Представьте себе число, четверичная запись которого в каждом разряде содержит единицу. Умножьте на три. Прибавьте единицу. Всё!


    1. moonbase-delta Автор
      22.08.2022 17:42
      #24654050

      Хех, ну это буквально набор всех чисел вида [N] получающихся из вершин первого же столбца.


  1. randomsimplenumber
    22.08.2022 16:48
    #24653914

    Такое ощущение, что первые несколько серий этого сериала пропустил, и теперь не совсем понимаю, что происходит.