Initial SFOSR system with Gradio interface

README.md

@@ -0,0 +1,70 @@
+---
+title: SFOSR
+emoji: 🏃
+colorFrom: yellow
+colorTo: gray
+sdk: gradio
+sdk_version: 5.24.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: SFOSR System
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# SFOSR: Система Формальной Оценки Смысла и Верификации
+
+This project implements core components of the SFOSR theory, including semantic analysis, contract verification, and proof construction using both input data and a knowledge base.
+
+## Project Structure
+
+- `sfosr_core/`: Contains the main system logic (`integrated_sfosr.py`, `sfosr_database.py`).
+- `tests/`: Contains unit tests (`test_*.py`).
+- `docs/`: Contains documentation and theoretical papers related to SFOSR.
+- `archive/`: Contains archived materials (e.g., old databases).
+- `sfosr.db`: The main SQLite database containing concepts, vectors, rules, etc.
+- `requirements.txt`: Project dependencies.
+- `README.md`: This file.
+
+## Installation
+
+(Currently, no external dependencies are required beyond standard Python libraries.)
+
+```bash
+# It's recommended to use a virtual environment
+python -m venv venv
+source venv/bin/activate # On Windows use `venv\\Scripts\\activate`
+
+# Install dependencies (if any added later)
+pip install -r requirements.txt
+```
+
+## Running Tests
+
+To run all tests, execute the following command from the project root directory:
+
+```bash
+python -m unittest discover tests -v
+```
+
+## Current Capabilities
+
+- Analyzes SFOSR structures for syntactic validity.
+- Verifies vectors against database concepts and predefined contracts.
+- Constructs proofs based on input vectors, prioritizing them first.
+- Integrates knowledge from the `sfosr.db` database into the proof process if input vectors are insufficient.
+- Supports inference rules: `chain_rule`, `causality_transfer`, `implication_causality_chain`, `part_of_transitivity`.
+- Correctly handles cyclic dependencies in proof paths.
+
+## Known Limitations / Future Work
+
+Запуск `python integrated_sfosr.py` демонстрирует обработку примера с построением доказательства и выводом **оценок достоверности**.
+
+## Вклад в проект
+
+Приглашаем заинтересованных исследователей и разработчиков присоединиться к развитию SFOSR.
+
+## Лицензия
+
+Проект SFOSR распространяется под лицензией MIT.

app.py

