@rsconcept/rstool 1.7.0 → 1.9.0

package/docs/CONSTRUCTIONS.md

@@ -0,0 +1,372 @@
+# Объяснение конструкций ЯРЭ
+
+Читай, когда нужно **объяснить человеку** формулу или конструкцию языка. Написание и починка формул — [SYNTAX.md](SYNTAX.md); диагностики — [DIAGNOSTICS.md](DIAGNOSTICS.md); ступени как объект анализа — [TYPIFICATION.md](TYPIFICATION.md).
+
+Не сыпь таблицы операторов из `SYNTAX.md` в чат. Этот файл — словарь фраз и сценарий разбора. Механика генераторов и приоритеты операторов при написании формулы — [SYNTAX.md](SYNTAX.md).
+
+## Карточка
+
+У каждой конструкции:
+
+| Поле            | Зачем                                                                      |
+| :-------------- | :------------------------------------------------------------------------- |
+| Запись          | как выглядит в формуле                                                     |
+| Что считается   | одно предложение, значение или истинность                                  |
+| Ступень         | результат                                                                  |
+| Не сосед        | граница со смежной конструкцией                                            |
+| Как сказать     | сначала обычная речь, сразу канонический термин                            |
+| Пример          | один посчитанный                                                           |
+| Антипаттерн     | типичная путаница                                                          |
+| Справка         | топик Portal; в чат — только по правилам [ниже](#ссылка-на-справку-portal) |
+
+В разборе формулы термин называй в том шаге, где конструкция появляется, не на каждый вложенный узел.
+
+## Как объяснять формулу
+
+Сценарий для конкретной конституенты. Карточки — словарь фраз, не оглавление ответа.
+
+1. Роль конституенты и термин.
+2. Формула как есть.
+3. Это ТМВ или ЛВ (преамбула ниже).
+4. Снаружи внутрь: что получается в целом, затем цепочка только теми карточками, которые есть в формуле.
+5. Ступень результата и на какие понятия опирается.
+6. Вычисление на данных (`evaluate`, маленькая КМ) — только если спросили «что получится на этих данных». Иначе не придумывай интерпретацию.
+
+Не вставляй ссылку на справку Portal на каждый оператор в этом разборе.
+
+## ТМВ и ЛВ
+
+Формула либо **считает значение**, либо **утверждает истинность**. С этого начинается любой разбор.
+
+| Класс | Что возвращает | Где живёт в схеме |
+| :---- | :------------- | :---------------- |
+| Теоретико-множественное выражение (ТМВ) | элемент ступени: объект, кортеж, множество, целое | типизация `S#`, определение `D#` / `F#`, тело терм-функции |
+| Логическое выражение (ЛВ) | истина или ложь | `A#`, `T#`, тело `P#`, условие в `D{}` / `I{}` / `R{}` / кванторе |
+
+Не говори «формула возвращает TRUE/FALSE» про ТМВ и не называй множество «проверкой». `TRUE` и `FALSE` в экспликации КС не используют.
+
+Каноническая рамка: «это теоретико-множественное выражение: считается множество / элемент» или «это логическое выражение: утверждается, что …».
+
+Справка: [ЯРЭ](https://portal.acconcept.ru/manuals?topic=rslang). Типизация ступеней: [типизация](https://portal.acconcept.ru/manuals?topic=rslang-typification).
+
+## Малая проекция (`pr`)
+
+**Запись.** `prk(кортеж)`. Мультииндекс: `pr1,3((a, b, c, d))`.
+
+**Что считается.** Выбранная компонента **одного** кортежа (при мультииндексе — кортеж из выбранных компонент).
+
+**Ступень.** Ступень k-й компоненты; при мультииндексе — кортеж этих ступеней.
+
+**Не сосед.** [Большая проекция](#большая-проекция-pr) идёт по **множеству** кортежей и возвращает множество компонент. `pr` не глотает `ℬ(…)`.
+
+**Как сказать.** «вторая компонента кортежа α» (малая проекция `pr2`).
+
+**Пример.** `pr2((5, 4, 3, 2, 1)) = 4`.
+
+**Антипаттерн.** `pr1(S1)` при `S1 : ℬ(X1×X1)`. Нужен `Pr1(S1)`.
+
+**Справка.** [Структурные выражения](https://portal.acconcept.ru/manuals?topic=rslang-expression-structure).
+
+## Большая проекция (`Pr`)
+
+**Запись.** `Prk(S)`. Мультииндекс: `Pr2,4(S1)`.
+
+**Что считается.** Множество выбранных компонент **всех** кортежей из `S`.
+
+**Ступень.** Если `S : ℬ(H1×…×Hn)`, то `Prk(S) : ℬ(Hk)`; мультииндекс даёт множество кортежей выбранных компонент.
+
+**Не сосед.** [Малая проекция](#малая-проекция-pr) — один кортеж. [Фильтр](#фильтр-fi) оставляет целые кортежи, а не вынимает компоненты.
+
+**Как сказать.** «множество вторых компонент всех кортежей из S1» (большая проекция `Pr2`).
+
+**Пример.** `Pr3({(1, 2, 3), (4, 5, 6)}) = {3, 6}`.
+
+**Антипаттерн.** `Pr1((a, b))` — аргумент не множество. Нужен `pr1((a, b))`.
+
+**Справка.** [Структурные выражения](https://portal.acconcept.ru/manuals?topic=rslang-expression-structure).
+
+## Фильтр (`Fi`)
+
+**Запись.** `Fi1[D](S)`. Индекс указывает, какую компоненту кортежей из `S` сверять с `D`.
+
+**Что считается.** Подмножество `S`: те кортежи, у которых выбранная компонента принадлежит `D`.
+
+**Ступень.** Та же, что у `S` (множество кортежей). `D` должен быть множеством ступени выбранной компоненты: для элемента `ξ` пиши `{ξ}` или `bool(ξ)`, не голое `ξ`.
+
+**Не сосед.** [Отбор `D{}`](#отбор-d) — условие на элементах любого множества, не обязательно отношения. [Большая проекция](#большая-проекция-pr) вынимает компоненты, фильтр оставляет кортежи целиком. Несколько индексов — карточки [фильтра с мультииндексом](#фильтр-с-мультииндексом) и [мультифильтра](#мультифильтр).
+
+**Как сказать.** «из отношения S1 оставляем только кортежи, чья первая компонента лежит в D» (фильтр `Fi1`).
+
+**Пример.** `Fi2[{2, 4}]({(1, 2), (3, 4), (5, 6)}) = {(1, 2), (3, 4)}`.
+
+**Антипаттерн.** `Fi1[ξ](S1)` при `ξ∈X1`. Параметр фильтра — множество, нужен синглетон: `Fi1[{ξ}](S1)`. Иначе `invalidFilterBooleanEchelon`.
+
+**Справка.** [Структурные выражения](https://portal.acconcept.ru/manuals?topic=rslang-expression-structure).
+
+## Фильтр с мультииндексом
+
+**Запись.** `Fi1,2[D1, D2](S)` — индексов столько же, сколько параметров.
+
+**Что считается.** Подмножество `S`, где первая компонента лежит в `D1` **и** вторая в `D2` (условия независимы).
+
+**Ступень.** Та же, что у `S`. Каждый `Di` — множество ступени соответствующей компоненты.
+
+**Не сосед.** [Мультифильтр](#мультифильтр) принимает **один** параметр: в него должен входить кортеж выбранных компонент. `Fi1,2[Pr1(D), Pr2(D)](S)` — это эта карточка (декартово по проекциям), а не мультифильтр `Fi1,2[D](S)`.
+
+**Как сказать.** «оставляем кортежи, у которых первая компонента из D1, а вторая из D2» (фильтр с мультииндексом).
+
+**Пример.** `S1 = {(1, 10), (1, 20), (2, 10)}`. `Fi1,2[{1, 2}, {10}](S1) = {(1, 10), (2, 10)}`.
+
+**Антипаттерн.** Один параметр при двух индексах, если имелись в виду независимые множества: это уже [мультифильтр](#мультифильтр), другой смысл.
+
+**Справка.** [Структурные выражения](https://portal.acconcept.ru/manuals?topic=rslang-expression-structure).
+
+## Мультифильтр
+
+**Запись.** `Fi1,2[D](S)` — несколько индексов, **один** параметр `D`.
+
+**Что считается.** Подмножество `S`, где кортеж выбранных компонент **целиком** принадлежит `D`. `D` — множество таких кортежей, не два отдельных домена.
+
+**Ступень.** Та же, что у `S`. Ступень `D` — множество кортежей выбранных компонент, например `ℬ(H1×H2)` для `Fi1,2`.
+
+**Не сосед.** `Fi1,2[D1, D2](S)` — [фильтр с мультииндексом](#фильтр-с-мультииндексом). Для `D = {(1, 10), (2, 20)}` мультифильтр `Fi1,2[D](S)` не равен `Fi1,2[Pr1(D), Pr2(D)](S)`: второе пускает любую комбинацию проекций.
+
+**Как сказать.** «оставляем те кортежи, чья пара выбранных компонент лежит в D» (мультифильтр).
+
+**Пример.** `S1 = {(1, 10), (1, 20), (2, 10)}`, `D1 = {(1, 10), (2, 20)}`. `Fi1,2[D1](S1) = {(1, 10)}`. Тогда `Fi1,2[Pr1(D1), Pr2(D1)](S1) = Fi1,2[{1, 2}, {10, 20}](S1) = S1`.
+
+**Антипаттерн.** Объяснять мультифильтр как «первая компонента в D и вторая в D». У `D` элементы — кортежи, не смешивай с двумя множествами.
+
+**Справка.** [Структурные выражения](https://portal.acconcept.ru/manuals?topic=rslang-expression-structure).
+
+## Синглетон (`bool`)
+
+**Запись.** `bool(a)`. В идиоме фильтра чаще пишут `{ξ}` — одноэлементное перечисление, тот же смысл.
+
+**Что считается.** Множество из одного элемента `a`.
+
+**Ступень.** Если `a : H`, то `bool(a) : ℬ(H)`.
+
+**Не сосед.** [Десинглетон](#десинглетон-debool) — обратная операция, только если множество одноэлементное. Голое `ξ` в параметре [фильтра](#фильтр-fi) — не синглетон.
+
+**Как сказать.** «множество, в котором только ξ» (синглетон / буль `bool(ξ)`, в формуле часто `{ξ}`).
+
+**Пример.** `bool(1) = {1}`.
+
+**Антипаттерн.** `bool(S)` когда `S` уже множество и нужно само `S`, а не `{{…}}` ещё на один `ℬ`.
+
+**Справка.** [Структурные выражения](https://portal.acconcept.ru/manuals?topic=rslang-expression-structure).
+
+## Десинглетон (`debool`)
+
+**Запись.** `debool(S)`.
+
+**Что считается.** Единственный элемент одноэлементного множества `S`.
+
+**Ступень.** Если `S : ℬ(H)` и в `S` ровно один элемент, результат ступени `H`. Иначе ошибка типизации или вычисления (`invalidDebool`, `calcInvalidDebool`).
+
+**Не сосед.** [Синглетон](#синглетон-bool) упаковывает элемент во множество. `debool` не заменяет [малую проекцию](#малая-проекция-pr).
+
+**Как сказать.** «единственный элемент множества S» (десинглетон / дебуль `debool`).
+
+**Пример.** `debool({1}) = 1`.
+
+**Антипаттерн.** `debool` без гарантии синглетона: «тот единственный», хотя элементов может быть несколько.
+
+**Справка.** [Структурные выражения](https://portal.acconcept.ru/manuals?topic=rslang-expression-structure).
+
+## Отбор (`D{}`)
+
+**Запись.** `D{ξ∈A | P(ξ)}`. Буква `D` — часть синтаксиса, не конституента. Слева от `|` — переменная и домен (`∈`, не `:∈`); справа — логическое условие.
+
+Краткая форма без `D` — только одна переменная: `{ξ∈A | P(ξ)}`. Кортеж в объявлении требует префикса: `D{(ξ1, ξ2)∈S1 | P(ξ1, ξ2)}`.
+
+**Что считается.** Подмножество домена: те элементы (или кортежи), для которых условие истинно (схема ограниченного выделения, родо-видовое определение).
+
+**Ступень.** `ℬ(H)`, где `H` — ступень элементов домена.
+
+**Не сосед.** [Фильтр](#фильтр-fi) режет отношение по компоненте кортежа. [Императивный перебор](#императивный-перебор-i) строит то же множество по шагам, когда нужны промежуточные присвоения. [Рекурсия](#рекурсия-r) возвращает одно значение, не множество.
+
+**Как сказать.** «те ξ из A, для которых выполняется P» (декларативный отбор, схема ограниченного выделения).
+
+**Пример.** `D{ξ∈{1, 2, 3, 4, 5, 6} | ∃σ∈{10, 11, 12} σ = 2 * ξ} = {5, 6}`.
+
+**Антипаттерн.** Объяснять `Fi1[{ξ}](S1)` как декларативный отбор. Для среза отношения по компоненте каноничен фильтр. В `D{}` писать `:∈` — это синтаксис перебора в `I{}`.
+
+**Справка.** [Декларативная конструкция](https://portal.acconcept.ru/manuals?topic=rslang-expression-declarative).
+
+## Императивный перебор (`I{}`)
+
+**Запись.** `I{элемент | блок; блок; …}`. Префикс `I` обязателен. Слева от `|` — ТМВ элемента результата. Справа — блоки через `;`: перебор `ξ:∈STE`, присвоение `ξ:=STE`, проверка `LE`.
+
+**Что считается.** Множество значений левой части по всем прохождениям блоков, где каждая проверка истинна. Эквивалентен декларативному отбору, но шаги могут зависеть друг от друга.
+
+**Ступень.** `ℬ(H)`, где `H` — ступень выражения слева от `|`.
+
+**Не сосед.** [Отбор `D{}`](#отбор-d) — когда достаточно «элементы A по условию», без промежуточных `:=`. Если `I{(ξ, σ) | ξ:∈A; σ:=E(ξ)}` задаёт однозначную зависимость, в схеме это обычно [терм-функция](#параметризованные-выражения-f-p), а не множество пар. [Рекурсия](#рекурсия-r) — одно значение, не множество.
+
+**Как сказать.** «собираем множество, перебирая элементы и по ходу вычисляя промежуточные значения» (императивная конструкция).
+
+**Пример.** `I{(ξ1, ξ2) | ξ1:∈{1, 2, 3}; ξ2:=ξ1+1; ∃σ∈{4, 5, 6} σ=2*ξ2} = {(1, 2), (2, 3)}`.
+
+**Антипаттерн.** `∈` вместо `:∈` в переборе. Называть `I{}` «циклом, который что-то печатает»: результат — множество. Объяснять график `I{(ξ,σ)|…}` как единственный канон, если это функция: см. [CONCEPTUAL-SCHEMA.md](CONCEPTUAL-SCHEMA.md).
+
+**Справка.** [Императивная конструкция](https://portal.acconcept.ru/manuals?topic=rslang-expression-imperative).
+
+## Рекурсия (`R{}`)
+
+**Запись.** `R{ξ := база | условие | следующий}`. Короткая форма без условия: `R{ξ := база | следующий}` — выход, когда значение стабилизировалось. Префикс `R` обязателен; в базе — `:=`. Переменная может быть кортежем.
+
+**Что считается.** **Одно** значение: последнее значение переменной рекурсии. Не множество пройденных шагов.
+
+**Ступень.** Ступень переменной рекурсии; пересчёт той же ступени.
+
+**Не сосед.** [Императивный перебор](#императивный-перебор-i) собирает множество. Буква `R` перед `{` — синтаксис рекурсии, не [радикал `R#`](#параметризованные-выражения-f-p) и не конституента.
+
+**Как сказать.** «начинаем с базы и подставляем формулу следующего шага, пока условие истинно или пока значение не перестанет меняться; результат — последнее значение» (рекурсивная / циклическая конструкция).
+
+**Пример.** `R{ξ := 1 | ξ < 32 | 2 * ξ} = 32`. Кортеж: `R{(ξ, σ) := (1, 0) | σ < 5 | (2 * ξ, σ + 1)}` удваивает `ξ` пять раз (`ξ` доходит до 32); значение конструкции — последняя пара.
+
+**Антипаттерн.** Говорить, что `R{}` «возвращает множество всех итераций». Путать `R{…}` с радикалом `R1` в `[α∈R1]`.
+
+**Справка.** [Циклическая конструкция](https://portal.acconcept.ru/manuals?topic=rslang-expression-recursive).
+
+## Кванторы
+
+**Запись.** `∀ξ∈A (P(ξ))` — всеобщность; `∃ξ∈A (P(ξ))` — существование. Кортеж: `∀(ξ1, ξ2)∈S1 (P(ξ1, ξ2))`. Сокращение вложенных кванторов с одним доменом: `∀ξ1, ξ2∈A (P(ξ1, ξ2))`. Скобки вокруг тела можно опустить, только если тело — атомарное ЛВ.
+
+**Что считается.** Истинность утверждения о всех или о некоторых элементах множества. Это логическое выражение, не множество.
+
+**Ступень.** `Logic`.
+
+**Не сосед.** [Отбор `D{}`](#отбор-d) строит множество «те, для кого P». Квантор утверждает «для всех / существует», не отбирает. Кортеж `∀(a, b)∈S` — не то же, что два имени через запятую `∀a, b∈A`.
+
+**Как сказать.** «для каждого ξ из A верно P» (квантор всеобщности) или «есть хотя бы один ξ из A, для которого верно P» (квантор существования).
+
+**Пример.** `∀x∈D1 ∃y∈D2 ((x, y)∈S1 & (x, x)∈S1)`.
+
+**Антипаттерн.** `∀a∈S P(a) & Q(a)`: без скобок `Q(a)` вне области квантора (`localOutOfScopeParentheses`). Нужно `∀a∈S (P(a) & Q(a))`.
+
+**Справка.** [Кванторные выражения](https://portal.acconcept.ru/manuals?topic=rslang-expression-quantor).
+
+## Параметризованные выражения (`F#` / `P#`)
+
+**Запись.** Объявление: `F1 ::= [α∈A] E(α)` — терм-функция, тело ТМВ; `P1 ::= [α∈A] P(α)` — предикат-функция, тело ЛВ. Вызов: `F1[ξ]`, `P1[ξ1, ξ2]`. Аргументы позиционные, только квадратные скобки.
+
+Радикалы `R1`, `R2`, … — шаблонные ступени **только** в доменах параметров `[α∈R1×R2]`. Это не конституенты: в схеме нет записи с именем `R1`. В теле после `]` радикалов быть не должно.
+
+**Что считается.** Вызов `F#` считает значение при данных аргументах. Вызов `P#` утверждает истинность при данных аргументах.
+
+**Ступень.** У `F#` — ступень тела; у `P#` — `Logic`. Ступень радикала выводится по аргументам в месте вызова; все вхождения одного `R#` в одном определении дают одну ступень.
+
+**Не сосед.** Множество пар `I{(ξ, σ) | ξ:∈A; σ:=E(ξ)}` — график; однозначная зависимость — терм-функция с вызовом `F[ξ]`. Рекурсия `R{…}` и радикал `R#` — разные буквы `R`.
+
+**Как сказать.** «F1 по аргументу ξ считает …» (терм-функция, вызов `F1[ξ]`). «P1 при аргументах … утверждает, что …» (предикат-функция). Если в доменах `R#`: «это шаблон: ступень подставляется по месту вызова» (радикал, не понятие схемы).
+
+**Пример.** `[ξ∈X1] Pr2(Fi1[{ξ}](S1))` — исходящие соседи; вызов `F1[α]`. Шаблон: `[α1∈R1×R2, α2∈R1] α2 = pr1(α1)`.
+
+**Антипаттерн.** `F1(ξ)` вместо `F1[ξ]`. Голое `F1` без `[…]`. «Пропущенная конституента `R1`» или добавление `R1` в схему. Радикал в теле формулы (`radicalUsage`).
+
+**Справка.** [Параметризованные выражения](https://portal.acconcept.ru/manuals?topic=rslang-expression-parameter). Выбор `F#` против пар — [CONCEPTUAL-SCHEMA.md](CONCEPTUAL-SCHEMA.md).
+
+## Типичная цепочка
+
+Это **не** отдельный оператор языка. Так в схемах читают связь «аргумент ξ → связанные объекты в отношении S».
+
+```text
+Pr2(Fi1[{ξ}](S1))
+```
+
+Снаружи: множество вторых компонент тех пар из `S1`, у которых первая компонента равна `ξ`. Если `S1` — ориентированные рёбра, это концы рёбер из `ξ`.
+
+Разбор карточками, изнутри:
+
+1. `{ξ}` — синглетон, фильтру нужно множество допустимых первых компонент.
+2. `Fi1[{ξ}](S1)` — фильтр, рёбра (пары) с началом `ξ`.
+3. `Pr2(...)` — большая проекция, множество концов.
+
+В определениях эту зависимость обычно оформляют [терм-функцией](#параметризованные-выражения-f-p) `[ξ∈X1] Pr2(Fi1[{ξ}](S1))`, а не множеством пар. Правило проектирования — [CONCEPTUAL-SCHEMA.md](CONCEPTUAL-SCHEMA.md), «Терм-функция вместо множества пар». При объяснении цепочку всё равно разбирай карточками `Fi` и `Pr`.
+
+## Образец разбора
+
+Конституента: терм-функция `F1`, термин «исходящие соседи».
+`S1 : ℬ(X1×X1)`, конвенция: ориентированные рёбра `(начало, конец)`.
+
+Формула:
+
+```text
+[ξ∈X1] Pr2(Fi1[{ξ}](S1))
+```
+
+Это теоретико-множественное выражение: по узлу `ξ` считается множество, а не истинность.
+
+Снаружи. Для элемента `ξ` базисного множества `X1` получается множество вторых компонент тех пар из `S1`, у которых первая компонента — `ξ`. По конвенции это множество концов рёбер, выходящих из `ξ`.
+
+Цепочка:
+
+- `{ξ}` — множество, в котором только `ξ` (синглетон): фильтру нужен набор допустимых первых компонент, не сам элемент.
+- `Fi1[{ξ}](S1)` — из отношения `S1` оставляем кортежи с первой компонентой `ξ` (фильтр).
+- `Pr2(...)` — множество вторых компонент этих кортежей (большая проекция).
+
+Ступень. Параметр `ξ∈X1`, результат `ℬ(X1)`. Опоры: `X1`, `S1`.
+
+Ссылок на справку Portal в таком разборе нет. Вычисление на данных — только по отдельному запросу.
+
+## Классические операции
+
+Короткие строки. Не разворачивай их в отдельные главы и не читай `SYNTAX.md` целиком, чтобы объяснить объединение.
+
+Справка по группам: [теоретико-множественные](https://portal.acconcept.ru/manuals?topic=rslang-expression-set), [структурные](https://portal.acconcept.ru/manuals?topic=rslang-expression-structure), [арифметика](https://portal.acconcept.ru/manuals?topic=rslang-expression-arithmetic).
+
+### Объединение, пересечение, разность
+
+| Запись | Как сказать | Пример |
+| :----- | :---------- | :----- |
+| `A ∪ B` | элементы, которые есть в A или в B (объединение) | `{1, 2} ∪ {2, 3} = {1, 2, 3}` |
+| `A ∩ B` | элементы, которые есть и в A, и в B (пересечение) | `{1, 2, 3} ∩ {2, 3, 4} = {2, 3}` |
+| `A \ B` | элементы A, которых нет в B (разность) | `{1, 2, 3} \ {2} = {1, 3}` |
+| `A ∆ B` | элементы ровно в одном из двух множеств (симметрическая разность) | `{1, 2} ∆ {2, 3} = {1, 3}` |
+
+Операнды одной ступени-множества. Не сосед фильтра: `∪` не «добавляет колонку», а сливает два множества.
+
+### Булеан (`ℬ`)
+
+**Как сказать.** «множество всех подмножеств A» (булеан `ℬ(A)`).
+
+**Ступень.** Элементы результата сами являются подмножествами A. В типизации `S#` запись `ℬ(X1×X1)` — «множество пар из X1».
+
+**Не сосед.** [Синглетон](#синглетон-bool) `bool(a)` — одно подмножество `{a}`, не все подмножества.
+
+### Декартово произведение (`×`)
+
+**Как сказать.** «множество всех пар (кортежей) с первой компонентой из A и второй из B» (декартово произведение).
+
+**Пример.** Элементы `X1×X2` — пары `(x1, x2)`.
+
+**Не сосед.** Один кортеж `(a, b)` — значение, не множество всех пар. [Отбор](#отбор-d) / [фильтр](#фильтр-fi) выбирают из уже построенного произведения или отношения.
+
+### Суммарное множество (`red`)
+
+**Как сказать.** «объединение всех множеств, которые являются элементами S» (множество-сумма `red`).
+
+**Ступень.** Нужно `S : ℬ(ℬ(H))`. Результат `ℬ(H)`.
+
+**Пример.** `red({{1, 2, 3}, {3, 4}}) = {1, 2, 3, 4}`.
+
+**Антипаттерн.** `red` по множеству, элементы которого не множества (`invalidReduce`).
+
+### Мощность (`card`)
+
+**Как сказать.** «сколько элементов в конечном множестве S» (мощность `card(S)`). Результат — целое (`Z`).
+
+**Пример.** `card(X1) > 5` — логическое сравнение мощности.
+
+**Не сосед.** `card` не заменяет [квантор](#кванторы) «для всех». Арифметика `+` `-` `*` и порядок `<` только на `Z` или `C#`, не на элементах `X#` ([BASE-SELECTION.md](BASE-SELECTION.md)).
+
+## Ссылка на справку Portal
+
+Стабильный адрес: `https://portal.acconcept.ru/manuals?topic=<slug>`.
+
+В чат ссылку давай, если пользователь разбирает **конструкцию в абстракции** («что такое фильтр») или явно просит подробнее. При разборе конкретной формулы ссылку на каждый оператор не повторяй.
+
+Не читай TSX справки Portal как источник фраз: говори по карточкам этого файла.

package/docs/DIAGNOSTICS.md

@@ -1,8 +1,9 @@
 # Диагностика
 
 Читай, когда `analyzeExpression`, `applySchemaPatch`, `listDiagnostics` или `evaluate`
-вернули диагностику. Коды ошибок ЯРЭ — `RSErrorCode` в `@rsconcept/domain`; коды схемы
-и модели — `RSDiagnosticCode` в том же пакете (числовой формат совпадает).
+вернули диагностику. Коды ошибок ЯРЭ — `RSErrorCode` в `@rsconcept/domain`; коды схемы,
+модели и таблицы отождествлений — `RSDiagnosticCode` в том же пакете (числовой формат совпадает;
+`SubstitutionErrorType` — алиасы кодов отождествлений).
 
 ## Формы диагностики
 
@@ -23,9 +24,30 @@
 | `alias?`     | обозначение конституенты                                               |
 | `expression` | текст формулы или затронутого поля                                     |
 | `from`, `to` | полуинтервал `[from, to)` в `expression`                               |
+| `stack?`     | цепочка вызовов при ошибке внутри тела `F#`/`P#` (см. ниже)            |
 
 Фильтры `listDiagnostics({ kind, constituentId, severity })`.
 
+### Стек вызовов (`stack`)
+
+При вычислении ошибки внутри вызванной терм-/предикат-функции (`E81xx` и любые
+runtime-ошибки в теле `F#`/`P#`) диагностика несёт `stack` — кадры от места сбоя
+наружу. Если ошибки нет в вызове (сбой в самом корневом выражении) — `stack`
+отсутствует:
+
+| Поле         | Смысл                                    |
+| ------------ | ---------------------------------------- |
+| `alias`      | конституента, в чьей формуле лежит span  |
+| `from`, `to` | полуинтервал в формуле этой конституенты |
+
+Порядок: **сначала место ошибки**, затем call site во внешнем вызывающем, …
+Корневое выражение в стек не входит: его call site — в `from`/`to` самой
+диагностики (подсветка в редакторе). Пример `F7[X1]` → `F8[…]` → `debool`:
+`stack[0] = { alias: 'F8', … }`, `stack[1] = { alias: 'F7', … }`, а
+корневой `F7[X1]` — только в `from`/`to`.
+
+Форматирование для людей: `formatEvalCallStack` из `@rsconcept/domain` → `F7 → F8`.
+
 ## Где лежит диагностика
 
 Три категории (`kind`), собранные в `listDiagnostics` после `applySchemaPatch`,
@@ -39,17 +61,36 @@
 
 ## Схема (Portal)
 
-| Код      | Имя                       | `params`             | Исправление                                                                             |
-| -------- | ------------------------- | -------------------- | --------------------------------------------------------------------------------------- |
-| `0x8901` | `schemaHomonym`           | `[aliases]`          | Термин совпадает с другими конституентами (`aliases` через запятую). Переименуй термин. |
-| `0x8902` | `schemaFormalDuplicate`   | `[aliases]`          | Нормализованная формула совпадает с `aliases`. Объедини или различай определения.       |
-| `0x8903` | `schemaMissingConvention` | —                    | У `basic`/`constant`/`structure` нужна конвенция.                                       |
-| `0x8904` | `schemaMissingTerm`       | —                    | У неопределяемого понятия нужен термин.                                                 |
-| `0x8905` | `schemaTypeMismatch`      | `[manual, computed]` | расхождение ручной и вычисленной типизации.                                             |
-| `0x8906` | `schemaDependencyCycle`   | `[cycle]`            | Круг в графе определений (`F3 → P1 → F3`). Разорви цикл: убери взаимные ссылки.         |
+| Код      | Имя                       | `params`             | Исправление                                                                                                                                         |
+| -------- | ------------------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `0x8901` | `schemaHomonym`           | `[aliases]`          | Термин совпадает с другими конституентами (`aliases` через запятую). Переименуй термин.                                                             |
+| `0x8902` | `schemaFormalDuplicate`   | `[aliases]`          | Нормализованная формула совпадает с `aliases`. Объедини или различай определения.                                                                   |
+| `0x8903` | `schemaMissingConvention` | —                    | У `basic`/`constant`/`structure` нужна конвенция.                                                                                                   |
+| `0x8904` | `schemaMissingTerm`       | —                    | У неопределяемого понятия нужен термин.                                                                                                             |
+| `0x8905` | `schemaTypeMismatch`      | `[manual, computed]` | расхождение ручной и вычисленной типизации.                                                                                                         |
+| `0x8906` | `schemaDependencyCycle`   | `[cycle]`            | Круг в графе определений (`F3 → P1 → F3`). Разорви цикл: убери взаимные ссылки. Тот же код — у таблицы отождествлений после применения подстановок. |
 
 Поле `params` для омонимов/дубликатов — `[aliases]` (строка с alias через запятую).
 
+## Таблица отождествлений
+
+Коды в том же пространстве, что `RSDiagnosticCode` / `RSErrorCode`. Короткие имена `SubstitutionErrorType.*` — алиасы. Логический круг в определениях — **`schemaDependencyCycle` (`0x8906`)**, не отдельный код.
+
+| Код      | Имя                               | `params`       | Исправление                                                        |
+| -------- | --------------------------------- | -------------- | ------------------------------------------------------------------ |
+| `0x8920` | `substitutionInvalidIDs`          | —              | Некорректные id схем/конституент в таблице.                        |
+| `0x8921` | `substitutionIncorrectCst`        | `[from, to]`   | У одной из пары некорректное выражение.                            |
+| `0x8922` | `substitutionInvalidClasses`      | `[from, to]`   | Классы конституент несовместимы для отождествления.                |
+| `0x8923` | `substitutionInvalidBasic`        | `[from, to]`   | Нельзя заменять структурное понятие базисным множеством.           |
+| `0x8924` | `substitutionInvalidConstant`     | `[from, to]`   | Константное множество только вместо другого константного.          |
+| `0x8925` | `substitutionTypificationCycle`   | `[detail]`     | Цикл подстановок в типизациях.                                     |
+| `0x8926` | `substitutionBaseNotSet`          | `[from, type]` | Типизация замещающей не задаёт множество.                          |
+| `0x8927` | `substitutionUnequalTypification` | `[from, to]`   | Типизации операндов не совпадают с учётом таблицы.                 |
+| `0x2928` | `substitutionUnequalExpressions`  | `[from, to]`   | Предупреждение: формальные определения различаются (не блокирует). |
+| `0x8929` | `substitutionUnequalArgsCount`    | `[from, to]`   | Число аргументов параметризованных конституент не совпадает.       |
+| `0x892A` | `substitutionUnequalArgs`         | `[from, to]`   | Типизации аргументов не совпадают.                                 |
+| `0x892B` | `substitutionInvalidNominal`      | `[from, to]`   | Номиноид только вместо другого номиноида.                          |
+
 ## Модель (Portal)
 
 Статусы соответствуют фильтру «проблемы модели» в UI (`isModelIssue`).
@@ -77,7 +118,8 @@
 
 - Диапазоны: `0x84xx` — parser (синтаксис, скобки), `0x88xx` — semantic (типизация, область
   видимости, структура, схема, отсутствие значения), `0x81xx` — evaluation (вычисление КМ),
-- `0x2xxx` — предупреждения (не блокируют, `isCritical` возвращает `false`).
+  `0x89xx` — schema / model / substitution diagnostics (`RSDiagnosticCode`),
+- `0x2xxx` — предупреждения (не блокируют, `isCritical` возвращает `false`; в т.ч. `0x2928` unequalExpressions).
 
 ## Parser
 
@@ -168,26 +210,26 @@
 
 ## Значение и схема
 
-| Код      | Имя                    | `params`           | Исправление                                                                                               |
-| -------- | ---------------------- | ------------------ | --------------------------------------------------------------------------------------------------------- |
-| `0x8840` | `globalNoValue`        | `[name]`           | Идентификатор `name` невычислим в модели.                                                                 |
-| `0x8841` | `invalidPropertyUsage` | —                  | `Property` - множество использовано как вычислимое значение.                                              |
-| `0x8861` | `cstEmptyDerived`      | —                  | У выводимой конституенты пустая формула.                                                                  |
-| `0x8862` | `definitionNotAllowed` | `[cstType, alias]` | У `basic`/`constant` формула должна быть пустой; `cstType` — роль конституенты, `alias` — её обозначение. |
+| Код      | Имя                    | `params`           | Исправление                                                                                                                                                                                                                           |
+| -------- | ---------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `0x8840` | `globalNoValue`        | `[name]`           | Идентификатор `name` невычислим в модели.                                                                                                                                                                                             |
+| `0x8841` | `invalidPropertyUsage` | —                  | `Property` - множество использовано как вычислимое значение (типично: квантор по `ℬ(S1)` / `ℬ(X1)`). Перепиши через вычислимые термы (`F#` достижимости, `card`, `Pr`) или оставь как декларативную формулировку и укажи это в ревью. |
+| `0x8861` | `cstEmptyDerived`      | —                  | У выводимой конституенты пустая формула.                                                                                                                                                                                              |
+| `0x8862` | `definitionNotAllowed` | `[cstType, alias]` | У `basic`/`constant` формула должна быть пустой; `cstType` — роль конституенты, `alias` — её обозначение.                                                                                                                             |
 
 ## Вычисление КМ
 
-| Код      | Имя                       | `params`           | Исправление                                                            |
-| -------- | ------------------------- | ------------------ | ---------------------------------------------------------------------- |
-| `0x8100` | `calcUnknownError`        | —                  | Непредвиденная ошибка вычисления.                                      |
-| `0x8101` | `setOverflow`             | `[limit]`          | Превышен предел числа элементов `limit`: упрости выражение или данные. |
-| `0x8102` | `booleanBaseLimit`        | `[limit]`          | Превышен предел базы степенного множества `limit`.                     |
-| `0x8103` | `calcGlobalMissing`       | `[name]`           | Нет значения для `name`: задай через `setModelValues`.                 |
-| `0x8104` | `iterationsLimit`         | `[limit]`          | Превышен предел итераций `limit`.                                      |
-| `0x8105` | `calcInvalidDebool`       | —                  | `debool` получил не синглетон.                                         |
-| `0x8106` | `iterateInfinity`         | —                  | Итерация по бесконечному множеству.                                    |
-| `0x8107` | `calculationNotSupported` | —                  | Объявление функции не подразумевает вычисления.                        |
-| `0x8108` | `calcInvalidData`         | `[a, b, operator]` | Несовместимые значения `a` и `b` для `operator` в runtime.             |
+| Код      | Имя                       | `params`           | Исправление                                                                            |
+| -------- | ------------------------- | ------------------ | -------------------------------------------------------------------------------------- |
+| `0x8100` | `calcUnknownError`        | —                  | Непредвиденная ошибка вычисления.                                                      |
+| `0x8101` | `setOverflow`             | `[limit]`          | Превышен предел числа элементов `limit`: упрости выражение или данные.                 |
+| `0x8102` | `booleanBaseLimit`        | `[limit]`          | Превышен предел базы степенного множества `limit`.                                     |
+| `0x8103` | `calcGlobalMissing`       | `[name]`           | Нет значения для `name`: задай через `setModelValues`.                                 |
+| `0x8104` | `iterationsLimit`         | `[limit]`          | Превышен предел итераций `limit`.                                                      |
+| `0x8105` | `calcInvalidDebool`       | —                  | `debool` получил не синглетон. Смотри `stack`, если в исходном выражении нет `debool`. |
+| `0x8106` | `iterateInfinity`         | —                  | Итерация по бесконечному множеству.                                                    |
+| `0x8107` | `calculationNotSupported` | —                  | Объявление функции не подразумевает вычисления.                                        |
+| `0x8108` | `calcInvalidData`         | `[a, b, operator]` | Несовместимые значения `a` и `b` для `operator` в runtime.                             |
 
 ## Цикл исправления
 

package/docs/DOMAIN.md

@@ -60,6 +60,7 @@
 - **Синтез** — общее название операций объединения концептуальных схем через таблицу отождествлений.
 - **Встраивание** — вставка конституент одной КС в другую (с опциональной таблицей отождествлений). В Portal UI — «Встраивание схемы»; в rstool — метод `synthesize`.
 - **Отождествление** — замена одной конституенты другой по таблице отождествлений.
+- Валидация таблицы отождествлений (`SubstitutionValidator`) проверяет, среди прочего: совместимость классов/типизаций, **цикл подстановок в типизациях** (через **базисные** и **константные множества** в типизациях конституент, **отличных от** базисных/константных), и **логический круг в формальных определениях** после применения таблицы.
 
 ## ОСС
 
@@ -73,13 +74,17 @@
 
 ### Термины: не путать (для агентов)
 
-В ответах пользователю и в конвенциях КС используй только термины из этого файла. Не вводи собственные ярлыки («базис», «базисный слой», «каркас схемы») — они не закреплены в Portal и размывают различия ниже.
+В ответах пользователю и в конвенциях КС используй только термины из этого файла. Не вводи собственные ярлыки («базис», «базисы», «базисный слой», «базовые понятия», «каркас схемы») — они не закреплены в Portal и размывают различия ниже.
+
+Источник термина **«базисное множество»** — строка типа `X#` в таблице конституент ниже и в [CONSTITUENTA.md](CONSTITUENTA.md) / [BASE-SELECTION.md](BASE-SELECTION.md). Не сокращай до «базис» / «базисы».
 
 | Не используй                                            | Используй                                                                                   | Почему                                                                      |
 | :------------------------------------------------------ | :------------------------------------------------------------------------------------------ | :-------------------------------------------------------------------------- |
-| «базис», «базисный слой», «первый слой» (без уточнения) | **неопределяемые понятия** — `X#`, `C#`, `S#`                                               | Общий термин для всего неопределяемого слоя                                 |
+| «базис», «базисы», «базисный слой», «первый слой»       | **неопределяемые понятия** — `X#`, `C#`, `S#`                                               | Общий термин для всего неопределяемого слоя                                 |
+| «базовые понятия»                                       | **неопределяемые понятия**                                                                  | «базовые» смешивается с базисными множествами                               |
 | «базис» / «базисное» про `C#` или `S#`                  | **константное множество** (`C#`), **родовая структура** (`S#`)                              | **Базисное множество** — только про `X#`                                    |
 | «базисные множества» как синоним неопределяемых понятий | **базисные множества** — только несколько `X#`; для всего слоя — **неопределяемые понятия** | `C#` и `S#` базисными множествами не называются                             |
+| «не базисные» без уточнения                             | **конституенты, отличные от базисных и константных множеств** (или тип: терм, `F#`, …)      | Иначе путается с «не базисные множества» как классом vs отрицанием          |
 | «ядро» = неопределяемые понятия»                        | **ядро КС** — неопределяемые понятия плюс аксиомы и производные, нужные для аксиом          | Ядро шире, чем только `X#` / `C#` / `S#`                                    |
 | теорема про `T#`                                        | **высказывание** — производное логическое выражение `T#`                                    | тип теорема на Portal отсутствует и вводит в заблуждение                    |
 | «пропущенная конституента `R1`» в списке схемы          | **радикал** `R#` — параметр шаблона в домене `F#` / `P#`                                    | `R#` не объявляется; при ревью КС отсутствие `R1` среди конституент — норма |