Create artistic expression base module

artistic expression base module

@@ -0,0 +1,613 @@
+#!/usr/bin/env python3
+"""
+TATTERED PAST PACKAGE - ARTISTIC EXPRESSION ANALYSIS MODULE
+Extending truth verification to all forms of artistic expression
+Starting with Literature, then expanding to all artistic domains
+"""
+
+import numpy as np
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, List, Any, Optional, Tuple
+from datetime import datetime
+import hashlib
+import json
+import asyncio
+from collections import Counter
+import re
+
+class ArtisticDomain(Enum):
+    """All major domains of artistic expression"""
+    LITERATURE = "literature"
+    VISUAL_ARTS = "visual_arts"
+    MUSIC = "music"
+    PERFORMING_ARTS = "performing_arts"
+    ARCHITECTURE = "architecture"
+    DIGITAL_ARTS = "digital_arts"
+    CINEMA = "cinema"
+    CRAFTS = "crafts"
+    CONCEPTUAL_ART = "conceptual_art"
+
+class LiteraryGenre(Enum):
+    """Major literary genres for truth analysis"""
+    FICTION = "fiction"
+    POETRY = "poetry"
+    DRAMA = "drama"
+    NON_FICTION = "non_fiction"
+    MYTHOLOGY = "mythology"
+    FOLKLORE = "folklore"
+    SCI_FI = "science_fiction"
+    FANTASY = "fantasy"
+    HISTORICAL = "historical"
+    PHILOSOPHICAL = "philosophical"
+
+class TruthRevelationMethod(Enum):
+    """Methods through which art reveals truth"""
+    SYMBOLIC_REPRESENTATION = "symbolic_representation"
+    EMOTIONAL_RESONANCE = "emotional_resonance"
+    PATTERN_RECOGNITION = "pattern_recognition"
+    ARCHETYPAL_EXPRESSION = "archetypal_expression"
+    COGNITIVE_DISSONANCE = "cognitive_dissonance"
+    SUBLIMINAL_MESSAGING = "subliminal_messaging"
+    CULTURAL_CRITIQUE = "cultural_critique"
+    HISTORICAL_REFERENCE = "historical_reference"
+
+@dataclass
+class LiteraryAnalysis:
+    """Comprehensive analysis of literary works for truth content"""
+    work_title: str
+    author: str
+    genre: LiteraryGenre
+    publication_year: Optional[int]
+    text_content: str
+    symbolic_density: float = field(init=False)
+    archetypal_resonance: float = field(init=False)
+    historical_accuracy: float = field(init=False)
+    philosophical_depth: float = field(init=False)
+    truth_revelation_score: float = field(init=False)
+    revelation_methods: List[TruthRevelationMethod] = field(default_factory=list)
+    
+    def __post_init__(self):
+        """Analyze literary work for truth revelation potential"""
+        # Symbolic density analysis
+        self.symbolic_density = self._calculate_symbolic_density()
+        
+        # Archetypal resonance analysis
+        self.archetypal_resonance = self._calculate_archetypal_resonance()
+        
+        # Historical accuracy assessment
+        self.historical_accuracy = self._assess_historical_accuracy()
+        
+        # Philosophical depth evaluation
+        self.philosophical_depth = self._evaluate_philosophical_depth()
+        
+        # Overall truth revelation score
+        self.truth_revelation_score = self._calculate_truth_revelation_score()
+        
+        # Identify revelation methods
+        self.revelation_methods = self._identify_revelation_methods()
+
+    def _calculate_symbolic_density(self) -> float:
+        """Calculate density of symbolic language in text"""
+        symbolic_patterns = [
+            r'\b(light|dark|water|fire|earth|air)\b',
+            r'\b(journey|quest|transformation|rebirth)\b',
+            r'\b(tree|serpent|circle|cross|mountain)\b',
+            r'\b(wisdom|knowledge|truth|illusion|reality)\b'
+        ]
+        
+        words = self.text_content.lower().split()
+        if not words:
+            return 0.0
+            
+        symbolic_matches = 0
+        for pattern in symbolic_patterns:
+            matches = re.findall(pattern, self.text_content.lower())
+            symbolic_matches += len(matches)
+            
+        return min(1.0, symbolic_matches / len(words) * 10)
+
+    def _calculate_archetypal_resonance(self) -> float:
+        """Calculate resonance with universal archetypes"""
+        archetypes = {
+            'hero': ['hero', 'champion', 'savior', 'protagonist'],
+            'wise_elder': ['wise', 'sage', 'mentor', 'teacher'],
+            'trickster': ['trickster', 'deceiver', 'jester', 'fool'],
+            'mother': ['mother', 'nurturer', 'caretaker', 'goddess'],
+            'child': ['child', 'innocent', 'youth', 'beginning']
+        }
+        
+        resonance_score = 0.0
+        text_lower = self.text_content.lower()
+        
+        for archetype, indicators in archetypes.items():
+            matches = sum(1 for indicator in indicators if indicator in text_lower)
+            resonance_score += matches * 0.1
+            
+        return min(1.0, resonance_score)
+
+    def _assess_historical_accuracy(self) -> float:
+        """Assess historical accuracy for relevant genres"""
+        if self.genre not in [LiteraryGenre.HISTORICAL, LiteraryGenre.NON_FICTION]:
+            return 0.5  # Neutral for fictional works
+            
+        # Basic historical indicator check
+        historical_indicators = [
+            'century', 'era', 'period', 'historical', 'actual',
+            'documented', 'recorded', 'archival', 'evidence'
+        ]
+        
+        matches = sum(1 for indicator in historical_indicators 
+                     if indicator in self.text_content.lower())
+        
+        return min(1.0, 0.3 + (matches * 0.1))
+
+    def _evaluate_philosophical_depth(self) -> float:
+        """Evaluate philosophical depth of the work"""
+        philosophical_terms = [
+            'truth', 'reality', 'existence', 'consciousness', 'being',
+            'knowledge', 'wisdom', 'understanding', 'meaning', 'purpose',
+            'ethics', 'morality', 'justice', 'freedom', 'will'
+        ]
+        
+        matches = sum(1 for term in philosophical_terms 
+                     if term in self.text_content.lower())
+        
+        # Genre-specific weighting
+        genre_weights = {
+            LiteraryGenre.PHILOSOPHICAL: 1.0,
+            LiteraryGenre.NON_FICTION: 0.8,
+            LiteraryGenre.FICTION: 0.6,
+            LiteraryGenre.POETRY: 0.7,
+            LiteraryGenre.DRAMA: 0.5
+        }
+        
+        base_score = min(1.0, matches * 0.1)
+        weight = genre_weights.get(self.genre, 0.5)
+        
+        return base_score * weight
+
+    def _calculate_truth_revelation_score(self) -> float:
+        """Calculate overall truth revelation score"""
+        weights = {
+            'symbolic_density': 0.25,
+            'archetypal_resonance': 0.30,
+            'historical_accuracy': 0.20,
+            'philosophical_depth': 0.25
+        }
+        
+        scores = {
+            'symbolic_density': self.symbolic_density,
+            'archetypal_resonance': self.archetypal_resonance,
+            'historical_accuracy': self.historical_accuracy,
+            'philosophical_depth': self.philosophical_depth
+        }
+        
+        weighted_score = sum(scores[factor] * weights[factor] for factor in weights)
+        return min(1.0, weighted_score)
+
+    def _identify_revelation_methods(self) -> List[TruthRevelationMethod]:
+        """Identify truth revelation methods used in the work"""
+        methods = []
+        
+        # Symbolic representation check
+        if self.symbolic_density > 0.3:
+            methods.append(TruthRevelationMethod.SYMBOLIC_REPRESENTATION)
+            
+        # Archetypal expression check
+        if self.archetypal_resonance > 0.4:
+            methods.append(TruthRevelationMethod.ARCHETYPAL_EXPRESSION)
+            
+        # Emotional resonance indicators
+        emotional_terms = ['love', 'fear', 'hope', 'despair', 'joy', 'sorrow']
+        emotional_matches = sum(1 for term in emotional_terms 
+                              if term in self.text_content.lower())
+        if emotional_matches > 5:
+            methods.append(TruthRevelationMethod.EMOTIONAL_RESONANCE)
+            
+        # Philosophical depth indicates cognitive methods
+        if self.philosophical_depth > 0.6:
+            methods.append(TruthRevelationMethod.PATTERN_RECOGNITION)
+            
+        return methods
+
+@dataclass
+class ArtisticExpressionAnalysis:
+    """Comprehensive analysis of any artistic expression"""
+    domain: ArtisticDomain
+    work_identifier: str
+    creation_period: str
+    cultural_context: str
+    medium_description: str
+    content_analysis: Dict[str, Any]
+    truth_revelation_metrics: Dict[str, float]
+    cross_domain_correlations: Dict[str, float]
+    integrated_truth_score: float = field(init=False)
+    
+    def __post_init__(self):
+        """Calculate integrated truth score across all metrics"""
+        # Weight different truth revelation metrics
+        metric_weights = {
+            'symbolic_power': 0.25,
+            'emotional_impact': 0.20,
+            'cultural_significance': 0.15,
+            'historical_accuracy': 0.20,
+            'philosophical_depth': 0.20
+        }
+        
+        # Calculate weighted score
+        weighted_sum = 0.0
+        total_weight = 0.0
+        
+        for metric, weight in metric_weights.items():
+            if metric in self.truth_revelation_metrics:
+                weighted_sum += self.truth_revelation_metrics[metric] * weight
+                total_weight += weight
+                
+        base_score = weighted_sum / total_weight if total_weight > 0 else 0.0
+        
+        # Cross-domain correlation boost
+        correlation_boost = np.mean(list(self.cross_domain_correlations.values())) * 0.2
+        
+        self.integrated_truth_score = min(1.0, base_score + correlation_boost)
+
+class ArtisticExpressionEngine:
+    """
+    Engine for analyzing all forms of artistic expression for truth content
+    Extends the Tattered Past Package with comprehensive artistic analysis
+    """
+    
+    def __init__(self):
+        self.literary_analyzer = LiteraryAnalysisEngine()
+        self.visual_arts_analyzer = VisualArtsAnalyzer()
+        self.music_analyzer = MusicAnalysisEngine()
+        self.cross_domain_integrator = CrossDomainIntegrator()
+        self.analysis_history = []
+        
+    async def analyze_artistic_work(self, domain: ArtisticDomain, work_data: Dict[str, Any]) -> ArtisticExpressionAnalysis:
+        """Analyze any artistic work for truth revelation potential"""
+        
+        # Domain-specific analysis
+        if domain == ArtisticDomain.LITERATURE:
+            domain_analysis = await self.literary_analyzer.analyze_literary_work(work_data)
+        elif domain == ArtisticDomain.VISUAL_ARTS:
+            domain_analysis = await self.visual_arts_analyzer.analyze_visual_art(work_data)
+        elif domain == ArtisticDomain.MUSIC:
+            domain_analysis = await self.music_analyzer.analyze_musical_work(work_data)
+        else:
+            domain_analysis = await self._generic_artistic_analysis(work_data)
+        
+        # Cross-domain correlation analysis
+        cross_correlations = await self.cross_domain_integrator.find_correlations(domain_analysis)
+        
+        analysis = ArtisticExpressionAnalysis(
+            domain=domain,
+            work_identifier=work_data.get('identifier', 'unknown'),
+            creation_period=work_data.get('period', 'unknown'),
+            cultural_context=work_data.get('cultural_context', 'unknown'),
+            medium_description=work_data.get('medium', 'unknown'),
+            content_analysis=domain_analysis.get('content_analysis', {}),
+            truth_revelation_metrics=domain_analysis.get('truth_metrics', {}),
+            cross_domain_correlations=cross_correlations
+        )
+        
+        self.analysis_history.append(analysis)
+        return analysis
+    
+    async def _generic_artistic_analysis(self, work_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Generic analysis for artistic domains without specialized analyzers"""
+        return {
+            'content_analysis': {
+                'description': work_data.get('description', ''),
+                'themes': work_data.get('themes', []),
+                'techniques': work_data.get('techniques', [])
+            },
+            'truth_metrics': {
+                'symbolic_power': 0.5,
+                'emotional_impact': 0.5,
+                'cultural_significance': 0.5,
+                'historical_accuracy': 0.3,
+                'philosophical_depth': 0.4
+            }
+        }
+
+class LiteraryAnalysisEngine:
+    """Specialized engine for literary analysis"""
+    
+    def __init__(self):
+        self.genre_classifier = GenreClassifier()
+        self.theme_analyzer = ThemeAnalysisEngine()
+        self.symbolic_analyzer = SymbolicAnalysisEngine()
+        
+    async def analyze_literary_work(self, work_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Comprehensive analysis of literary works"""
+        
+        # Create literary analysis object
+        literary_work = LiteraryAnalysis(
+            work_title=work_data.get('title', 'Unknown'),
+            author=work_data.get('author', 'Unknown'),
+            genre=self.genre_classifier.classify_genre(work_data),
+            publication_year=work_data.get('publication_year'),
+            text_content=work_data.get('content', '')
+        )
+        
+        # Additional thematic analysis
+        themes = await self.theme_analyzer.identify_themes(literary_work.text_content)
+        symbols = await self.symbolic_analyzer.analyze_symbols(literary_work.text_content)
+        
+        return {
+            'content_analysis': {
+                'literary_analysis': literary_work,
+                'identified_themes': themes,
+                'symbolic_elements': symbols,
+                'word_count': len(literary_work.text_content.split()),
+                'complexity_score': self._calculate_complexity(literary_work.text_content)
+            },
+            'truth_metrics': {
+                'symbolic_power': literary_work.symbolic_density,
+                'emotional_impact': self._assess_emotional_impact(literary_work.text_content),
+                'cultural_significance': self._assess_cultural_significance(work_data),
+                'historical_accuracy': literary_work.historical_accuracy,
+                'philosophical_depth': literary_work.philosophical_depth
+            }
+        }
+    
+    def _calculate_complexity(self, text: str) -> float:
+        """Calculate text complexity"""
+        words = text.split()
+        if not words:
+            return 0.0
+            
+        avg_word_length = np.mean([len(word) for word in words])
+        sentence_count = text.count('.') + text.count('!') + text.count('?')
+        avg_sentence_length = len(words) / sentence_count if sentence_count > 0 else len(words)
+        
+        complexity = (avg_word_length * 0.3) + (avg_sentence_length * 0.2) / 10
+        return min(1.0, complexity)
+    
+    def _assess_emotional_impact(self, text: str) -> float:
+        """Assess emotional impact of text"""
+        emotional_words = {
+            'positive': ['love', 'joy', 'hope', 'peace', 'beautiful', 'wonderful'],
+            'negative': ['hate', 'fear', 'anger', 'sad', 'terrible', 'horrible'],
+            'intense': ['passion', 'rage', 'ecstasy', 'despair', 'fury', 'bliss']
+        }
+        
+        text_lower = text.lower()
+        emotional_density = 0.0
+        
+        for category, words in emotional_words.items():
+            matches = sum(1 for word in words if word in text_lower)
+            emotional_density += matches * 0.05
+            
+        return min(1.0, emotional_density)
+    
+    def _assess_cultural_significance(self, work_data: Dict[str, Any]) -> float:
+        """Assess cultural significance of literary work"""
+        significance_indicators = [
+            work_data.get('awards', []),
+            work_data.get('cultural_impact', ''),
+            work_data.get('historical_period', ''),
+            work_data.get('translation_count', 0)
+        ]
+        
+        indicator_score = sum(1 for indicator in significance_indicators if indicator) / len(significance_indicators)
+        return min(1.0, 0.3 + indicator_score * 0.7)
+
+class GenreClassifier:
+    """Classifies literary genres"""
+    
+    def classify_genre(self, work_data: Dict[str, Any]) -> LiteraryGenre:
+        """Classify literary genre"""
+        genre_hints = work_data.get('genre_hints', [])
+        content = work_data.get('content', '').lower()
+        
+        # Genre detection logic
+        if any(hint in content for hint in ['poem', 'verse', 'rhyme']):
+            return LiteraryGenre.POETRY
+        elif any(hint in content for hint in ['act', 'scene', 'dialogue', 'stage']):
+            return LiteraryGenre.DRAMA
+        elif any(hint in content for hint in ['philosophy', 'truth', 'reality', 'existence']):
+            return LiteraryGenre.PHILOSOPHICAL
+        elif any(hint in content for hint in ['historical', 'century', 'era', 'period']):
+            return LiteraryGenre.HISTORICAL
+        elif any(hint in content for hint in ['science', 'future', 'technology', 'space']):
+            return LiteraryGenre.SCI_FI
+        elif any(hint in content for hint in ['magic', 'fantasy', 'mythical', 'legend']):
+            return LiteraryGenre.FANTASY
+        else:
+            return LiteraryGenre.FICTION
+
+class ThemeAnalysisEngine:
+    """Analyzes literary themes"""
+    
+    async def identify_themes(self, text: str) -> List[str]:
+        """Identify major themes in literary text"""
+        theme_indicators = {
+            'love': ['love', 'romance', 'affection', 'passion'],
+            'death': ['death', 'mortality', 'afterlife', 'funeral'],
+            'power': ['power', 'control', 'authority', 'dominance'],
+            'justice': ['justice', 'fairness', 'equality', 'rights'],
+            'freedom': ['freedom', 'liberty', 'liberation', 'free will'],
+            'truth': ['truth', 'reality', 'knowledge', 'wisdom'],
+            'identity': ['identity', 'self', 'consciousness', 'being']
+        }
+        
+        text_lower = text.lower()
+        identified_themes = []
+        
+        for theme, indicators in theme_indicators.items():
+            matches = sum(1 for indicator in indicators if indicator in text_lower)
+            if matches >= 2:  # Minimum threshold for theme identification
+                identified_themes.append(theme)
+                
+        return identified_themes
+
+class SymbolicAnalysisEngine:
+    """Analyzes symbolic content"""
+    
+    async def analyze_symbols(self, text: str) -> Dict[str, float]:
+        """Analyze symbolic elements in text"""
+        common_symbols = {
+            'light': ['light', 'bright', 'illumination', 'enlightenment'],
+            'dark': ['dark', 'shadow', 'night', 'obscurity'],
+            'water': ['water', 'river', 'ocean', 'flow'],
+            'fire': ['fire', 'flame', 'burn', 'passion'],
+            'journey': ['journey', 'quest', 'travel', 'path'],
+            'transformation': ['change', 'transform', 'become', 'evolve']
+        }
+        
+        text_lower = text.lower()
+        symbol_strengths = {}
+        
+        for symbol, indicators in common_symbols.items():
+            matches = sum(1 for indicator in indicators if indicator in text_lower)
+            symbol_strengths[symbol] = min(1.0, matches * 0.2)
+            
+        return symbol_strengths
+
+class VisualArtsAnalyzer:
+    """Placeholder for visual arts analysis"""
+    async def analyze_visual_art(self, work_data: Dict[str, Any]) -> Dict[str, Any]:
+        await asyncio.sleep(0.1)  # Simulate processing
+        return {
+            'content_analysis': {'medium': work_data.get('medium', 'unknown')},
+            'truth_metrics': {'symbolic_power': 0.6, 'emotional_impact': 0.7, 'cultural_significance': 0.5}
+        }
+
+class MusicAnalysisEngine:
+    """Placeholder for music analysis"""
+    async def analyze_musical_work(self, work_data: Dict[str, Any]) -> Dict[str, Any]:
+        await asyncio.sleep(0.1)  # Simulate processing
+        return {
+            'content_analysis': {'genre': work_data.get('genre', 'unknown')},
+            'truth_metrics': {'emotional_impact': 0.8, 'cultural_significance': 0.6}
+        }
+
+class CrossDomainIntegrator:
+    """Integrates analysis across artistic domains"""
+    
+    async def find_correlations(self, domain_analysis: Dict[str, Any]) -> Dict[str, float]:
+        """Find correlations with other truth discovery domains"""
+        # Simulate correlation finding
+        await asyncio.sleep(0.05)
+        
+        return {
+            'archaeological': 0.7,  # Literature often references historical/archaeological themes
+            'philosophical': 0.8,   # Strong correlation with philosophical inquiry
+            'scientific': 0.4,      # Moderate correlation with scientific truth
+            'spiritual': 0.6        # Moderate-strong correlation with spiritual truth
+        }
+
+# =============================================================================
+# TATTERED PAST PACKAGE INTEGRATION
+# =============================================================================
+
+class EnhancedTatteredPastPackage:
+    """
+    Tattered Past Package with enhanced artistic expression analysis
+    """
+    
+    def __init__(self):
+        self.artistic_engine = ArtisticExpressionEngine()
+        self.integration_records = []
+        
+    async def analyze_artistic_truth(self, domain: ArtisticDomain, work_data: Dict[str, Any]) -> ArtisticExpressionAnalysis:
+        """Analyze artistic work for truth content"""
+        return await self.artistic_engine.analyze_artistic_work(domain, work_data)
+    
+    async def integrate_artistic_findings(self, artistic_analysis: ArtisticExpressionAnalysis, 
+                                        other_findings: Dict[str, Any]) -> Dict[str, Any]:
+        """Integrate artistic findings with other truth discovery methods"""
+        
+        integration = {
+            'artistic_domain': artistic_analysis.domain.value,
+            'work_identifier': artistic_analysis.work_identifier,
+            'integrated_truth_score': artistic_analysis.integrated_truth_score,
+            'cross_domain_synergy': self._calculate_synergy(artistic_analysis, other_findings),
+            'revelation_potential': artistic_analysis.integrated_truth_score * 0.8,  # Artistic works often reveal indirect truths
+            'integration_timestamp': datetime.utcnow().isoformat()
+        }
+        
+        self.integration_records.append(integration)
+        return integration
+    
+    def _calculate_synergy(self, artistic_analysis: ArtisticExpressionAnalysis, 
+                          other_findings: Dict[str, Any]) -> float:
+        """Calculate synergy between artistic findings and other domains"""
+        base_synergy = artistic_analysis.integrated_truth_score
+        
+        # Boost if multiple domains confirm similar truths
+        if 'archaeological_confidence' in other_findings:
+            arch_confidence = other_findings['archaeological_confidence']
+            base_synergy += arch_confidence * 0.2
+            
+        if 'philosophical_certainty' in other_findings:
+            phil_certainty = other_findings['philosophical_certainty']
+            base_synergy += phil_certainty * 0.3
+            
+        return min(1.0, base_synergy)
+
+# =============================================================================
+# DEMONSTRATION AND TESTING
+# =============================================================================
+
+async def demonstrate_artistic_analysis():
+    """Demonstrate artistic expression analysis capabilities"""
+    
+    print("🎨 ARTISTIC EXPRESSION ANALYSIS MODULE - LITERATURE FOCUS")
+    print("=" * 70)
+    
+    enhanced_package = EnhancedTatteredPastPackage()
+    
+    # Test literary works
+    test_works = [
+        {
+            'domain': ArtisticDomain.LITERATURE,
+            'title': 'The Alchemist',
+            'author': 'Paulo Coelho',
+            'genre_hints': ['philosophical', 'journey'],
+            'content': """
+            The boy's name was Santiago. Dusk was falling as the boy arrived with his herd at an abandoned church.
+            The roof had fallen in long ago, and an enormous sycamore had grown on the spot where the sacristy had once stood.
+            He decided to spend the night there. He saw to it that all the sheep entered through the ruined gate, and then laid some planks across it to prevent the flock from wandering away during the night.
+            There were no wolves in the region, but once an animal had strayed during the night, and the boy had had to spend the entire next day searching for it.
+            He swept the floor with his jacket and lay down, using the book he had just finished reading as a pillow.
+            He told himself that he would have to start reading thicker books: they lasted longer, and made more comfortable pillows.
+            """
+        },
+        {
+            'domain': ArtisticDomain.LITERATURE,
+            'title': '1984',
+            'author': 'George Orwell',
+            'genre_hints': ['political', 'dystopian'],
+            'content': """
+            It was a bright cold day in April, and the clocks were striking thirteen.
+            Winston Smith, his chin nuzzled into his breast in an effort to escape the vile wind,
+            slipped quickly through the glass doors of Victory Mansions, though not quickly enough to prevent a swirl of gritty dust from entering along with him.
+            The hallway smelt of boiled cabbage and old rag mats. At one end of it a coloured poster, too large for indoor display, had been tacked to the wall.
+            It depicted simply an enormous face, more than a metre wide: the face of a man of about forty-five, with a heavy black moustache and ruggedly handsome features.
+            """
+        }
+    ]
+    
+    for work in test_works:
+        print(f"\n📖 Analyzing: {work['title']} by {work['author']}")
+        
+        analysis = await enhanced_package.analyze_artistic_truth(work['domain'], work)
+        
+        print(f"   Domain: {analysis.domain.value}")
+        print(f"   Integrated Truth Score: {analysis.integrated_truth_score:.3f}")
+        print(f"   Truth Metrics: {list(analysis.truth_revelation_metrics.keys())}")
+        
+        # Show specific metrics for literature
+        if analysis.domain == ArtisticDomain.LITERATURE:
+            lit_analysis = analysis.content_analysis.get('literary_analysis')
+            if lit_analysis:
+                print(f"   Symbolic Density: {lit_analysis.symbolic_density:.3f}")
+                print(f"   Archetypal Resonance: {lit_analysis.archetypal_resonance:.3f}")
+                print(f"   Philosophical Depth: {lit_analysis.philosophical_depth:.3f}")
+                print(f"   Revelation Methods: {[m.value for m in lit_analysis.revelation_methods]}")
+
+if __name__ == "__main__":
+    asyncio.run(demonstrate_artistic_analysis())