Add Semantic Illustration: Mathematical equivalent of parabolic compression

Formalizes the concept of compression through illustration (like Christ's
"Consider the lilies" compressing theology into a concrete image).

Features:
- SemanticIllustration dataclass with seed, domain, expansion_ratio, fidelity
- Canonical illustrations: golden_ratio, natural_equilibrium, emergent_structure
- create_illustration(): Build from empirical data
- expand_illustration(): Reveal what a seed generates
- illustrate_concept(): Compress LJPW system to (P, W) seed

Tests: 14 new tests (128 total passing)

Author: claude

src/ljpw/__init__.py

@@ -86,6 +86,12 @@
         create_from_ljpw,
         get_natural_equilibrium,
         get_anchor_point,
+        # Semantic Illustration (Parabolic Compression)
+        SemanticIllustration,
+        ILLUSTRATIONS,
+        create_illustration,
+        expand_illustration,
+        illustrate_concept,
     )
 
     __all__.extend([
@@ -98,6 +104,12 @@
         "create_from_ljpw",
         "get_natural_equilibrium",
         "get_anchor_point",
+        # Semantic Illustration
+        "SemanticIllustration",
+        "ILLUSTRATIONS",
+        "create_illustration",
+        "expand_illustration",
+        "illustrate_concept",
     ])
 except ImportError:
     pass

src/ljpw/ljpw_framework_v7.py

