Computational Narratology: Algorithmic Analysis of Literary Structure and Meaning

import numpy as np
from collections import defaultdict

class NarrativeMarkovChain:
    def __init__(self, n_gram=2):
        self.n_gram = n_gram
        self.transitions = defaultdict(list)
        
    def train(self, text_sequences):
        for sequence in text_sequences:
            for i in range(len(sequence) - self.n_gram):
                state = tuple(sequence[i:i+self.n_gram])
                next_word = sequence[i+self.n_gram]
                self.transitions[state].append(next_word)
    
    def generate_sequence(self, seed, length=50):
        sequence = list(seed)
        for _ in range(length):
            current_state = tuple(sequence[-self.n_gram:])
            if current_state in self.transitions:
                next_word = np.random.choice(
                    self.transitions[current_state]
                )
                sequence.append(next_word)
            else:
                break
        return sequence

import matplotlib.pyplot as plt
import numpy as np
from textblob import TextBlob

def analyze_emotional_trajectory(text_segments):
    """Extract emotional trajectory from text segments"""
    sentiments = []
    for segment in text_segments:
        blob = TextBlob(segment)
        # Combine polarity and subjectivity for rich emotional signal
        emotion_score = blob.sentiment.polarity * (1 + blob.sentiment.subjectivity)
        sentiments.append(emotion_score)
    
    # Apply smoothing filter to reduce noise
    window_size = min(5, len(sentiments) // 10)
    smoothed = np.convolve(sentiments, 
                          np.ones(window_size)/window_size, 
                          mode='same')
    
    return np.array(smoothed)

def find_emotional_peaks(trajectory, prominence=0.3):
    """Identify dramatic peaks and valleys in emotional journey"""
    from scipy.signal import find_peaks
    
    peaks, _ = find_peaks(trajectory, prominence=prominence)
    valleys, _ = find_peaks(-trajectory, prominence=prominence)
    
    return peaks, valleys

import networkx as nx
import re
from collections import Counter, defaultdict

class CharacterNetwork:
    def __init__(self):
        self.graph = nx.Graph()
        self.character_mentions = defaultdict(int)
        
    def extract_characters(self, text, character_list):
        """Extract character co-occurrence from text"""
        sentences = re.split(r'[.!?]', text)
        
        for sentence in sentences:
            mentioned_chars = []
            for char in character_list:
                if char.lower() in sentence.lower():
                    mentioned_chars.append(char)
                    self.character_mentions[char] += 1
            
            # Add edges for characters mentioned together
            for i, char1 in enumerate(mentioned_chars):
                for char2 in mentioned_chars[i+1:]:
                    if self.graph.has_edge(char1, char2):
                        self.graph[char1][char2]['weight'] += 1
                    else:
                        self.graph.add_edge(char1, char2, weight=1)
    
    def analyze_importance(self):
        """Calculate various centrality measures"""
        centrality_metrics = {
            'betweenness': nx.betweenness_centrality(self.graph),
            'closeness': nx.closeness_centrality(self.graph),
            'eigenvector': nx.eigenvector_centrality(self.graph),
            'pagerank': nx.pagerank(self.graph)
        }
        return centrality_metrics
    
    def detect_communities(self):
        """Find character communities/factions"""
        return nx.community.greedy_modularity_communities(self.graph)

import math
from collections import Counter
import zlib

def calculate_entropy(text):
    """Calculate Shannon entropy of text"""
    # Count character frequencies
    counter = Counter(text.lower())
    total_chars = sum(counter.values())
    
    # Calculate entropy
    entropy = 0
    for count in counter.values():
        probability = count / total_chars
        if probability > 0:
            entropy -= probability * math.log2(probability)
    
    return entropy

def compression_ratio(text):
    """Calculate compression ratio using zlib"""
    original_size = len(text.encode('utf-8'))
    compressed_size = len(zlib.compress(text.encode('utf-8')))
    return compressed_size / original_size

def lexical_diversity(text):
    """Calculate Type-Token Ratio (TTR)"""
    words = text.lower().split()
    unique_words = set(words)
    return len(unique_words) / len(words) if words else 0

# Advanced metrics
def calculate_perplexity(text, n_gram=3):
    """Calculate perplexity - measure of how well model predicts text"""
    words = text.split()
    n_grams = [tuple(words[i:i+n_gram]) for i in range(len(words)-n_gram+1)]
    
    counter = Counter(n_grams)
    total_grams = len(n_grams)
    
    log_prob_sum = 0
    for n_gram, count in counter.items():
        probability = count / total_grams
        log_prob_sum += math.log(probability)
    
    average_log_prob = log_prob_sum / total_grams
    perplexity = math.exp(-average_log_prob)
    
    return perplexity

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
import numpy as np

class StylometricAnalyzer:
    def __init__(self):
        # Focus on function words and common patterns
        self.function_words = [
            'the', 'be', 'to', 'of', 'and', 'a', 'in', 'that', 'have',
            'i', 'it', 'for', 'not', 'on', 'with', 'he', 'as', 'you',
            'do', 'at', 'this', 'but', 'his', 'by', 'from', 'they',
            'we', 'say', 'her', 'she', 'or', 'an', 'will', 'my',
            'one', 'all', 'would', 'there', 'their'
        ]
        
    def extract_features(self, texts):
        """Extract stylometric features from texts"""
        features = []
        
        for text in texts:
            words = text.lower().split()
            sentences = text.split('.')
            
            # Calculate various metrics
            feature_vector = {
                'avg_word_length': np.mean([len(w) for w in words]),
                'avg_sentence_length': np.mean([len(s.split()) for s in sentences if s]),
                'lexical_diversity': len(set(words)) / len(words),
                'punctuation_density': sum(1 for c in text if c in ',.!?;:') / len(text)
            }
            
            # Function word frequencies
            word_counts = Counter(words)
            total_words = len(words)
            
            for fw in self.function_words:
                feature_vector[f'freq_{fw}'] = word_counts[fw] / total_words
            
            features.append(list(feature_vector.values()))
        
        return np.array(features)
    
    def cluster_authors(self, features, n_clusters):
        """Cluster texts by stylistic similarity"""
        # Reduce dimensionality
        pca = PCA(n_components=min(10, features.shape[1]))
        reduced_features = pca.fit_transform(features)
        
        # Cluster
        kmeans = KMeans(n_clusters=n_clusters, random_state=42)
        clusters = kmeans.fit_predict(reduced_features)
        
        return clusters, pca.explained_variance_ratio_

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleTransformerBlock(nn.Module):
    def __init__(self, d_model, n_heads, d_ff, dropout=0.1):
        super().__init__()
        self.attention = nn.MultiheadAttention(d_model, n_heads, dropout=dropout)
        self.feed_forward = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.ReLU(),
            nn.Linear(d_ff, d_model)
        )
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)
        
    def forward(self, x, mask=None):
        # Self-attention with residual connection
        attended, _ = self.attention(x, x, x, attn_mask=mask)
        x = self.norm1(x + self.dropout(attended))
        
        # Feed-forward with residual connection
        ff_output = self.feed_forward(x)
        x = self.norm2(x + self.dropout(ff_output))
        
        return x

