@rsconcept/rstool 1.7.1 → 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

@@ -210,12 +210,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` — её обозначение.                                                                                                                             |
 
 ## Вычисление КМ
 

package/docs/MODEL-TESTING.md

@@ -35,6 +35,16 @@ await tool.setModelValues({
 
 Здесь `X1` получает подписи элементов, а `S1: ℬ(X1×X1)` получает множество пар по индексам элементов `X1`.
 
+- Порядок элементов и дубликаты во входе не важны: `setModelValues` приводит значения `S#` к канонической форме (сортировка `compare`, без повторов). В `getModelState` и в результатах вычисления множества всегда отсортированы — сравнивай с ожиданием как с отсортированным массивом.
+- Кортежи — `[TUPLE_ID, …]`; вложенные множества — обычные массивы (`ℬℬ(X1)`: `[[0, 1], [2]]`).
+- `status` в `evaluate` / `recalculateModel` — числовой `EvalStatus` (`7` `HAS_DATA`, `6` `EMPTY`, `5` `AXIOM_FALSE`, `4` `EVAL_FAIL`); таблица — в `REFERENCE.md`.
+
+## Чтение результата
+
+- Конституента: `evaluate({ constituentId })` — вычисляет её и все поставщики.
+- Scratch: `evaluate({ expression, cstType })`. `cstType` задаёт ожидаемую ступень: `'term'` — множество или число, `'axiom'` — логическое выражение (`P1[S1]`, `D2⊆S1`). В scratch-выражении можно ссылаться на любые конституенты схемы, включая производные `D#`.
+- Литералов элементов `X#` в ЯРЭ нет: выражай тестовые элементы через схему (`debool(D3)`, `Pr1(S1)\Pr2(S1)`), а не через подписи.
+
 ## Скрипты-тесты
 
 Если проверка влияет на поведение схемы или есть риск регрессии, вынеси ее в маленький скрипт или colocated `*.test.ts`:
@@ -46,6 +56,44 @@ await tool.setModelValues({
 
 Тест должен проверять смысл формулы, а не только отсутствие диагностик. Для аксиом отдельно проверяй положительный и отрицательный набор данных: корректная модель должна давать истинную аксиому, ошибочная — `AXIOM_FALSE` или диагностируемый сбой вычисления.
 
+```ts
+import { EvalStatus, TUPLE_ID } from '@rsconcept/domain';
+
+// X1 — вершины, S1: ℬ(X1×X1) — рёбра, A1 ::= ∀α∈X1 α∉F4[α] — ацикличность
+const X1 = 1,
+  S1 = 2,
+  A1 = 17;
+await tool.setModelValues({
+  set: [
+    { target: X1, value: { 0: 'a', 1: 'b', 2: 'c' } },
+    {
+      target: S1,
+      value: [
+        [TUPLE_ID, 0, 1],
+        [TUPLE_ID, 1, 2]
+      ]
+    }
+  ]
+});
+let a1 = tool.evaluate({ constituentId: A1 });
+// a1.status === EvalStatus.HAS_DATA, a1.value === 1
+
+await tool.setModelValues({
+  set: [
+    {
+      target: S1,
+      value: [
+        [TUPLE_ID, 0, 1],
+        [TUPLE_ID, 1, 2],
+        [TUPLE_ID, 2, 0]
+      ]
+    }
+  ]
+});
+a1 = tool.evaluate({ constituentId: A1 });
+// a1.status === EvalStatus.AXIOM_FALSE, a1.value === 0
+```
+
 ## Ограничения
 
 - Маленькая КМ проверяет семантику на выбранных данных, но не доказывает определение для всех моделей.

package/docs/README.md

@@ -11,6 +11,7 @@
 - **CONSTITUENTA.md** — структура и правила конституент.
 - **BASE-SELECTION.md** — выбор основания: `X#`, `C#` или `Z`.
 - **SYNTAX.md** — синтаксис ЯРЭ: операторы, генераторы `D{}`/`I{}`/`R{}`, кванторы, `F#`/`P#`.
+- **CONSTRUCTIONS.md** — объяснение формул и конструкций человеку (карточки, разбор снаружи внутрь).
 - **TYPIFICATION.md** — типизация (`AnalysisResult.type`, `valueClass`).
 - **MODEL-TESTING.md** — проверка семантики определений на маленьких концептуальных моделях.
 - **DIAGNOSTICS.md** — диагностики анализа и способы исправления ошибок.

package/docs/SYNTAX.md

@@ -1,6 +1,6 @@
 # Синтаксис ЯРЭ
 
-Единая справка для агента: читай при построении или исправлении `definitionFormal`. Типизация — `TYPIFICATION.md`; ошибки — `DIAGNOSTICS.md`.
+Единая справка для агента: читай при построении или исправлении `definitionFormal`. Типизация — `TYPIFICATION.md`; ошибки — `DIAGNOSTICS.md`. Объяснение человеку — [CONSTRUCTIONS.md](CONSTRUCTIONS.md).
 
 ## Имена и литералы
 

package/docs/TYPIFICATION.md

@@ -25,8 +25,17 @@
 ## `AnalysisResult.type`
 
 1. Сначала проверь `analysis.success === true` и `analysis.type !== null`.
-2. Не разбирай объект вручную; используй helpers из `@rsconcept/domain`.
-3. `valueClass` уточняет вычислимость: `Value`, `Property`, `Invalid`.
+2. Не разбирай объект вручную; печатай через `labelType` из `@rsconcept/domain/rslang/labels`:
+
+   ```ts
+   import { labelType } from '@rsconcept/domain/rslang/labels';
+
+   labelType(analysis.type); // 'ℬ(X1×X1)', '[X1] → ℬ(X1)', '[ℬ(X1×X1)] → Logic', 'Logic'
+   ```
+
+   Для скрипта вне пакета — `file:///<workspace>/rsconcept/domain/src/rslang/labels.ts` (см. GUIDE, «Как запускать rstool»). `normalizeType` из того же модуля даёт каноническую строку для сравнения типизаций.
+
+3. `valueClass` уточняет вычислимость: `'value'` (вычислимо), `'property'` (только проверка принадлежности), `null` (ошибка). `success: true` не исключает диагностику `error`: квантор по `ℬ(…)` разбирается, но даёт `invalidPropertyUsage` и `valueClass: null`.
 
 ## `S#` и `D#`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsconcept/rstool",
-  "version": "1.7.1",
+  "version": "1.9.0",
   "description": "Agent-facing library for incremental RSForm construction, RSLang analysis, diagnostics, modeling, and evaluation. Wraps @rsconcept/domain with a deterministic session contract.",
   "license": "MIT",
   "author": "IRBorisov",
@@ -50,6 +50,23 @@
     "README.md",
     "LICENSE"
   ],
+  "dependencies": {
+    "eslint": "^10.9.1",
+    "eslint-plugin-simple-import-sort": "^14.0.0",
+    "@rsconcept/domain": "3.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "@vitest/coverage-v8": "^4.1.11",
+    "tsdown": "^0.22.14",
+    "tsx": "^4.23.13",
+    "typescript": "^6.0.3",
+    "unrun": "^0.3.1",
+    "vitest": "^4.1.11"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "tsdown",
     "typecheck": "tsc -p tsconfig.json --noEmit",
@@ -68,22 +85,6 @@
     "example:build-expression-bank-schema": "tsx examples/expression-bank/build-rsform.ts",
     "example:build-template-apply-schema": "tsx examples/template-apply/build-rsform.ts",
     "example:audit-diagnostics": "tsx examples/audit-diagnostics.ts",
-    "kinship:cli": "tsx examples/kinship/cli.ts",
-    "prepublishOnly": "pnpm run build"
-  },
-  "dependencies": {
-    "@rsconcept/domain": "workspace:*"
-  },
-  "devDependencies": {
-    "@types/node": "^26.1.1",
-    "@vitest/coverage-v8": "^4.1.10",
-    "tsdown": "^0.22.4",
-    "tsx": "^4.23.0",
-    "typescript": "^6.0.3",
-    "unrun": "^0.3.1",
-    "vitest": "^4.1.10"
-  },
-  "publishConfig": {
-    "access": "public"
+    "kinship:cli": "tsx examples/kinship/cli.ts"
   }
-}
+}

