mirror of
https://github.com/IRBorisov/ConceptPortal.git
synced 2025-11-15 17:21:38 +03:00
D: Add documentation for RS Language
This commit is contained in:
Ivan
parent
0d2d0bdad8
commit
f3327f9c5f
6
.vscode/settings.json
vendored
6
.vscode/settings.json
vendored
|
|
@ -193,6 +193,8 @@
|
|||
"Бурбакизатор",
|
||||
"Версионирование",
|
||||
"Владельцом",
|
||||
"генемные",
|
||||
"дебуль",
|
||||
"Демешко",
|
||||
"Десинглетон",
|
||||
"доксинг",
|
||||
|
|
@ -214,6 +216,9 @@
|
|||
"Кучкаров",
|
||||
"Кучкарова",
|
||||
"мультиграфа",
|
||||
"мультииндекс",
|
||||
"Мультииндексы",
|
||||
"Мультифильтр",
|
||||
"неинтерпретируемый",
|
||||
"неитерируемого",
|
||||
"Никанорова",
|
||||
|
|
@ -230,6 +235,7 @@
|
|||
"подпапках",
|
||||
"Присакарь",
|
||||
"ПРОКСИМА",
|
||||
"родовидовое",
|
||||
"Родоструктурная",
|
||||
"родоструктурного",
|
||||
"Родоструктурное",
|
||||
|
|
|
|||
|
|
@ -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>
|
||||
|
|
|
|||
|
|
@ -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 className='dense'>
|
||||
<div>
|
||||
<h1>Родоструктурная экспликация</h1>
|
||||
<p>Формальная запись (<i>экспликация</i>) концептуальных схем осуществляется с помощью языка родов структур.</p>
|
||||
<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 className='dense'>
|
||||
<p>
|
||||
Формальная запись (<i>экспликация</i>) концептуальных схем осуществляется с помощью языка родов структур (далее
|
||||
– Язык). В данном разделе поясняются основные понятия и формальные конструкции Языка. В своей основе Язык
|
||||
является формальной логикой первого порядка, все дополнительные обозначения основываются на предикате
|
||||
принадлежности <code>x∈y</code>.
|
||||
</p>
|
||||
<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>);
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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' />
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ export function HelpRSLangCorrect() {
|
|||
Правила проверки теоретико-множественных выражений выводятся из условия биективной переносимости предиката
|
||||
принадлежности – элемент должен соответствовать множеству, для которого проверяется принадлежность. Необходимым
|
||||
условием биективной переносимости является выполнение{' '}
|
||||
<LinkTopic text='соотношения типизации' topic={HelpTopic.RSL_TYPES} /> для всех локальных и глобальных
|
||||
<LinkTopic text='соотношения типизации' topic={HelpTopic.RSL_TYPIFICATION} /> для всех локальных и глобальных
|
||||
идентификаторов.
|
||||
</p>
|
||||
<p>
|
||||
|
|
|
|||
|
|
@ -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 < b</code>
|
||||
</li>
|
||||
<li>
|
||||
<b>Меньше или равно</b>: <code>a ≤ b</code>
|
||||
</li>
|
||||
<li>
|
||||
<b>Больше</b>: <code>a > 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) > 5</code>
|
||||
</li>
|
||||
<li>
|
||||
<code>x ≤ y + 1</code>
|
||||
</li>
|
||||
</ul>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
|
@ -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>
|
||||
);
|
||||
}
|
||||
|
|
@ -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>
|
||||
);
|
||||
}
|
||||
|
|
@ -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 < 4</code>.
|
||||
</li>
|
||||
<li>
|
||||
<b>Меньше или равно</b>: <code>2 ≤ 4</code>.
|
||||
</li>
|
||||
<li>
|
||||
<b>Больше</b>: <code>2 > 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>
|
||||
);
|
||||
}
|
||||
|
|
@ -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>
|
||||
);
|
||||
}
|
||||
|
|
@ -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>
|
||||
);
|
||||
}
|
||||
|
|
@ -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>
|
||||
);
|
||||
}
|
||||
|
|
@ -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>
|
||||
);
|
||||
}
|
||||
|
|
@ -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>
|
||||
);
|
||||
}
|
||||
|
|
@ -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>
|
||||
Интерпретация производных понятий может быть задана внешними методами либо автоматически вычислена с помощью
|
||||
|
|
|
|||
|
|
@ -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>
|
||||
);
|
||||
}
|
||||
|
|
@ -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>
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
export function HelpRSLangTypes() {
|
||||
export function HelpRSLangTypification() {
|
||||
return (
|
||||
<div>
|
||||
<h1>Типизация</h1>
|
||||
|
|
@ -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]: 'формальные операции',
|
||||
|
|
|
|||
|
|
@ -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],
|
||||
|
|
|
|||
|
|
@ -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 />;
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user