@rsconcept/rstool 1.7.1 → 2.0.0

package/docs/CONSTRUCTIONS.md

@@ -0,0 +1,384 @@
+# Объяснение конструкций ЯРЭ
+
+Читай, когда нужно **объяснить человеку** формулу или конструкцию языка. Написание и починка формул — [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`).
+
+### Пустое множество (`∅`)
+
+**Запись.** `∅`. Сравнение: `S = ∅`, `S ≠ ∅`.
+
+**Что считается.** Пустое множество. В равенстве и неравенстве типизация `ℬ(R0)` подстраивается под сравниваемое множество.
+
+**Как сказать.** «S пусто» / «S непусто».
+
+**Пример.** `F1[a] ∩ F1[b] ≠ ∅` — пересечение непусто.
+
+**Антипаттерн.** `card(S) > 0` или `card(S) = 0` вместо сравнения с `∅`. `X1 ∪ ∅` — бессмысленная операция (`invalidEmptySetUsage`).
+
+### Мощность (`card`)
+
+**Как сказать.** «сколько элементов в конечном множестве S» (мощность `card(S)`). Результат — целое (`Z`).
+
+**Пример.** `card(X1) > 5` — логическое сравнение мощности. `card(S) = 1` — ровно один элемент.
+
+**Не сосед.** (Не)пустота — карточка «Пустое множество» выше. `card` не заменяет [квантор](#кванторы) «для всех». Арифметика `+` `-` `*` и порядок `<` только на `Z` или `C#`, не на элементах `X#` ([BASE-SELECTION.md](BASE-SELECTION.md)).
+
+## Ссылка на справку Portal
+
+Стабильный адрес: `https://portal.acconcept.ru/manuals?topic=<slug>`.
+
+В чат ссылку давай, если пользователь разбирает **конструкцию в абстракции** («что такое фильтр») или явно просит подробнее. При разборе конкретной формулы ссылку на каждый оператор не повторяй.
+
+Не читай TSX справки Portal как источник фраз: говори по карточкам этого файла.

package/docs/DIAGNOSTICS.md

@@ -178,6 +178,7 @@ runtime-ошибки в теле `F#`/`P#`) диагностика несёт `s
 | `0x8808` | `invalidCard`                      | `[arg]`                            | `card(arg)` только над множеством.                                                                                                                                                                                               |
 | `0x8809` | `invalidDebool`                    | `[arg]`                            | `debool(arg)` требует ступень-множество с гарантией синглетона.                                                                                                                                                                  |
 | `0x880B` | `globalFuncWithoutArgs`            | `[name]`                           | Терм-/предикат-функция `name` вызвана без аргументов: нужен `F#[…]` / `P#[…]`.                                                                                                                                                   |
+| `0x880C` | `globalDeleted`                    | `[name]`                           | Ссылка на удаленную конституенту: при удалении в формулах зависимых конституент обозначение заменяется на `DEL`. Подставь действующее обозначение или перепиши формулу. Синтаксические ошибки в такой формуле не сообщаются.     |
 | `0x8830` | `projectionSetArgumentNotSet`      | `[operator, actual]`               | `Pr*` применяется к множеству; аргумент не типизирован как `ℬ(H)`.                                                                                                                                                               |
 | `0x8831` | `projectionSetArgumentNotTupleSet` | `[operator, actual]`               | `Pr*` требует множество кортежей `ℬ(H1×…×Hn)`; аргумент — множество не-кортежей, напр. `ℬ(X1)`.                                                                                                                                  |
 | `0x8832` | `projectionSetIndexOutOfRange`     | `[operator, index, arity, actual]` | Индекс проекции `index` превышает размерность `arity` кортежа аргумента `actual`.                                                                                                                                                |
