D: Add documentation for RS Language

.vscode/settings.json

@@ -193,6 +193,8 @@
     "Бурбакизатор",
     "Версионирование",
     "Владельцом",
+    "генемные",
+    "дебуль",
     "Демешко",
     "Десинглетон",
     "доксинг",
@@ -214,6 +216,9 @@
     "Кучкаров",
     "Кучкарова",
     "мультиграфа",
+    "мультииндекс",
+    "Мультииндексы",
+    "Мультифильтр",
     "неинтерпретируемый",
     "неитерируемого",
     "Никанорова",
@@ -230,6 +235,7 @@
     "подпапках",
     "Присакарь",
     "ПРОКСИМА",
+    "родовидовое",
     "Родоструктурная",
     "родоструктурного",
     "Родоструктурное",

rsconcept/frontend/src/features/help/items/cc/help-concept-system.tsx

@@ -35,8 +35,8 @@ export function HelpConceptSystem() {
         экспликации. Портал поддерживает <LinkTopic text='экспликацию в родах структур' topic={HelpTopic.RSLANG} />.
         Помимо аксиом также могут приводиться дополнительные утверждения, называемые <b>теоремами</b>. Понятия, которым
         даются формальные определения называют <b>производными</b>. Следует отметить, что в родоструктурной экспликации
-        к аксиомам также относят соотношения <LinkTopic text='типизации' topic={HelpTopic.RSL_TYPES} />, а к производным
+        к аксиомам также относят соотношения <LinkTopic text='типизации' topic={HelpTopic.RSL_TYPIFICATION} />, а к
-        понятиям, – термы, терм-функции и предикат-функции.
+        производным понятиям, – термы, терм-функции и предикат-функции.
       </p>
 
       <p>

rsconcept/frontend/src/features/help/items/help-rslang.tsx

@@ -1,23 +1,66 @@
 import { external_urls, videos } from '@/utils/constants';
 
 import { BadgeVideo } from '../components/badge-video';
+import { LinkTopic } from '../components/link-topic';
 import { Subtopics } from '../components/subtopics';
 import { HelpTopic } from '../models/help-topic';
 
 export function HelpRSLang() {
-  // prettier-ignore
   return (
-  <div className='flex flex-col gap-4'>
+    <div>
-    <div className='dense'>
       <h1>Родоструктурная экспликация</h1>
-      <p>Формальная запись (<i>экспликация</i>) концептуальных схем осуществляется с помощью языка родов структур.</p>
+      <p>
-      <p>Для ознакомления с основами родов структур можно использовать следующие материалы:</p>
+        Формальная запись (<i>экспликация</i>) концептуальных схем осуществляется с помощью языка родов структур (далее
-      <p>1. <BadgeVideo className='inline-icon' video={videos.explication} /> Видео: Краткое введение в мат. аппарат</p>
+        – Язык). В данном разделе поясняются основные понятия и формальные конструкции Языка. В своей основе Язык
-      <p>2. <a className='underline' href={external_urls.ponomarev}>Текст: Учебник И. Н. Пономарева</a></p>
+        является формальной логикой первого порядка, все дополнительные обозначения основываются на предикате
-      <p>3. <a className='underline' href={external_urls.full_course}>Видео: лекции для 4 курса (второй семестр 2022-23 год)</a></p>
+        принадлежности <code>x∈y</code>.
-    </div>
+      </p>
-    <div className='dense'>
+      <p>
+        Используются строгие правила написания идентификаторов для обозначений понятий, локальных переменных и
+        литералов.
+      </p>
+      <p>
+        Элементы Языка подразделяются на теоретико-множественные выражения и логические выражения. Упрощенно говоря,
+        теоретико-множественное выражение возвращает элемент некоторой{' '}
+        <LinkTopic topic={HelpTopic.RSL_TYPIFICATION} text='ступени' />, логическое выражение возвращает логическое
+        значение ИСТИНА или ЛОЖЬ.
+      </p>
+      <p>
+        Помимо указанных выражений также допускаются параметризованные и шаблонные выражения, значения и типизация
+        которых зависят от вводимых параметров. Такие выражения используются в определениях{' '}
+        <LinkTopic
+          topic={HelpTopic.CC_CONSTITUENTA}
+          text='терм-функций и
+        предикат-функций'
+        />
+        .
+      </p>
+      <p>Выражения, позволяющие манипулировать ступенями операндов называются структурными выражениями.</p>
+      <p>
+        Отдельно рассматриваются сложные конструкции, задающие множество через отбор элементов, императивно или
+        рекурсивно.
+      </p>
+
       <Subtopics headTopic={HelpTopic.RSLANG} />
+
+      <div className='dense'>
+        <p>Для глубокого ознакомления с основами родов структур можно использовать следующие материалы:</p>
+        <p>
+          1. <BadgeVideo className='inline-icon' video={videos.explication} /> Видео: Краткое введение в мат. аппарат
+        </p>
+        <p>
+          2.{' '}
+          <a className='underline' href={external_urls.ponomarev}>
+            Текст: Учебник И. Н. Пономарева
+          </a>
+        </p>
+        <p>
+          3.{' '}
+          <a className='underline' href={external_urls.full_course}>
+            Видео: лекции для 4 курса (второй семестр 2022-23 год)
+          </a>
+        </p>
       </div>
-  </div>);
+    </div>
+  );
 }

rsconcept/frontend/src/features/help/items/help-thesaurus.tsx