@@ -0,0 +1,212 @@
+"""
+Gradio application for SFOSR (Semantic Formal Ontology Structure Representation) System.
+
+Provides an interface to analyze, verify, and construct proofs using the SFOSR framework.
+"""
+
+import gradio as gr
+import json
+import os
+from sfosr_core.sfosr_system import SFOSRSystem # Assuming sfosr_system.py is in sfosr_core
+
+# --- Configuration ---
+DB_PATH = "sfosr.db" # Assumes the database is in the root directory
+
+# Check if DB exists, otherwise handle appropriately (e.g., log an error)
+if not os.path.exists(DB_PATH):
+    print(f"Error: Database file not found at {DB_PATH}. Please ensure it exists.")
+    # In a real scenario, you might want to exit or provide a way to upload/create it.
+    sfosr_instance = None # Indicate that the system is not ready
+else:
+    # --- Initialize SFOSR System ---
+    try:
+        sfosr_instance = SFOSRSystem(db_path=DB_PATH)
+        print("SFOSR System initialized successfully.")
+    except Exception as e:
+        print(f"Error initializing SFOSR System: {e}")
+        sfosr_instance = None # Indicate that the system failed to initialize
+
+# --- Helper Functions for Gradio ---
+
+def handle_system_unavailable():
+    """Returns an error message if the SFOSR system isn't ready."""
+    return "SFOSR System is not available. Please check server logs.", "", "", ""
+
+def process_input_json(json_string):
+    """Safely parse input JSON string."""
+    if not json_string:
+        return None, "Input JSON cannot be empty."
+    try:
+        data = json.loads(json_string)
+        if not isinstance(data, dict):
+            return None, "Input must be a valid JSON object (dictionary)."
+        if "vectors" not in data or not isinstance(data["vectors"], list):
+             return None, "Input JSON must contain a 'vectors' key with a list of vectors."
+        # Add more validation as needed (e.g., text key)
+        return data, None
+    except json.JSONDecodeError as e:
+        return None, f"Invalid JSON format: {e}"
+    except Exception as e:
+        return None, f"Error processing input: {e}"
+
+def run_analysis_verification(input_json_str):
+    """Gradio function to run analysis and verification."""
+    if sfosr_instance is None:
+        return handle_system_unavailable()
+
+    input_data, error = process_input_json(input_json_str)
+    if error:
+        return f"Input Error: {error}", "", "", ""
+
+    try:
+        # Use the main process method which handles both analysis and verification
+        result = sfosr_instance.process(input_data)
+
+        # Format the output
+        analysis_summary = f"**Analysis Status:** {result.get('analysis', {}).get('status', 'N/A')}\n" \
+                           f"**Compilable:** {result.get('analysis', {}).get('is_compilable', 'N/A')}\n" \
+                           f"**Graph Metrics:** {result.get('analysis', {}).get('graph_metrics', {})}"
+
+        verification_summary = f"**Total Vectors Processed:** {result.get('verification', {}).get('total_vectors', 0)}\n" \
+                               f"**Valid Vectors:** {result.get('verification', {}).get('valid_count', 0)}\n" \
+                               f"**Compliance Rate:** {result.get('verification', {}).get('compliance_rate', 0.0):.2f}"
+
+        vector_details = result.get('verification', {}).get('vectors_data', {})
+
+        # Optional: Add graph visualization logic here later
+        graph_output = "Graph visualization placeholder"
+
+        return analysis_summary, verification_summary, vector_details, graph_output
+
+    except Exception as e:
+        print(f"Error during SFOSR processing: {e}") # Log for debugging
+        return f"An error occurred: {e}", "", "", ""
+
+def run_proof_construction(input_json_str, source_concept, target_concept):
+    """Gradio function to run proof construction."""
+    if sfosr_instance is None:
+        return handle_system_unavailable()[:1] + ("",) # Only return one value for proof status
+
+    input_data, error = process_input_json(input_json_str)
+    if error:
+        return f"Input Error: {error}", ""
+
+    if not source_concept or not target_concept:
+        return "Source and Target concepts cannot be empty.", ""
+
+    # Add the proof query to the input data
+    input_data["proof_query"] = {
+        "source": source_concept,
+        "target": target_concept
+    }
+
+    try:
+        # Use the main process method - it includes proof if query exists
+        result = sfosr_instance.process(input_data)
+
+        proof_result = result.get("proof")
+
+        if not proof_result:
+             # This might happen if the process function structure changes or proof wasn't run
+             return "Proof was not attempted or failed silently.", ""
+
+        proof_status = f"**Proof Status:** {proof_result.get('status', 'N/A')}\n" \
+                       f"**Is Valid:** {proof_result.get('is_valid', 'N/A')}"
+        if proof_result.get('reason'):
+            proof_status += f"\n**Reason:** {proof_result.get('reason')}"
+
+        proof_details = proof_result # Return the whole proof structure for now
+
+        return proof_status, proof_details
+
+    except Exception as e:
+        print(f"Error during SFOSR proof: {e}") # Log for debugging
+        return f"An error occurred: {e}", ""
+
+
+# --- Gradio Interface Definition ---
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # SFOSR: Semantic Formal Ontology Structure Representation
+        Interact with the SFOSR system to analyze, verify semantic structures,
+        and construct formal proofs based on input vectors.
+        Provide input data in the specified JSON format.
+        [Link to GitHub Repo - Placeholder]
+        """
+    )
+
+    with gr.Tabs():
+        with gr.TabItem("Analyze & Verify"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Input Data (JSON)")
+                    input_json_av = gr.Textbox(
+                        lines=15,
+                        label="SFOSR JSON Input",
+                        info="Paste the JSON containing 'text' (optional) and 'vectors' (required list).",
+                        placeholder='{\n  "text": "Example context...",\n  "vectors": [\n    {\n      "id": "V1",\n      "source": "ConceptA",\n      "target": "ConceptB",\n      "type": "Causality",\n      "axis": "relationship",\n      "justification": "A causes B based on evidence X."\n    }\n    // ... more vectors\n  ],\n "instance_definitions": {\n    "Inst1": {"is_a": "ConceptA", "label": "My Instance"}\n }\n}'
+                    )
+                    av_button = gr.Button("Run Analysis & Verification", variant="primary")
+                with gr.Column(scale=1):
+                    gr.Markdown("### Analysis Summary")
+                    analysis_output = gr.Markdown()
+                    gr.Markdown("### Verification Summary")
+                    verification_output = gr.Markdown()
+                    gr.Markdown("### Vector Verification Details")
+                    vector_details_output = gr.JSON(label="Vector Details")
+                    gr.Markdown("### Concept Graph (Placeholder)")
+                    graph_placeholder_output = gr.Textbox(label="Graph Info") # Placeholder
+
+            # Add examples later using gr.Examples
+            # gr.Examples(
+            #     examples=[
+            #         [sample_json_1],
+            #         [sample_json_2]
+            #      ],
+            #     inputs=input_json_av
+            # )
+
+        with gr.TabItem("Construct Proof"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Input Data & Query (JSON)")
+                    input_json_p = gr.Textbox(
+                        lines=10,
+                        label="SFOSR JSON Context",
+                        info="Paste the JSON containing 'vectors' to be used as premises.",
+                         placeholder='{\n  "vectors": [\n    {\n      "id": "V1", "source": "A", "target": "B", "type": "Implication", "axis": "logic", "is_valid": true \n    },\n    {\n      "id": "V2", "source": "B", "target": "C", "type": "Implication", "axis": "logic", "is_valid": true \n    }\n  ]\n}'
+                    )
+                    source_concept_input = gr.Textbox(label="Source Concept", info="The starting concept for the proof.")
+                    target_concept_input = gr.Textbox(label="Target Concept", info="The concept to prove reachability for.")
+                    p_button = gr.Button("Find Proof", variant="primary")
+                with gr.Column(scale=1):
+                     gr.Markdown("### Proof Result")
+                     proof_status_output = gr.Markdown()
+                     gr.Markdown("### Proof Details / Path")
+                     proof_details_output = gr.JSON(label="Proof Structure")
+
+            # Add examples later using gr.Examples
+
+    # --- Event Handlers ---
+    if sfosr_instance: # Only wire up buttons if the system initialized
+        av_button.click(
+            fn=run_analysis_verification,
+            inputs=[input_json_av],
+            outputs=[analysis_output, verification_output, vector_details_output, graph_placeholder_output]
+        )
+
+        p_button.click(
+            fn=run_proof_construction,
+            inputs=[input_json_p, source_concept_input, target_concept_input],
+            outputs=[proof_status_output, proof_details_output]
+        )
+    else:
+         # Display a persistent error if the system couldn't load
+         gr.Markdown("**Error: SFOSR System failed to initialize. Cannot run operations. Check logs.**")
+
+
+# --- Launch the App ---
+if __name__ == "__main__":
+    demo.launch() # Share=True for public link if needed 

requirements.txt

@@ -0,0 +1,4 @@
+# Add project dependencies here
+# e.g., streamlit 
+streamlit
+gradio 

sfosr_core/sfosr_database.py

@@ -0,0 +1,452 @@
+"""
+SFOSR Database Module
+
+Обеспечивает взаимодействие с базой данных SFOSR.
+Предоставляет методы для извлечения аксиом, правил вывода,
+концептов и их свойств, необходимых для работы системы.
+"""
+
+import sqlite3
+import json
+from typing import Dict, List, Any, Optional, Tuple, Union, Set
+
+class SFOSRDatabase:
+    """
+    Класс для работы с базой данных SFOSR
+    
+    Предоставляет интерфейс для:
+    - Получения аксиом и правил вывода
+    - Извлечения информации о концептах
+    - Получения векторных связей между концептами
+    - Добавления новых данных в базу знаний
+    """
+    
+    def __init__(self, db_path="sfosr.db"):
+        """Инициализация соединения с БД"""
+        self.db_path = db_path
+        self.connection = None
+        
+    def connect(self):
+        """Подключение к БД"""
+        # Возвращаем новое соединение каждый раз
+        # row_factory установим здесь же
+        connection = sqlite3.connect(self.db_path)
+        connection.row_factory = sqlite3.Row
+        return connection
+        
+    # Добавляем контекстный менеджер
+    def __enter__(self):
+        self.connection = self.connect()
+        return self.connection
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.connection:
+            self.connection.close()
+            self.connection = None # Сбрасываем соединение
+
+    def get_axioms(self) -> List[Dict]:
+        """Получение всех аксиом из БД"""
+        with self as conn: # Используем with
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM axioms")
+            axioms = [dict(row) for row in cursor.fetchall()]
+        return axioms
+    
+    def get_inference_rules(self) -> List[Dict]:
+        """Получение всех правил вывода из БД"""
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT id, name, description, pattern, premise_types, conclusion_types, domain FROM inference_rules")
+            rules = [dict(row) for row in cursor.fetchall()]
+        return rules
+    
+    def get_concept_by_name(self, name: str) -> Optional[Dict]:
+        """Поиск концепта по имени"""
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT id, name, description, domain, level FROM concepts WHERE name=?", (name,))
+            concept = cursor.fetchone()
+        return dict(concept) if concept else None
+    
+    def get_all_concepts(self) -> List[Dict]:
+        """Получение всех концептов из БД"""
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT id, name, description, domain, level FROM concepts")
+            concepts = [dict(row) for row in cursor.fetchall()]
+        return concepts
+    
+    def get_all_concept_names(self) -> Set[str]:
+        """Получение имен всех концептов из БД"""
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT name FROM concepts")
+            names = {row['name'] for row in cursor.fetchall()}
+        return names
+    
+    def get_vectors_for_concept(self, concept_id: int) -> List[Dict]:
+        """
+        Получение всех векторов, связанных с концептом
+        
+        Args:
+            concept_id: ID концепта
+            
+        Returns:
+            Список векторов с именами источника и цели
+        """
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                SELECT v.id, v.source_id, v.target_id, v.vector_type, v.axis, v.justification, 
+                       c1.name as source_name, c2.name as target_name 
+                FROM vectors v
+                JOIN concepts c1 ON v.source_id = c1.id
+                JOIN concepts c2 ON v.target_id = c2.id
+                WHERE v.source_id=? OR v.target_id=?
+            """, (concept_id, concept_id))
+            vectors = [dict(row) for row in cursor.fetchall()]
+        return vectors
+    
+    def get_concept_properties(self, concept_id: int) -> Dict[str, Any]:
+        """
+        Получение всех свойств концепта
+        
+        Args:
+            concept_id: ID концепта
+            
+        Returns:
+            Словарь свойств в формате {имя_свойства: значение}
+        """
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                SELECT property_name, property_value 
+                FROM concept_properties
+                WHERE concept_id=?
+            """, (concept_id,))
+            properties = {}
+            for row in cursor.fetchall():
+                prop_name = row['property_name']
+                prop_value = row['property_value']
+                try:
+                    if isinstance(prop_value, str) and (prop_value.startswith('[') or prop_value.startswith('{')):
+                        prop_value = json.loads(prop_value)
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                properties[prop_name] = prop_value
+        return properties
+        
+    def get_complete_concept_info(self, concept_name: str) -> Optional[Dict]:
+        """
+        Получение полной информации о концепте
+        
+        Args:
+            concept_name: Имя концепта
+            
+        Returns:
+            Словарь с информацией о концепте, его свойствах и связях
+        """
+        concept = self.get_concept_by_name(concept_name)
+        if not concept:
+            return None
+            
+        concept_id = concept['id']
+        properties = self.get_concept_properties(concept_id)
+        vectors = self.get_vectors_for_concept(concept_id)
+        
+        return {
+            "concept": concept,
+            "properties": properties,
+            "vectors": vectors
+        }
+    
+    def get_related_concepts(self, concept_id: int, depth: int = 1) -> List[Dict]:
+        """
+        Получение связанных концептов с заданной глубиной
+        
+        Args:
+            concept_id: ID исходного концепта
+            depth: Глубина поиска связей (1 = только прямые связи)
+            
+        Returns:
+            Список связанных концептов
+        """
+        if depth <= 0:
+            return []
+            
+        # Получаем прямые связи
+        vectors = self.get_vectors_for_concept(concept_id)
+        related_ids = set()
+        
+        for vector in vectors:
+            if vector['source_id'] != concept_id:
+                related_ids.add(vector['source_id'])
+            if vector['target_id'] != concept_id:
+                related_ids.add(vector['target_id'])
+                
+        # Рекурсивно получаем связи с заданной глубиной
+        all_related = []
+        for related_id in related_ids:
+            with self as conn:
+                cursor = conn.cursor()
+                cursor.execute("SELECT * FROM concepts WHERE id=?", (related_id,))
+                concept = cursor.fetchone()
+            
+            if concept:
+                related_concept = dict(concept)
+                all_related.append(related_concept)
+                
+                # Если нужна большая глубина, рекурсивно получаем связанные концепты
+                if depth > 1:
+                    deeper_related = self.get_related_concepts(related_id, depth - 1)
+                    all_related.extend(deeper_related)
+                    
+        return all_related
+    
+    def find_path_between_concepts(self, source_name: str, target_name: str, max_depth: int = 3) -> List[Dict]:
+        """
+        Поиск пути между двумя концептами
+        
+        Args:
+            source_name: Имя исходного концепта
+            target_name: Имя целевого концепта
+            max_depth: Максимальная глубина поиска
+            
+        Returns:
+            Список векторов, образующих путь между концептами
+        """
+        source = self.get_concept_by_name(source_name)
+        target = self.get_concept_by_name(target_name)
+        
+        if not source or not target:
+            return []
+            
+        # Поиск в ширину для нахождения пути
+        visited_concepts = {source['id']} # Храним ID концептов, чтобы не зацикливаться
+        queue = [(source['id'], [])]  # (id_концепта, path_из_векторов_до_него)
+        
+        # Ограничиваем глубину поиска
+        current_depth = 0
+        nodes_at_current_depth = 1
+        nodes_at_next_depth = 0
+
+        while queue and current_depth < max_depth:
+            if nodes_at_current_depth == 0:
+                current_depth += 1
+                nodes_at_current_depth = nodes_at_next_depth
+                nodes_at_next_depth = 0
+                if current_depth >= max_depth: # Проверка после инкремента глубины
+                    break 
+
+            current_id, path = queue.pop(0)
+            nodes_at_current_depth -= 1
+            
+            # Проверка, не достигли ли мы цели
+            if current_id == target['id']:
+                return path # Возвращаем список векторов
+                
+            # Получаем связанные векторы для текущего концепта
+            # Используем get_vectors_for_concept, так как он возвращает нужные данные
+            connected_vectors = self.get_vectors_for_concept(current_id)
+            
+            for vector in connected_vectors:
+                next_id = None
+                
+                # Определяем следующий концепт в пути
+                if vector['source_id'] == current_id and vector['target_id'] not in visited_concepts:
+                    next_id = vector['target_id']
+                elif vector['target_id'] == current_id and vector['source_id'] not in visited_concepts:
+                    next_id = vector['source_id']
+                    
+                if next_id:
+                    visited_concepts.add(next_id)
+                    # Добавляем сам вектор (как словарь) в путь
+                    new_path = path + [vector] 
+                    queue.append((next_id, new_path))
+                    nodes_at_next_depth += 1
+                    
+        return []  # Путь не найден в пределах max_depth
+    
+    def convert_db_vector_to_system_format(self, db_vector: Dict) -> Dict:
+        """
+        Преобразование вектора из формата БД в формат системы SFOSR
+        
+        Args:
+            db_vector: Вектор в формате БД
+            
+        Returns:
+            Вектор в формате системы SFOSR
+        """
+        return {
+            "id": f"V{db_vector['id']}",
+            "source": db_vector['source_name'],
+            "target": db_vector['target_name'],
+            "type": db_vector['vector_type'],
+            "axis": db_vector['axis'],
+            "justification": db_vector['justification']
+        }
+    
+    # Методы для обновления БД
+    
+    def add_concept(self, name: str, description: str, domain: str, level: str) -> int:
+        """
+        Добавление нового концепта в БД
+        
+        Args:
+            name: Имя концепта
+            description: Описание концепта
+            domain: Домен (область знаний)
+            level: Уровень абстракции
+            
+        Returns:
+            ID добавленного концепта
+        """
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO concepts (name, description, domain, level)
+                VALUES (?, ?, ?, ?)
+            """, (name, description, domain, level))
+            new_id = cursor.lastrowid
+            conn.commit()
+        return new_id
+    
+    def add_concept_property(self, concept_id: int, property_name: str, property_value: Union[str, List, Dict]) -> int:
+        """
+        Добавление свойства концепта
+        
+        Args:
+            concept_id: ID концепта
+            property_name: Имя свойства
+            property_value: Значение свойства (строка или JSON)
+            
+        Returns:
+            ID добавленного свойства
+        """
+        # Если значение не строка, преобразуем в JSON
+        if not isinstance(property_value, str):
+            property_value = json.dumps(property_value)
+            
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO concept_properties (concept_id, property_name, property_value)
+                VALUES (?, ?, ?)
+            """, (concept_id, property_name, property_value))
+            new_id = cursor.lastrowid
+            conn.commit()
+        return new_id
+    
+    def add_vector(self, source_id: int, target_id: int, vector_type: str, 
+                  axis: str, justification: Optional[str] = None) -> int:
+        """
+        Добавление нового вектора (связи между концептами)
+        
+        Args:
+            source_id: ID исходного концепта
+            target_id: ID целевого концепта
+            vector_type: Тип вектора
+            axis: Семантическая ось
+            justification: Обоснование связи
+            
+        Returns:
+            ID добавленного вектора
+        """
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO vectors (source_id, target_id, vector_type, axis, justification)
+                VALUES (?, ?, ?, ?, ?)
+            """, (source_id, target_id, vector_type, axis, justification))
+            new_id = cursor.lastrowid
+            conn.commit()
+        return new_id
+    
+    def add_axiom(self, name: str, description: str, formulation: str, domain: str) -> int:
+        """
+        Добавление новой аксиомы
+        
+        Args:
+            name: Имя аксиомы
+            description: Описание аксиомы
+            formulation: Формальная формулировка
+            domain: Домен (область применения)
+            
+        Returns:
+            ID добавленной аксиомы
+        """
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO axioms (name, description, formulation, domain)
+                VALUES (?, ?, ?, ?)
+            """, (name, description, formulation, domain))
+            new_id = cursor.lastrowid
+            conn.commit()
+        return new_id
+    
+    def add_inference_rule(self, name: str, description: str, pattern: str, 
+                          premise_types: str, conclusion_types: str, domain: str) -> int:
+        """
+        Добавление нового правила вывода
+        
+        Args:
+            name: Имя правила
+            description: Описание правила
+            pattern: Паттерн вывода
+            premise_types: Типы посылок
+            conclusion_types: Типы выводов
+            domain: Домен (область применения)
+            
+        Returns:
+            ID добавленного правила
+        """
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                INSERT INTO inference_rules (name, description, pattern, premise_types, 
+                                         conclusion_types, domain)
+                VALUES (?, ?, ?, ?, ?, ?)
+            """, (name, description, pattern, premise_types, conclusion_types, domain))
+            new_id = cursor.lastrowid
+            conn.commit()
+        return new_id 
+
+    def get_all_vectors(self):
+        """Получить все векторы из базы данных"""
+        query = """
+            SELECT 
+                v.id,
+                v.source_id,
+                v.target_id,
+                v.vector_type,
+                v.axis,
+                v.justification,
+                s.name as source_name,
+                t.name as target_name,
+                v.is_valid
+            FROM vectors v
+            JOIN concepts s ON v.source_id = s.id
+            JOIN concepts t ON v.target_id = t.id
+            WHERE v.is_valid = 1
+        """
+        
+        with self as conn:
+            cursor = conn.cursor()
+            cursor.execute(query)
+            rows = cursor.fetchall()
+            
+            vectors = []
+            for row in rows:
+                vector = {
+                    "id": f"V{row[0]}",  # Добавляем префикс V к ID
+                    "source_name": row[6],
+                    "target_name": row[7],
+                    "type": row[3],  # vector_type из БД становится type в объекте
+                    "axis": row[4],
+                    "justification": row[5],
+                    "is_valid": bool(row[8])
+                }
+                vectors.append(vector)
+            
+            return vectors 

