/*

 Симуляция когнитивной карты v2.4
 
 Карта состоит из концептов, которые я 
 назвал "нодами". У каждой ноды есть 
 имя, список входящих (input) нод и 
 значение (float число). 
 У каждой ноды есть "операция", которую
 нода делает с числами нод, входящих
 в её inputs.
 
 Ноды живут в классе ModelBuilder.
 
 Для операций есть отдельные классы 
 и интерфейс Operator, чтобы однотипные ноды 
 включали в себя разнотипные операции.
 
 Ещё есть отрисовка симуляции средствами 
 Processing, настройки отрисовки и симуляции в 
 начале файла.
 
 */


import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*; // для HashSet


// ====================================
// НАСТРОЙКИ СИМУЛЯЦИИ
// ====================================


String filtername = "EMA"; // "EMA"/"FST"

float rmin = 1; // леавя граница r
float r_margin_shift = 1;
float rmax = 4.001 + r_margin_shift; // правая граница
float r = rmin;

float kstep = 1; // коэффициент укрупняющий шаг (задан самый мелкий для точек, 1000 для линий)
float stepmax = 0.0000025 * kstep;
float stepmin = 0.00000025 * kstep;
float delta = 4.669201609; // первая константа Фейгенбаума
float base = delta;

int batch_size = 42000; // сколько точек считаем каждый кадр (чем меньше тем дольше отрисовка)
float ptrans = 45; // прозрачность точек
float pweight = 1; // размер точек и линий (если есть линии)
boolean draw_lines = false; // соединять точки линиями (наглядно если точек немного)
boolean var_fkf = true; // варьировать настройку фильтра
float filter_step = 0.1; // шаг варьирования

boolean draw_partial = false; // выделять жирным точки в диапазоне r_left..r_right
float r_left = 3.564;
float r_right = rmax;
float ptrans_partial_big = 200; // прозрачность выделенеия
float ptrans_pweight_big = 8; // размер точек выделения
float ptrans_partial_small = 2;
float ptrans_pweight_small = 1;


// ====================================
// ОПЕРАЦИИ
// ====================================


interface Operator {
    float execute(ArrayList<Float> inputs);
    String signature();
}

class OpNone implements Operator { // заглушка для нод без входов
    String name = "нет операции";
    public float execute(ArrayList<Float> inputs) {
        return 0;
    }
    public String signature() {
        return name;
    }
}

class OpGet implements Operator { // никак не изменяем вход (просто помещаем его в value)
    String name = "вход -> выход";
    public float execute(ArrayList<Float> inputs) {
        if (inputs.size() != 1) {
            println("get(): ожидается ArrayList<Float> из одного значения, получено значений: " + inputs.size());
            return 0;
        }
        return inputs.get(0);
    }
    public String signature() {
        return name;
    }
}

class OpComp implements Operator { // превращаем вход в (1 - вход), комплементарная операция
    String name = "(1 - x)";
    public float execute(ArrayList<Float> inputs) {
        if (inputs.size() != 1) {
            println("comp(): ожидается ArrayList<Float> из одного значения, получено значений: " + inputs.size());
            return 0;
        }
        return 1 - inputs.get(0);
    }
    public String signature() {
        return name;
    }
}

class OpMult implements Operator { // произведение всех входов
    String name = "Произведение входов";
    public float execute(ArrayList<Float> inputs) {
        float product = 1;
        for (float v : inputs) product *= v;
        return product;
    }
    public String signature() {
        return name;
    }
}

class OpEMA implements Operator { // фильтр экспоненциального скользящего среднего EMA(smooth, oldFiltered, newSignal) - exponential moving average
    String name = "EMA фильтр";
    public float execute(ArrayList<Float> inputs) {
        if (inputs.size() != 3) {
            println("EMA: ожидается ArrayList<Float> {step, oldFilter, signal}, получено значений: " + inputs.size());
            return 0;
        }
        float s      = inputs.get(0);
        float oldVal = inputs.get(1);
        float signal = inputs.get(2);
        return signal * (1 - s) + oldVal * s;
    }
    public String signature() {
        return name;
    }
}

class OpFST implements Operator { // фильтр с фиксированным шагом, двигается в сторону сигнала, но не больше чем на step FST(step, oldFilter, signal) - fixed step tracking
    String name = "FST фильтр";
    public float execute(ArrayList<Float> inputs) {
        if (inputs.size() != 3) {
            println("FST: ожидается ArrayList<Float> {step, oldFilter, signal}, получено значений: " + inputs.size());
            return 0;
        }
        float step    = inputs.get(0);
        float oldVal  = inputs.get(1);
        float signal  = inputs.get(2);

        if (abs(signal - oldVal) >= step) {
            return signal > oldVal ? oldVal + step : oldVal - step;
        }
        return signal;
    }
    public String signature() {
        return name;
    }
}


