lionagi 0.9.12__tar.gz → 0.9.14__tar.gz

{lionagi-0.9.12 → lionagi-0.9.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.9.12
+Version: 0.9.14
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -227,6 +227,7 @@ Requires-Dist: pillow>=10.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: tiktoken>=0.8.0
+Requires-Dist: toml>=0.9.0
 Provides-Extra: llms
 Requires-Dist: litellm>=1.59.5; extra == 'llms'
 Provides-Extra: ollama

{lionagi-0.9.12 → lionagi-0.9.14}/lionagi/libs/file/chunk.py

@@ -216,7 +216,7 @@ def chunk_content(
     chunk_size: int = 1024,
     overlap: float = 0,
     threshold: int = 256,
-    metadata: dict[str, Any] = {},
+    metadata: dict[str, Any] = None,
     return_tokens: bool = False,
     as_node: bool = False,
     **kwargs: Any,
@@ -268,7 +268,7 @@ def chunk_content(
                     "chunk_id": i + 1,
                     "total_chunks": len(chunks),
                     "chunk_size": len(chunk),
-                    **metadata,
+                    **(metadata or {}),
                 },
             )
             for i, chunk in enumerate(chunks)
@@ -280,7 +280,7 @@ def chunk_content(
             "chunk_id": i + 1,
             "total_chunks": len(chunks),
             "chunk_size": len(chunk),
-            **metadata,
+            **(metadata or {}),
         }
         for i, chunk in enumerate(chunks)
     ]

lionagi-0.9.14/lionagi/libs/token_transform/base.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+
+from pydantic import Field
+
+from lionagi.tools.base import Resource, ResourceCategory
+
+here = Path(__file__).parent.resolve()
+MAPPING_PATH = "synthlang_/resources/mapping"
+
+
+class TokenMappingTemplate(str, Enum):
+    RUST_CHINESE = "rust_chinese"
+
+    @property
+    def fp(self) -> Path:
+        return here / MAPPING_PATH / f"{self.value}_mapping.toml"
+
+
+class TokenMapping(Resource):
+    category: ResourceCategory = Field(
+        default=ResourceCategory.UTILITY, frozen=True
+    )
+    content: dict
+
+    @classmethod
+    def load_from_template(
+        cls, template: TokenMappingTemplate | str
+    ) -> TokenMapping:
+        if isinstance(template, str):
+            template = template.lower().strip()
+            template = (
+                template.replace(".toml", "")
+                .replace(" ", "_")
+                .replace("-", "_")
+                .strip()
+            )
+            if template.endswith("_mapping"):
+                template = template[:-8]
+            if "/" in template:
+                template = template.split("/")[-1]
+            template = TokenMappingTemplate(template)
+
+        if isinstance(template, TokenMappingTemplate):
+            template = template.fp
+            return cls.adapt_from(template, ".toml", many=False)
+
+        raise ValueError(
+            f"Invalid template: {template}. Must be a TokenMappingTemplate or a valid path."
+        )

{lionagi-0.9.12 → lionagi-0.9.14}/lionagi/libs/token_transform/perplexity.py

