netkeep80 · konard · Feb 6, 2026 · Feb 6, 2026 · Feb 6, 2026
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -2,7 +2,7 @@
 cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
 message( "Configuring: ${CMAKE_CURRENT_SOURCE_DIR}")
 
-set(CMAKE_PROJECT_VERSION 0.0.5 )
+set(CMAKE_PROJECT_VERSION 0.0.6 )
 
 # Project name
 project( avm

diff --git a/README.md b/README.md
@@ -43,6 +43,7 @@ The Associative Relations Model (ARM) is a mathematical model for storing and pr
 - Support for structured data (arrays and associative arrays)
 - JSON serialization/deserialization (null, boolean, array, number, string, object)
 - Logical operations (NOT, AND, OR) defined as truth tables in entity maps
+- Standard library of logical operations (XOR, NAND, NOR, Implies, Eq) as truth tables
 - Conditional construct `If` with lazy evaluation of then/else branches
 - Recursive functions via `Def`/`Call` with named parameters and recursion depth protection
 - Relative addressing operator `[]` for evaluating functions via `eval()`
@@ -52,17 +53,18 @@ The Associative Relations Model (ARM) is a mathematical model for storing and pr
 
 ### Current Status
 
-**Version: 0.0.5** (Alpha)
+**Version: 0.0.6** (Alpha)
 
 Implemented:
 - JSON null, boolean, array, number (unsigned, integer, float), string, object serialization/deserialization
-- Base vocabulary initialization (R, E, True, False, Unsigned, Integer, Float, String, Object, Not, And, Or, If, Def, Call)
+- Base vocabulary initialization (R, E, True, False, Unsigned, Integer, Float, String, Object, Not, And, Or, If, Def, Call, Xor, Nand, Nor, Implies, Eq)
 - Logical operations NOT, AND, OR with truth tables via entity map
+- Standard library: XOR, NAND, NOR, Implies (a → b), Eq (a ↔ b) with truth tables via entity map
 - Conditional construct If with lazy evaluation (e.g. `{"If": [true, "yes", "no"]}` → `"yes"`)
 - Recursive functions via Def/Call (e.g. `[{"Def": ["f", ["x"], body]}, {"Call": ["f", arg]}]`)
 - Relative addressing operator `[]` via `eval()` function for computing logical functions
 - Expression interpreter for evaluating logical, conditional and recursive expressions from JSON
-- 179 unit tests + 16 JSON roundtrip tests
+- 240 unit tests + 16 JSON roundtrip tests
 - CI/CD pipeline (GitHub Actions) for Linux, macOS, Windows
 
 In Progress:
@@ -127,6 +129,21 @@ echo '[{"Def": ["myNot", ["x"], {"Not": ["x"]}]}, {"Call": ["myNot", true]}]' >
 cat res.json  # false
 ```
 
+Standard library operations (XOR, NAND, NOR, Implies, Eq):
+```bash
+echo '{"Xor": [true, false]}' > xor.json
+./avm xor.json
+cat res.json  # true
+
+echo '{"Implies": [true, false]}' > imp.json
+./avm imp.json
+cat res.json  # false
+
+echo '{"Eq": [true, true]}' > eq.json
+./avm eq.json
+cat res.json  # true
+```
+
 ### Dependencies
 
 - C++20 compatible compiler
@@ -173,6 +190,7 @@ AVM (Associative Virtual Machine) — проект, реализующий ви
 - Поддержка структурированных данных (массивы и ассоциативные массивы)
 - Сериализация/десериализация JSON (null, boolean, array, number, string, object)
 - Логические операции (NOT, AND, OR), определённые как таблицы истинности в entity map
+- Стандартная библиотека логических операций (XOR, NAND, NOR, Implies, Eq) как таблицы истинности
 - Условная конструкция `If` с ленивым вычислением веток then/else
 - Рекурсивные функции через `Def`/`Call` с именованными параметрами и защитой от бесконечной рекурсии
 - Оператор относительной адресации `[]` для вычисления функций через `eval()`
@@ -182,17 +200,18 @@ AVM (Associative Virtual Machine) — проект, реализующий ви
 
 ### Текущее состояние
 
-**Версия: 0.0.5** (Альфа)
+**Версия: 0.0.6** (Альфа)
 
 Реализовано:
 - Сериализация/десериализация JSON null, boolean, array, number (unsigned, integer, float), string, object
-- Инициализация базового словаря (R, E, True, False, Unsigned, Integer, Float, String, Object, Not, And, Or, If, Def, Call)
+- Инициализация базового словаря (R, E, True, False, Unsigned, Integer, Float, String, Object, Not, And, Or, If, Def, Call, Xor, Nand, Nor, Implies, Eq)
 - Логические операции NOT, AND, OR с таблицами истинности через entity map
+- Стандартная библиотека: XOR, NAND, NOR, Implies (a → b), Eq (a ↔ b) с таблицами истинности
 - Условная конструкция If с ленивым вычислением (например `{"If": [true, "да", "нет"]}` → `"да"`)
 - Рекурсивные функции через Def/Call (например `[{"Def": ["f", ["x"], тело]}, {"Call": ["f", арг]}]`)
 - Оператор относительной адресации `[]` через функцию `eval()` для вычисления логических функций
 - Интерпретатор выражений для вычисления логических, условных и рекурсивных выражений из JSON
-- 179 модульных тестов + 16 JSON roundtrip тестов
+- 240 модульных тестов + 16 JSON roundtrip тестов
 - CI/CD пайплайн (GitHub Actions) для Linux, macOS, Windows
 
 В разработке:
@@ -257,6 +276,21 @@ echo '[{"Def": ["myNot", ["x"], {"Not": ["x"]}]}, {"Call": ["myNot", true]}]' >
 cat res.json  # false
 ```
 
+Операции стандартной библиотеки (XOR, NAND, NOR, Implies, Eq):
+```bash
+echo '{"Xor": [true, false]}' > xor.json
+./avm xor.json
+cat res.json  # true
+
+echo '{"Implies": [true, false]}' > imp.json
+./avm imp.json
+cat res.json  # false
+
+echo '{"Eq": [true, true]}' > eq.json
+./avm eq.json
+cat res.json  # true
+```
+
 ### Зависимости
 
 - Компилятор с поддержкой C++20

diff --git a/analysis.md b/analysis.md
@@ -132,8 +132,8 @@ AVM (Associative Virtual Machine) — это проект, реализующи
 | Заголовочный файл | ~473 строки (avm.h) |
 | Внешние зависимости | nlohmann/json, LinksPlatform, str_switch |
 | Лицензия | MIT |
-| Unit-тесты | 179 модульных тестов |
-| Тестовые файлы | 27 JSON файлов |
+| Unit-тесты | 240 модульных тестов |
+| Тестовые файлы | 32 JSON файла |
 
 ---
 
@@ -142,9 +142,9 @@ AVM (Associative Virtual Machine) — это проект, реализующи
 Проект находится на стадии альфа-версии:
 
 - **Концепция**: Хорошо проработана теоретически
-- **Реализация**: JSON roundtrip полностью работает, логические операции реализованы, интерпретатор выражений работает, условная конструкция If с ленивым вычислением, рекурсивные функции через Def/Call
+- **Реализация**: JSON roundtrip полностью работает, логические операции реализованы, интерпретатор выражений работает, условная конструкция If с ленивым вычислением, рекурсивные функции через Def/Call, стандартная библиотека (XOR, NAND, NOR, Implies, Eq)
 - **Документация**: Двуязычная документация, описание алгоритма сериализации
-- **Тестирование**: 179 модульных тестов + 16 интеграционных, CI/CD на 3 платформах
+- **Тестирование**: 240 модульных тестов + 16 интеграционных, CI/CD на 3 платформах
 - **Готовность к использованию**: Прототип с работающей базовой функциональностью
 
 ---
@@ -160,9 +160,10 @@ AVM представляет собой интересный исследова
 4. Пакеты для менеджеров зависимостей (vcpkg, Conan)
 5. ~~Условные конструкции~~ ✅ If с ленивым вычислением (PR #28)
 6. ~~Рекурсивные функции~~ ✅ Def/Call с параметрами и защитой от бесконечной рекурсии (PR #29)
+7. ~~Стандартная библиотека~~ ✅ XOR, NAND, NOR, Implies, Eq как таблицы истинности (PR #30)
 
 ---
 
 *Дата анализа: январь 2026*
 *Последнее обновление: февраль 2026*
-*Версия проекта: 0.0.5*
+*Версия проекта: 0.0.6*
diff --git a/include/avm.h b/include/avm.h
@@ -280,6 +280,11 @@ struct rel_t : obj_aspect<rel_t>,
     static inline rel_t *If;
     static inline rel_t *Def;
     static inline rel_t *Call;
+    static inline rel_t *Xor;
+    static inline rel_t *Nand;
+    static inline rel_t *Nor;
+    static inline rel_t *Implies;
+    static inline rel_t *Eq;
 
 protected:
     rel_t()
@@ -369,13 +374,23 @@ struct rel_t : obj_aspect<rel_t>,
             add_rel(If);
             add_rel(Def);
             add_rel(Call);
-
-            Not->update(Not, E);   //  (NOT, Ent) — NOT есть сущность
-            And->update(And, E);   //  (AND, Ent) — AND есть сущность
-            Or->update(Or, E);     //  (OR, Ent) — OR есть сущность
-            If->update(If, E);     //  (IF, Ent) — IF есть сущность
-            Def->update(Def, E);   //  (DEF, Ent) — DEF есть сущность
-            Call->update(Call, E); //  (CALL, Ent) — CALL есть сущность
+            add_rel(Xor);
+            add_rel(Nand);
+            add_rel(Nor);
+            add_rel(Implies);
+            add_rel(Eq);
+
+            Not->update(Not, E);         //  (NOT, Ent) — NOT есть сущность
+            And->update(And, E);         //  (AND, Ent) — AND есть сущность
+            Or->update(Or, E);           //  (OR, Ent) — OR есть сущность
+            If->update(If, E);           //  (IF, Ent) — IF есть сущность
+            Def->update(Def, E);         //  (DEF, Ent) — DEF есть сущность
+            Call->update(Call, E);       //  (CALL, Ent) — CALL есть сущность
+            Xor->update(Xor, E);         //  (XOR, Ent) — XOR есть сущность
+            Nand->update(Nand, E);       //  (NAND, Ent) — NAND есть сущность
+            Nor->update(Nor, E);         //  (NOR, Ent) — NOR есть сущность
+            Implies->update(Implies, E); //  (IMPLIES, Ent) — IMPLIES есть сущность
+            Eq->update(Eq, E);           //  (EQ, Ent) — EQ есть сущность
 
             //  NOT: таблица истинности через entity map
             //  NOT[True] = False, NOT[False] = True
@@ -421,6 +436,89 @@ struct rel_t : obj_aspect<rel_t>,
             //  IF[True] = True, IF[False] = False
             (*If)[True] = True;
             (*If)[False] = False;
+
+            //  === Стандартная библиотека логических операций ===
+            //  Standard library of logical operations
+
+            //  XOR: исключающее ИЛИ через вложенные entity map
+            //  XOR[arg1][arg2] = result
+            auto xor_true = rel_t::rel();   //  XOR[True]
+            auto xor_false = rel_t::rel();  //  XOR[False]
+
+            (*Xor)[True] = xor_true;
+            (*Xor)[False] = xor_false;
+
+            //  XOR[True][True] = False, XOR[True][False] = True
+            (*xor_true)[True] = False;
+            (*xor_true)[False] = True;
+
+            //  XOR[False][True] = True, XOR[False][False] = False
+            (*xor_false)[True] = True;
+            (*xor_false)[False] = False;
+
+            //  NAND: НЕ-И через вложенные entity map
+            //  NAND[arg1][arg2] = NOT[AND[arg1][arg2]]
+            auto nand_true = rel_t::rel();   //  NAND[True]
+            auto nand_false = rel_t::rel();  //  NAND[False]
+
+            (*Nand)[True] = nand_true;
+            (*Nand)[False] = nand_false;
+
+            //  NAND[True][True] = False, NAND[True][False] = True
+            (*nand_true)[True] = False;
+            (*nand_true)[False] = True;
+
+            //  NAND[False][True] = True, NAND[False][False] = True
+            (*nand_false)[True] = True;
+            (*nand_false)[False] = True;
+
+            //  NOR: НЕ-ИЛИ через вложенные entity map
+            //  NOR[arg1][arg2] = NOT[OR[arg1][arg2]]
+            auto nor_true = rel_t::rel();   //  NOR[True]
+            auto nor_false = rel_t::rel();  //  NOR[False]
+
+            (*Nor)[True] = nor_true;
+            (*Nor)[False] = nor_false;
+
+            //  NOR[True][True] = False, NOR[True][False] = False
+            (*nor_true)[True] = False;
+            (*nor_true)[False] = False;
+
+            //  NOR[False][True] = False, NOR[False][False] = True
+            (*nor_false)[True] = False;
+            (*nor_false)[False] = True;
+
+            //  IMPLIES: логическая импликация через вложенные entity map
+            //  IMPLIES[arg1][arg2] = OR[NOT[arg1]][arg2] = (¬a ∨ b)
+            auto imp_true = rel_t::rel();   //  IMPLIES[True]
+            auto imp_false = rel_t::rel();  //  IMPLIES[False]
+
+            (*Implies)[True] = imp_true;
+            (*Implies)[False] = imp_false;
+
+            //  IMPLIES[True][True] = True, IMPLIES[True][False] = False
+            (*imp_true)[True] = True;
+            (*imp_true)[False] = False;
+
+            //  IMPLIES[False][True] = True, IMPLIES[False][False] = True
+            (*imp_false)[True] = True;
+            (*imp_false)[False] = True;
+
+            //  EQ: логическая эквивалентность (биконденсация) через entity map
+            //  EQ[arg1][arg2] = (a → b) ∧ (b → a) = NOT[XOR[a][b]]
+            auto eq_true = rel_t::rel();   //  EQ[True]
+            auto eq_false = rel_t::rel();  //  EQ[False]
+
+            (*Eq)[True] = eq_true;
+            (*Eq)[False] = eq_false;
+
+            //  EQ[True][True] = True, EQ[True][False] = False
+            (*eq_true)[True] = True;
+            (*eq_true)[False] = False;
+
+            //  EQ[False][True] = False, EQ[False][False] = True
+            (*eq_false)[True] = False;
+            (*eq_false)[False] = True;
         }
         ~base_voc()
         {

diff --git a/plan.md b/plan.md
@@ -55,7 +55,7 @@
 #### Средний приоритет
 4. ~~**Реализовать условные конструкции**~~ ✅ — If с ленивым вычислением через entity map и `interpret()` (PR #28)
 5. ~~**Добавить поддержку рекурсии**~~ ✅ — рекурсивные определения функций через `Def`/`Call` с параметрами и защитой от бесконечной рекурсии (PR #29)
-6. **Создать стандартную библиотеку** — базовые функции и операции
+6. ~~**Создать стандартную библиотеку**~~ ✅ — XOR, NAND, NOR, Implies, Eq как таблицы истинности в базовом словаре (PR #30)
 
 #### Низкий приоритет
 7. **Оптимизация вычислений** — кэширование результатов, ленивые вычисления
@@ -135,7 +135,7 @@
 ### Задачи по приоритетам
 
 #### Критический приоритет (сделать в первую очередь)
-1. ~~**Добавить unit-тесты**~~ ✅ — 179 модульных тестов (PR #9, #19, #20, #28, #29)
+1. ~~**Добавить unit-тесты**~~ ✅ — 240 модульных тестов (PR #9, #19, #20, #28, #29, #30)
 2. ~~**Настроить CI/CD**~~ ✅ — GitHub Actions для Ubuntu, Windows, macOS (PR #6)
 3. ~~**Обеспечить кроссплатформенность**~~ ✅ — сборка для Linux, macOS, Windows (PR #6, #14)
 4. ~~**Улучшить README**~~ ✅ — двуязычная документация (PR #2)
@@ -182,6 +182,7 @@
 - ~~Интерпретатор выражений~~ ✅ вычисление логических выражений из JSON через `interpret()` (PR #20)
 - ~~Условные конструкции~~ ✅ If с ленивым вычислением через entity map (PR #28)
 - ~~Рекурсивные функции~~ ✅ Def/Call с параметрами и защитой от бесконечной рекурсии (PR #29)
+- ~~Стандартная библиотека~~ ✅ XOR, NAND, NOR, Implies, Eq (PR #30)
 - Персистентное хранение
 - API для программного использования
 - Примеры и руководства
@@ -210,4 +211,4 @@
 
 *Дата создания: январь 2026*
 *Последнее обновление: февраль 2026*
-*Версия плана: 1.3*
+*Версия плана: 1.4*
diff --git a/src/main.cpp b/src/main.cpp
@@ -188,6 +188,11 @@ rel_t *import_json(const json &j)
 //	  {"Not": [expr]} — логическое НЕ
 //	  {"And": [expr1, expr2]} — логическое И
 //	  {"Or": [expr1, expr2]} — логическое ИЛИ
+//	  {"Xor": [expr1, expr2]} — исключающее ИЛИ
+//	  {"Nand": [expr1, expr2]} — НЕ-И
+//	  {"Nor": [expr1, expr2]} — НЕ-ИЛИ
+//	  {"Implies": [expr1, expr2]} — логическая импликация (a → b)
+//	  {"Eq": [expr1, expr2]} — логическая эквивалентность (a ↔ b)
 //	  {"If": [cond, then, else]} — условная конструкция
 //	  {"Def": ["name", ["param1", ...], body]} — определение рекурсивной функции
 //	  {"Call": ["name", arg1, ...]} — вызов определённой функции
@@ -208,6 +213,16 @@ rel_t *resolve_operator(const string &name)
 		return rel_t::Def;
 	if (name == "Call")
 		return rel_t::Call;
+	if (name == "Xor")
+		return rel_t::Xor;
+	if (name == "Nand")
+		return rel_t::Nand;
+	if (name == "Nor")
+		return rel_t::Nor;
+	if (name == "Implies")
+		return rel_t::Implies;
+	if (name == "Eq")
+		return rel_t::Eq;
 	return nullptr;
 }
 
@@ -626,7 +641,7 @@ int main(int argc, char *argv[])
 		break;
 	default:
 		cout << R"(https://github.com/netkeep80/avm
-     Associative Virtual Machine [Version 0.0.5]
+     Associative Virtual Machine [Version 0.0.6]
              _____________
             /             \
            /               \
@@ -665,7 +680,8 @@ Copyright (c) 2022 Vertushkin Roman Pavlovich <https://vk.com/earthbirthbook>
 		res = json::object();
 		// parse_json(root, res);
 		//	Проверяем, является ли вход выражением для интерпретации
-		//	Выражение — JSON объект с одним ключом-оператором (Not, And, Or, If, Def, Call)
+		//	Выражение — JSON объект с одним ключом-оператором
+		//	(Not, And, Or, Xor, Nand, Nor, Implies, Eq, If, Def, Call)
 		//	или JSON массив выражений (для Def + Call последовательностей)
 		bool is_expression = (root.is_object() && root.size() == 1 &&
 			resolve_operator(root.begin().key()) != nullptr) ||

diff --git a/test/expr_eq.json b/test/expr_eq.json
@@ -0,0 +1 @@
+{"Eq": [true, true]}
diff --git a/test/expr_implies.json b/test/expr_implies.json
@@ -0,0 +1 @@
+{"Implies": [true, false]}
diff --git a/test/expr_nand.json b/test/expr_nand.json
@@ -0,0 +1 @@
+{"Nand": [true, true]}
diff --git a/test/expr_nor.json b/test/expr_nor.json
@@ -0,0 +1 @@
+{"Nor": [false, false]}
diff --git a/test/expr_xor.json b/test/expr_xor.json
@@ -0,0 +1 @@
+{"Xor": [true, false]}