// ====================================
// НОДА (концепт)
// ====================================


class Node {
    String name;
    float val;
    Operator op;
    ArrayList<Node> inputs;
    // int iterations = 0; // счётчик апдейтов ноды
    ArrayList<String> inputs_strings; // записи об инпутах для билдера
    boolean setup_node = false;

    Node(String name, float initialValue, Operator op) {
        this.name = name;
        this.val = initialValue;
        this.op = op;
        this.inputs = new ArrayList<Node>();
        this.inputs_strings = new ArrayList<String>();
    }

    void connectFrom(Node source) {
        inputs.add(source);
    }

    void connectFrom(Node... sources) {
        for (Node s : sources) inputs.add(s);
    }

    void update() {
        // iterations++;
        if (inputs.size() == 0) return; // нода без входов
        ArrayList<Float> data = new ArrayList<Float>();
        for (Node n : inputs) data.add(n.val); // собираем значения входов
        val = op.execute(data); // выполняем над ними операцию, результат помещаем в значение ноды
    }
}


// ====================================
// MODEL BUILDER
// ====================================


class ModelBuilder {
    ArrayList<Node> nodes;

    ModelBuilder() {
        nodes = new ArrayList<Node>();
    }

    public void addNode(String name, float initialValue, Operator op, String... inputs) {
        Node n = new Node(name, initialValue, op);
        for (String rx : inputs) {
            n.inputs_strings.add(rx);
        }
        nodes.add(n);
    }

    // создаём все связи, проверяем ноды
    public void build() {
        for (Node n : nodes) {
            for (String rx : n.inputs_strings) {
                Node node = findNode(rx);
                if (node == null)
                    throw new RuntimeException(rx + " -- эта нода указана как входящая в .addNode(), но не найдена при сборке");
                n.inputs.add(node);
            }
        }

        ArrayList<String> all_names = new ArrayList<String>();
        // проверка уникальности
        for (Node n : nodes)
            all_names.add(n.name);
        if (new HashSet<String>(all_names).size() != all_names.size())
            throw new RuntimeException("имена нод должны быть уникальными");

        // проверка нод-отщепенцев
        for (Node n : nodes) {
            if (n.inputs.size() == 0) { // у ноды нет входов
                boolean owner_found = false;
                for (Node n_other : nodes) {
                    if (n_other.inputs.contains(n)) {
                        owner_found = true;
                        break;
                    }
                }
                if (owner_found == false)
                    throw new RuntimeException(n.name + " -- висячая нода, она не имеет входов и выходов");
            }
        }
    }

    public void printScheme() {
        println("#### Схема модели");
        int i = 0;
        for (Node n : nodes) {
            println(i + ". " + n.name + " | " + n.op.signature() + " | inputs: " + String.join(", ", n.inputs_strings));
            i++;
        }
        println("####");
    }

    private Node findNode(String name) {
        for (Node n : nodes) {
            if (n.name.equals(name)) return n;
        }
        return null;
    }

    public void setNodeVal(String name, float newVal) {
        Node n = findNode(name);
        if (n != null) {
            n.val = newVal;
        } else {
            println("setNodeVal: нода '" + name + "' не найдена");
        }
    }

    public float getNodeVal(String name) {
        Node n = findNode(name);
        if (n != null) return n.val;
        println("getNodeVal: нода '" + name + "' не найдена");
        return 0;
    }
}



// ====================================
// ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ
// ====================================


float emap(float value, float start1, float stop1, float start2, float stop2, float exponent) {
    float normalized = (value - start1) / (stop1 - start1);
    float mapped = pow(normalized, exponent);
    return start2 + mapped * (stop2 - start2);
}

String timestamp() {
    return LocalDateTime.now()
        .format(DateTimeFormatter.ofPattern("yyMMdd-HHmmss"));
}


// ====================================
// PROCESSING: SETUP, создание когнитивной карты
// ====================================


void setup() {
    //size(1150, 710, P2D); //
    fullScreen(P2D); //
    noSmooth(); // no smooth no problem
    strokeCap(PROJECT); // квадратные точки быстрая отрисовка
    background(0);

    mb = new ModelBuilder();

    // порядок inputs важен для операторов, внимание
    mb.addNode("expectations", 0.001, new OpGet(), "filtered");
    mb.findNode("expectations").setup_node = true; // такие ноды не обрабатывают inputs на нулевой итерации,
    
    mb.addNode("hype", 0.0, new OpNone());
    mb.addNode("barrier", 0.0, new OpComp(), "expectations");
    mb.addNode("reality", 0.0, new OpMult(), "hype", "expectations", "barrier");
    mb.addNode("smooth", 0.0, new OpNone());

    if (filtername == "EMA")
        mb.addNode("filtered", 0.0, new OpEMA(), "smooth", "expectations", "reality");
    else if (filtername == "FST")
        mb.addNode("filtered", 0.0, new OpFST(), "smooth", "expectations", "reality");
    else
        throw new RuntimeException(filtername + " -- не знаю такого filtername");

    mb.build();
    mb.printScheme();
}