@@ -186,7 +187,7 @@ runtime-ошибки в теле `F#`/`P#`) диагностика несёт `s
 | `0x8813` | `invalidEnumeration`               | `[a, b]`                           | Элементы перечисления разной типизации (`a` ≠ `b`).                                                                                                                                                                              |
 | `0x8814` | `invalidCortegeDeclare`            | —                                  | Число переменных кортежа ≠ размерности `×` (напр. `∀(a,b)∈X1`).                                                                                                                                                                  |
 | `0x8816` | `invalidElementPredicate`          | `[a, operator, c]`                 | `a operator c` (`ξ∈S`) с несовместимыми ступенями: `a` — тип элемента, `c` — тип множества.                                                                                                                                      |
-| `0x8817` | `invalidEmptySetUsage`             | —                                  | Бессмысленное использование `∅` (напр. `X1∪∅`).                                                                                                                                                                                  |
+| `0x8817` | `invalidEmptySetUsage`             | —                                  | Бессмысленное использование `∅` как нейтрального элемента операций (напр. `X1∪∅`). Сравнение `S=∅` / `S≠∅` допустимо.                                                                                                            |
 | `0x8818` | `invalidArgsArity`                 | `[expected, actual]`               | Неверное число аргументов функции (`expected` ≠ `actual`).                                                                                                                                                                       |
 | `0x8819` | `invalidArgumentType`              | `[expected, actual]`               | Тип аргумента не соответствует объявлению: ожидалось `expected`, получено `actual`.                                                                                                                                              |
 | `0x881C` | `globalStructure`                  | —                                  | Некорректный домен родовой структуры (`cstType` STRUCTURED): нужна ступень-структура вроде `ℬ(X1×D2)`, а не, напр., `X1∩X1`.                                                                                                     |
@@ -210,12 +211,12 @@ runtime-ошибки в теле `F#`/`P#`) диагностика несёт `s
 
 ## Значение и схема
 
-| Код      | Имя                    | `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` — её обозначение.                                                                                                                             |
 
 ## Вычисление КМ
 
@@ -233,4 +234,4 @@ runtime-ошибки в теле `F#`/`P#`) диагностика несёт `s
 
 ## Цикл исправления
 
-Пошаговый цикл — в `../skills/rstool-helper/GUIDE.md`, раздел «Цикл диагностик». Здесь — справочник кодов.
+Пошаговый цикл — в `../skills/rs-explicate/SKILL.md`, раздел «Цикл диагностик». Здесь — справочник кодов.

package/docs/DOMAIN.md

@@ -22,6 +22,18 @@
 - **Интерпретация** — соотнесение понятий КС с сущностями предметной области. В концептуальной модели задаётся значениями неопределяемых конституент и вычислением производных.
 - **Биективная переносимость** — независимость значения формального определения от биективной замены интерпретаций неопределяемых понятий. Для `X#` опирается на несравнимость элементов; анализатор ЯРЭ отсекает формулы, нарушающие переносимость.
 
+## Термины метода
+
+Процесс концептуализации — [METHOD.md](METHOD.md); бриф — [BRIEF.md](BRIEF.md).
+
+- **Требования к выразительным средствам** — понятия, которые КС обязана выразить: то, ради чего её строят. В брифе — `expressiveness`.
+- **Ограничения предметной области** — что сознательно исключено из рассмотрения (время, история, процедуры…) вместе с перечнем понятий, которые из-за этого **невыразимы**. В брифе — `restrictions`.
+- **Различение** — пара понятий, которые схема должна развести, хотя в источнике они смешаны или легко склеиваются.
+- **Журнал решений** — записанные решения о ядре: альтернативы, выбор, обоснование; отсутствие аксиомы — тоже решение. Изменить решение можно только новым решением (`supersedes`).
+- **Сценарий** — маленькая интерпретация неопределяемых понятий подписями элементов с ожидаемыми значениями производных понятий и истинностью аксиом: пример или контрпример.
+- **Микротеория** — небольшая КС одного аспекта (3–6 отношений, 2–4 уровня конкретизации); сложная предметная область собирается из микротеорий синтезом.
+- **Ранг терма** — глубина терма в графе термов от ядра: термы первого ранга строятся непосредственно из неопределяемых понятий.
+
 ## Конституенты
 
 **Конституента** — часть КС. Поля и правила валидации см. в [CONSTITUENTA.md](CONSTITUENTA.md); здесь только предметные роли.