package/skills/README.md

@@ -9,7 +9,7 @@ Each skill lives in its own subdirectory: `skills/<skill-name>/SKILL.md` (plus r
 - `rstool-helper/GUIDE.md`: entry point — task→read matrix, workflows (incl. review), checklists (Russian)
 - `rstool-helper/REFERENCE.md`: API, stdio, MCP names, response shapes, help map (Russian)
 - `rstool-helper/EXAMPLES.md`: snippets, anti-patterns, diagnostics, `examples/` index (Russian)
-- `../docs/*.md`: language reference (DOMAIN, SYNTAX, DIAGNOSTICS, …)
+- `../docs/*.md`: language reference (DOMAIN, SYNTAX, CONSTRUCTIONS, DIAGNOSTICS, …)
 
 ## npm workflow
 

package/skills/rstool-helper/EXAMPLES.md

@@ -153,6 +153,7 @@ tool.applySchemaPatch({
 | `globalFuncParenCall`                             | `F1(ξ)`                                            | `F1[ξ]`                                                          |
 | `globalFuncWithoutArgs`                           | голое `F1` в формуле                               | `F1[…]`                                                          |
 | `radicalUsage`                                    | `R1` в теле формулы или как конституента           | `R#` только в `[…]` у `F#`/`P#`                                  |
+| `invalidPropertyUsage`                            | `∀σ∈ℬ(S1)\{∅} ¬P1[σ]` — квантор по булеану         | вычислимая форма через достижимость: `∀α∈X1 α∉F4[α]`             |
 | `schemaMissingConvention`                         | `X1` без конвенции                                 | добавь предметную конвенцию                                      |
 | `schemaHomonym`                                   | одинаковый термин у разных конституент             | различай термины                                                 |
 | `schemaDependencyCycle`                           | круг в определениях (`F3 → P1 → F3`)               | разорви цикл: убери взаимные ссылки                              |
@@ -237,6 +238,29 @@ const scratch = tool.evaluate({ expression: '1+2', cstType: CstType.TERM });
 const recalc = tool.recalculateModel();
 ```
 
+Множества `S#` — кортежи `[TUPLE_ID, i, j]` по индексам `X#`; порядок во входе не важен (нормализуется). Scratch может ссылаться на производные конституенты; логические выражения — с `cstType: CstType.AXIOM`:
+
+```ts
+import { EvalStatus, TUPLE_ID } from '@rsconcept/domain';
+
+await tool.setModelValues({
+  set: [
+    { target: 1, value: { 0: 'a', 1: 'b', 2: 'c' } },
+    {
+      target: 2,
+      value: [
+        [TUPLE_ID, 1, 2],
+        [TUPLE_ID, 0, 1]
+      ]
+    } // S1: ℬ(X1×X1)
+  ]
+});
+const closure = tool.evaluate({ constituentId: 9 }); // D9 — транзитивное замыкание
+closure.status === EvalStatus.HAS_DATA; // status — число: 7
+const check = tool.evaluate({ expression: 'S1⊆D9', cstType: CstType.AXIOM });
+check.value === 1;
+```
+
 ## Экспорт / импорт и Portal round-trip
 
 ```ts