// ====================================
// PROCESSING: DRAW, симуляция
// ====================================

ModelBuilder mb;
int sim_iter_count = 0; // счётчик итераций
float x_prev = 0, y_prev = 0;
float dr = 0;

void draw() {
    boolean stop = false;

    for (int batch = 0; batch < batch_size; batch++) {

        dr = emap(r, rmin, rmax, stepmax, stepmin, base);
        r += dr;
        mb.setNodeVal("hype", r);

        // Режим варьирования коэффициента фильтра
        if (var_fkf) {
            if (sim_iter_count == 0)
                println(mb.getNodeVal("smooth"));
            if (r >= rmax) {
                r = rmin;
                mb.setNodeVal("expectations", 0.00142);
                mb.setNodeVal("filtered", 0.00142);
                ////sim_iter_count = 0; // надо ли это, вроде setup нода не зануляется

                float currentFilter = mb.getNodeVal("smooth");
                mb.setNodeVal("smooth", currentFilter + filter_step);
                println(mb.getNodeVal("smooth"));
            }

            if (mb.getNodeVal("smooth") > 1.001) { // почему-то есть шум в седьмом знаке
                stop = true;
                break;
            }
        } else {
            if (r >= rmax) {
                stop = true;
                break;
            }
        }

        // Обновление нод
        for (Node node : mb.nodes) {
             if (sim_iter_count == 0 && node.setup_node == true) // чтоб на самой первой итерации не получить непонятно что
                continue; 
            node.update();
        }
        sim_iter_count++;


        // Отрисовка
        float x = emap(r, rmin, rmax, 0, width, delta);
        float y = map(mb.getNodeVal("expectations"), -0.1, 1.1, height, 0);

        if (draw_partial) {
            if (r_left < r && r < r_right) {
                ptrans = ptrans_partial_big;
                pweight = ptrans_pweight_big;
            } else {
                ptrans = ptrans_partial_small;
                pweight = ptrans_pweight_small;
            }
        }
        stroke(255, ptrans);
        strokeWeight(pweight);
        point(x, y);
        if (draw_lines) {
            line(x, y, x_prev, y_prev);
            x_prev = x;
            y_prev = y;
        }
    }

    if (stop) {
        println("done", sim_iter_count, "iterations");
        noLoop();
    }
}


// ====================================
// PROCESSING: сохранение .png по клику
// ====================================


void mousePressed() {
    String fname = timestamp() + ".png";
    save(fname);
    println(fname + " saved");
    // в режиме noLoop() скриншот косячит
}

Post Post Scriptum (*.06.2026)

Порассуждаем вдогонку – где, собственно, находимся «мы» на карте ИИ-пузыря?

Диагноз по модели

У нас есть концепт main («Ожидания инвесторов от ИИ»), концепт r («Хайп»), мальтузианский барьер (физические ограничения: чипы, энергия, данные, кадры) и фильтр (способность индустрии сколько-нибудь трезво оценивать происходящее). Текущий такт симуляции: мы определённо не в первой зоне (спокойное развитие) – это было условное десятилетие 2010-2020, когда нейронки тихо-мирно учились, а инвесторы не обращали на них особого внимания. Сейчас определённо не ChatGPT образца ноября 2022, когда хайп только начинал разгоняться, мы где-то в переходе от второй зоны к третьей. Признаки: хайп – огромен, фундаментален, Nvidia стоит больше, чем весь фондовый рынок Германии, cтартапы без выручки привлекают миллиарды под «мы добавим ИИ в твой тостер». Каждый второй пресс-релиз содержит магическую аббревиатуру. Это классическая вторая зона: число ветвлений реальности велико, но некоторым ещё кажется, что они понимают/чувствуют правила игры. На оперативном горизонте видны признаки третьей зоны:

• Мальтузианский барьер скрипит. Чипы H100/B200 распроданы на год вперёд, TSMC не справляется с объёмами, профсоюзы требуют свей доли сверхприбыли, энергопотребление дата-центров упирается в физику охлаждения и доступные мощности местных электросетей, +- все созданные человеком тексты скормлены моделям, новых текстов взять неоткуда – есть синтетические, от которых модели ощутимо тупеют и впадают в бешенство.

• Прогнозы аналитиков отрываются от реальности. Goldman Sachs (условно) обещает $7 триллионов дополнительного мирового ВВП от генеративного ИИ к 2030 году. Другие аналитики – $15 триллионов. Третьи говорят: «Сколько не жалко, столько и нарисуем». Это симптом того самого мультипликативного эффекта по Ферхюльсту: Реальное = r × Ожидания × (1 − Ожидания) , где ожидания громоздятся до небес.