@@ -137,7 +137,7 @@ export function HelpThesaurus() {
           <IconCstStructured size='1rem' className='inline-icon' />
           {'\u2009'}родовая структура (S#) – неопределяемое понятие, имеющее структуру, построенную на базисных
           множествах и константных множеств. Содержание родовой структуры формируется{' '}
-          <LinkTopic text='отношением типизации' topic={HelpTopic.RSL_TYPES} />, аксиомами и конвенцией.
+          <LinkTopic text='отношением типизации' topic={HelpTopic.RSL_TYPIFICATION} />, аксиомами и конвенцией.
         </li>
         <li>
           <IconCstAxiom size='1rem' className='inline-icon' />

rsconcept/frontend/src/features/help/items/rslang/help-rslang-correct.tsx

@@ -18,7 +18,7 @@ export function HelpRSLangCorrect() {
         Правила проверки теоретико-множественных выражений выводятся из условия биективной переносимости предиката
         принадлежности – элемент должен соответствовать множеству, для которого проверяется принадлежность. Необходимым
         условием биективной переносимости является выполнение{' '}
-        <LinkTopic text='соотношения типизации' topic={HelpTopic.RSL_TYPES} /> для всех локальных и глобальных
+        <LinkTopic text='соотношения типизации' topic={HelpTopic.RSL_TYPIFICATION} /> для всех локальных и глобальных
         идентификаторов.
       </p>
       <p>

rsconcept/frontend/src/features/help/items/rslang/help-rslang-expression-arithmetic.tsx

@@ -0,0 +1,63 @@
+export function HelpRSLangExpressionArithmetic() {
+  return (
+    <div>
+      <h1>Арифметические выражения</h1>
+      <p>Арифметические выражения в языке родов структур предназначены для работы с целыми числами.</p>
+
+      <h2>Основные операции</h2>
+      <p>
+        Данные операции формируют теоретико-множественное выражение, которое имеет типизацию <code>Z</code> (целое
+        число).
+      </p>
+      <ul>
+        <li>
+          <b>Сложение</b>: <code>a + b</code> — сумма чисел <code>a</code> и <code>b</code>.
+        </li>
+        <li>
+          <b>Вычитание</b>: <code>a - b</code> — разность чисел <code>a</code> и <code>b</code>.
+        </li>
+        <li>
+          <b>Умножение</b>: <code>a * b</code> — произведение чисел <code>a</code> и <code>b</code>.
+        </li>
+      </ul>
+
+      <h2>Операции сравнения</h2>
+      <p>
+        Данные операции формируют логическое выражение, которое имеет типизацию <code>Logic</code>.
+      </p>
+      <ul>
+        <li>
+          <b>Меньше</b>: <code>a &lt; b</code>
+        </li>
+        <li>
+          <b>Меньше или равно</b>: <code>a ≤ b</code>
+        </li>
+        <li>
+          <b>Больше</b>: <code>a &gt; b</code>
+        </li>
+        <li>
+          <b>Больше или равно</b>: <code>a ≥ b</code>
+        </li>
+      </ul>
+
+      <h2>Вычисление мощности</h2>
+      <p>
+        <b>Мощность множества</b>: <code>card(X1)</code> — количество элементов множества <code>X</code>. Так как на
+        практике используются только конечные множества, мощность всегда является целым числом.
+      </p>
+
+      <h2>Примеры</h2>
+      <ul>
+        <li>
+          <code>(4 + 5) * 3</code>
+        </li>
+        <li>
+          <code>card(X1) &gt; 5</code>
+        </li>
+        <li>
+          <code>x ≤ y + 1</code>
+        </li>
+      </ul>
+    </div>
+  );
+}

rsconcept/frontend/src/features/help/items/rslang/help-rslang-expression-declarative.tsx

@@ -0,0 +1,45 @@
+import { LinkTopic } from '../../components/link-topic';
+import { HelpTopic } from '../../models/help-topic';
+
+export function HelpRSLangExpressionDeclarative() {
+  return (
+    <div>
+      <h1>Декларативные выражения</h1>
+      <p>
+        Декларативная конструкция, также известная как схема ограниченного выделения, в языке родов структур задает
+        множество через перебираемое множество и проверяемое условие. С точки зрения определения понятий такие выражения
+        задают родовидовое определение.
+      </p>
+      <p>
+        <LinkTopic topic={HelpTopic.RSL_TYPIFICATION} text='Типизация' /> конструкции совпадает с типизацией множества,
+        из которого происходит отбор.
+      </p>
+
+      <h2>Синтаксис</h2>
+      <ul>
+        <li>
+          <code>D{'{ξ∈ТМВ | ЛВ(ξ)}'}</code>
+        </li>
+        <li>
+          <code>D{'{(ξ₁, ξ₂)∈ТМВ | ЛВ(ξ₁, ξ₂)}'}</code>
+        </li>
+        <li>
+          Буква <code>D</code> — часть синтаксиса, а не идентификатор.
+        </li>
+      </ul>
+
+      <h2>Семантика</h2>
+      <p>
+        Локальные переменные перебирают свою область определения. Если для текущего значения переменной логическое
+        выражение справа истинно, то это значение (или кортеж значений) включается в результирующее множество.
+      </p>
+
+      <h2>Пример</h2>
+      <p>
+        <code>
+          D{'{ξ∈{1, 2, 3, 4, 5, 6} | ∃σ∈{10, 11, 12} (σ = 2 ∗ ξ)}'} = {'{5, 6}'}
+        </code>
+      </p>
+    </div>
+  );
+}

rsconcept/frontend/src/features/help/items/rslang/help-rslang-expression-imperative.tsx

@@ -0,0 +1,71 @@
+import { LinkTopic } from '../../components/link-topic';
+import { HelpTopic } from '../../models/help-topic';
+
+export function HelpRSLangExpressionImperative() {
+  return (
+    <div>
+      <h1>Императивные выражения</h1>
+      <p>
+        Императивная конструкция в языке родов структур является теоретико-множественным выражением, построенным с
+        помощью блоков и правил вычисления. Она выражает конструктивные (генемные) способы определения понятий.
+      </p>
+      <p>
+        Императивная конструкция может быть преобразовано в эквивалентную с точки зрения теории множеств{' '}
+        <LinkTopic topic={HelpTopic.RSL_EXPRESSION_DECLARATIVE} text='декларативную конструкцию' />, что обосновывает ее
+        теоретические свойства. Однако использование императивной конструкции при экспликации отличается от
+        декларативной тем, что позволяет выражать другие типы определений и точно указывает способ интерпретации
+        понятия.
+      </p>
+
+      <h2>Синтаксис</h2>
+      <ul>
+        <li>
+          <code>I{'{ТМВ(ξ1, ξ2) | ξ1∶∈ТМВ1; ξ2≔ТМВ2; ξk∶∈ТМВk; ЛВ(ξ1,ξ2); ...}'}</code>
+        </li>
+        <li>
+          Буква <code>D</code> — часть синтаксиса, а не идентификатор.
+        </li>
+        <li>
+          Левая часть — выражение <code>ТМВ(ξ1, ..., ξk)</code>, которое задаёт результирующий элемент, из которых
+          формируется множества.
+        </li>
+        <li>
+          Правая часть — последовательность блоков, разделённых точкой с запятой. Блоки рассматриваются слева направо.
+        </li>
+      </ul>
+
+      <h2>Блоки правой части</h2>
+      <ul>
+        <li>
+          <b>Перебор</b>
+          <code> ∶∈ </code>
+          объявленная переменная или кортеж переменных перебирает элементы множества.
+        </li>
+        <li>
+          <b>Присвоение</b>
+          <code> ≔ </code>
+          объявленная переменная или кортеж переменных получает значение выражения. Значение вычисляется заново при
+          каждом переходе к следующему набору значений перебираемых переменных.
+        </li>
+        <li>
+          <b>Логическое выражение</b>. При переборах проверка на истинность позволяет прекратить рассмотрение текущего
+          значения и не добавлять его в результат.
+        </li>
+      </ul>
+
+      <h2>Семантика</h2>
+      <p>
+        Для каждого набора значений перебираемых и определяемых переменных вычисляется значение{' '}
+        <code>ТМВ(ξ1, ..., ξk)</code>. Этот результат включается в итоговое множество, если все логические выражения
+        истинны.
+      </p>
+
+      <h2>Пример</h2>
+      <p>
+        <code>
+          I{'{(ξ1,ξ2) | ξ1∶∈{1, 2, 3}; ξ2≔ξ1+1; ∃σ∈{4, 5, 6} (σ=2∗ξ2)}'} = {'{(1, 2), (2, 3)}'}
+        </code>
+      </p>
+    </div>
+  );
+}

rsconcept/frontend/src/features/help/items/rslang/help-rslang-expression-logic.tsx

@@ -0,0 +1,91 @@
+export function HelpRSLangExpressionLogic() {
+  return (
+    <div>
+      <h1>Логические выражения</h1>
+      <p>
+        Пропозициональные формулы в языке родов структур — это логические выражения, построенные из предикатов
+        (логических выражений) и переменных с помощью связок. Константы ИСТИНА И ЛОЖЬ не используются в экспликации
+        концептуальных схем.
+      </p>
+
+      <h2>Теоретико-множественные предикаты</h2>
+      <ul>
+        <li>
+          <b>Принадлежность</b>: <code>ξ∈S</code> — элемент ξ принадлежит множеству S.
+        </li>
+        <li>
+          <b>Непринадлежность</b>: <code>ξ∉S</code> — элемент ξ не принадлежит множеству S.
+        </li>
+        <li>
+          <b>Равенство множеств</b>: <code>S1=S2</code>.
+        </li>
+        <li>
+          <b>Неравенство множеств</b>: <code>S1≠S2</code>.
+        </li>
+        <li>
+          <b>Включение</b>: <code>S1⊆S2</code> — S₁ является подмножеством S₂.
+        </li>
+        <li>
+          <b>Строгое включение</b>: <code>S1⊂S2</code>.
+        </li>
+        <li>
+          <b>Невключение</b>: <code>S1⊄S2</code>.
+        </li>
+      </ul>
+
+      <h2>Арифметические предикаты</h2>
+      <ul>
+        <li>
+          <b>Равенство</b>: <code>2 = 4</code>.
+        </li>
+        <li>
+          <b>Неравенство</b>: <code>2 ≠ 4</code>.
+        </li>
+        <li>
+          <b>Меньше</b>: <code>2 &lt; 4</code>.
+        </li>
+        <li>
+          <b>Меньше или равно</b>: <code>2 ≤ 4</code>.
+        </li>
+        <li>
+          <b>Больше</b>: <code>2 &gt; 4</code>.
+        </li>
+        <li>
+          <b>Больше или равно</b>: <code>2 ≥ 4</code>.
+        </li>
+      </ul>
+
+      <h2>Логические связки</h2>
+      <ul>
+        <li>
+          <b>Отрицание</b>: <code>¬A</code> — истина тогда и только тогда, когда A ложно.
+        </li>
+        <li>
+          <b>Конъюнкция</b>: <code>A & B</code> — истина, если оба A и B истинны.
+        </li>
+        <li>
+          <b>Дизъюнкция</b>: <code>A ∨ B</code> — истина, если хотя бы одно из A или B истинно.
+        </li>
+        <li>
+          <b>Импликация</b>: <code>A ⇒ B</code> — истина, если из A следует B (ложно только при A истинно и B ложно).
+        </li>
+        <li>
+          <b>Эквивалентность</b>: <code>A ⇔ B</code> — истина, если A и B имеют одинаковое значение истины.
+        </li>
+      </ul>
+
+      <h2>Примеры</h2>
+      <ul>
+        <li>
+          <code>¬α∈S1</code>
+        </li>
+        <li>
+          <code>D1∈S1 ⇒ 2+2=5</code>
+        </li>
+        <li>
+          <code>{`D1⊆D2 ⇔ ∀x∈D1 x∈D2`}</code>
+        </li>
+      </ul>
+    </div>
+  );
+}

rsconcept/frontend/src/features/help/items/rslang/help-rslang-expression-parameter.tsx

@@ -0,0 +1,55 @@
+export function HelpRSLangExpressionParameter() {
+  return (
+    <div>
+      <h1>Параметризованные выражения</h1>
+      <p>
+        Параметризованные выражения в языке родов структур образуют самостоятельный класс конструкций. Они используются
+        для объявления терм-функций и предикат-функций. Вызов таких функций является соответственно
+        теоретико-множественным выражением (ТМВ) или логическим выражением (ЛВ).
+      </p>
+
+      <h2>Объявление терм-функции</h2>
+      <code>F1 ::= [α1∈ТМВ1, α2∈ТМВ2(α1)] ТМВ(α1, α2)</code>
+      <ul>
+        <li>В квадратных скобках через запятую указывается упорядоченный набор объявлений параметров.</li>
+        <li>
+          Объявление параметра производится с помощью предиката принадлежности <code>∈</code>. Слева — идентификатор
+          локальной переменной, справа — область определения параметра.
+        </li>
+        <li>
+          Объявленные переменные могут использоваться в областях определения последующих параметров и в ТМВ, задающем
+          результат функции.
+        </li>
+      </ul>
+
+      <h2>Объявление предикат-функции</h2>
+      <code>P1 ::= [α1∈ТМВ1, α2∈ТМВ2(α1)] ЛВ(α1, α2)</code>
+      <p>Отличие от терм-функции состоит в том, что после списка параметров задаётся логическое выражение, а не ТМВ.</p>
+
+      <h2>Вызов функций</h2>
+      <code>F1[ξ1, S1], P1[ξ1\ξ2, ξ3]</code>
+      <ul>
+        <li>После имени функции в квадратных скобках указываются аргументы, порядок имеет значение.</li>
+        <li>Проверяется соответствие типизаций аргументов типизациям параметров, указанным при объявлении.</li>
+        <li>Результатом вызова терм-функции является ТМВ, вызова предикат-функции — ЛВ.</li>
+      </ul>
+
+      <h2>Шаблонные выражения</h2>
+      <code>F2 ::= [α1∈R1×R2, α2∈R1] α2=pr1(α1)</code>
+      <p>
+        Функции, параметры которых содержат <b>радикалы</b>, называются шаблонными. Радикал используется для обозначения
+        произвольной типизации в ступени аргумента функции.
+      </p>
+      <ul>
+        <li>
+          При вызове функции значение радикала вычисляется из типизаций аргументов. Все вычисленные значения должны
+          совпадать.
+        </li>
+        <li>Радикалы с разными индексами считаются различными по типизации.</li>
+        <li>
+          Радикалы могут использоваться только в описании областей определения параметров, но не в выражении результата.
+        </li>
+      </ul>
+    </div>
+  );
+}

rsconcept/frontend/src/features/help/items/rslang/help-rslang-expression-quantor.tsx

@@ -0,0 +1,53 @@
+export function HelpRSLangExpressionQuantor() {
+  return (
+    <div>
+      <h1>Кванторные выражения</h1>
+      <p>
+        Кванторные выражения в языке родов структур используются для формулировки утверждений о всех или некоторых
+        элементах множества.
+      </p>
+
+      <h2>Синтаксис</h2>
+      <ul>
+        <li>
+          <b>Всеобщность</b>: <code>∀ξ∈ТМВ (ЛВ(ξ))</code>
+        </li>
+        <li>
+          <b>Существование</b>: <code>∃ξ∈ТМВ (ЛВ(ξ))</code>
+        </li>
+        <li>
+          <code>∀(ξ1, ξ2)∈ТМВ (ЛВ(ξ1, ξ2))</code>
+        </li>
+        <li>
+          <code>∀ξ1,ξ2∈ТМВ (ЛВ(ξ1, ξ2))</code>
+        </li>
+        <li>Скобки вокруг ЛВ могут быть опущены для атомарных логических выражений.</li>
+      </ul>
+
+      <h2>Семантика</h2>
+      <ul>
+        <li>
+          <b>Всеобщность</b>: выражение истинно, если для всех значений <code>ξ</code> из области определения
+          выполняется условие <code>ЛВ(ξ)</code>.
+        </li>
+        <li>
+          <b>Существование</b>: выражение истинно, если существует хотя бы одно значение <code>ξ</code> из области
+          определения, для которого условие <code>ЛВ(ξ)</code> выполняется.
+        </li>
+        <li>
+          Кортеж переменных означает объявление переменной, пробегающий значения и введение обозначений для ее проекций.
+        </li>
+        <li>
+          Перечисление переменных является сокращением вложенных кванторов с одним типом и одной областью определения.
+        </li>
+      </ul>
+
+      <h2>Пример</h2>
+      <ul>
+        <li>
+          <code>∀x∈D1 ∃y∈D2 (x,y)∈S1 & (x,x)∈S1</code>
+        </li>
+      </ul>
+    </div>
+  );
+}

rsconcept/frontend/src/features/help/items/rslang/help-rslang-expression-recursive.tsx

@@ -0,0 +1,58 @@
+export function HelpRSLangExpressionRecursive() {
+  return (
+    <div>
+      <h1>Циклические конструкции</h1>
+      <p>Циклическая (рекурсивная) конструкция является теоретико-множественным выражением.</p>
+
+      <h2>Синтаксис</h2>
+      <ul>
+        <li>
+          <code>{'R{ξ ≔ ТМВ1 | ТМВ2(ξ)}'}</code>
+        </li>
+        <li>
+          <code>{'R{ξ ≔ ТМВ1 | ЛВ(ξ) | ТМВ2(ξ)}'}</code>
+        </li>
+        <li>
+          <code>{'R{(ξ,σ) ≔ (ТМВ1,ТМВ2) | ЛВ(ξ,σ) | ТМВ3(ξ,σ)}'}</code>
+        </li>
+        <li>
+          Буква <code>R</code> — часть синтаксиса, а не идентификатор.
+        </li>
+      </ul>
+
+      <h2>Состав конструкции</h2>
+      <ul>
+        <li>
+          <b>База рекурсии</b> — в первом блоке оператором присваивания <code>≔</code> задаётся начальное значение
+          переменной (или кортежа переменных) рекурсии.
+        </li>
+        <li>
+          <b>Условие продолжения</b> — во втором блоке указывается логическое выражение <code>ЛВ</code>, которое
+          пересчитывается на каждом шаге для текущего значения переменной рекурсии. Второй блок опционален, условием
+          выхода по умолчанию считается повторение предыдущего значения на текущем шаге.
+        </li>
+        <li>
+          <b>Пересчёт</b> — в третьем блоке задаётся ТМВ, вычисляемое на текущем значении переменной и дающее значение
+          переменной на следующем шаге.
+        </li>
+      </ul>
+
+      <h2>Порядок выполнения шага</h2>
+      <p>На каждом шаге сначала вычисляется условие продолжения рекурсии, затем выполняется пересчёт.</p>
+
+      <h2>Завершение и результат</h2>
+      <p>
+        Рекурсия продолжается, пока условие продолжения истинно, или до стабилизации значения переменной рекурсии
+        (значение на шаге <i>k</i> равно значению на шаге <i>k+1</i>). Результатом является последнее значение
+        переменной (или кортежа переменных) рекурсии.
+      </p>
+
+      <h2>Пример</h2>
+      <p>
+        Вычисление степеней двойки:
+        <br />
+        <code>{'R{(ξ,σ) ≔ (1, 0) | σ<5 | (2∗ξ, σ+1)} = 32'}</code>
+      </p>
+    </div>
+  );
+}

rsconcept/frontend/src/features/help/items/rslang/help-rslang-expression-set.tsx

@@ -0,0 +1,45 @@
+export function HelpRSLangExpressionSet() {
+  return (
+    <div>
+      <h1>Теоретико-множественные выражения</h1>
+      <p>
+        Теоретико-множественные выражения (ТМВ) в языке родов структур используются для задания и преобразования
+        множеств. Сложные конструкции теоретико-множественных выражений выделены в индивидуальные разделы справочника.
+      </p>
+      <p>
+        В данном разделе приведены классические операции над множествами, построенные на основе предикатов
+        принадлежности и логических связок.
+      </p>
+
+      <h2>Основные операции</h2>
+      <ul>
+        <li>
+          <b>Объединение</b>: <code>D1 ∪ D2</code> — множество элементов, принадлежащих D1 или D2.
+        </li>
+        <li>
+          <b>Пересечение</b>: <code>D1 ∩ D2</code> — множество элементов, принадлежащих и D1, и D2.
+        </li>
+        <li>
+          <b>Разность</b>: <code>D1 \ D2</code> — множество элементов, принадлежащих D1, но не D2.
+        </li>
+        <li>
+          <b>Симметрическая разность</b>: <code>D1 ∆ D2</code> — множество элементов, принадлежащих исключительно D1 или
+          исключительно D2.
+        </li>
+      </ul>
+
+      <h2>Примеры</h2>
+      <ul>
+        <li>
+          <code>{`{1,2} ∪ {2,3} = {1,2,3}`}</code>
+        </li>
+        <li>
+          <code>{`{1,2,3} ∩ {2,3,4} = {2,3}`}</code>
+        </li>
+        <li>
+          <code>{`{1,2,3} \\ {2} = {1,3}`}</code>
+        </li>
+      </ul>
+    </div>
+  );
+}

rsconcept/frontend/src/features/help/items/rslang/help-rslang-expression-structure.tsx

@@ -0,0 +1,123 @@
+import { LinkTopic } from '../../components/link-topic';
+import { HelpTopic } from '../../models/help-topic';
+
+export function HelpRSLangExpressionStructure() {
+  return (
+    <div>
+      <h1>Структурные выражения</h1>
+      <p>
+        Структурные выражения в языке родов структур используются для преобразований, меняющий{' '}
+        <LinkTopic topic={HelpTopic.RSL_TYPIFICATION} text='типизацию' /> аргументов, позволяя порождать структурно
+        зависимые или структурно новые понятия.
+      </p>
+
+      <h2>Порождение структур</h2>
+      <ul>
+        <li>
+          <b>Булеан / Множество подмножеств</b>: <code>ℬ(X1)</code> — множество всех подмножеств <code>X1</code>.
+        </li>
+        <li>
+          <b>Декартово произведение</b>: <code>X1×X2</code> — множество всех пар элементов из <code>X1</code> и{' '}
+          <code>X2</code>.
+        </li>
+        <li>
+          <b>Кортеж</b>: <code>(a, b, c)</code> — упорядоченная n-ка (n ≥ 2).
+        </li>
+        <li>
+          <b>Перечисление</b>: <code>{'{a, b, c}'}</code> — неупорядоченная n-ка (n ≥ 1).
+        </li>
+        <li>
+          <b>Синглетон / буль</b>: <code>bool(a)</code> = <code>{`{a}`}</code> — множество, состоящее из одного
+          элемента.
+        </li>
+      </ul>
+
+      <h2>Производные структуры</h2>
+
+      <ul>
+        <li>
+          <b>Множество-сумма</b>: <code>red(S1)</code> — объединение элементов всех множеств в <code>S1</code>. Операция
+          применима только к множествам, состоящим из множеств.
+        </li>
+        <li>
+          <b>Десинглетон / дебуль</b>: <code>debool({`{a}`})</code> = <code>a</code> — извлечение единственного элемента
+          из множества. Операция применима только к множествам с одним элементом.
+        </li>
+        <li>
+          <b>Малая проекция</b>: <code>pr1((a1, …, an))</code> = <code>a1</code>.
+        </li>
+        <li>
+          <b>Большая проекция</b>: <code>Pr1(S1)</code> — множество первых компонентов всех кортежей из <code>S1</code>.
+        </li>
+      </ul>
+      <p>
+        Индексы у операций над кортежами для упрощения отображаются равными 1, но их можно заменить на другие
+        натуральные числа или их последовательность, разделенная запятой.
+      </p>
+
+      <h2>Мультииндексы</h2>
+      <p>
+        Вместо одного индекса можно использовать <b>мультииндекс</b> — последовательность натуральных чисел через
+        запятую. В этом случае проекция или фильтр возвращает сразу несколько позиций кортежа.
+      </p>
+      <ul>
+        <li>
+          <code>pr1,3((a1, a2, a3, a4)) = (a1, a3)</code>
+        </li>
+        <li>
+          <code>Pr2,4(S1)</code> — множество пар, составленных из второй и четвёртой компонент кортежей из{' '}
+          <code>S1</code>.
+        </li>
+      </ul>
+
+      <h2>Фильтр</h2>
+      <ul>
+        <li>
+          <b>Фильтр</b>: <code>Fi1[D1](S1)</code> — подмножество <code>S1</code>, в котором для каждого элемента первая
+          проекция принадлежит <code>D1</code>.
+        </li>
+        <li>
+          К фильтру применим <b>мультииндексы</b>, тогда нужно указывать столько же параметров в квадратных скобках.
+        </li>
+        <li>
+          Допустимо использование мультииндексов в фильтре с одним параметром. Тогда проверяется принадлежность
+          параметру кортежа, составленного из соответствующих проекций элементов фильтруемого множества.
+        </li>
+        <li>
+          <b>Мультифильтр</b>: <code>Fi1,2[D1](S1)</code> отличается от фильтра с мультииндексом{' '}
+          <code>Fi1,2[Pr1(D1), Pr2(D2)](S1)</code> тем, что в первом случае проверяется принадлежность парам из D1, а во
+          втором — полному декартову произведению проекций D1
+        </li>
+      </ul>
+
+      <h2>Примеры</h2>
+      <ul>
+        <li>
+          <code>{`ℬ(2) = {{}, {1}, {2}, {1, 2}}`}</code>
+        </li>
+        <li>
+          <code>(1,2,3)</code> — кортеж из трёх чисел
+        </li>
+        <li>
+          <code>pr2((5, 4, 3, 2, 1)) = 4</code>
+        </li>
+        <li>
+          <code>
+            Pr3({`{(1, 2, 3),(4, 5, 6)}`}) = {`{3, 6}`}
+          </code>
+        </li>
+        <li>
+          <code>
+            red({`{{1, 2, 3},{3, 4}}`}) = {`{1, 2, 3, 4}`}
+          </code>
+        </li>
+        <li>
+          <code>bool(1) = {`{1}`}</code>, <code>debool({`{1}`}) = 1</code>
+        </li>
+        <li>
+          <code>{`Fi2[{2, 4}]({((1, 2), (3, 4), (5, 6))}) = {((1, 2), (3, 4))}`}</code>
+        </li>
+      </ul>
+    </div>
+  );
+}

rsconcept/frontend/src/features/help/items/rslang/help-rslang-interpret.tsx

@@ -10,7 +10,7 @@ export function HelpRSLangInterpret() {
         содержания и схемных терминов и определений. Для этого в соответствии с{' '}
         <LinkTopic text='конвенциями' topic={HelpTopic.CC_CONSTITUENTA} /> вводятся списки объектов предметной области,
         соответствующих неопределяемым понятиям. При этом обеспечивается корректность отношений{' '}
-        <LinkTopic text='типизации' topic={HelpTopic.RSL_TYPES} /> для родовых структур.
+        <LinkTopic text='типизации' topic={HelpTopic.RSL_TYPIFICATION} /> для родовых структур.
       </p>
       <p>
         Интерпретация производных понятий может быть задана внешними методами либо автоматически вычислена с помощью

rsconcept/frontend/src/features/help/items/rslang/help-rslang-literals.tsx

@@ -0,0 +1,60 @@
+import { LinkTopic } from '../../components/link-topic';
+import { HelpTopic } from '../../models/help-topic';
+
+export function HelpRSLangLiterals() {
+  return (
+    <div>
+      <h1>Идентификаторы и литералы</h1>
+      <p>
+        В языке родов структур идентификаторы и литералы имеют строгие правила записи, определяющие их роль в выражениях
+        и обеспечивающие однозначность интерпретации.
+      </p>
+
+      <h2>Правила написания идентификаторов</h2>
+      <ul>
+        <li>
+          <b>Понятия</b> — идентификаторы, начинающиеся с заглавной латинской буквы, соответствующей типу{' '}
+          <LinkTopic topic={HelpTopic.CC_CONSTITUENTA} text='конституенты' />: <code>X1</code>,<code>F11</code>,{' '}
+          <code>D24</code>.
+        </li>
+        <li>
+          <b>Радикалы</b> — обозначения для произвольных типизаций, используемые в{' '}
+          <LinkTopic topic={HelpTopic.RSL_EXPRESSION_PARAMETER} text='шаблонных выражениях' /> — идентификаторы,
+          начинающиеся с буквы R.
+        </li>
+        <li>
+          <b>Переменные</b> — идентификаторы, начинающиеся со строчной греческой или латинской буквы, например:
+          <code>ξ</code>, <code>μ2</code>, <code>y1</code>.
+        </li>
+        <li>
+          <b>Специальные идентификаторы</b> — зарезервированные слова и обозначения, имеющие фиксированное значение в
+          языке.
+        </li>
+      </ul>
+
+      <h2>Литералы</h2>
+      <p>Литералы задают фиксированные значения в выражениях.</p>
+      <ul>
+        <li>
+          <b>Целые числа</b> — последовательность цифр. Отрицательные числа не поддерживаются:
+          <code>0</code>, <code>42</code>.
+        </li>
+        <li>
+          <b>Множество целых чисел</b> — символ <code>Z</code>.
+        </li>
+        <li>
+          <b>Пустое множество</b> — символ <code>∅</code>.
+        </li>
+      </ul>
+
+      <h2>Примеры</h2>
+      <p>
+        Пример использования переменной и понятия: <code>x ∈ X1</code>, где <code>x</code> — переменная, а{' '}
+        <code>X1</code> — понятие.
+      </p>
+      <p>
+        Пример с литералами: <code>card(X1) = 5</code>.
+      </p>
+    </div>
+  );
+}

rsconcept/frontend/src/features/help/items/rslang/help-rslang-operations.tsx

@@ -47,7 +47,7 @@ export function HelpRSLangOperations() {
       </h2>
       <p>
         Порождение полной совокупности термов, раскрывающих структуру выбранной конституенты. Операция применима к
-        терм-функциям, термам и родовым структурам с <LinkTopic text='типизацией' topic={HelpTopic.RSL_TYPES} />{' '}
+        терм-функциям, термам и родовым структурам с <LinkTopic text='типизацией' topic={HelpTopic.RSL_TYPIFICATION} />{' '}
         множество и кортеж.
         <br />
         <code>{'Generate(S1∈ℬ(X1×ℬ(X1))) = {Pr1(S1), Pr2(S1), red(Pr2(S1))}'}</code>

rsconcept/frontend/src/features/help/items/rslang/help-rslang-typification.tsx

@@ -1,4 +1,4 @@
-export function HelpRSLangTypes() {
+export function HelpRSLangTypification() {
   return (
     <div>
       <h1>Типизация</h1>

rsconcept/frontend/src/features/help/labels.ts

@@ -31,7 +31,17 @@ const labelHelpTopicRecord: Record<HelpTopic, string> = {
   [HelpTopic.CC_PROPAGATION]: 'Сквозные изменения',
 
   [HelpTopic.RSLANG]: '🚀 Экспликация',
-  [HelpTopic.RSL_TYPES]: 'Типизация',
+  [HelpTopic.RSL_LITERALS]: 'Идентификаторы',
+  [HelpTopic.RSL_TYPIFICATION]: 'Типизация',
+  [HelpTopic.RSL_EXPRESSION_LOGIC]: 'Логические выражения',
+  [HelpTopic.RSL_EXPRESSION_SET]: 'Операции с множествами',
+  [HelpTopic.RSL_EXPRESSION_STRUCTURE]: 'Структурные выражения',
+  [HelpTopic.RSL_EXPRESSION_ARITHMETIC]: 'Арифметика',
+  [HelpTopic.RSL_EXPRESSION_QUANTOR]: 'Кванторные конструкции',
+  [HelpTopic.RSL_EXPRESSION_DECLARATIVE]: 'Декларативные',
+  [HelpTopic.RSL_EXPRESSION_IMPERATIVE]: 'Императивные',
+  [HelpTopic.RSL_EXPRESSION_RECURSIVE]: 'Рекурсивные',
+  [HelpTopic.RSL_EXPRESSION_PARAMETER]: 'Параметризованные',
   [HelpTopic.RSL_CORRECT]: 'Переносимость',
   [HelpTopic.RSL_INTERPRET]: 'Интерпретируемость',
   [HelpTopic.RSL_OPERATIONS]: 'Операции',
@@ -82,7 +92,17 @@ const describeHelpTopicRecord: Record<HelpTopic, string> = {
   [HelpTopic.CC_PROPAGATION]: 'сквозные изменения в ОСС',
 
   [HelpTopic.RSLANG]: 'экспликация и язык родов структур',
-  [HelpTopic.RSL_TYPES]: 'система типов в <br/>родоструктурной экспликации',
+  [HelpTopic.RSL_LITERALS]: 'обозначения конституент,<br/>локальных переменных и литералов',
+  [HelpTopic.RSL_TYPIFICATION]: 'система типов в <br/>родоструктурной экспликации',
+  [HelpTopic.RSL_EXPRESSION_LOGIC]: 'логические связывающие конструкции',
+  [HelpTopic.RSL_EXPRESSION_SET]: 'операции с множествами',
+  [HelpTopic.RSL_EXPRESSION_STRUCTURE]: 'операции со ступенями',
+  [HelpTopic.RSL_EXPRESSION_ARITHMETIC]: 'арифметические выражения',
+  [HelpTopic.RSL_EXPRESSION_QUANTOR]: 'кванторные конструкции',
+  [HelpTopic.RSL_EXPRESSION_DECLARATIVE]: 'декларативные выражения',
+  [HelpTopic.RSL_EXPRESSION_IMPERATIVE]: 'императивные выражения',
+  [HelpTopic.RSL_EXPRESSION_RECURSIVE]: 'рекурсивные выражения',
+  [HelpTopic.RSL_EXPRESSION_PARAMETER]: 'выражения с внешними параметрами',
   [HelpTopic.RSL_CORRECT]: 'биективная переносимость',
   [HelpTopic.RSL_INTERPRET]: 'интерпретация определений <br/>и утверждений',
   [HelpTopic.RSL_OPERATIONS]: 'формальные операции',

rsconcept/frontend/src/features/help/models/help-topic.ts

@@ -32,7 +32,17 @@ export const HelpTopic = {
   CC_PROPAGATION: 'concept-change-propagation',
 
   RSLANG: 'rslang',
-  RSL_TYPES: 'rslang-types',
+  RSL_LITERALS: 'rslang-literals',
+  RSL_TYPIFICATION: 'rslang-typification',
+  RSL_EXPRESSION_LOGIC: 'rslang-expression-logic',
+  RSL_EXPRESSION_SET: 'rslang-expression-set',
+  RSL_EXPRESSION_STRUCTURE: 'rslang-expression-structure',
+  RSL_EXPRESSION_ARITHMETIC: 'rslang-expression-arithmetic',
+  RSL_EXPRESSION_QUANTOR: 'rslang-expression-quantor',
+  RSL_EXPRESSION_DECLARATIVE: 'rslang-expression-declarative',
+  RSL_EXPRESSION_IMPERATIVE: 'rslang-expression-imperative',
+  RSL_EXPRESSION_RECURSIVE: 'rslang-expression-recursive',
+  RSL_EXPRESSION_PARAMETER: 'rslang-expression-parameter',
   RSL_CORRECT: 'rslang-correctness',
   RSL_INTERPRET: 'rslang-interpretation',
   RSL_OPERATIONS: 'rslang-operations',
@@ -88,7 +98,17 @@ export const topicParent = new Map<HelpTopic, HelpTopic>([
   [HelpTopic.CC_PROPAGATION, HelpTopic.CONCEPTUAL],
 
   [HelpTopic.RSLANG, HelpTopic.RSLANG],
-  [HelpTopic.RSL_TYPES, HelpTopic.RSLANG],
+  [HelpTopic.RSL_LITERALS, HelpTopic.RSLANG],
+  [HelpTopic.RSL_TYPIFICATION, HelpTopic.RSLANG],
+  [HelpTopic.RSL_EXPRESSION_LOGIC, HelpTopic.RSLANG],
+  [HelpTopic.RSL_EXPRESSION_SET, HelpTopic.RSLANG],
+  [HelpTopic.RSL_EXPRESSION_STRUCTURE, HelpTopic.RSLANG],
+  [HelpTopic.RSL_EXPRESSION_ARITHMETIC, HelpTopic.RSLANG],
+  [HelpTopic.RSL_EXPRESSION_QUANTOR, HelpTopic.RSLANG],
+  [HelpTopic.RSL_EXPRESSION_DECLARATIVE, HelpTopic.RSLANG],
+  [HelpTopic.RSL_EXPRESSION_IMPERATIVE, HelpTopic.RSLANG],
+  [HelpTopic.RSL_EXPRESSION_RECURSIVE, HelpTopic.RSLANG],
+  [HelpTopic.RSL_EXPRESSION_PARAMETER, HelpTopic.RSLANG],
   [HelpTopic.RSL_CORRECT, HelpTopic.RSLANG],
   [HelpTopic.RSL_INTERPRET, HelpTopic.RSLANG],
   [HelpTopic.RSL_OPERATIONS, HelpTopic.RSLANG],

rsconcept/frontend/src/features/help/pages/manuals-page/topic-page.tsx

@@ -23,10 +23,20 @@ import { HelpContributors } from '../../items/info/help-contributors';
 import { HelpPrivacy } from '../../items/info/help-privacy';
 import { HelpRules } from '../../items/info/help-rules';
 import { HelpRSLangCorrect } from '../../items/rslang/help-rslang-correct';
+import { HelpRSLangExpressionArithmetic } from '../../items/rslang/help-rslang-expression-arithmetic';
+import { HelpRSLangExpressionDeclarative } from '../../items/rslang/help-rslang-expression-declarative';
+import { HelpRSLangExpressionImperative } from '../../items/rslang/help-rslang-expression-imperative';
+import { HelpRSLangExpressionLogic } from '../../items/rslang/help-rslang-expression-logic';
+import { HelpRSLangExpressionParameter } from '../../items/rslang/help-rslang-expression-parameter';
+import { HelpRSLangExpressionQuantor } from '../../items/rslang/help-rslang-expression-quantor';
+import { HelpRSLangExpressionRecursive } from '../../items/rslang/help-rslang-expression-recursive';
+import { HelpRSLangExpressionSet } from '../../items/rslang/help-rslang-expression-set';
+import { HelpRSLangExpressionStructure } from '../../items/rslang/help-rslang-expression-structure';
 import { HelpRSLangInterpret } from '../../items/rslang/help-rslang-interpret';
+import { HelpRSLangLiterals } from '../../items/rslang/help-rslang-literals';
 import { HelpRSLangOperations } from '../../items/rslang/help-rslang-operations';
 import { HelpRSLangTemplates } from '../../items/rslang/help-rslang-templates';
-import { HelpRSLangTypes } from '../../items/rslang/help-rslang-types';
+import { HelpRSLangTypification } from '../../items/rslang/help-rslang-typification';
 import { HelpCstClass } from '../../items/ui/help-cst-class';
 import { HelpCstStatus } from '../../items/ui/help-cst-status';
 import { HelpFormulaTree } from '../../items/ui/help-formula-tree';
@@ -86,7 +96,17 @@ export function TopicPage({ topic }: TopicPageProps) {
   if (topic === HelpTopic.CC_PROPAGATION) return <HelpConceptPropagation />;
 
   if (topic === HelpTopic.RSLANG) return <HelpRSLang />;
-  if (topic === HelpTopic.RSL_TYPES) return <HelpRSLangTypes />;
+  if (topic === HelpTopic.RSL_LITERALS) return <HelpRSLangLiterals />;
+  if (topic === HelpTopic.RSL_TYPIFICATION) return <HelpRSLangTypification />;
+  if (topic === HelpTopic.RSL_EXPRESSION_LOGIC) return <HelpRSLangExpressionLogic />;
+  if (topic === HelpTopic.RSL_EXPRESSION_SET) return <HelpRSLangExpressionSet />;
+  if (topic === HelpTopic.RSL_EXPRESSION_STRUCTURE) return <HelpRSLangExpressionStructure />;
+  if (topic === HelpTopic.RSL_EXPRESSION_ARITHMETIC) return <HelpRSLangExpressionArithmetic />;
+  if (topic === HelpTopic.RSL_EXPRESSION_QUANTOR) return <HelpRSLangExpressionQuantor />;
+  if (topic === HelpTopic.RSL_EXPRESSION_DECLARATIVE) return <HelpRSLangExpressionDeclarative />;
+  if (topic === HelpTopic.RSL_EXPRESSION_IMPERATIVE) return <HelpRSLangExpressionImperative />;
+  if (topic === HelpTopic.RSL_EXPRESSION_RECURSIVE) return <HelpRSLangExpressionRecursive />;
+  if (topic === HelpTopic.RSL_EXPRESSION_PARAMETER) return <HelpRSLangExpressionParameter />;
   if (topic === HelpTopic.RSL_CORRECT) return <HelpRSLangCorrect />;
   if (topic === HelpTopic.RSL_INTERPRET) return <HelpRSLangInterpret />;
   if (topic === HelpTopic.RSL_OPERATIONS) return <HelpRSLangOperations />;