@@ -101,7 +101,7 @@ async def compute_perplexity(
     chat_model: iModel,
     initial_context: str = None,
     tokens: list[str] = None,
-    system_msg: str = None,
+    system: str = None,
     n_samples: int = 1,
     use_residue: bool = True,
     **kwargs,
@@ -142,9 +142,9 @@ async def compute_perplexity(
     api_calls = []
     for sample_txt in sampless:
         messages = []
-        if system_msg:
+        if system:
             if not chat_model.sequential_exchange:
-                messages.append({"role": "system", "content": system_msg})
+                messages.append({"role": "system", "content": system})
             messages.append({"role": "user", "content": sample_txt})
         else:
             messages.append({"role": "user", "content": sample_txt})
@@ -171,10 +171,10 @@ class LLMCompressor:
     def __init__(
         self,
         chat_model: iModel,
-        system_msg=None,
+        system=None,
         tokenizer=None,
         splitter=None,
-        target_ratio=0.2,
+        compression_ratio=0.2,
         n_samples=5,
         chunk_size=64,
         max_tokens_per_sample=80,
@@ -193,10 +193,8 @@ class LLMCompressor:
         self.chat_model = chat_model
         self.tokenizer = tokenizer
         self.splitter = splitter
-        self.system_msg = (
-            system_msg or "Concisely summarize content for storage:"
-        )
-        self.target_ratio = target_ratio
+        self.system = system or "Concisely summarize content for storage:"
+        self.compression_ratio = compression_ratio
         self.n_samples = n_samples
         self.chunk_size = chunk_size
         self.max_tokens_per_sample = max_tokens_per_sample
@@ -281,7 +279,7 @@ class LLMCompressor:
                 initial_context=initial_text,
                 tokens=item_toks,
                 n_samples=n_samples or self.n_samples,
-                system_msg=self.system_msg,
+                system=self.system,
                 use_residue=use_residue,
                 **kwargs,
             )
@@ -347,6 +345,7 @@ class LLMCompressor:
         # Tokenize once to get total length
         all_tokens = self.tokenize(text)
         original_len = len(all_tokens)
+        ttl_chars = len(text)
 
         # Split text
         items = self.split(text, **split_kwargs)
@@ -363,26 +362,26 @@ class LLMCompressor:
         # Select
         selected = self.select_by_pplex(
             ranked_items=ranked,
-            target_compression_ratio=compression_ratio or self.target_ratio,
+            target_compression_ratio=compression_ratio
+            or self.compression_ratio,
             original_length=original_len,
             min_pplx=min_pplx or self.min_pplx,
         )
 
-        if self.verbose:
-            compressed_len = sum(
-                len(to_list(self.tokenize(x), dropna=True, flatten=True))
-                for x in selected
-            )
-            ratio = compressed_len / original_len if original_len else 1
-            print(
-                f"Original tokens: {original_len}\n"
-                f"Selected tokens: {compressed_len}\n"
-                f"Compression ratio: {ratio:.3f}\n"
-                f"Time: {timer() - start:.3f}s\n"
-            )
-
         # Join final
         out_str = " ".join(selected)
+
+        if self.verbose:
+            compressed_chars = len(out_str)
+            ratio = compressed_chars / ttl_chars if original_len else 1
+            msg = "------------------------------------------\n"
+            msg += f"Compression Method: Perplexity\n"
+            msg += f"Compressed Characters number: {compressed_chars}\n"
+            msg += f"Character Compression Ratio: {ratio:.1%}\n"
+            msg += f"Compression Time: {timer() - start:.3f}s\n"
+            msg += f"Compression Model: {self.chat_model.model_name}\n"
+            print(msg)
+
         return out_str.strip()
 
     def select_by_pplex(
@@ -419,21 +418,34 @@ class LLMCompressor:
 async def compress_text(
     text: str,
     chat_model: iModel,
-    system_msg: str = None,
-    target_ratio: float = 0.2,
+    system: str = None,
+    compression_ratio: float = 0.2,
     n_samples: int = 5,
     max_tokens_per_sample=80,
     verbose=True,
+    initial_text=None,
+    cumulative=False,
+    split_kwargs=None,
+    min_pplx=None,
+    **kwargs,
 ) -> str:
     """
     Convenience function that instantiates LLMCompressor and compresses text.
     """
     compressor = LLMCompressor(
         chat_model=chat_model,
-        system_msg=system_msg,
-        target_ratio=target_ratio,
+        system=system,
+        compression_ratio=compression_ratio,
         n_samples=n_samples,
         max_tokens_per_sample=max_tokens_per_sample,
         verbose=verbose,
     )
-    return await compressor.compress(text)
+    return await compressor.compress(
+        text,
+        compression_ratio=compression_ratio,
+        initial_text=initial_text,
+        cumulative=cumulative,
+        split_kwargs=split_kwargs,
+        min_pplx=min_pplx,
+        **kwargs,
+    )

lionagi-0.9.14/lionagi/libs/token_transform/symbolic_compress_context.py

@@ -0,0 +1,138 @@
+from collections.abc import Callable
+from pathlib import Path
+from typing import Literal
+
+from lionagi.service.imodel import iModel
+from lionagi.session.branch import Branch
+from lionagi.utils import alcall
+
+from .base import TokenMapping, TokenMappingTemplate
+from .synthlang_.base import SynthlangFramework, SynthlangTemplate
+
+FRAMEWORK_OPTIONS = SynthlangFramework.load_framework_options()
+FRAMEWORK_CHOICES = Literal["math", "optim", "custom_algebra"]
+
+
+async def symbolic_compress_context(
+    *,
+    text: str = None,
+    url_or_path: str | Path = None,
+    chunk_by="tokens",
+    chunk_size: int = 1000,
+    chunk_tokenizer: Callable = str.split,
+    threshold=50,
+    output_path: Path | str = None,
+    overlap=0.05,
+    system: str = None,
+    chat_model: iModel = None,
+    use_lion_system_message: bool = True,
+    max_concurrent=10,
+    throttle_period=1,
+    framework: Literal["synthlang"] = "synthlang",
+    framework_template: (
+        SynthlangTemplate | SynthlangFramework
+    ) = SynthlangTemplate.REFLECTIVE_PATTERNS,
+    framework_options: list[FRAMEWORK_CHOICES] = None,
+    compress: bool = False,
+    compress_model: iModel = None,
+    compression_ratio: float = 0.2,
+    compress_initial_text=None,
+    compress_cumulative=False,
+    compress_split_kwargs=None,
+    compress_min_pplx=None,
+    encode_token_map: TokenMappingTemplate | dict | TokenMapping = None,
+    num_encodings: int = 3,
+    encode_output: bool = False,
+    num_output_encodings: int = None,
+    verbose: bool = True,
+    branch: Branch = None,
+    additional_text: str = "",
+    **kwargs,
+):
+    if framework != "synthlang":
+        raise ValueError(f"Unsupported framework: {framework}")
+
+    if not text and not url_or_path:
+        raise ValueError("Either text or url_or_path must be provided.")
+
+    if text and url_or_path:
+        raise ValueError("Only one of text or url_or_path should be provided.")
+
+    from .synthlang_.translate_to_synthlang import translate_to_synthlang
+
+    async def _inner(text: str):
+        b_ = None
+        if branch:
+            b_ = await branch.aclone()
+        else:
+            b_ = Branch(
+                system=system,
+                use_lion_system_message=use_lion_system_message,
+                chat_model=chat_model,
+            )
+
+        return await translate_to_synthlang(
+            text,
+            branch=b_,
+            framework_template=framework_template,
+            framework_options=framework_options,
+            compress=compress,
+            compress_model=compress_model,
+            compression_ratio=compression_ratio,
+            compress_kwargs={
+                "initial_text": compress_initial_text,
+                "cumulative": compress_cumulative,
+                "split_kwargs": compress_split_kwargs,
+                "min_pplx": compress_min_pplx,
+            },
+            encode_token_map=encode_token_map,
+            num_encodings=num_encodings,
+            encode_output=encode_output,
+            num_output_encodings=num_output_encodings,
+            verbose=verbose,
+            additional_text=additional_text,
+            **kwargs,
+        )
+
+    from lionagi.libs.file.process import chunk, chunk_content
+
+    texts = []
+    if url_or_path:
+        chunks = chunk(
+            url_or_path=url_or_path,
+            chunk_by=chunk_by,
+            chunk_size=chunk_size,
+            overlap=overlap,
+            threshold=threshold,
+        )
+        texts = [i.content for i in chunks if i.content]
+
+    elif text:
+        texts = chunk_content(
+            text=text,
+            chunk_by=chunk_by,
+            chunk_size=chunk_size,
+            overlap=overlap,
+            threshold=threshold,
+            tokenizer=chunk_tokenizer,
+        )
+
+    results = await alcall(
+        texts,
+        _inner,
+        max_concurrent=max_concurrent,
+        retry_default=None,
+        throttle_period=throttle_period,
+        flatten=True,
+        dropna=True,
+    )
+    text = "\n".join(results)
+
+    if output_path:
+        fp = Path(output_path)
+        fp.write_text(text)
+        if verbose:
+            print(f"Results of {len(text)} characters saved to: {fp}")
+
+        return fp
+    return text

lionagi-0.9.14/lionagi/libs/token_transform/synthlang.py

@@ -0,0 +1,9 @@
+from .synthlang_.base import SynthlangFramework, SynthlangTemplate
+from .synthlang_.translate_to_synthlang import translate_to_synthlang
+
+# backwards compatibility
+__all__ = (
+    "translate_to_synthlang",
+    "SynthlangFramework",
+    "SynthlangTemplate",
+)

lionagi-0.9.14/lionagi/libs/token_transform/synthlang_/base.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+from typing import Literal
+
+from pydantic import Field
+
+from lionagi.tools.base import Prompt, Resource, ResourceCategory
+
+here = Path(__file__).parent.resolve()
+
+FRAMEWORK_PATH = "resources/frameworks"
+FRAMEWORK_CHOICES = Literal["math", "optim", "custom_algebra"]
+
+
+__all__ = (
+    "SynthlangFramework",
+    "SynthlangTemplate",
+)
+
+
+class SynthlangFramework(Resource):
+
+    category: ResourceCategory = Field(
+        default=ResourceCategory.FRAMEWORK, frozen=True
+    )
+
+    @classmethod
+    def load_framework_options(cls) -> dict:
+        import json
+
+        fp = here / FRAMEWORK_PATH / "framework_options.json"
+        with open(fp, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+    @classmethod
+    def load_from_template(
+        cls, template: SynthlangTemplate | str
+    ) -> SynthlangFramework:
+        return SynthlangTemplate.load(template)
+
+    @classmethod
+    def load_base_system_prompt(cls) -> Prompt:
+        fp = here / "resources/utility" / "base_synthlang_system_prompt.toml"
+        return SynthlangFramework.adapt_from(fp, ".toml", many=False)
+
+    @classmethod
+    def build_framework_text(
+        cls, framework_options: list[FRAMEWORK_CHOICES] = None
+    ) -> str:
+        FRAMEWORK_OPTIONS = cls.load_framework_options()
+        lines = []
+        if not framework_options:
+            framework_options = FRAMEWORK_OPTIONS["options"].keys()
+
+        for fw_key in framework_options:
+            fw = FRAMEWORK_OPTIONS.get(fw_key, None)
+            if fw:
+                print(fw)
+                lines.append(f"{fw['name']}: {fw['description']}")
+                lines.append("Glyphs:")
+                for g in fw["glyphs"]:
+                    lines.append(
+                        f"  {g['symbol']} -> {g['name']} ({g['description']})"
+                    )
+                lines.append("")
+        return "\n".join(lines).strip()
+
+    def create_system_prompt(
+        self,
+        framework_options: list[FRAMEWORK_CHOICES] = None,
+        additional_text: str = "",
+    ) -> str:
+
+        framework_options_text = self.build_framework_text(framework_options)
+        base_prompt = self.load_base_system_prompt()
+        template_details = (
+            f"Title: {self.meta_obj.title}\n"
+            f"Domain: {str(self.meta_obj.domain)}\n"
+            f"Category: {str(self.category)}\n"
+            f"Overview: {self.meta_obj.overview}\n"
+            "Excerpt:\n"
+            f"{self.content}\n"
+        )
+        prompt = (
+            f"{base_prompt.content}\n\n"
+            "[Active Frameworks]\n"
+            f"{framework_options_text}\n\n"
+            "[Template]\n"
+            f"{template_details}\n"
+        )
+        if additional_text.strip():
+            prompt += f"\n[Additional]\n{additional_text.strip()}\n"
+
+        return prompt.strip()
+
+
+class SynthlangTemplate(str, Enum):
+    ABSTRACT_ALGEBRA = "abstract_algebra"
+    CATEGORY_THEORY = "category_theory"
+    COMPLEX_ANALYSIS = "complex_analysis"
+    GROUP_THEORY = "group_theory"
+    MATH_LOGIC = "math_logic"
+    REFLECTIVE_PATTERNS = "reflective_patterns"
+    SET_THEORY = "set_theory"
+    TOPOLOGY_FUNDAMENTALS = "topology_fundamentals"
+
+    @property
+    def fp(self) -> Path:
+        return here / FRAMEWORK_PATH / f"{self.value}.toml"
+
+    @classmethod
+    def list_templates(cls) -> list[str]:
+        return [template.value for template in cls]
+
+    @classmethod
+    def load(cls, framework: str) -> SynthlangFramework:
+        framework = str(framework).strip().lower()
+        framework = framework.replace(" ", "_").replace("-", "_")
+        if ".toml" in framework:
+            framework = framework.replace(".toml", "").strip()
+        if "synthlangtemplate." in framework:
+            framework = framework.replace("synthlangtemplate.", "").strip()
+        try:
+            framework = cls(framework)
+        except ValueError:
+            raise ValueError(f"Invalid synthlang framework name: {framework}")
+
+        return SynthlangFramework.adapt_from(framework.fp, ".toml", many=False)

lionagi-0.9.14/lionagi/libs/token_transform/synthlang_/resources/frameworks/abstract_algebra.toml

@@ -0,0 +1,11 @@
+id = "11968433-1402-4783-b167-25afbe0a6c4f"
+created_at = 1740606622.114634
+content = "\n## Group Actions\n`G × X → X`\n\n### Reflective Pattern\n↹ transformations•symmetries•invariants\n⊕ identify => patterns\n⊕ analyze => operations\n⊕ preserve => structure\nΣ systematic•approach + invariant•properties\n\n### Example Prompt\n\"What patterns remain constant as we apply different transformations to our approach?\"\n\n## Ring Structure\n`(R, +, ×)`\n\n### Reflective Pattern\n↹ operations•interactions•composition\n⊕ combine => methods\n⊕ distribute => resources\n⊕ verify => closure\nΣ integrated•framework + operational•rules\n"
+category = "framework"
+
+[metadata]
+title = "Abstract Algebra Reflective Symbolic Compression"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "A resource for learning and exploring abstract algebra concepts."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

lionagi-0.9.14/lionagi/libs/token_transform/synthlang_/resources/frameworks/category_theory.toml

@@ -0,0 +1,11 @@
+id = "b8588217-3da0-4809-8a8e-1bc9489a718a"
+created_at = 1740606718.863813
+content = "\n# Category Theory Reflective Prompts\n\n## Functors\n`F: C → D`\n\n### Reflective Pattern\n↹ domain•codomain•mapping\n⊕ preserve => structure\n⊕ transform => concepts\n⊕ maintain => relationships\nΣ transformed•insight + preserved•properties\n\n### Example Prompt\n\"How can we translate this solution from one context to another while preserving its essential properties?\"\n\n## Natural Transformations\n`η: F ⇒ G`\n\n### Reflective Pattern\n↹ approaches•methods•transitions\n⊕ compare => strategies\n⊕ identify => transformations\n⊕ validate => coherence\nΣ systematic•evolution + consistency•check\n"
+category = "framework"
+
+[metadata]
+title = "Category Theory Concepts Symbolic Compression"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Abstract mathematical framework dealing with mathematical structures and relationships between them."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

lionagi-0.9.14/lionagi/libs/token_transform/synthlang_/resources/frameworks/complex_analysis.toml

@@ -0,0 +1,11 @@
+id = "f7ea039c-829b-453c-a562-85e8e66df2b0"
+created_at = 1740602435.49488
+content = "\n# Complex Analysis Reflective Prompts\n\n## Residue Theorem\n`∮_C f(z)dz = 2πi ∑Res(f,ak)`\n\n### Reflective Pattern\n↹ local•global•interactions\n⊕ analyze => singularities\n⊕ integrate => effects\n⊕ synthesize => global•view\nΣ comprehensive•understanding + local•insights\n\n### Example Prompt\n\"How do local decisions and singular points in our approach contribute to the overall solution?\"\n\n## Analytic Continuation\n`f(z)` extends uniquely\n\n### Reflective Pattern\n↹ partial•solution•constraints\n⊕ extend => domain\n⊕ preserve => consistency\n⊕ validate => uniqueness\nΣ complete•solution + coherence•check\n"
+category = "framework"
+
+[metadata]
+title = "Complex Analysis Foundations"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Advanced study of complex functions, including integration and residue theory."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

lionagi-0.9.14/lionagi/libs/token_transform/synthlang_/resources/frameworks/framework_options.json

@@ -0,0 +1,52 @@
+{
+    "options": {
+        "math": {
+            "name": "Mathematical Framework",
+            "description": "Offers a suite of math glyphs and notation rules.",
+            "glyphs": [
+                {
+                    "symbol": "\u21b9",
+                    "name": "Focus/Filter",
+                    "description": "Used for focusing instructions"
+                },
+                {
+                    "symbol": "\u03a3",
+                    "name": "Summarize",
+                    "description": "Condense large sets of data"
+                },
+                {
+                    "symbol": "\u2295",
+                    "name": "Combine/Merge",
+                    "description": "Merge multiple data sources"
+                },
+                {
+                    "symbol": "\u2022",
+                    "name": "Group Operation",
+                    "description": "Binary operation in group theory"
+                }
+            ]
+        },
+        "optim": {
+            "name": "Optimization Framework",
+            "description": "Compression and optimization for code/math expressions.",
+            "glyphs": [
+                {
+                    "symbol": "IF",
+                    "name": "Conditional Operator",
+                    "description": "Represents branching logic"
+                }
+            ]
+        },
+        "custom_algebra": {
+            "name": "Custom Algebraic Framework",
+            "description": "Extra rules for ring, group, field expansions.",
+            "glyphs": [
+                {
+                    "symbol": "\u221e",
+                    "name": "Infinite Operator",
+                    "description": "Represents unbounded algebraic ops"
+                }
+            ]
+        }
+    }
+}

lionagi-0.9.14/lionagi/libs/token_transform/synthlang_/resources/frameworks/group_theory.toml

@@ -0,0 +1,11 @@
+id = "c077186b-30cd-42d9-88ae-563859a00db3"
+created_at = 1740602288.669331
+content = "# Structures\nLet G be a group with operation •\nLet H be a subgroup of G\nLet N be a normal subgroup of G\n\n# Properties\nP(x): \"x is a homomorphism\"\nQ(x): \"x preserves group structure\"\nR(x): \"x maps to kernel\"\n\n# Objectives\n1. Prove fundamental homomorphism theorem\n2. Show group action properties\n3. Analyze quotient groups\n"
+category = "framework"
+
+[metadata]
+title = "Group Theory Analysis"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Investigation of algebraic structures using group theory and ring theory."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

lionagi-0.9.14/lionagi/libs/token_transform/synthlang_/resources/frameworks/math_logic.toml

@@ -0,0 +1,11 @@
+id = "bc244d9c-3fcc-4e7c-9a13-d0e208904c22"
+created_at = 1740602490.430191
+content = "\n# Sets and Axioms\nLet A be the set of all logical propositions.\nLet T be the subset of A that are tautologies.\nLet C be the subset of A that are contradictions.\n\n# Predicates\nP(x): \"x is a well-formed formula\"\nQ(x): \"x is satisfiable\"\nR(x): \"x is valid\"\n\n# Objectives\n1. Prove completeness theorem using predicate calculus\n2. Demonstrate soundness of the system\n3. Show relationship between syntax and semantics\n\n# Complex Integration\n∮ f(z)dz = 2πi∑Res(f,ak)\nLet f(z) = ∑(n=0 to ∞) an(z-z₀)ⁿ\nRes(f,a) = 1/(2πi)∮ f(z)dz\nw = f(z) preserves angles\n∂u/∂x = ∂v/∂y\n∂u/∂y = -∂v/∂x\n"
+category = "framework"
+
+[metadata]
+title = "Mathematical Logic Foundations"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Exploration of fundamental mathematical logic concepts using set theory and predicate calculus."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

lionagi-0.9.14/lionagi/libs/token_transform/synthlang_/resources/frameworks/reflective_patterns.toml

@@ -0,0 +1,11 @@
+id = "8d77ef3c-50a5-45c1-a1e4-1719e4de5337"
+created_at = 1740602200.381864
+content = "\n\n## Pattern Structure\n- Input (↹): Context and constraints\n- Process (⊕): Transformation steps\n- Output (Σ): Results and insights\n\n## Mathematical Frameworks\n# Abstract Algebra Reflective Prompts\n\n## Group Actions\n`G × X → X`\n\n### Reflective Pattern\n↹ transformations•symmetries•invariants\n⊕ identify => patterns\n⊕ analyze => operations\n⊕ preserve => structure\nΣ systematic•approach + invariant•properties\n\n### Example Prompt\n\"What patterns remain constant as we apply different transformations to our approach?\"\n\n## Ring Structure\n`(R, +, ×)`\n\n### Reflective Pattern\n↹ operations•interactions•composition\n⊕ combine => methods\n⊕ distribute => resources\n⊕ verify => closure\nΣ integrated•framework + operational•rules\n# Category Theory Reflective Prompts\n\n## Functors\n`F: C → D`\n\n### Reflective Pattern\n↹ domain•codomain•mapping\n⊕ preserve => structure\n⊕ transform => concepts\n⊕ maintain => relationships\nΣ transformed•insight + preserved•properties\n\n### Example Prompt\n\"How can we translate this solution from one context to another while preserving its essential properties?\"\n\n## Natural Transformations\n`η: F ⇒ G`\n\n### Reflective Pattern\n↹ approaches•methods•transitions\n⊕ compare => strategies\n⊕ identify => transformations\n⊕ validate => coherence\nΣ systematic•evolution + consistency•check\n# Complex Analysis Reflective Prompts\n\n## Residue Theorem\n`∮_C f(z)dz = 2πi ∑Res(f,ak)`\n\n### Reflective Pattern\n↹ local•global•interactions\n⊕ analyze => singularities\n⊕ integrate => effects\n⊕ synthesize => global•view\nΣ comprehensive•understanding + local•insights\n\n### Example Prompt\n\"How do local decisions and singular points in our approach contribute to the overall solution?\"\n\n## Analytic Continuation\n`f(z)` extends uniquely\n\n### Reflective Pattern\n↹ partial•solution•constraints\n⊕ extend => domain\n⊕ preserve => consistency\n⊕ validate => uniqueness\nΣ complete•solution + coherence•check\n# Set Theory Reflective Prompts\n\n## Union and Intersection\n`A ∪ B` and `A ∩ B`\n\n### Reflective Pattern\n↹ problem•domains•constraints\n⊕ identify => common•elements\n⊕ analyze => unique•aspects\n⊕ synthesize => unified•solution\nΣ integrated•approach + shared•insights\n\n### Example Prompt\n\"Consider two different approaches to solving this problem. How might we combine their strengths (union) while identifying their common successful elements (intersection)?\"\n\n## Power Set\n`P(A) = {x | x ⊆ A}`\n\n### Reflective Pattern\n↹ solution•space•constraints\n⊕ enumerate => possibilities\n⊕ analyze => subsets\n⊕ evaluate => combinations\nΣ comprehensive•analysis + feasibility•matrix\n\n### Example Prompt\n\"What are all possible combinations of approaches we could take? How do these subsets of solutions interact with each other?\"\n\n## Complement\n`A' = {x ∈ U | x ∉ A}`\n\n### Reflective Pattern\n↹ current•approach•limitations\n⊕ identify => gaps\n⊕ explore => alternatives\n⊕ analyze => completeness\nΣ holistic•perspective + blind•spots\n# Topology Reflective Prompts\n\n## Continuity\n`f: X → Y` is continuous\n\n### Reflective Pattern\n↹ transitions•changes•preservation\n⊕ identify => connections\n⊕ maintain => continuity\n⊕ analyze => boundaries\nΣ smooth•transition + preserved•properties\n\n### Example Prompt\n\"How can we ensure our solution remains robust under small perturbations or changes in conditions?\"\n\n## Homeomorphism\n`f: X → Y` is bijective and bicontinuous\n\n### Reflective Pattern\n↹ transformations•equivalences•preservation\n⊕ map => structure\n⊕ preserve => properties\n⊕ verify => reversibility\nΣ equivalent•perspective + structural•insight\n\n## Application Guidelines\n\n### Pattern Selection\n1. Identify the type of reflection needed:\n   - Structure preservation (Category Theory)\n   - Completeness analysis (Set Theory)\n   - Transformation analysis (Abstract Algebra)\n   - Continuity and connection (Topology)\n   - Local-global relationships (Complex Analysis)\n\n### Pattern Application\n1. Context Definition\n   - Clearly specify the domain\n   - Identify constraints\n   - Define objectives\n\n2. Process Execution\n   - Follow transformation steps\n   - Maintain mathematical properties\n   - Verify consistency\n\n3. Output Analysis\n   - Validate results\n   - Check coherence\n   - Ensure completeness\n\n### Best Practices\n1. Property Preservation\n   - Maintain essential structure\n   - Preserve important relationships\n   - Ensure consistency\n\n2. Transformation Clarity\n   - Clear mapping definitions\n   - Well-defined steps\n   - Verifiable results\n\n3. Completeness\n   - Cover all cases\n   - Address edge conditions\n   - Validate assumptions\n\n## Next Steps\n1. Pattern Refinement\n   - Collect usage feedback\n   - Refine transformations\n   - Expand examples\n\n2. Framework Extension\n   - Add new patterns\n   - Develop combinations\n   - Create variations\n\n3. Application Development\n   - Create specific instances\n   - Document case studies\n   - Build pattern library\n"
+category = "framework"
+
+[metadata]
+title = "Mathematical Reflective Patterns Analysis"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "reflective patterns derived from fundamental mathematical concepts. Each pattern provides a structured approach to problem-solving and reflection."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

lionagi-0.9.14/lionagi/libs/token_transform/synthlang_/resources/frameworks/set_theory.toml

@@ -0,0 +1,11 @@
+id = "518a9d70-ebb7-4f6c-aa7a-e6c8238a6671"
+created_at = 1740602563.169808
+content = "\n## Union and Intersection\n`A ∪ B` and `A ∩ B`\n\n### Reflective Pattern\n↹ problem•domains•constraints\n⊕ identify => common•elements\n⊕ analyze => unique•aspects\n⊕ synthesize => unified•solution\nΣ integrated•approach + shared•insights\n\n### Example Prompt\n\"Consider two different approaches to solving this problem. How might we combine their strengths (union) while identifying their common successful elements (intersection)?\"\n\n## Power Set\n`P(A) = {x | x ⊆ A}`\n\n### Reflective Pattern\n↹ solution•space•constraints\n⊕ enumerate => possibilities\n⊕ analyze => subsets\n⊕ evaluate => combinations\nΣ comprehensive•analysis + feasibility•matrix\n\n### Example Prompt\n\"What are all possible combinations of approaches we could take? How do these subsets of solutions interact with each other?\"\n\n## Complement\n`A' = {x ∈ U | x ∉ A}`\n\n### Reflective Pattern\n↹ current•approach•limitations\n⊕ identify => gaps\n⊕ explore => alternatives\n⊕ analyze => completeness\nΣ holistic•perspective + blind•spots\n"
+category = "framework"
+
+[metadata]
+title = "Set Theory Reflective Analysis"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Exploration of fundamental set theory concepts and operations."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"