class NarrativeGenerator(nn.Module):
    def __init__(self, vocab_size, d_model=512, n_heads=8, n_layers=6):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.pos_encoding = self._positional_encoding(d_model, 5000)
        
        self.transformer_blocks = nn.ModuleList([
            SimpleTransformerBlock(d_model, n_heads, d_model * 4)
            for _ in range(n_layers)
        ])
        
        self.output_projection = nn.Linear(d_model, vocab_size)
        
    def _positional_encoding(self, d_model, max_len):
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len).unsqueeze(1).float()
        
        div_term = torch.exp(torch.arange(0, d_model, 2).float() *
                           -(math.log(10000.0) / d_model))
        
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        
        return pe.unsqueeze(0)
    
    def forward(self, x):
        seq_len = x.size(1)
        
        # Embedding + positional encoding
        x = self.embedding(x) + self.pos_encoding[:, :seq_len]
        
        # Apply transformer blocks
        for transformer in self.transformer_blocks:
            x = transformer(x)
        
        # Generate output probabilities
        return self.output_projection(x)

import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt
from textblob import TextBlob
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import LatentDirichletAllocation
import seaborn as sns

class LiteraryAnalysisEngine:
    def __init__(self):
        self.text = None
        self.segments = []
        self.characters = []
        self.emotions = []
        self.topics = []
        self.network = None
        
    def load_text(self, filepath_or_text, is_filepath=True):
        """Load and preprocess text"""
        if is_filepath:
            with open(filepath_or_text, 'r', encoding='utf-8') as f:
                self.text = f.read()
        else:
            self.text = filepath_or_text
            
        # Segment into chapters/sections
        self.segments = self._segment_text(self.text)
        
    def _segment_text(self, text, method='paragraph'):
        """Segment text for analysis"""
        if method == 'paragraph':
            return [p.strip() for p in text.split('\n\n') if p.strip()]
        elif method == 'sentence':
            return [s.strip() for s in text.split('.') if s.strip()]
        else:  # chapter
            chapters = re.split(r'Chapter \d+|CHAPTER \d+', text, flags=re.IGNORECASE)
            return [c.strip() for c in chapters if c.strip()]
    
    def analyze_emotions(self, window_size=5):
        """Analyze emotional trajectory"""
        emotions = []
        for i in range(0, len(self.segments), window_size):
            window = ' '.join(self.segments[i:i+window_size])
            blob = TextBlob(window)
            emotions.append({
                'position': i / len(self.segments),
                'polarity': blob.sentiment.polarity,
                'subjectivity': blob.sentiment.subjectivity,
                'emotional_intensity': abs(blob.sentiment.polarity) * blob.sentiment.subjectivity
            })
        
        self.emotions = emotions
        return emotions
    
    def extract_topics(self, n_topics=5):
        """Extract main themes using LDA"""
        vectorizer = TfidfVectorizer(max_features=100, stop_words='english')
        doc_term_matrix = vectorizer.fit_transform(self.segments)
        
        lda = LatentDirichletAllocation(n_components=n_topics, random_state=42)
        lda.fit(doc_term_matrix)
        
        feature_names = vectorizer.get_feature_names_out()
        topics = []
        
        for topic_idx, topic in enumerate(lda.components_):
            top_words_idx = topic.argsort()[-10:]
            top_words = [feature_names[i] for i in top_words_idx]
            topics.append(top_words)
            
        self.topics = topics
        return topics
    
    def build_character_network(self, characters):
        """Build and analyze character interaction network"""
        self.characters = characters
        network_builder = CharacterNetwork()  # From previous example
        network_builder.extract_characters(self.text, characters)
        
        self.network = network_builder.graph
        return network_builder.analyze_importance()
    
    def generate_report(self):
        """Generate comprehensive analysis report"""
        report = {
            'text_stats': {
                'total_words': len(self.text.split()),
                'total_segments': len(self.segments),
                'avg_segment_length': np.mean([len(s.split()) for s in self.segments]),
                'lexical_diversity': len(set(self.text.lower().split())) / len(self.text.split())
            },
            'emotional_analysis': self.emotions,
            'topics': self.topics,
            'entropy': calculate_entropy(self.text),  # From previous example
            'compression_ratio': compression_ratio(self.text)
        }
        
        if self.network:
            report['network_stats'] = {
                'nodes': self.network.number_of_nodes(),
                'edges': self.network.number_of_edges(),
                'density': nx.density(self.network),
                'avg_clustering': nx.average_clustering(self.network)
            }
            
        return report

# Usage example
engine = LiteraryAnalysisEngine()
engine.load_text('path/to/novel.txt')
emotion_data = engine.analyze_emotions()
topics = engine.extract_topics(n_topics=8)
character_analysis = engine.build_character_network(['Alice', 'Bob', 'Charlie'])
report = engine.generate_report()

print(f"Emotional complexity: {np.std([e['emotional_intensity'] for e in emotion_data]):.3f}")
print(f"Narrative entropy: {report['entropy']:.2f} bits")
print(f"Main topics: {[' '.join(topic[:3]) for topic in topics]}")