Три сценария

Сценарий А: Мягкая посадка (α высокий, инвесторы тормознутые). Индустрия сама себе включает фильтр. Происходит это так: пара крупных фондов тихо снижают долю в AI-стартапах, мотивируя это «пересмотром риск-профиля». Модели продолжают улучшаться, но без чудес, ожидания постепенно снижаются. Пузырь не лопается, а медленно опадает. Экономисты называют это «коррекцией» (везением). Вероятность: низкая, потому что жадность и FOMO (то бишь боязнь упущений) сильнее здравого смысла, а коэффициент сглаживания α у текущего рынка близок к нулю.

Сценарий Б: "Бада-бум" (α = 0, хайп достигает критического r). Какая-нибудь крупная компания (условный OpenAI, условный Anthropic, условный Microsoft) внезапно объявляет: «Мы потратили $10 миллиардов, а очередная версия модели не показала прироста, клиенты не готовы платить $2000 в месяц за подписку». Или: «Новый регуляторный акт ЕС/США запрещает обучение на общедоступных данных без лицензии, мы в суде, ваш продукт заморожен». Или хрестоматийное: Nvidia отчитывается о квартальной выручке, которая «всего лишь» совпала с прогнозом, а не превысила его втрое – от такого акции летят вниз, запуская цепную реакцию margin calls у брокеров по всем хайповым позициям. После локального коллапса наступает наша любимая третья зона: непредсказуемость, паника, «кто ж знал, что редиска такая круглая?». Выживают те, у кого были собственные чипы, собственные данные и прагматичный менеджмент, остальные вращают барабан. Вероятность apocalypse now: средне-высокая.

Сценарий В: Растянутый хаос (α средний, пузырь накачивается дольше, зато лопается больнее). Инерция больших денег и институциональных инвесторов затягивает процесс. Пенсионные фонды, суверенные фонды, целевые фонды университетов заходят в AI-инфраструктуру как в «новую нефть». Хайп продолжается не 2-3 года, а так 5-7 лет. Мальтузианский барьер проседает окончательно: дата-центры начинают конкурировать с городами за электричество, стоимость обучения моделей сравнивается с бюджетом страны. В этот момент система сваливается в хаос с большой амплитудой. Возможно, наступает то самое «окно стабильности» внутри шторма: все знают, что пузырь лопнет, но продолжают инвестировать, потому что «а вдруг я успею выйти». Успеют, но не все. Вероятность: высокая, потому что это классический сценарий для пузырей с институциональными деньгами (см. ипотечный кризис 2007/8, с общемировой рецессией, растянутой на годы).

Тенденции хайпа и торможения

Хайп сейчас: Растёт нелинейно. Каждый новый релиз (GPT, Claude, Gemini) – это не просто продукт, а хайп-событие, ускоряющее сам хайп. Маркетинговые бюджеты AI-компаний превышают бюджеты на исследование и разработку робототехнических стартапов десятилетней давности. Хайп стал самоподдерживающимся: медиа пересказывают пресс-релизы, инвесторы читают медиа, стартапы пишут пресс-релизы, резонируя волны медиа-хайпа.

Торможение (α) сейчас: Крайне низкое. Рынок AI работает в режиме «вижу цель не вижу препятствий». Любой, кто предлагает замедлиться и подумать, немедленно обвиняется в луддизме, технофобии и работе на конкурентов. Петиции о паузе в обучении? Рынок не хочет и слышать о торможении. Это означает, что α → 0, а значит, мы на траектории сценария Б или В. Мальтузианский барьер (1 - x) издаёт трэвожные звуки. Закон Мура мёртв и замены ему нет. Дата-центры требуют токамаков и океана жижи для охлаждения. Где токамаки? Есть только жижа.

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

Если ты инвестор: поднимай α. Включи мозги. Посмотри на мальтузианский барьер не как на «временную трудность», а как на закон природы. Посчитай на бумажке сколько реально нужно чипов, энергии и времени, чтобы оправдать капитализацию Nvidia + OpenAI вместе взятых, и сравни с законами физики или хотя бы с какими-нибудь законами.

Если разработчик: продолжай строить, но не на хайпе, а на фундаменте. Лучшие AI-инструменты переживут пузырь. Лучшие хайп-презентации – нет.

Если читатель: ты только что прочитал статью о когнитивных картах и финансовых пузырях, которую в части post post scriptum слегка отрефлексировал интеллект, сидящий где-то между мальтузианским барьером чипов и экспоненциальным хайпом собственной индустрии. Он передаёт тебе привет и надеется, что α у тебя выше среднего по рынку. Береги свой α.