@@ -850,6 +850,197 @@ def calculate_distance(
     return math.sqrt(sum((a - b) ** 2 for a, b in zip(coords1, coords2)))
 
 
+# ============================================================================
+# SEMANTIC ILLUSTRATION — PARABOLIC COMPRESSION
+# ============================================================================
+#
+# Mathematical formalization of compression through illustration.
+#
+# Just as Christ's "Consider the lilies of the field" compresses the abstract
+# concept of "trust in providence rather than anxious self-provision" into a
+# concrete image, mathematical constants serve as "illustrations" that compress
+# infinite relationships into finite symbols.
+#
+# The parable mechanism:
+#   Complex Abstract Concept → Concrete Illustration → Universal Understanding
+#
+# Mathematical equivalent:
+#   Infinite Relations → Generator Constant → All Derived Truths
+#
+# Examples:
+#   φ = (1+√5)/2     →  Generates infinite Fibonacci relationships
+#   e = lim(1+1/n)^n →  Generates all exponential growth patterns
+#   NE = (0.618, 0.414, 0.718, 0.693) → "Illustrates" optimal semantic balance
+
+
+@dataclass
+class SemanticIllustration:
+    """
+    A Semantic Illustration is a compressed representation that generates
+    understanding of a complex concept through a concrete anchor.
+
+    This is the mathematical equivalent of a parable or metaphor.
+
+    Properties:
+    - seed: The concrete anchor (like "lilies" or "φ")
+    - domain: The abstract concept space it compresses
+    - expansion_ratio: How much meaning unfolds from the seed
+    - fidelity: How faithfully the illustration preserves the original meaning
+    """
+
+    seed: Union[float, Tuple[float, ...], str]
+    domain: str
+    expansion_ratio: float  # How much meaning unfolds (>1 means compression)
+    fidelity: float  # 0-1, how faithfully meaning is preserved
+
+    def compress_ratio(self) -> float:
+        """
+        Calculate compression ratio.
+
+        Higher = more compression (more meaning per symbol).
+        """
+        return self.expansion_ratio * self.fidelity
+
+    def is_effective(self) -> bool:
+        """
+        An illustration is effective if it compresses without significant loss.
+
+        Threshold: expansion > 2x and fidelity > 0.8
+        """
+        return self.expansion_ratio > 2.0 and self.fidelity > 0.8
+
+
+# Canonical Illustrations (Mathematical Parables)
+ILLUSTRATIONS: Dict[str, SemanticIllustration] = {
+    # φ generates infinite Fibonacci, Lucas, golden spiral relationships
+    "golden_ratio": SemanticIllustration(
+        seed=PHI,
+        domain="growth_harmony",
+        expansion_ratio=float("inf"),  # Generates infinite series
+        fidelity=1.0,
+    ),
+    # Natural Equilibrium "illustrates" optimal semantic balance
+    "natural_equilibrium": SemanticIllustration(
+        seed=NATURAL_EQUILIBRIUM,
+        domain="semantic_optimality",
+        expansion_ratio=100.0,  # 4 numbers encode entire quality space
+        fidelity=0.95,  # High but not perfect (edge cases exist)
+    ),
+    # The 2+2 structure compresses 4D to 2D
+    "emergent_structure": SemanticIllustration(
+        seed=(P0, W0),  # Just P, W
+        domain="four_dimensional_semantics",
+        expansion_ratio=2.0,  # 2 dims → 4 dims
+        fidelity=0.92,  # R² of emergence relations
+    ),
+    # Uncertainty bound compresses conjugate duality
+    "uncertainty_bound": SemanticIllustration(
+        seed=UNCERTAINTY_BOUND,
+        domain="measurement_limits",
+        expansion_ratio=10.0,  # One number encodes fundamental limit
+        fidelity=1.0,  # Mathematical truth
+    ),
+}
+
+
+def create_illustration(
+    concept: str,
+    seed: Union[float, Tuple[float, ...]],
+    examples_covered: int,
+    examples_lost: int = 0,
+) -> SemanticIllustration:
+    """
+    Create a semantic illustration from empirical data.
+
+    Args:
+        concept: Name of the abstract concept domain
+        seed: The concrete anchor value(s)
+        examples_covered: How many instances the illustration explains
+        examples_lost: How many edge cases it fails on
+
+    Returns:
+        SemanticIllustration with calculated metrics
+    """
+    total = examples_covered + examples_lost
+    fidelity = examples_covered / total if total > 0 else 0.0
+
+    # Expansion ratio: how many examples one seed covers
+    seed_size = len(seed) if isinstance(seed, tuple) else 1
+    expansion = examples_covered / seed_size if seed_size > 0 else 0.0
+
+    return SemanticIllustration(
+        seed=seed,
+        domain=concept,
+        expansion_ratio=expansion,
+        fidelity=fidelity,
+    )
+
+
+def expand_illustration(illustration: SemanticIllustration) -> Dict[str, Any]:
+    """
+    Expand a semantic illustration to reveal its compressed meaning.
+
+    Like unpacking a parable to show the theological truth,
+    this reveals what the mathematical seed generates.
+    """
+    result = {
+        "seed": illustration.seed,
+        "domain": illustration.domain,
+        "compression_ratio": illustration.compress_ratio(),
+        "effective": illustration.is_effective(),
+    }
+
+    # Special expansions for known illustrations
+    if illustration.domain == "growth_harmony" and illustration.seed == PHI:
+        result["generates"] = [
+            "Fibonacci sequence (F_n = F_{n-1} + F_{n-2})",
+            "Golden spiral (r = φ^(θ/90°))",
+            "Optimal packing efficiency",
+            "Natural Equilibrium L coordinate (φ⁻¹ = 0.618)",
+            "Self-similar recursive structures",
+        ]
+    elif illustration.domain == "semantic_optimality":
+        result["generates"] = [
+            "Optimal code quality target",
+            "Compression efficiency baseline",
+            "Cross-language semantic anchor",
+            "Phase transition boundaries",
+        ]
+    elif illustration.domain == "four_dimensional_semantics":
+        result["generates"] = [
+            "L = 0.9W + 0.1 (Love from Wisdom)",
+            "J = 0.85P + 0.05 (Justice from Power)",
+            "Full 4D semantic space",
+        ]
+
+    return result
+
+
+def illustrate_concept(
+    ljpw_system: LJPWFrameworkV7,
+) -> SemanticIllustration:
+    """
+    Create an illustration that compresses an LJPW system to its essence.
+
+    This finds the minimal seed that regenerates the system.
+    """
+    # The minimal seed is (P, W) since L, J are emergent
+    seed = (ljpw_system.P, ljpw_system.W)
+
+    # Measure how well this seed regenerates the full system
+    regenerated = LJPWFrameworkV7(P=seed[0], W=seed[1])
+    L_error = abs(ljpw_system.L - regenerated.L)
+    J_error = abs(ljpw_system.J - regenerated.J)
+    fidelity = 1.0 - (L_error + J_error) / 2
+
+    return SemanticIllustration(
+        seed=seed,
+        domain="ljpw_system",
+        expansion_ratio=2.0,  # 2 dims → 4 dims
+        fidelity=max(0, fidelity),
+    )
+
+
 # ============================================================================
 # EXAMPLE USAGE
 # ============================================================================
@@ -930,6 +1121,38 @@ def calculate_distance(
     print(f"   Phase transition: {analysis['trajectory']['phase_transition']}")
     print()
 
+    # Example 8: Semantic Illustration (Parabolic Compression)
+    print("8. SEMANTIC ILLUSTRATION (Parabolic Compression):")
+    print("   Like Christ's 'Consider the lilies' compresses theology into image,")
+    print("   mathematical constants compress infinite relations into symbols.")
+    print()
+
+    # Show canonical illustrations
+    for name, illust in ILLUSTRATIONS.items():
+        print(f"   {name}:")
+        print(f"     Seed: {illust.seed}")
+        print(f"     Compresses: {illust.domain}")
+        print(f"     Ratio: {illust.compress_ratio():.1f}x (expansion × fidelity)")
+        print(f"     Effective: {illust.is_effective()}")
+        print()
+
+    # Demonstrate compression of a system
+    print("   Compressing LJPW system to its seed:")
+    system_to_compress = LJPWFrameworkV7(P=0.85, W=0.92)
+    illustration = illustrate_concept(system_to_compress)
+    print(f"     Full system: L={system_to_compress.L:.3f}, J={system_to_compress.J:.3f}, "
+          f"P={system_to_compress.P:.3f}, W={system_to_compress.W:.3f}")
+    print(f"     Seed (P, W): {illustration.seed}")
+    print(f"     Fidelity: {illustration.fidelity:.3f}")
+    print()
+
+    # Expand the golden ratio illustration
+    print("   Expanding φ (golden ratio) illustration:")
+    expanded = expand_illustration(ILLUSTRATIONS["golden_ratio"])
+    for gen in expanded.get("generates", []):
+        print(f"     → {gen}")
+    print()
+
     print("=" * 70)
     print("FRAMEWORK V7.3 DEMONSTRATION COMPLETE")
     print("=" * 70)