sfosr_core/sfosr_system.py

@@ -0,0 +1,1403 @@
+"""
+SFOSR Integrated System (with Binary Validity)
+
+Этот модуль объединяет основные компоненты системы SFOSR:
+- Анализатор структуры (`SFOSRAnalyzer`)
+- Верификатор контрактов (`ContractVerifier`)
+- Систему построения доказательств (`ProofSystem`)
+
+для обеспечения комплексной обработки и формальной оценки
+смысловых структур на основе бинарной валидности.
+"""
+
+import json
+import subprocess
+import os
+from typing import Dict, List, Any, Tuple, Optional, Set, Union
+from .sfosr_database import SFOSRDatabase  # Use relative import within the package
+
+# Конфигурация системы
+SFOSR_CONFIG = {
+    "version": "0.4.0",
+    "description": "Integrated SFOSR System",
+    "components": ["analyzer", "verifier", "proof_system"],
+    "debug_mode": False,
+    "auto_update_plausibility": True  # Автоматическое обновление plausibility
+}
+
+# Общие типы векторов
+VECTOR_TYPES = {
+    "Causality": {"weight": 2.0, "requires_justification": True, "description": "Причинно-следственная связь"},
+    "Implication": {"weight": 1.8, "requires_justification": True, "description": "Логическое следование (если-то)"},
+    "Transformation": {"weight": 1.5, "requires_justification": False, "description": "Превращение из одного состояния в другое"},
+    "Goal": {"weight": 1.3, "requires_justification": False, "description": "Целеполагание, намерение"},
+    "Prevention": {"weight": 1.3, "requires_justification": False, "description": "Предотвращение нежелательного исхода"},
+    "Contrast": {"weight": 1.2, "requires_justification": False, "description": "Противопоставление"},
+    "Comparison": {"weight": 1.0, "requires_justification": False, "description": "Сравнение элементов"},
+    "Inclusion": {"weight": 0.8, "requires_justification": False, "description": "Отношение часть-целое"},
+    "Attribution": {"weight": 0.7, "requires_justification": False, "description": "Приписывание свойства объекту"},
+    "Temporal": {"weight": 1.1, "requires_justification": False, "description": "Временная последовательность"},
+    "Qualification": {"weight": 0.6, "requires_justification": False, "description": "Ограничение или уточнение"},
+    "Definition": {"weight": 1.4, "requires_justification": False, "description": "Определение понятия"},
+    "PartOf": {"constraints": [], "requires_justification": False},
+    "Mechanism": {"constraints": [], "requires_justification": True},
+    "Example": {"constraints": [], "requires_justification": False},
+    "Requirement": {"constraints": [], "requires_justification": True},
+    "Action": {"constraints": [], "requires_justification": False},
+    "Capability": {"constraints": [], "requires_justification": False},
+    "PropertyOf": {"constraints": [], "requires_justification": False},
+    "Purpose": {"constraints": [], "requires_justification": False},
+    "Governs": {"constraints": [], "requires_justification": False},
+    "Contains": {"constraints": [], "requires_justification": False},
+    "Represents": {"constraints": [], "requires_justification": False},
+    "Context": {"constraints": [], "requires_justification": False},
+    "IsA": {"constraints": [], "requires_justification": False},
+    # "ActsOn": {"constraints": [], "requires_justification": False},  # Removed as it's not used now
+    "Dependency": {"constraints": [], "requires_justification": True}
+}
+
+# Интерфейс для интеграции компонентов
+class SFOSRSystem:
+    """
+    Основной класс интегрированной системы SFOSR (на бинарной валидности)
+    
+    Объединяет:
+    - Анализ структуры векторов
+    - Проверку контрактов и определение валидности
+    - Построение валидных доказательств
+    """
+    
+    def __init__(self, db_path="sfosr.db", debug=False):
+        self.db_path = db_path
+        self.db = SFOSRDatabase(db_path) # Database connection
+        self._analyzer = SFOSRAnalyzer()
+        
+        # Prepare data for ContractVerifier
+        all_concepts = self.db.get_all_concepts()
+        known_concepts_names = {c['name'] for c in all_concepts}
+        concepts_data_map = {c['name']: c for c in all_concepts}
+        
+        self._verifier = ContractVerifier(known_concepts=known_concepts_names, concepts_data=concepts_data_map) 
+        self._proof_system = ProofSystem(db_conn=self.db) # Pass db connection
+        self.concept_graph = None
+        self.debug = debug
+        
+        # Load inference rules from DB 
+        try:
+            db_rules = self.db.get_inference_rules()
+            if db_rules:
+                 self._proof_system.load_rules(db_rules)
+        except Exception as e:
+             if self.debug:
+                 print(f"Error loading inference rules from database: {str(e)}")
+        
+        # Графы
+        self.concept_graph = {}
+    
+    def process(self, input_data):
+        """
+        Основной метод обработки входных данных (с бинарной валидностью)
+        
+        Последовательно выполняет:
+        1. Анализ структуры
+        2. Проверку контрактов (определение is_valid)
+        3. Построение доказательств (если применимо, определение is_valid)
+           (Использует только валидированные векторы из input_data, без обогащения из БД)
+        
+        Args:
+            input_data: Словарь с текстом и векторами SFOSR
+            
+        Returns:
+            Dict: Результаты обработки (с полями is_valid)
+        """
+        # Шаг 1: Анализ структуры
+        analysis_result = self._analyzer.analyze(input_data)
+        self.concept_graph = analysis_result["concept_graph"]
+        
+        # Если анализ не прошел
+        if analysis_result["analysis_status"] != "Completed":
+             return {
+                "status": "Error",
+                "message": f"Analysis failed: {analysis_result['analysis_status']}",
+                "details": {
+                    "validation_issues": analysis_result["validation_issues"]
+                }
+            }
+        
+        # Получаем инстансы из контекста, если они есть
+        instance_definitions = input_data.get("instance_definitions", {})
+
+        # Шаг 2: Проверка контрактов
+        vectors_to_verify = analysis_result["vectors_analyzed"]
+        # Передаем инстансы в верификатор
+        verification_result = self._verifier.verify_all(vectors_to_verify, instance_definitions)
+        
+        # Собираем только валидные векторы для системы доказательств
+        valid_input_vectors = []
+        vectors_data = verification_result["vectors_data"]
+        for vector in vectors_to_verify:
+            v_id = vector.get("id")
+            # Используем get для безопасного доступа и проверяем наличие ключа 'vector'
+            vector_dict = vectors_data.get(v_id, {}).get('vector') 
+            if vector_dict and vectors_data[v_id].get("is_valid", False):
+                 valid_input_vectors.append(vector_dict) # Добавляем исходный вектор
+
+        # --- Генерация временных IsA векторов --- 
+        temporary_isa_vectors = []
+        for instance_id, definition in instance_definitions.items():
+            general_type = definition.get('is_a')
+            instance_label = definition.get('label', instance_id) # Use label or ID
+            if general_type:
+                 # Проверяем, существует ли общий тип в БД
+                 if self.db.get_concept_by_name(general_type):
+                      temporary_isa_vectors.append({
+                          "id": f"isa_{instance_id}", # Уникальный временный ID
+                          "source": instance_id, # Используем временный ID
+                          "target": general_type, # Ссылка на общий тип в БД
+                          "type": "IsA",
+                          "axis": "classification",
+                          "justification": f"Instance '{instance_label}' defined as type '{general_type}' in input context.",
+                          "is_valid": True # Считаем эти связи априори валидными для доказательства
+                      })
+                 else:
+                      print(f"Warning: General type '{general_type}' for instance '{instance_id}' not found in DB. Skipping IsA vector generation.")
+        # ----------------------------------------
+
+        # Базовый результат обработки
+        result = {
+            "status": "Success",
+            "input_text": input_data.get("text", ""),
+            "analysis": {
+                "status": analysis_result["analysis_status"],
+                "is_compilable": analysis_result["is_compilable"],
+                "graph_metrics": analysis_result["graph_metrics"]
+            },
+            "verification": {
+                "total_vectors": verification_result["total_vectors_processed"],
+                "valid_count": verification_result["valid_count"],
+                "compliance_rate": verification_result["compliance_rate"],
+                "vectors_data": verification_result["vectors_data"]
+            }
+        }
+        
+        # Шаг 3: Построение доказательств 
+        vectors_for_proof = valid_input_vectors + temporary_isa_vectors
+        # Запускаем, если есть запрос И есть ХОТЬ КАКИЕ-ТО векторы (входные или IsA)
+        if "proof_query" in input_data and vectors_for_proof: 
+            query = input_data["proof_query"]
+            source = query.get("source")
+            target = query.get("target")
+            
+            if source and target:
+                proof_result = self._proof_system.construct_proof(
+                    vectors_for_proof, source, target 
+                )
+                result["proof"] = proof_result
+            else: # Нет source/target
+               result["proof"] = {"status": "Failed", "reason": "Missing source or target in proof query", "is_valid": False}
+        # else: # Нет proof_query или нет векторов - proof не создается
+        #    pass 
+        
+        return result
+    
+    def analyze(self, input_data):
+        """Удобный метод для выполнения только анализа"""
+        return self._analyzer.analyze(input_data)
+    
+    def verify(self, input_data):
+        """Удобный метод для выполнения только верификации"""
+        vectors = input_data.get("vectors", [])
+        # Сначала базовый анализ для получения структурно валидных векторов
+        analysis_result = self._analyzer.analyze(input_data)
+        # Передаем пустой словарь instance_definitions, т.к. verify не работает с контекстом
+        return self._verifier.verify_all(analysis_result["vectors_analyzed"], instance_definitions={})
+    
+    def prove(self, input_data, source, target):
+        """Удобный метод для построения доказательства.
+        
+        Анализирует, верифицирует и строит доказательство, используя только
+        валидированные векторы из input_data (без обогащения из БД).
+        """
+        # Сначала анализ
+        analysis_res = self.analyze(input_data)
+        if analysis_res["analysis_status"] != "Completed":
+            return {"status": "Failed", "reason": "Analysis failed"}
+        
+        # Получаем список векторов, прошедших анализ
+        vectors_analyzed = analysis_res.get("vectors_analyzed", [])
+        if not vectors_analyzed:
+            return {"status": "Failed", "reason": "No vectors passed analysis"}
+
+        # Затем верификация этих векторов
+        # Передаем пустой instance_definitions, т.к. prove работает с готовым input_data
+        # Хотя, возможно, стоило бы передавать реальный instance_definitions из input_data?
+        # Пока оставим пустым для совместимости.
+        verification_res = self._verifier.verify_all(vectors_analyzed, instance_definitions={})
+        vectors_data = verification_res.get("vectors_data", {})
+
+        # Извлекаем валидные векторы, ИТЕРРИРУЯ ПО ИСХОДНОМУ СПИСКУ
+        valid_vectors = [
+            vector # Берем исходный вектор
+            for vector in vectors_analyzed # Итерируем по результатам анализа
+            if vectors_data.get(vector.get("id", ""), {}).get("is_valid", False) # Проверяем валидность в результатах верификации
+        ]
+
+        if not valid_vectors:
+             return {"status": "Failed", "reason": "No valid vectors after verification"}
+
+        # Enrichment is disabled, use valid_vectors directly
+        vectors_for_proof = valid_vectors
+
+        return self._proof_system.construct_proof(vectors_for_proof, source, target)
+    
+    def get_concept_info(self, concept_name):
+        """
+        Получение информации о концепте из БД
+        
+        Args:
+            concept_name: Имя концепта
+            
+        Returns:
+            Dict: Информация о концепте или None
+        """
+        return self.db.get_complete_concept_info(concept_name)
+    
+    def find_related_concepts(self, concept_name, depth=1):
+        """
+        Поиск связанных концептов
+        
+        Args:
+            concept_name: Имя концепта
+            depth: Глубина поиска
+            
+        Returns:
+            List: Список связанных концептов
+        """
+        concept = self.db.get_concept_by_name(concept_name)
+        if not concept:
+            return []
+        
+        return self.db.get_related_concepts(concept["id"], depth)
+    
+    def add_concept_to_db(self, name, description, domain, level):
+        """
+        Добавление нового концепта в БД
+        
+        Args:
+            name: Имя концепта
+            description: Описание
+            domain: Домен (область знаний)
+            level: Уровень абстракции
+            
+        Returns:
+            int: ID добавленного концепта
+        """
+        return self.db.add_concept(name, description, domain, level)
+    
+    def add_vector_to_db(self, source_name, target_name, vector_type, axis, justification=None):
+        """
+        Добавление нового вектора в БД
+        
+        Args:
+            source_name: Имя исходного концепта
+            target_name: Имя целевого концепта
+            vector_type: Тип вектора
+            axis: Ось
+            justification: Обоснование
+            
+        Returns:
+            int: ID добавленного вектора или None в случае ошибки
+        """
+        source = self.db.get_concept_by_name(source_name)
+        target = self.db.get_concept_by_name(target_name)
+        
+        if not source or not target:
+            return None
+        
+        return self.db.add_vector(source["id"], target["id"], vector_type, axis, justification)
+
+# Реализация компонентов системы
+
+class SFOSRAnalyzer:
+    """
+    Анализатор структуры векторов SFOSR
+    
+    Отвечает за:
+    - Проверку синтаксиса и базовой структуры векторов
+    - Проверку компилируемости (наличие необходимых полей)
+    - Построение графа концептов
+    """
+    
+    def __init__(self, vector_types=None):
+        """Инициализация анализатора"""
+        self.vector_types = vector_types or VECTOR_TYPES
+    
+    def build_concept_graph(self, vectors):
+        """
+        Строит граф концептов и связей между ними
+        
+        Args:
+            vectors: Список векторов SFOSR
+            
+        Returns:
+            Dict: Структура графа с узлами и связями
+        """
+        # Структура для хранения графа
+        graph = {
+            "nodes": set(),       # уникальные концепты
+            "edges": [],          # связи (кортежи source, target, vector_id)
+            "adjacency": {},      # словарь смежности для быстрого доступа
+        }
+        
+        # Собираем все уникальные концепты и ребра
+        all_nodes = set()
+        for vector in vectors:
+            source = vector.get("source")
+            target = vector.get("target")
+            vector_id = vector.get("id")
+            
+            if source:
+                all_nodes.add(source)
+                if source not in graph["adjacency"]:
+                    graph["adjacency"][source] = {"out": [], "in": []}
+                    
+            if target:
+                all_nodes.add(target)
+                if target not in graph["adjacency"]:
+                    graph["adjacency"][target] = {"out": [], "in": []}
+                    
+            if source and target and vector_id:
+                edge = (source, target, vector_id)
+                graph["edges"].append(edge)
+                graph["adjacency"][source]["out"].append((target, vector_id))
+                graph["adjacency"][target]["in"].append((source, vector_id))
+        
+        graph["nodes"] = all_nodes
+        
+        return graph
+    
+    def validate_vector_structure(self, vector):
+        """
+        Проверяет структуру вектора на соответствие базовым требованиям
+        
+        Args:
+            vector: Словарь с данными вектора
+            
+        Returns:
+            Tuple[bool, Optional[str]]: (валидность, сообщение об ошибке)
+        """
+        required_keys = ["id", "source", "target", "type", "axis"]
+        missing_keys = [key for key in required_keys if key not in vector or not vector[key]]
+        
+        if missing_keys:
+            return False, f"Vector {vector.get('id', 'Unknown')} missing keys: {', '.join(missing_keys)}"
+        
+        # Проверяем, существует ли указанный тип вектора
+        vector_type = vector.get("type")
+        if vector_type not in self.vector_types:
+            return False, f"Vector {vector.get('id', 'Unknown')} has invalid type: {vector_type}"
+        
+        return True, None
+    
+    def validate_compilability(self, vector):
+        """
+        Проверяет на компилируемость (достаточность данных)
+        
+        Args:
+            vector: Словарь с данными вектора
+            
+        Returns:
+            Tuple[bool, Optional[str]]: (компилируемость, сообщение об ошибке)
+        """
+        vector_type = vector.get("type")
+        
+        # Проверяем требования обоснования в зависимости от типа
+        if (vector_type in self.vector_types and 
+                self.vector_types[vector_type]["requires_justification"]):
+            if not vector.get("justification"):
+                return False, f"Vector {vector.get('id', 'Unknown')} requires justification for type {vector_type}."
+        
+        return True, None
+    
+    def analyze(self, input_data):
+        """
+        Главная функция анализа структуры SFOSR (упрощенная)
+        
+        Args:
+            input_data: Словарь с текстом и векторами
+            
+        Returns:
+            Dict: Результаты анализа (валидация и граф)
+        """
+        input_text = input_data.get("text", "N/A")
+        vectors = input_data.get("vectors", [])
+        
+        valid_vectors = []
+        validation_issues = []
+        analysis_status = "Completed"
+        
+        # 1. Валидация структуры и компилируемости каждого вектора
+        for vector in vectors:
+            is_struct_valid, struct_error = self.validate_vector_structure(vector)
+            if not is_struct_valid:
+                validation_issues.append(struct_error)
+                analysis_status = "Validation Error"
+                continue # Невалидную структуру дальше не проверяем
+            
+            is_comp_valid, comp_error = self.validate_compilability(vector)
+            if not is_comp_valid:
+                validation_issues.append(comp_error)
+                # Продолжаем анализ, но помечаем проблему
+            
+            # Собираем только структурно валидные векторы
+            valid_vectors.append(vector)
+        
+        # Определяем компилируемость по наличию проблем
+        is_compilable = len(validation_issues) == 0
+        if not is_compilable and analysis_status == "Completed":
+            analysis_status = "Compilability Error" # Если были только проблемы компилируемости
+        
+        # 2. Построение графа концептов (только из структурно валидных векторов)
+        graph = self.build_concept_graph(valid_vectors)
+        
+        # 3. Формирование упрощенного результата
+        result = {
+            "input_text": input_text,
+            "analysis_status": analysis_status,
+            "is_compilable": is_compilable,
+            "validation_issues": validation_issues,
+            "graph_metrics": { # Упрощенные метрики графа
+                "concepts_count": len(graph["nodes"]),
+                "connections_count": len(graph["edges"]),
+            },
+            "vectors_analyzed": valid_vectors, # Содержит только структурно валидные
+            "concept_graph": graph
+        }
+        
+        return result
+
+class ContractVerifier:
+    """
+    Верификатор контрактов векторов SFOSR
+    
+    Проверяет соответствие векторов формальным контрактам,
+    определяет бинарную валидность (`is_valid`) вектора 
+    и собирает метаданные.
+    """
+    
+    def __init__(self, contract_types=None, known_concepts: Optional[Set[str]] = None, concepts_data: Optional[Dict[str, Dict]] = None):
+        """Инициализация верификатора с известными концептами и их данными (уровнями)."""
+        self.contract_types = contract_types or set(VECTOR_TYPES.keys())
+        self.known_concepts = known_concepts or set()
+        # --- Сохраняем данные об уровнях --- 
+        self.concepts_data = concepts_data or {}
+        # ----------------------------------
+        self.axis_registry = set()
+    
+    def verify_vector_contract(self, vector: Dict[str, Any], instance_definitions: Dict[str, Dict]) -> Tuple[bool, List[str], Dict[str, Any]]:
+        """Проверяет отдельный вектор на ��оответствие контрактам"""
+        issues = []
+        metadata = {}
+        is_valid = True # Начинаем с предположения о валидности
+
+        # --- Проверка существования концептов и их типов --- 
+        source_name = vector.get("source")
+        target_name = vector.get("target")
+        vector_type = vector.get("type")
+        vector_id = vector.get("id", "Unknown")
+        
+        # --- Получаем реальные ТИПЫ концептов для проверки --- 
+        source_type_name = source_name
+        target_type_name = target_name
+        is_source_instance = False
+        is_target_instance = False
+        
+        if source_name in instance_definitions:
+            source_type_name = instance_definitions[source_name].get("is_a")
+            is_source_instance = True
+            if not source_type_name:
+                issues.append(f"Instance '{source_name}' in vector {vector_id} has no 'is_a' type defined in context.")
+                is_valid = False
+                source_type_name = None # Не можем проверить дальше
+                
+        if target_name in instance_definitions:
+            target_type_name = instance_definitions[target_name].get("is_a")
+            is_target_instance = True
+            if not target_type_name:
+                issues.append(f"Instance '{target_name}' in vector {vector_id} has no 'is_a' type defined in context.")
+                is_valid = False
+                target_type_name = None # Не можем проверить дальше
+        # ----------------------------------------------------
+
+        source_concept_data = None
+        target_concept_data = None
+
+        if source_type_name and is_valid:
+             source_concept_data = self.concepts_data.get(source_type_name)
+             if not source_concept_data:
+                 issues.append(f"Source concept/type '{source_type_name}' (for '{source_name}') not found in known concepts for vector {vector_id}.")
+                 is_valid = False
+                 
+        if target_type_name and is_valid:
+             target_concept_data = self.concepts_data.get(target_type_name)
+             if not target_concept_data:
+                 issues.append(f"Target concept/type '{target_type_name}' (for '{target_name}') not found in known concepts for vector {vector_id}.")
+                 is_valid = False
+        
+        # --- Проверка контрактов типа Transformation --- 
+        if is_valid and vector_type == "Transformation":
+            if source_name == target_name: 
+                issues.append(f"Transformation vector {vector_id} cannot have the same source and target ('{source_name}').")
+                is_valid = False
+                
+        # --- Проверка контракта для Causality (разные уровни) --- 
+        if is_valid and vector_type == "Causality" and "level" in vector.get("axis", ""):
+             if source_concept_data and target_concept_data: 
+                  source_level = source_concept_data.get('level')
+                  target_level = target_concept_data.get('level')
+                  if source_level and target_level and source_level == target_level:
+                       issues.append(f"Causality vector {vector_id} ('{source_type_name}' -> '{target_type_name}') links concepts on the same level '{source_level}' with axis containing 'level'.")
+                       is_valid = False
+        
+        # --- Добавить другие специфичные для типов векторов проверки --- 
+        # Например, для ActsOn: source должен быть подтипом Action, target - подтипом Object?
+        # Это потребует иерархии в БД или более сложной логики.
+
+        # Регистрация осей остается
+        if vector.get("axis") and vector["axis"] not in self.axis_registry:
+             self.axis_registry.add(vector["axis"])
+        
+        # Добавляем сами данные вектора в метаданные для использования в `prove`
+        # metadata['vector'] = vector # Убрали - теперь prove получает исходный список
+        
+        return is_valid, issues, metadata
+
+    def verify_all(self, vectors: List[Dict[str, Any]], instance_definitions: Dict[str, Dict]) -> Dict[str, Any]:
+        """Проверка всех векторов, агрегация валидности и метаданных"""
+        vectors_data = {}
+        valid_count = 0
+        processed_count = 0
+
+        for vector in vectors:
+            processed_count += 1
+            vector_id = vector.get("id", f"unknown_{processed_count}")
+            # Передаем instance_definitions в проверку контракта
+            is_valid, issues, metadata = self.verify_vector_contract(vector, instance_definitions)
+            
+            vectors_data[vector_id] = {
+                "vector": vector, 
+                "is_valid": is_valid,
+                "issues": issues,
+                "metadata": metadata
+            }
+            
+            if is_valid:
+                 valid_count += 1
+        
+        # Формируем отчет
+        report = {
+            "total_vectors_processed": processed_count,
+            "valid_count": valid_count,
+            "compliance_rate": round(valid_count / processed_count, 3) if processed_count > 0 else 0.0,
+            "vectors_data": vectors_data # Основные данные теперь здесь
+        }
+        
+        return report
+
+class ProofSystem:
+    """
+    Система построения доказательств SFOSR
+    
+    Отвечает за:
+    - Построение доказательств на основе ВАЛИДНЫХ векторов (и данных из БД)
+    - Проверку итоговой валидности (`is_valid`) доказательств
+    - Поиск путей доказательства между концептами (с использованием БД)
+    """
+    
+    def __init__(self, db_conn):
+        """Инициализация системы доказательств.
+        
+        Args:
+            db_conn: Экземпляр SFOSRDatabase для доступа к БД.
+        """
+        self.db_conn = db_conn # Store the database connection
+        # Базовые правила вывода (с бинарной валидностью)
+        self.inference_rules = {
+            "chain_rule": {
+                "pattern": "A → B, B → C ⊢ A → C",
+                "premise_types": ["Implication", "Implication"],
+                "conclusion_type": "Implication",
+                "domain": "logical_inference"
+            },
+            "causality_transfer": {
+                "pattern": "A → B (Causality), B → C (Causality) ⊢ A → C (Causality)",
+                "premise_types": ["Causality", "Causality"],
+                "conclusion_type": "Causality",
+                "domain": "causal_inference"
+            },
+            "implication_causality_chain": {
+                "pattern": "A → B (Implication), B → C (Causality) ⊢ A → C (Causality)",
+                "premise_types": ["Implication", "Causality"],
+                "conclusion_type": "Causality", 
+                "domain": "mixed_inference"
+            },
+            # --- New Rule --- 
+            "part_of_transitivity": {
+                "pattern": "A PartOf B, B PartOf C ⊢ A PartOf C",
+                "premise_types": ["PartOf", "PartOf"],
+                "conclusion_type": "PartOf",
+                "domain": "mereology"
+            },
+            # --- НОВОЕ ПРАВИЛО --- 
+            "action_causality_chain": {
+                "pattern": "A -> B (Action), B -> C (Causality) |- A -> C (Causality)",
+                "premise_types": ["Action", "Causality"],
+                "conclusion_type": "Causality",
+                "domain": "action_inference"
+            },
+            # --- ЕЩЕ ОДНО НОВОЕ ПРАВИЛО --- 
+            "action_isa_generalization": {
+                "pattern": "A -> B_inst (Action), B_inst IsA B_type |- A -> B_type (Action)",
+                "premise_types": ["Action", "IsA"],
+                "conclusion_type": "Action", # Результат - обобщенное действие
+                "domain": "inheritance_inference"
+            }
+        }
+        
+        # Кэш для хранения построенных доказательств (только структура вывода)
+        self.proof_cache = {}
+        
+    def load_rules(self, db_rules):
+        """
+        Загрузка правил вывода из БД (игнорируя любые старые данные plausibility)
+        
+        Args:
+            db_rules: Словарь с правилами вывода из БД
+        """
+        for name, rule_data in db_rules.items():
+            rule_data.pop('plausibility', None) # Убеждаемся, что plausibility удалено
+            self.inference_rules[name] = rule_data
+    
+    # --- Helper for Input-Only BFS --- 
+    def _find_path_using_input_graph(self, input_graph, source_concept, target_concept) -> Dict[str, Any]:
+        """BFS using only the input graph."""
+        # print(f"DEBUG _find_path_using_input_graph: Start {source_concept} -> {target_concept}") # UNCOMMENTED
+        if source_concept not in input_graph["nodes"]:
+            # --- DEBUG PRINT ---
+            # print(f"DEBUG construct_proof: Source '{source_concept}' not in input graph nodes: {input_graph['nodes']}")
+            # --- END DEBUG PRINT ---
+            return {"status": "Source node not found"}
+        
+        visited = {source_concept}
+        queue: List[Tuple[str, List[Tuple[str, str, str, str]]]] = [(source_concept, [])] 
+        
+        while queue:
+            current_concept, path = queue.pop(0)
+            # print(f"DEBUG _find_path_using_input_graph: Dequeue '{current_concept}'") # UNCOMMENTED
+            
+            if current_concept in input_graph["adjacency"]:
+                for next_concept_input, vector_id_input in input_graph["adjacency"][current_concept].get("out", []):
+                    # --- DEBUG PRINT ---
+                    # print(f"DEBUG construct_proof (Input BFS): Edge {current_concept} -> {next_concept_input} via {vector_id_input}") # UNCOMMENTED
+                    # --- END DEBUG PRINT ---
+                    if next_concept_input == target_concept:
+                        final_path = path + [(current_concept, next_concept_input, vector_id_input, 'input')]
+                        # print(f"DEBUG _find_path_using_input_graph: Target reached. Path: {final_path}") # UNCOMMENTED
+                        # --- DEBUG PRINT ---
+                        # print(f"DEBUG construct_proof (Input BFS): Target '{target_concept}' reached. Path: {final_path}")
+                        # --- END DEBUG PRINT ---
+                        return {"status": "Path found", "path": final_path, "db_vectors_used": []} 
+
+                    if next_concept_input not in visited:
+                        visited.add(next_concept_input)
+                        new_path = path + [(current_concept, next_concept_input, vector_id_input, 'input')]
+                        queue.append((next_concept_input, new_path))
+                        # print(f"DEBUG _find_path_using_input_graph: Enqueue '{next_concept_input}'") # UNCOMMENTED
+        
+        # print(f"DEBUG _find_path_using_input_graph: Path not found.") # UNCOMMENTED
+        # --- DEBUG PRINT ---
+        # print(f"DEBUG construct_proof (Input BFS): Path not found from '{source_concept}' to '{target_concept}'")
+        # --- END DEBUG PRINT ---
+        return {"status": "Path not found (input only)"}
+        
+    # --- Helper for Combined BFS --- 
+    def _find_path_using_combined_graph(self, input_graph, source_concept, target_concept) -> Dict[str, Any]:
+        """BFS using input graph AND database lookups."""
+        # print(f"\\nDEBUG _find_path_using_combined_graph: Start {source_concept} -> {target_concept}") 
+        # --- DEBUG PRINT ---
+        # print(f"DEBUG construct_proof (Combined BFS): Start {source_concept} -> {target_concept}")
+        # --- END DEBUG PRINT ---
+        if source_concept not in input_graph["nodes"]:
+            if not self.db_conn.get_concept_by_name(source_concept):
+                 # --- DEBUG PRINT ---
+                 # print(f"DEBUG construct_proof (Combined BFS): Source '{source_concept}' not in input graph or DB.")
+                 # --- END DEBUG PRINT ---
+                 return {"status": "Source node not found"}
+        
+        # visited теперь словарь: {concept_name: origin ('input' или 'db')}
+        visited: Dict[str, str] = {source_concept: 'start'} 
+        queue: List[Tuple[str, List[Tuple[str, str, str, str]], Set[int]]] = [(source_concept, [], set())]
+        used_db_vector_ids = set() 
+        db_vector_cache = {} 
+
+        while queue:
+            current_concept, path, current_used_db_ids = queue.pop(0)
+            # --- DEBUG PRINT ---
+            # print(f"DEBUG construct_proof (Combined BFS): Dequeue '{current_concept}'")
+            # --- END DEBUG PRINT ---
+
+            # --- Шаг 1: Входной граф --- 
+            if current_concept in input_graph["adjacency"]:
+                for next_concept_input, vector_id_input in input_graph["adjacency"][current_concept].get("out", []):
+                    # --- DEBUG PRINT ---
+                    # print(f"DEBUG construct_proof (Combined BFS): Input Edge {current_concept} -> {next_concept_input} via {vector_id_input}")
+                    # --- END DEBUG PRINT ---
+                    if next_concept_input == target_concept:
+                        final_path = path + [(current_concept, next_concept_input, vector_id_input, 'input')]
+                        final_db_vectors_list = [ self.db_conn.convert_db_vector_to_system_format(db_vector_cache[vid]) for vid in current_used_db_ids if vid in db_vector_cache ]
+                        # --- DEBUG PRINT ---
+                        # print(f"DEBUG construct_proof (Combined BFS): Target '{target_concept}' reached via input edge. Path: {final_path}")
+                        # --- END DEBUG PRINT ---
+                        return {"status": "Path found", "path": final_path, "db_vectors_used": final_db_vectors_list}
+
+                    if next_concept_input not in visited:
+                        visited[next_concept_input] = 'input' # Помечаем как посещенный через input
+                        new_path = path + [(current_concept, next_concept_input, vector_id_input, 'input')]
+                        queue.append((next_concept_input, new_path, current_used_db_ids))
+                         
+            # --- Шаг 2: База Данных --- 
+            try:
+                current_concept_info = self.db_conn.get_concept_by_name(current_concept)
+                if not current_concept_info:
+                    # --- DEBUG PRINT ---
+                    # print(f"DEBUG construct_proof (Combined BFS): Concept '{current_concept}' not found in DB for DB search.")
+                    # --- END DEBUG PRINT ---
+                    continue 
+                current_concept_id = current_concept_info['id']
+                # --- MORE DEBUG --- 
+                # print(f"DEBUG _find_path_using_combined_graph: Querying DB vectors for concept '{current_concept}' (ID: {current_concept_id})")
+                # --- END MORE DEBUG ---
+                db_vectors_raw = self.db_conn.get_vectors_for_concept(current_concept_id)
+                # --- MORE DEBUG --- 
+                # print(f"DEBUG _find_path_using_combined_graph: Received {len(db_vectors_raw)} vectors from DB for ID {current_concept_id}:")
+                # for dbv in db_vectors_raw:
+                #     print(f"  - ID: V{dbv.get('id')}, Type: {dbv.get('vector_type')}, Source: {dbv.get('source_name')}, Target: {dbv.get('target_name')}")
+                # --- END MORE DEBUG ---
+                
+                for db_vector in db_vectors_raw:
+                    if db_vector['source_id'] == current_concept_id:
+                        next_concept_db = db_vector['target_name']
+                        db_vector_actual_id = db_vector['id'] 
+                        db_vector_system_id = f"V{db_vector_actual_id}"
+                        # --- DEBUG PRINT ---
+                        # print(f"DEBUG construct_proof (Combined BFS): DB Edge {current_concept} -> {next_concept_db} via {db_vector_system_id}")
+                        # --- END DEBUG PRINT ---
+                        
+                        if db_vector_actual_id not in db_vector_cache:
+                             db_vector_cache[db_vector_actual_id] = db_vector
+                        
+                        new_used_db_ids = current_used_db_ids.union({db_vector_actual_id})
+
+                        if next_concept_db == target_concept:
+                            final_path = path + [(current_concept, next_concept_db, db_vector_system_id, 'db')]
+                            final_db_vectors_list = [ self.db_conn.convert_db_vector_to_system_format(db_vector_cache[vid]) for vid in new_used_db_ids if vid in db_vector_cache ]
+                            # --- DEBUG PRINT ---
+                            # print(f"DEBUG construct_proof (Combined BFS): Target '{target_concept}' reached via DB edge. Path: {final_path}")
+                            # --- END DEBUG PRINT ---
+                            return {"status": "Path found", "path": final_path, "db_vectors_used": final_db_vectors_list}
+
+                        # Проверяем, был ли узел посещен и откуда
+                        current_visit_status = visited.get(next_concept_db)
+                        # Добавляем в очередь, ТОЛЬКО если не посещен через input
+                        if current_visit_status != 'input': 
+                            # Если еще не посещался или посещался через db, обновляем/добавляем
+                            if current_visit_status is None or current_visit_status == 'db':
+                                visited[next_concept_db] = 'db' # Помечаем как посещенный через db
+                                new_path = path + [(current_concept, next_concept_db, db_vector_system_id, 'db')]
+                                queue.append((next_concept_db, new_path, new_used_db_ids))
+
+            except Exception as e:
+                print(f"DB Error during path finding in combined search: {e}") 
+                return {"status": "DB error", "reason": str(e)}
+
+        return {"status": "Path not found (combined)"}
+        
+    # --- Orchestrator Method --- 
+    def find_proof_path(self, input_graph, source_concept, target_concept) -> Dict[str, Any]:
+        """
+        Ищет путь доказательства: сначала только по входным данным, затем с БД.
+        
+        Args:
+            input_graph: Граф, построенный ТОЛЬКО из валидных входных векторов.
+            source_concept: Имя исходного концепта.
+            target_concept: Имя целевого концепта.
+            
+        Returns:
+            Dict: Результат поиска пути (статус, путь, db_vectors_used).
+        """
+        # Phase 1: Input vectors only
+        # print("DEBUG find_proof_path: Starting Phase 1 (Input Only)")
+        input_path_info = self._find_path_using_input_graph(input_graph, source_concept, target_concept)
+        
+        if input_path_info["status"] == "Path found":
+            # print("DEBUG find_proof_path: Path found in Phase 1. Returning.")
+            return input_path_info
+            
+        # Phase 2: Combined input and DB vectors
+        # print("DEBUG find_proof_path: Path not found in Phase 1. Starting Phase 2 (Combined Input+DB)")
+        combined_path_info = self._find_path_using_combined_graph(input_graph, source_concept, target_concept)
+        
+        if combined_path_info["status"] == "Path not found (combined)":
+             combined_path_info["status"] = "Path not found"
+             
+        # print(f"DEBUG find_proof_path: Phase 2 finished with status: {combined_path_info['status']}")
+        return combined_path_info
+
+    def _apply_chain_rule(self, premises: List[Dict]) -> Tuple[Optional[Dict], bool]:
+        """Логика для правила chain_rule. Возвращает (вывод, валидность_шага)."""
+        if len(premises) != 2:
+            return None, False
+        v1, v2 = premises
+        
+        # Проверяем соответствие паттерну правила
+        if v1["target"] == v2["source"] and \
+           v1["type"] == "Implication" and \
+           v2["type"] == "Implication": # Вторая посылка должна быть Implication
+           
+            # Определяем тип вывода (просто берем из правила)
+            conclusion_type = self.inference_rules["chain_rule"]["conclusion_type"]
+           
+            # Формируем вывод
+            conclusion = {
+                "id": f"S{len(self.proof_cache) + 1}", # Генерируем ID для шага
+                "source": v1["source"],
+                "target": v2["target"],
+                "type": conclusion_type,
+                "axis": v1["axis"], # Берем ось из первой посылки (можно уточнить)
+                "justification": f"Derived by chain_rule from {v1['id']} and {v2['id']}",
+                "derived": True # Помечаем, что вектор выведен
+            }
+            return conclusion, True # Шаг валиден
+           
+        return None, False # Правило неприменимо
+
+    def _apply_causality_transfer(self, premises: List[Dict]) -> Tuple[Optional[Dict], bool]:
+        """Логика для правила causality_transfer. Возвращает (вывод, валидность_шага)."""
+        if len(premises) != 2:
+            return None, False
+        v1, v2 = premises
+        
+        # Проверяем соответствие паттерну правила
+        if v1["target"] == v2["source"] and \
+           v1["type"] == "Causality" and \
+           v2["type"] == "Causality": # Вторая посылка должна быть Causality
+          
+            conclusion_type = self.inference_rules["causality_transfer"]["conclusion_type"]
+           
+            conclusion = {
+                "id": f"S{len(self.proof_cache) + 1}",
+                "source": v1["source"],
+                "target": v2["target"],
+                "type": conclusion_type,
+                "axis": v1["axis"], 
+                "justification": f"Derived by causality_transfer from {v1['id']} and {v2['id']}",
+                "derived": True
+            }
+            return conclusion, True
+           
+        return None, False
+
+    def _apply_implication_causality_chain(self, premises: List[Dict]) -> Tuple[Optional[Dict], bool]:
+        """Логика для правила implication_causality_chain. Возвращает (вывод, валидность_шага)."""
+        if len(premises) != 2:
+            return None, False
+        v1, v2 = premises
+        
+        # Проверяем соответствие паттерну
+        if v1["target"] == v2["source"] and \
+           v1["type"] == "Implication" and \
+           v2["type"] == "Causality":
+           
+            conclusion_type = self.inference_rules["implication_causality_chain"]["conclusion_type"]
+           
+            conclusion = {
+                "id": f"S{len(self.proof_cache) + 1}",
+                "source": v1["source"],
+                "target": v2["target"],
+                "type": conclusion_type,
+                "axis": v1["axis"], # Берем ось из первой посылки 
+                "justification": f"Derived by implication_causality_chain from {v1['id']} and {v2['id']}",
+                "derived": True
+            }
+            return conclusion, True
+           
+        return None, False
+    
+    # --- New Method for PartOf Rule --- 
+    def _apply_part_of_transitivity(self, premises: List[Dict]) -> Tuple[Optional[Dict], bool]:
+        """Логика для правила part_of_transitivity."""
+        if len(premises) != 2:
+            return None, False
+        v1, v2 = premises
+        
+        # Проверяем типы посылок и связь
+        if v1["target"] == v2["source"] and \
+           v1.get("type") == "PartOf" and \
+           v2.get("type") == "PartOf":
+           
+            conclusion_type = self.inference_rules["part_of_transitivity"]["conclusion_type"]
+           
+            conclusion = {
+                "id": f"S{len(self.proof_cache) + 1}",
+                "source": v1["source"],
+                "target": v2["target"],
+                "type": conclusion_type,
+                "axis": v1.get("axis", "partonomy"), # Use axis from v1 or default
+                "justification": f"Derived by part_of_transitivity from {v1.get('id', '?')} and {v2.get('id', '?')}",
+                "derived": True
+            }
+            return conclusion, True
+           
+        return None, False
+
+    # --- Новая логика для правила Action -> Causality --- 
+    def _apply_action_causality_chain(self, premises: List[Dict]) -> Tuple[Optional[Dict], bool]:
+        """Логика для правила action_causality_chain. Возвращает (вывод, валидность_шага)."""
+        if len(premises) != 2:
+            return None, False
+        v1, v2 = premises
+        
+        # Проверяем соответствие паттерну правила: A->B (Action), B->C (Causality)
+        if v1["target"] == v2["source"] and \
+           v1.get("type") == "Action" and \
+           v2.get("type") == "Causality":
+           
+            conclusion_type = self.inference_rules["action_causality_chain"]["conclusion_type"]
+           
+            conclusion = {
+                "id": f"S{len(self.proof_cache) + 1}",
+                "source": v1["source"],
+                "target": v2["target"],
+                "type": conclusion_type,
+                "axis": v1.get("axis", v2.get("axis")), # Ось можно взять из Action или Causality
+                "justification": f"Derived by action_causality_chain from {v1.get('id', '?')} and {v2.get('id', '?')}",
+                "derived": True
+            }
+            return conclusion, True # Шаг считаем валидным, если правило применилось
+           
+        return None, False
+
+    # --- Логика для правила Action -> IsA --- 
+    def _apply_action_isa_generalization(self, premises: List[Dict]) -> Tuple[Optional[Dict], bool]:
+        """Логика для правила action_isa_generalization."""
+        if len(premises) != 2:
+            return None, False
+        v_action, v_isa = premises # Ожидаем Action, затем IsA
+        
+        # Проверяем типы и связь: A -> B_inst (Action), B_inst IsA B_type
+        if v_action.get("type") == "Action" and \
+           v_isa.get("type") == "IsA" and \
+           v_action.get("target") == v_isa.get("source"): # Target(Action) == Source(IsA)
+           
+            conclusion_type = self.inference_rules["action_isa_generalization"]["conclusion_type"]
+            source_a = v_action.get("source")
+            target_b_type = v_isa.get("target") # Берем тип из IsA
+            
+            conclusion = {
+                "id": f"S{len(self.proof_cache) + 1}",
+                "source": source_a,
+                "target": target_b_type,
+                "type": conclusion_type, # Тип сохраняется как Action
+                "axis": v_action.get("axis"), # Ось берем из Action
+                "justification": f"Derived by action_isa_generalization from {v_action.get('id', '?')} and {v_isa.get('id', '?')}",
+                "derived": True
+            }
+            # print(f"DEBUG _apply_action_isa_generalization: Applied. Conclusion: {conclusion}") # Временный дебаг
+            return conclusion, True
+        
+        # print(f"DEBUG _apply_action_isa_generalization: Rule not applicable. v_action type: {v_action.get('type')}, v_isa type: {v_isa.get('type')}, link: {v_action.get('target')} == {v_isa.get('source')}") # Временный дебаг
+        return None, False
+
+    def apply_inference_rule(self, rule_name: str, premises: List[Dict]) -> Tuple[Optional[Dict], bool]:
+        """Применяет правило вывода, возвращая (вывод, валидность_шага)."""
+        rule_functions = {
+            "chain_rule": self._apply_chain_rule,
+            "causality_transfer": self._apply_causality_transfer,
+            "implication_causality_chain": self._apply_implication_causality_chain,
+            "part_of_transitivity": self._apply_part_of_transitivity,
+            "action_causality_chain": self._apply_action_causality_chain, # Добавляем новое правило
+            "action_isa_generalization": self._apply_action_isa_generalization # Добавляем еще одно новое правило
+        }
+        
+        conclusion, is_step_valid = None, False
+        if rule_name in rule_functions:
+            # Предполагаем, что в premises УЖЕ только валидные векторы
+            conclusion, is_step_valid = rule_functions[rule_name](premises)
+        
+        # --- DEBUG PRINT ---
+        # print(f"DEBUG apply_inference_rule: Rule='{rule_name}', Premises={[p.get('id', '?') for p in premises]}, Conclusion='{conclusion.get('id', None) if conclusion else None}', StepValid={is_step_valid}")
+        # --- END DEBUG PRINT ---
+
+        if conclusion:
+             # Кэшируем только структуру успешного вывода
+             self.proof_cache[conclusion["id"]] = conclusion 
+             
+        return conclusion, is_step_valid
+    
+    def construct_proof(self, vectors_for_proof: List[Dict], source_concept: str, target_concept: str) -> Dict:
+        """Построение доказательства от source_concept к target_concept.
+        Использует граф из предоставленных векторов (входных + временных IsA)
+        и динамически подгружает векторы из БД.
+        """
+        # --- DEBUG PRINT ---
+        # print(f"\\nDEBUG construct_proof: Start. Query: {source_concept} -> {target_concept}")
+        # print(f"DEBUG construct_proof: Input vectors count: {len(vectors_for_proof)}")
+        # --- END DEBUG PRINT ---
+        
+        # Убираем instance_definitions из параметров
+        valid_vectors_input = vectors_for_proof # Переименуем для консистентности с кодом ниже
+        
+        if not valid_vectors_input and not self.db_conn.get_concept_by_name(source_concept): 
+             # --- DEBUG PRINT ---
+             # print("DEBUG construct_proof: Failed - No input vectors and source concept not found in DB.")
+             # --- END DEBUG PRINT ---
+             return {"status": "Failed", "reason": "No input vectors and source concept not found in DB", "is_valid": False}
+
+        # --- Теперь строим граф и vector_map из ВСЕХ предоставленных векторов --- 
+        input_graph = self._build_proof_graph(valid_vectors_input)
+        vector_map = {v["id"]: v for v in valid_vectors_input} 
+        # --- DEBUG PRINT ---
+        # print(f"DEBUG construct_proof: Built input graph with {len(input_graph['nodes'])} nodes and {len(input_graph['edges'])} edges.")
+        # print(f"DEBUG construct_proof: Vector map keys: {list(vector_map.keys())}")
+        # --- MORE DEBUG ---
+        import pprint
+        # print(f"DEBUG construct_proof: Input Graph Adjacency:\n{pprint.pformat(input_graph.get('adjacency', {}))}")
+        # --- END MORE DEBUG ---
+        # --- END DEBUG PRINT ---
+        # ---------------------------------------------------------------------
+
+        # Ищем путь: сначала только входные, потом с БД
+        path_info = self.find_proof_path(input_graph, source_concept, target_concept)
+        # --- DEBUG PRINT ---
+        # print(f"DEBUG construct_proof: Path finding result: Status='{path_info.get('status')}', Path length={len(path_info.get('path', []))}")
+        # --- END DEBUG PRINT ---
+
+        if path_info.get("status") != "Path found":
+            # --- DEBUG PRINT ---
+            # print(f"DEBUG construct_proof: Failed - Path not found. Reason: {path_info.get('status', 'Unknown')}")
+             # --- END DEBUG PRINT ---
+            return {"status": "Failed", "reason": f"Path not found: {path_info.get('status', 'Unknown')}", "is_valid": False}
+
+        path = path_info["path"]
+        db_vectors_used = path_info.get("db_vectors_used", [])
+        
+        # --- MORE DEBUG --- 
+        # print(f"DEBUG construct_proof: Found Path: {path}")
+        # print(f"DEBUG construct_proof: DB Vectors Used: {[v.get('id') for v in db_vectors_used]}")
+        # --- END MORE DEBUG ---
+
+        # Добавляем векторы из БД в vector_map
+        for db_vec in db_vectors_used:
+            if db_vec["id"] not in vector_map:
+                vector_map[db_vec["id"]] = db_vec
+        
+        # --- MORE DEBUG --- 
+        # print(f"DEBUG construct_proof: Vector Map Contents:")
+        # for vid, vdata in vector_map.items():
+        #     print(f"  - {vid}: Type={vdata.get('type')}, Source={vdata.get('source')}, Target={vdata.get('target')}")
+        # --- END MORE DEBUG ---
+        
+        # --- Проверка на прямой путь ---
+        if len(path) == 1:
+            direct_vector_id = path[0][2]
+            direct_vector = vector_map.get(direct_vector_id)
+            # --- DEBUG PRINT ---
+            # print(f"DEBUG construct_proof: Path length is 1. Direct vector ID: {direct_vector_id}")
+             # --- END DEBUG PRINT ---
+            if direct_vector:
+                # --- DEBUG PRINT ---
+                # print(f"DEBUG construct_proof: Success - Direct proof found using vector {direct_vector_id}.")
+                 # --- END DEBUG PRINT ---
+                return {
+                    "status": "Success",
+                    "source": source_concept,
+                    "target": target_concept,
+                    "steps": [], # Нет шагов для прямого доказательства
+                    "rule": "direct", # Указываем, что это прямой путь
+                    "direct_vector_id": direct_vector_id,
+                    "is_valid": True, # Прямой путь считается валидным
+                    "final_conclusion_type": direct_vector.get("type"),
+                    "metadata": {} # Пока без метаданных о цикле здесь
+                }
+            else:
+                 # --- DEBUG PRINT ---
+                 # print(f"DEBUG construct_proof: Failed - Direct vector {direct_vector_id} not found in map.")
+                 # --- END DEBUG PRINT ---
+                 return {"status": "Failed", "reason": f"Direct vector {direct_vector_id} not found", "is_valid": False}
+
+        # --- Построение доказательства по шагам ---
+        steps = []
+        current_premise = None # Будет содержать ВЕКТОР (словарь)
+        overall_validity = True # Валидность всего доказательства
+        cycle_warning = None
+        visited_nodes_in_proof = {source_concept} # Для обнаружения циклов во время ПОСТРОЕНИЯ
+
+        # --- DEBUG PRINT ---
+        # print("DEBUG construct_proof: Starting step-by-step construction...")
+        # --- END DEBUG PRINT ---
+        for i, (seg_source, seg_target, vector_id, origin) in enumerate(path):
+            # --- DEBUG PRINT ---
+            # print(f"DEBUG construct_proof: Processing segment {i+1}/{len(path)}: {seg_source} -> {seg_target} via {vector_id} (from {origin})")
+            # --- END DEBUG PRINT ---
+            
+            # Защита от отсутствия вектора в карте (на всякий случай)
+            premise2 = vector_map.get(vector_id)
+            if not premise2:
+                 # --- DEBUG PRINT ---
+                 # print(f"DEBUG construct_proof: Failed - Vector {vector_id} for segment {i+1} not found in map.")
+                 # --- END DEBUG PRINT ---
+                 overall_validity = False
+                 return {"status": "Failed", "reason": f"Vector {vector_id} not found during step construction", "is_valid": False}
+                 
+            premise2_source = origin # 'input' or 'db'
+            
+            if current_premise is None:
+                current_premise = premise2
+                source1 = premise2_source # Источник первой посылки - сам этот вектор
+                # --- DEBUG PRINT ---
+                # print(f"DEBUG construct_proof: Segment {i+1}: Initial premise set to {current_premise.get('id')}")
+                # --- MORE DEBUG --- 
+                # print(f"DEBUG construct_proof: Segment {i+1}: Initial premise set to: ID={current_premise.get('id', 'NO_ID')}, Type={current_premise.get('type', 'NO_TYPE')}, Source={current_premise.get('source')}, Target={current_premise.get('target')}")
+                # --- END MORE DEBUG ---
+                # --- END DEBUG PRINT ---
+            else:
+                premises = [current_premise, premise2]
+                premise_ids = [p.get("id", "?") for p in premises]
+                source1 = "derived" if current_premise.get("derived") else current_premise.get("origin", "input") # Откуда первая посылка?
+                
+                conclusion = None
+                is_step_valid = False
+                rule_name = None
+                
+                # --- DEBUG PRINT ---
+                # print(f"DEBUG construct_proof: Segment {i+1}: Trying to apply rules. Premise1='{premises[0].get('id')}' ({source1}), Premise2='{premises[1].get('id')}' ({premise2_source})")
+                # --- MORE DEBUG --- 
+                prem1_id = current_premise.get('id', 'NO_ID')
+                prem1_type = current_premise.get('type', 'NO_TYPE')
+                prem2_id = premise2.get('id', 'NO_ID')
+                prem2_type = premise2.get('type', 'NO_TYPE')
+                # print(f"DEBUG construct_proof: Applying rules. Premise1: ID={prem1_id}, Type={prem1_type} | Premise2: ID={prem2_id}, Type={prem2_type}")
+                # --- MORE DEBUG --- 
+                # print(f"  Premise1 Details: Source={current_premise.get('source')}, Target={current_premise.get('target')}")
+                # print(f"  Premise2 Details: Source={premise2.get('source')}, Target={premise2.get('target')}")
+                # --- END MORE DEBUG ---
+                # --- END DEBUG PRINT ---
+
+                # Применяем подходящее правило
+                for key in self.inference_rules.keys():
+                    temp_conclusion, temp_valid = self.apply_inference_rule(key, premises)
+                    if temp_conclusion:
+                        conclusion = temp_conclusion
+                        is_step_valid = temp_valid
+                        rule_name = key
+                        # --- DEBUG PRINT ---
+                        # print(f"DEBUG construct_proof: Segment {i+1}: Applied rule '{rule_name}'. Conclusion='{conclusion.get('id')}', StepValid={is_step_valid}")
+                        # --- END DEBUG PRINT ---
+                        break # Нашли подходящее правило
+                
+                if conclusion:
+                    conclusion["origin"] = "derived" # Помечаем, что вывод получен
+                    step_detail = {
+                        "id": conclusion["id"],
+                        "rule": rule_name,
+                        "premises": premise_ids,
+                        "conclusion": conclusion,
+                        "is_valid": is_step_valid,
+                        "premise1_source": source1,
+                        "premise2_source": premise2_source, # 'input' or 'db'
+                        # --- DEBUG PRINT ---
+                        # "debug_premise1": current_premise, 
+                        # "debug_premise2": premise2
+                         # --- END DEBUG PRINT ---
+                    }
+                    steps.append(step_detail)
+                    current_premise = conclusion # Результат этого шага становится первой посылкой для следующего
+                    
+                    if not is_step_valid:
+                        overall_validity = False
+                        # --- DEBUG PRINT ---
+                        # print(f"DEBUG construct_proof: Segment {i+1}: Step marked invalid, setting overall validity to False.")
+                         # --- END DEBUG PRINT ---
+                        # Можно прервать, если один шаг невалиден? Или достроить? Пока достраиваем.
+                        
+                    # Проверка на цикл в построении
+                    target_node = conclusion.get("target")
+                    if target_node in visited_nodes_in_proof:
+                        cycle_warning = f"Cycle detected during proof construction: revisiting node '{target_node}'"
+                        # --- DEBUG PRINT ---
+                        # print(f"DEBUG construct_proof: Segment {i+1}: {cycle_warning}")
+                         # --- END DEBUG PRINT ---
+                    else:
+                        visited_nodes_in_proof.add(target_node)
+                        
+                else:
+                    # Не смогли применить правило - доказательство невалидно
+                    overall_validity = False
+                    # --- DEBUG PRINT ---
+                    # print(f"DEBUG construct_proof: Failed - No applicable rule found for premises {premise_ids} in segment {i+1}.")
+                     # --- END DEBUG PRINT ---
+                    return {"status": "Failed", "reason": f"No inference rule applicable for premises {premise_ids}", "is_valid": False}
+
+        # --- Финальное формирование результата ---
+        final_conclusion = current_premise # Последний вывод - это и есть результат
+        
+        # Проверка, что финальный вывод соответствует запросу
+        if not final_conclusion or \
+           final_conclusion.get("source") != source_concept or \
+           final_conclusion.get("target") != target_concept:
+           # --- DEBUG PRINT ---
+           final_src = final_conclusion.get('source') if final_conclusion else 'None'
+           final_tgt = final_conclusion.get('target') if final_conclusion else 'None'
+           # print(f"DEBUG construct_proof: Failed - Final conclusion mismatch. Expected={source_concept}->{target_concept}, Got={final_src}->{final_tgt}")
+            # --- END DEBUG PRINT ---
+           overall_validity = False
+           # Статус все еще может быть Success, но is_valid = False? Или статус Failed?
+           # Сделаем статус Failed, если вывод не совпал.
+           return {
+               "status": "Failed", 
+               "reason": f"Final conclusion mismatch: expected {source_concept}->{target_concept}, got {final_conclusion.get('source') if final_conclusion else 'N/A'}->{final_conclusion.get('target') if final_conclusion else 'N/A'}",
+               "is_valid": False,
+               "source": source_concept,
+               "target": target_concept,
+               "steps": steps,
+               "metadata": {"cycle_warning": cycle_warning} if cycle_warning else {}
+           }
+
+        final_result = {
+            "status": "Success", # Если дошли сюда, структура доказательства построена
+            "source": source_concept,
+            "target": target_concept,
+            "steps": steps,
+            "is_valid": overall_validity, # Валидность зависит от валидности всех шагов
+            "final_conclusion_type": final_conclusion.get("type"),
+            "metadata": {"cycle_warning": cycle_warning} if cycle_warning else {}
+        }
+        # --- DEBUG PRINT ---
+        # print(f"DEBUG construct_proof: Finished successfully.")
+        # print(f"DEBUG construct_proof: Final Result Status: {final_result['status']}")
+        # print(f"DEBUG construct_proof: Final Result IsValid: {final_result['is_valid']}")
+        # print(f"DEBUG construct_proof: Final Result Steps Count: {len(final_result['steps'])}")
+        # if final_result['steps']:
+        #     for idx, step in enumerate(final_result['steps']):
+        #         print(f"  Step {idx+1} ({step['id']}): Rule='{step['rule']}', Premises={step['premises']}, Valid={step['is_valid']}, Conc={step['conclusion']['source']}->{step['conclusion']['target']}")
+        # print(f"DEBUG construct_proof: Final Conclusion Type: {final_result['final_conclusion_type']}")
+        # print(f"DEBUG construct_proof: Metadata: {final_result['metadata']}")
+        # --- END DEBUG PRINT ---
+        return final_result
+
+
+    def _build_proof_graph(self, vectors):
+        """Вспомогательная функция для построения графа из векторов"""
+        graph = {"nodes": set(), "edges": [], "adjacency": {}}
+        for v in vectors:
+            source, target, v_id = v["source"], v["target"], v["id"]
+            graph["nodes"].add(source)
+            graph["nodes"].add(target)
+            graph["edges"].append((source, target, v_id))
+            
+            # Обновление списка смежности
+            if source not in graph["adjacency"]:
+                graph["adjacency"][source] = {"out": [], "in": []}
+            if target not in graph["adjacency"]:
+                graph["adjacency"][target] = {"out": [], "in": []}
+            
+            graph["adjacency"][source]["out"].append((target, v_id))
+            graph["adjacency"][target]["in"].append((source, v_id))
+            
+        return graph
+
+if __name__ == "__main__":
+    print(f"SFOSR Integrated System v{SFOSR_CONFIG['version']}")
+    print("Готов к анализу смысловых структур.")
+    
+    # Пример входных данных (используем концепты из БД для демонстрации)
+    example = {
+        "text": "Emergence leads to multi-level space, which causes cross-level causation, finally leading to regulatory flow.",
+        "vectors": [
+            {
+                "id": "V_EC_MLS",
+                "source": "emergent_complexity",
+                "target": "multi_level_space",
+                "type": "Implication",
+                "axis": "structure <-> hierarchy",
+                "justification": "Emergence creates levels"
+            },
+            {
+                "id": "V_MLS_CLC",
+                "source": "multi_level_space",
+                "target": "cross_level_causation",
+                "type": "Causality", # Тип Causality
+                "axis": "level <-> interaction",
+                "justification": "Levels imply cross-level effects"
+            },
+            {
+                "id": "V_CLC_RF",
+                "source": "cross_level_causation",
+                "target": "regulatory_flow",
+                "type": "Causality", # Тип Causality
+                "axis": "cause <-> regulation",
+                "justification": "Cross-level effects drive regulation"
+            }
+        ],
+        "proof_query": {
+            "source": "multi_level_space",
+            "target": "regulatory_flow"
+        }
+    }
+    
+    # Создаем и тестируем интегрированную систему
+    system = SFOSRSystem()
+    result = system.process(example)
+    
+    # Выводим результаты (обновлено для бинарной валидности)
+    print("\n--- Результаты Обработки ---")
+    print(f"Статус: {result['status']}")
+    if result['status'] == 'Success':
+        print(f"Компилируемость: {result['analysis']['is_compilable']}")
+        print("\n--- Верификация ---")
+        print(f"Всего обработано векторов: {result['verification']['total_vectors_processed']}")
+        print(f"Валидных векторов: {result['verification']['valid_count']}")
+        print(f"Уровень соответствия: {result['verification']['compliance_rate'] * 100:.1f}%")
+        print("Данные по Векторам:")
+        for v_id, data in result['verification']['vectors_data'].items():
+            valid_str = "Валиден" if data['is_valid'] else "Не валиден"
+            issues_str = ', '.join(data['issues']) if data['issues'] else 'Нет'
+            print(f"  - {v_id}: Статус={valid_str}, Проблемы: {issues_str}")
+        
+        if "proof" in result:
+            print("\n--- Доказательство ---")
+            proof = result['proof']
+            print(f"Статус: {proof['status']}")
+            valid_proof_str = "Валидно" if proof.get('is_valid', False) else "Не валидно"
+            print(f"Общая Валидность: {valid_proof_str}")
+            if proof['status'] == 'Success':
+                print(f"Доказательство: {proof['source']} → {proof['target']}")
+                print(f"Тип финального вывода: {proof.get('final_conclusion_type', 'N/A')}")
+                print("Шаги доказательства:")
+                if proof['steps']:
+                    for step in proof['steps']:
+                        step_valid_str = "Валиден" if step['is_valid'] else "Не валиден"
+                        print(f"  - {step['id']}: Правило={step['rule']}, Посылки=({', '.join(step['premises'])}) | Статус={step_valid_str}")
+                        if step['conclusion']:
+                             print(f"      Вывод: {step['conclusion']['source']} → {step['conclusion']['target']} ({step['conclusion']['type']})")
+                        else:
+                             print(f"      Вывод: None (Ошибка: {step.get('reason', '')})")
+                else:
+                     print("  (Нет шагов)")
+            elif 'reason' in proof:
+                 print(f"Причина неудачи: {proof['reason']}")
+            
+    elif 'details' in result and 'validation_issues' in result['details']:
+         print("\n--- Ошибки Анализа ---")
+         for issue in result['details']['validation_issues']:
+             print(f"  - {issue}")