stylometric-fingerprinting

name	stylometric-fingerprinting
description	Use when extracting a stable writing fingerprint from a text corpus based on function word frequencies, sentence structure patterns, and punctuation habits, defining syntactic constraints that make an author's writing identifiable regardless of topic, or building a replicable style profile from distributional features rather than content words

Stylometric Fingerprinting

Overview

Extract a stable stylometric fingerprint from a text corpus by measuring function word frequencies, sentence structure distributions, and punctuation patterns -- the features that remain consistent across topics and time periods because they are produced unconsciously. The core principle: function words and syntactic patterns are more stable authorship markers than content words because content words change with topic while function words reflect deeply ingrained grammatical habits (Mosteller & Wallace, 1963; Kestemont, 2014). The fingerprint is a distributional profile, not a set of point estimates -- each feature is characterized by its mean, standard deviation, and cross-context stability coefficient.

Research foundation: Function words have been the backbone of computational stylometry since the Federalist Papers attribution (Mosteller & Wallace, 1963). Argamon & Levitan (2005) demonstrated that function word frequencies alone achieve 80%+ accuracy in authorship attribution across genres. Eder (2011) established that 2,500+ words are needed for reliable frequency estimation with the 100 most frequent words, while Stamatatos (2009) showed that character n-grams and function word distributions are among the most robust features for cross-domain authorship identification.

When to Use

• Extracting an author's stable writing signature from a corpus of their text
• Building a style profile for writing voice replication that survives topic changes
• Defining syntactic constraints that characterize an author's habitual patterns
• Comparing writing style consistency across contexts, time periods, or platforms
• Creating a feature set for authorship verification or attribution tasks
• Feeding stable stylometric features into a persona or archetype system

When NOT to use:

• Corpus contains fewer than 2,500 words (see Insufficient Data Handling)
• Text is heavily edited by others, machine-translated, or ghostwritten (author signal is diluted)
• Goal is content analysis or topic modeling (use NMF or LDA instead)
• Deanonymizing or surveilling individuals without their knowledge or consent
• Claiming definitive authorship proof in legal or forensic contexts without validated tooling (use JGAAP or stylo with proper validation)
• Single very short text (< 500 words) as the sole sample

digraph fingerprint_decision {
    rankdir=TB;
    "Enough text?\n(2,500+ words)" [shape=diamond];
    "Multiple samples or\ncontexts?" [shape=diamond];
    "Surveillance or\ndeanonymization?" [shape=diamond];
    "Proceed with\nfull analysis" [shape=box];
    "Report insufficient\ndata" [shape=box];
    "Proceed with\nstability caveat" [shape=box];
    "STOP: Ethical\nboundary" [shape=box];

    "Enough text?\n(2,500+ words)" -> "Multiple samples or\ncontexts?" [label="yes"];
    "Enough text?\n(2,500+ words)" -> "Report insufficient\ndata" [label="no"];
    "Multiple samples or\ncontexts?" -> "Surveillance or\ndeanonymization?" [label="yes"];
    "Multiple samples or\ncontexts?" -> "Proceed with\nstability caveat" [label="no, single context"];
    "Surveillance or\ndeanonymization?" -> "STOP: Ethical\nboundary" [label="yes"];
    "Surveillance or\ndeanonymization?" -> "Proceed with\nfull analysis" [label="no"];
}

Quick Reference

Feature Categories and Stability Ranking

Feature Category	Example Features	Cross-Context Stability	Minimum Words for Reliable Estimate
Function words (articles, prepositions, conjunctions, pronouns, auxiliaries)	the, of, and, to, a, in, is, that, it, for, was, with, but, not, as, be, have, which	Highest -- unconscious, topic-independent	2,500+
Punctuation patterns	Comma rate, semicolon usage, dash frequency, ellipsis rate, exclamation/question ratio	High -- habitual, genre-sensitive	1,500+
Sentence length distribution	Mean, median, std, skewness of words-per-sentence	High -- reflects planning complexity	2,000+ (50+ sentences)
Word length distribution	Mean word length, % short (1-3 char), % long (7+ char)	Moderate-High	2,000+
Type-token ratio (TTR)	Vocabulary richness (unique/total, MATTR for longer texts)	Moderate -- affected by topic and text length	2,500+ (use MATTR for texts > 5,000 words)
POS tag ratios	Noun/verb ratio, adjective density, adverb rate	Moderate -- partly topic-sensitive	3,000+
Character n-grams	Most frequent 2-3 character sequences	High -- captures morphological habits	3,000+
Readability metrics	Flesch-Kincaid, Coleman-Liau, average syllables/word	Moderate-High -- reflects complexity habits	2,000+

Core Function Word List (English)

These 50 function words form the minimum stable feature set, derived from Mosteller & Wallace (1963), Burrows (2002), and Kestemont (2014):

Articles:       a, an, the
Prepositions:   at, by, for, from, in, of, on, to, with, about, after, between, through, into, over, upon
Conjunctions:   and, but, or, nor, so, yet, although, because, if, than, that, while
Pronouns:       i, me, my, we, us, our, you, your, he, him, his, she, her, it, its, they, them, their
Auxiliaries:    be, is, am, are, was, were, been, have, has, had, do, does, did, will, would, shall, should, can, could, may, might, must
Determiners:    this, that, these, those, each, every, some, any, no, all, both
Adverbs:        not, very, also, then, there, here, now, just, only, still, even, already, always, never

Key Metric Thresholds

Parameter	Value	Source
Minimum corpus (basic profile)	2,500 words	Eder (2011) on MFW reliability
Minimum corpus (stable profile)	5,000+ words	Consensus across Stamatatos (2009), Eder (2011)
Optimal corpus	10,000+ words across 5+ contexts	Multiple studies; diminishing returns beyond 20,000
Minimum samples for stability test	3+ independent texts	Cross-context comparison requires multiple samples
Stability coefficient threshold	CV < 0.30 for "stable" feature	Coefficient of variation across contexts
Function word count	50-150 most frequent	Burrows (2002): 150 MFW; minimum viable: 50
Sentence count for length distribution	50+ sentences	Below 50, distribution statistics are unreliable
Character n-gram order	2-3 characters	Higher orders become content-sensitive

Workflow

Copy this checklist and track progress:

Stylometric Fingerprinting Progress:
- [ ] Step 1: Validate corpus suitability and segment into samples
- [ ] Step 2: Extract function word frequency profiles
- [ ] Step 3: Measure sentence structure distributions
- [ ] Step 4: Compute punctuation pattern profiles
- [ ] Step 5: Calculate supplementary features (word length, TTR, readability)
- [ ] Step 6: Test cross-context stability of all features
- [ ] Step 7: Define the stable fingerprint and syntactic constraints
- [ ] Step 8: Write findings to docs/analysis/18-stylometric-fingerprinting.md

Step 1: Validate Corpus Suitability and Segment

Before analysis, verify the corpus can support fingerprint extraction and divide it into independent samples for stability testing.

Suitability checks:

Check	Pass Condition	Fail Action
Word count	2,500+ words total	Below 2,500: STOP. Report insufficient data. Do not compute fingerprint.
Word count confidence	5,000+ words for stable profile	2,500-5,000: Proceed but flag ALL features as "preliminary."
Language	Predominantly one language	Mixed-language text invalidates function word frequency comparison. Segment by language first.
Authorship	Single author	Multi-author corpus produces a blended fingerprint. Must segment by author.
Sample diversity	Text from 2+ contexts, topics, or time periods	Single-context text may reflect genre constraints, not personal style. Flag prominently.
Editing level	Natural writing, minimally edited	Heavily edited text reflects editorial process, not author habit. Document limitation.
Text type	Prose (not poetry, code, or structured data)	Non-prose text has fundamentally different function word distributions.

Segmentation for stability testing:

Divide the corpus into 3+ roughly equal samples, ideally along natural boundaries (different threads, time periods, topics). Each segment should contain at least 800 words. If the corpus is too small to segment, skip stability testing (Step 6) and flag in report.

import re
from collections import Counter

def segment_corpus(texts, min_words_per_segment=800, target_segments=5):
    """Divide a list of texts into segments for cross-context stability testing.
    Each text is a dict with 'text' and optionally 'context' (topic/time/source)."""
    # If context labels exist, group by context
    if all('context' in t for t in texts):
        from itertools import groupby
        sorted_texts = sorted(texts, key=lambda t: t['context'])
        segments = []
        for context, group in groupby(sorted_texts, key=lambda t: t['context']):
            combined = ' '.join(t['text'] for t in group)
            word_count = len(combined.split())
            if word_count >= min_words_per_segment:
                segments.append({
                    'context': context,
                    'text': combined,
                    'word_count': word_count,
                })
        return segments

    # Otherwise, divide sequentially
    all_text = ' '.join(t['text'] for t in texts)
    words = all_text.split()
    total = len(words)
    seg_size = max(min_words_per_segment, total // target_segments)
    segments = []
    for i in range(0, total, seg_size):
        chunk = ' '.join(words[i:i + seg_size])
        if len(chunk.split()) >= min_words_per_segment:
            segments.append({
                'context': f'segment_{len(segments)+1}',
                'text': chunk,
                'word_count': len(chunk.split()),
            })
    return segments

Step 2: Extract Function Word Frequency Profiles

Measure the frequency of each function word as a proportion of total words. This is the most stable and important feature category.

FUNCTION_WORDS = [
    # Articles
    'a', 'an', 'the',
    # Prepositions
    'at', 'by', 'for', 'from', 'in', 'of', 'on', 'to', 'with',
    'about', 'after', 'between', 'through', 'into', 'over', 'upon',
    # Conjunctions
    'and', 'but', 'or', 'nor', 'so', 'yet', 'although', 'because',
    'if', 'than', 'that', 'while',
    # Pronouns
    'i', 'me', 'my', 'we', 'us', 'our', 'you', 'your',
    'he', 'him', 'his', 'she', 'her', 'it', 'its',
    'they', 'them', 'their',
    # Auxiliaries
    'be', 'is', 'am', 'are', 'was', 'were', 'been',
    'have', 'has', 'had', 'do', 'does', 'did',
    'will', 'would', 'shall', 'should',
    'can', 'could', 'may', 'might', 'must',
    # Determiners
    'this', 'these', 'those', 'each', 'every',
    'some', 'any', 'no', 'all', 'both',
    # Adverbs (function-like)
    'not', 'very', 'also', 'then', 'there', 'here',
    'now', 'just', 'only', 'still', 'even',
    'already', 'always', 'never',
]

def extract_function_word_profile(text):
    """Extract function word frequencies as proportions of total words."""
    words = re.findall(r"\b[a-z']+\b", text.lower())
    total = len(words)
    if total == 0:
        return None
    word_counts = Counter(words)
    profile = {}
    for fw in FUNCTION_WORDS:
        profile[fw] = word_counts.get(fw, 0) / total
    # Also compute aggregate categories
    articles = sum(profile.get(w, 0) for w in ['a', 'an', 'the'])
    prepositions = sum(profile.get(w, 0) for w in [
        'at', 'by', 'for', 'from', 'in', 'of', 'on', 'to', 'with',
        'about', 'after', 'between', 'through', 'into', 'over', 'upon'])
    pronouns_1s = sum(profile.get(w, 0) for w in ['i', 'me', 'my'])
    pronouns_1p = sum(profile.get(w, 0) for w in ['we', 'us', 'our'])
    pronouns_3 = sum(profile.get(w, 0) for w in [
        'he', 'him', 'his', 'she', 'her', 'they', 'them', 'their'])
    profile['_articles_total'] = articles
    profile['_prepositions_total'] = prepositions
    profile['_pronouns_1s_total'] = pronouns_1s
    profile['_pronouns_1p_total'] = pronouns_1p
    profile['_pronouns_3_total'] = pronouns_3
    profile['_total_words'] = total
    profile['_function_word_density'] = sum(
        profile[fw] for fw in FUNCTION_WORDS)
    return profile

Interpreting function word profiles:

• Function word density (total function words / total words): Typically 40-60% of English prose. Higher density suggests more syntactically complex, connective writing. Lower density suggests more nominal, content-heavy writing.
• Pronoun ratios (1st singular vs. 1st plural vs. 3rd person): Reflects self-focus, group orientation, and narrative perspective respectively.
• Article rate: Higher article usage correlates with noun-heavy, descriptive writing and with Openness (Pennebaker & King, 1999).
• Conjunction patterns: Heavy "but/although/while" usage reflects contrastive thinking. Heavy "and/or" usage reflects additive thinking.

Step 3: Measure Sentence Structure Distributions

Capture not just average sentence length but the full distribution -- the shape reveals more about style than the mean alone.

import numpy as np
from scipy import stats as scipy_stats

def extract_sentence_structure(text):
    """Extract sentence-level structural features."""
    # Split into sentences (handles common abbreviations)
    sentences = re.split(r'(?<=[.!?])\s+(?=[A-Z])', text)
    sentences = [s.strip() for s in sentences if len(s.strip().split()) >= 3]

    if len(sentences) < 10:
        return {'_insufficient_sentences': True, 'sentence_count': len(sentences)}

    lengths = [len(s.split()) for s in sentences]
    lengths_arr = np.array(lengths)

    # Sentence-initial word patterns (reveals habitual openings)
    openers = [s.split()[0].lower() for s in sentences if s.split()]
    opener_counts = Counter(openers)
    top_openers = opener_counts.most_common(10)

    # Sentence type distribution
    question_rate = sum(1 for s in sentences if s.rstrip().endswith('?')) / len(sentences)
    exclamation_rate = sum(1 for s in sentences if s.rstrip().endswith('!')) / len(sentences)
    declarative_rate = 1.0 - question_rate - exclamation_rate

    return {
        'sentence_count': len(sentences),
        'mean_length': float(np.mean(lengths_arr)),
        'median_length': float(np.median(lengths_arr)),
        'std_length': float(np.std(lengths_arr)),
        'min_length': int(np.min(lengths_arr)),
        'max_length': int(np.max(lengths_arr)),
        'skewness': float(scipy_stats.skew(lengths_arr)),
        'kurtosis': float(scipy_stats.kurtosis(lengths_arr)),
        'iqr': float(np.percentile(lengths_arr, 75) - np.percentile(lengths_arr, 25)),
        'pct_short': float(np.mean(lengths_arr <= 10)),      # short sentences
        'pct_medium': float(np.mean((lengths_arr > 10) & (lengths_arr <= 25))),
        'pct_long': float(np.mean(lengths_arr > 25)),         # long sentences
        'question_rate': question_rate,
        'exclamation_rate': exclamation_rate,
        'declarative_rate': declarative_rate,
        'top_openers': top_openers,
        'length_distribution': lengths,  # raw data for histogram
    }

Interpreting sentence structure:

• Positive skewness: Most sentences are short with occasional long ones (common in informal writing).
• Negative skewness: Most sentences are long with occasional short punchy ones (common in academic/formal writing).
• High kurtosis: Sentence lengths cluster tightly around the mean (uniform rhythm).
• Low kurtosis: Wide variety of sentence lengths (varied rhythm).
• High question rate: Interrogative style, engagement-seeking.
• Top openers: Habitual sentence-initial words (e.g., frequent "I" openers vs. "The" openers) reveal deep syntactic habits.

Step 4: Compute Punctuation Pattern Profiles

Punctuation habits are highly individualized and relatively stable across contexts.

def extract_punctuation_profile(text):
    """Extract punctuation usage patterns."""
    total_chars = len(text)
    sentences = re.split(r'(?<=[.!?])\s+', text)
    sentence_count = max(len(sentences), 1)
    word_count = len(text.split())

    # Per-sentence rates (normalized by sentence count)
    # Per-word rates (normalized by word count)
    features = {
        'comma_per_sentence': text.count(',') / sentence_count,
        'semicolon_per_sentence': text.count(';') / sentence_count,
        'colon_per_sentence': text.count(':') / sentence_count,
        'dash_per_sentence': (text.count('--') + text.count('\u2014')) / sentence_count,
        'ellipsis_per_sentence': (text.count('...') + text.count('\u2026')) / sentence_count,
        'paren_per_sentence': text.count('(') / sentence_count,
        'quote_per_sentence': (text.count('"') + text.count('\u201c')) / (2 * sentence_count),

        # Rates per 1000 words
        'comma_per_1k': text.count(',') / word_count * 1000,
        'semicolon_per_1k': text.count(';') / word_count * 1000,
        'colon_per_1k': text.count(':') / word_count * 1000,
        'dash_per_1k': (text.count('--') + text.count('\u2014')) / word_count * 1000,
        'ellipsis_per_1k': (text.count('...') + text.count('\u2026')) / word_count * 1000,
        'paren_per_1k': text.count('(') / word_count * 1000,
        'exclamation_per_1k': text.count('!') / word_count * 1000,
        'question_per_1k': text.count('?') / word_count * 1000,

        # Ratios
        'excl_to_question_ratio': (
            text.count('!') / max(text.count('?'), 1)
        ),
        'total_punctuation_density': sum(
            text.count(p) for p in ',.;:!?'
        ) / max(word_count, 1),
    }
    return features

Interpreting punctuation profiles:

• High comma rate: Complex, multi-clause sentences (correlates with sentence length).
• Semicolon/colon usage: Formal or precise writing style. Many authors use these at near-zero rates.
• Dash and ellipsis usage: Conversational, thought-in-progress style. Highly variable and highly individual.
• Parenthetical usage: Aside-heavy writing, often academic or digressive.
• Exclamation-to-question ratio: Emphatic vs. interrogative orientation.

Step 5: Calculate Supplementary Features

These features add resolution to the fingerprint but are less stable than function words and punctuation.

def extract_supplementary_features(text):
    """Compute word-level and readability features."""
    words = re.findall(r"\b[a-z']+\b", text.lower())
    total = len(words)
    if total == 0:
        return None
    unique = set(words)

    # Word length distribution
    word_lengths = [len(w) for w in words]
    wl_arr = np.array(word_lengths)

    # Type-Token Ratio (for short texts) or MATTR (for long texts)
    ttr = len(unique) / total
    # Moving Average TTR for texts > 1000 words (window=500)
    mattr = None
    if total > 1000:
        window = 500
        ratios = []
        for i in range(0, total - window + 1, window // 2):
            chunk = words[i:i + window]
            ratios.append(len(set(chunk)) / len(chunk))
        mattr = float(np.mean(ratios))

    # Hapax legomena (words appearing exactly once)
    word_freq = Counter(words)
    hapax = sum(1 for w, c in word_freq.items() if c == 1)
    hapax_ratio = hapax / total

    # Syllable approximation for readability
    def approx_syllables(word):
        word = word.lower()
        count = len(re.findall(r'[aeiouy]+', word))
        if word.endswith('e'):
            count = max(count - 1, 1)
        return max(count, 1)

    syllables_per_word = np.mean([approx_syllables(w) for w in words])

    # Flesch-Kincaid Grade Level
    sentences = re.split(r'[.!?]+', text)
    sentences = [s for s in sentences if s.strip()]
    words_per_sentence = total / max(len(sentences), 1)
    fk_grade = 0.39 * words_per_sentence + 11.8 * syllables_per_word - 15.59

    return {
        'mean_word_length': float(np.mean(wl_arr)),
        'std_word_length': float(np.std(wl_arr)),
        'pct_short_words': float(np.mean(wl_arr <= 3)),
        'pct_long_words': float(np.mean(wl_arr >= 7)),
        'ttr': ttr,
        'mattr': mattr,
        'hapax_ratio': hapax_ratio,
        'syllables_per_word': float(syllables_per_word),
        'flesch_kincaid_grade': float(fk_grade),
    }

Step 6: Test Cross-Context Stability of All Features

This is the critical step that separates a fingerprint from a description. Compute each feature across the segments from Step 1, then measure stability using the coefficient of variation (CV = std / mean).

def compute_stability(segment_profiles, feature_keys):
    """Compute cross-context stability for each feature.
    segment_profiles: list of dicts, one per segment
    feature_keys: list of feature names to evaluate
    Returns: dict of {feature: {mean, std, cv, stable}} """
    stability = {}
    for key in feature_keys:
        values = [p[key] for p in segment_profiles if key in p and p[key] is not None]
        if len(values) < 2:
            stability[key] = {'mean': values[0] if values else None,
                              'std': None, 'cv': None, 'stable': None,
                              'n_segments': len(values)}
            continue
        arr = np.array(values, dtype=float)
        mean = float(np.mean(arr))
        std = float(np.std(arr, ddof=1))  # sample std
        cv = std / mean if mean != 0 else float('inf')
        stability[key] = {
            'mean': mean,
            'std': std,
            'cv': cv,
            'stable': cv < 0.30,  # CV < 0.30 = stable feature
            'n_segments': len(values),
            'values': values,
        }
    return stability

def classify_feature_stability(stability_results):
    """Classify features into stability tiers."""
    highly_stable = []   # CV < 0.15
    stable = []          # CV 0.15-0.30
    moderate = []        # CV 0.30-0.50
    unstable = []        # CV > 0.50
    for key, data in stability_results.items():
        if data['cv'] is None:
            continue
        if data['cv'] < 0.15:
            highly_stable.append((key, data))
        elif data['cv'] < 0.30:
            stable.append((key, data))
        elif data['cv'] < 0.50:
            moderate.append((key, data))
        else:
            unstable.append((key, data))
    return {
        'highly_stable': highly_stable,
        'stable': stable,
        'moderate': moderate,
        'unstable': unstable,
    }

Stability interpretation:

• Highly stable (CV < 0.15): Core fingerprint features. These define the author across contexts. Typically: common function words (the, of, and, to), total function word density, comma rate.
• Stable (CV 0.15-0.30): Reliable fingerprint features with some context sensitivity. Typically: pronoun ratios, sentence length mean/median, dash and parenthetical usage.
• Moderate (CV 0.30-0.50): Context-influenced features. Include in fingerprint with caveat. Typically: question rate, exclamation rate, some less frequent function words.
• Unstable (CV > 0.50): Exclude from fingerprint. These vary too much across contexts to be authorial markers. Report as "context-dependent features."

Step 7: Define the Stable Fingerprint and Syntactic Constraints

Assemble the fingerprint from stable features only, and translate into replicable syntactic constraints.

Fingerprint assembly rules:

1. Include ALL highly stable features (CV < 0.15)
2. Include stable features (CV 0.15-0.30)
3. Exclude unstable features (CV > 0.50) entirely
4. Include moderate features (CV 0.30-0.50) only as "secondary markers" with explicit variability notes
5. For each included feature, report: mean value, standard deviation across contexts, CV, and the range observed

Syntactic constraint derivation:

Convert the numeric fingerprint into prose constraints that a writer (human or AI) could follow:

Feature Type	Constraint Template
Function word density	"Use function words at approximately [X]% of total words (range: [min]-[max]%)"
Article rate	"Articles (a/an/the) should comprise approximately [X]% of words"
Pronoun balance	"First-person singular pronouns at [X]%, first-person plural at [Y]%, third-person at [Z]%"
Sentence length	"Target sentences of [mean] words on average (std [S]), with [X]% short (<10), [Y]% medium (10-25), [Z]% long (>25)"
Sentence length skewness	"Sentence length distribution should be [positively/negatively] skewed (skew=[X])"
Comma rate	"Use approximately [X] commas per sentence (range: [min]-[max])"
Dash/ellipsis usage	"[Frequent/occasional/rare] use of dashes ([X] per 1k words) and ellipses ([Y] per 1k words)"
Question/exclamation ratio	"Questions in [X]% of sentences, exclamations in [Y]%"
Vocabulary complexity	"Target Flesch-Kincaid grade [X], with [Y]% long words (7+ chars)"
Sentence openers	"Commonly begin sentences with: [top 5 opener words with frequencies]"

Step 8: Write the Report

Write all findings to docs/analysis/18-stylometric-fingerprinting.md.

Report Output Template

The final report MUST be written to docs/analysis/18-stylometric-fingerprinting.md with this structure:

# Stylometric Fingerprint

## Methodology
- **Approach:** Distributional analysis of function word frequencies, sentence structure, punctuation patterns, and supplementary lexical features
- **Corpus:** [N words total, N texts/documents, N contexts/topics, date range if available]
- **Segmentation:** [N segments of ~N words each, segmented by context/time/sequential]
- **Feature categories:** Function words (N features), sentence structure (N features), punctuation (N features), supplementary (N features)
- **Stability metric:** Coefficient of variation (CV) across segments; threshold CV < 0.30 for inclusion
- **Tools/approach:** [Custom Python implementation / stylo / JGAAP -- describe what was used]

## Corpus Suitability Assessment
- **Word count:** [N] words ([sufficient / marginal / insufficient])
- **Language:** [English / other]
- **Authorship:** [Single / multiple]
- **Context diversity:** [N contexts -- list them]
- **Sample count for stability:** [N segments]
- **Overall suitability:** [Suitable for full fingerprint / suitable with caveats / insufficient]

## Function Word Profile

### Top 20 Function Words by Frequency
| Rank | Word | Frequency (%) | CV Across Segments | Stability |
|------|------|--------------|--------------------|-----------|
| 1 | [word] | [X.XX%] | [X.XX] | [highly stable / stable / moderate / unstable] |
| ... | ... | ... | ... | ... |

### Function Word Category Totals
| Category | Rate (%) | CV | Stability |
|----------|---------|-----|-----------|
| Articles | [X.XX] | [X.XX] | [label] |
| Prepositions | [X.XX] | [X.XX] | [label] |
| Conjunctions | [X.XX] | [X.XX] | [label] |
| 1st person singular pronouns | [X.XX] | [X.XX] | [label] |
| 1st person plural pronouns | [X.XX] | [X.XX] | [label] |
| 3rd person pronouns | [X.XX] | [X.XX] | [label] |
| Auxiliaries | [X.XX] | [X.XX] | [label] |
| Total function word density | [X.XX] | [X.XX] | [label] |

## Sentence Structure Profile

| Metric | Value | CV | Stability |
|--------|-------|-----|-----------|
| Mean sentence length (words) | [X.X] | [X.XX] | [label] |
| Median sentence length | [X.X] | [X.XX] | [label] |
| Std sentence length | [X.X] | [X.XX] | [label] |
| Skewness | [X.XX] | [X.XX] | [label] |
| % short sentences (<=10 words) | [X.X%] | [X.XX] | [label] |
| % medium sentences (11-25 words) | [X.X%] | [X.XX] | [label] |
| % long sentences (>25 words) | [X.X%] | [X.XX] | [label] |
| Question rate | [X.X%] | [X.XX] | [label] |
| Exclamation rate | [X.X%] | [X.XX] | [label] |

### Habitual Sentence Openers
| Rank | Opener Word | Frequency (%) |
|------|------------|--------------|
| 1 | [word] | [X.X%] |
| ... | ... | ... |

## Punctuation Profile

| Feature | Rate (per 1k words) | CV | Stability |
|---------|---------------------|-----|-----------|
| Commas | [X.X] | [X.XX] | [label] |
| Semicolons | [X.X] | [X.XX] | [label] |
| Colons | [X.X] | [X.XX] | [label] |
| Dashes | [X.X] | [X.XX] | [label] |
| Ellipses | [X.X] | [X.XX] | [label] |
| Parentheses | [X.X] | [X.XX] | [label] |
| Total punctuation density | [X.XX] | [X.XX] | [label] |

## Supplementary Features

| Feature | Value | CV | Stability |
|---------|-------|-----|-----------|
| Mean word length | [X.XX] | [X.XX] | [label] |
| % short words (<=3 chars) | [X.X%] | [X.XX] | [label] |
| % long words (>=7 chars) | [X.X%] | [X.XX] | [label] |
| Type-token ratio / MATTR | [X.XX] | [X.XX] | [label] |
| Hapax ratio | [X.XX] | [X.XX] | [label] |
| Flesch-Kincaid grade | [X.X] | [X.XX] | [label] |

## Cross-Context Stability Summary

### Stability Tiers
| Tier | Count | Features |
|------|-------|----------|
| Highly stable (CV < 0.15) | [N] | [list] |
| Stable (CV 0.15-0.30) | [N] | [list] |
| Moderate (CV 0.30-0.50) | [N] | [list] |
| Unstable (CV > 0.50) | [N] | [list] |

### Fingerprint Reliability Assessment
- **Core fingerprint features:** [N] features with CV < 0.30
- **Fingerprint confidence:** [high / moderate / low] based on [corpus size, segment count, feature stability]
- **Most distinctive features:** [top 3-5 features that are both stable AND deviate most from typical English prose]

## The Stylometric Fingerprint

### Numeric Profile (Stable Features Only)
[Table of all features with CV < 0.30, showing mean, std, range]

### Syntactic Constraints for Replication
[Prose description of each stable feature translated into an actionable writing constraint, using the templates from Step 7]

Example format:
- **Function word density:** Use function words at approximately [X]% of total words (observed range: [min]-[max]%)
- **Sentence rhythm:** Target [mean] words per sentence with [description of distribution shape]
- **Pronoun balance:** [constraint]
- **Punctuation habits:** [constraint]
- **Vocabulary level:** [constraint]
- **Sentence openers:** [constraint]

### Exemplar Sentences
[3-5 sentences from the corpus that best exemplify the fingerprint -- sentences where the most stable features are at their mean values]

## Limitations and Caveats
- Stylometric fingerprints capture habitual patterns, not immutable traits. Style can shift over time, with audience, or with deliberate effort.
- Function word frequencies require [minimum word count] for reliable estimation. This corpus contained [N] words.
- [Stability was / was not] tested across multiple contexts. [If not: fingerprint may reflect genre constraints rather than personal style.]
- Cross-domain stability was measured across [N] segments. More diverse samples would strengthen confidence.
- This fingerprint should NOT be used for deanonymization, surveillance, or forensic attribution without proper validation using established tools (JGAAP, stylo) and expert review.
- Features marked "moderate" or "unstable" were excluded from / flagged in the core fingerprint.
- [Corpus-specific limitations from Step 1]

## References
- Mosteller, F. & Wallace, D.L. (1963). Inference in an Authorship Problem. *Journal of the American Statistical Association*, 58(302), 275-309.
- Burrows, J. (2002). 'Delta': A Measure of Stylistic Difference and a Guide to Likely Authorship. *Literary and Linguistic Computing*, 17(3), 267-287.
- Stamatatos, E. (2009). A Survey of Modern Authorship Attribution Methods. *Journal of the American Society for Information Science and Technology*, 60(3), 538-556.
- Eder, M. (2011). Style-markers in authorship attribution: A cross-language study of the authorial fingerprint. *Studies in Polish Linguistics*, 6, 99-114.
- Argamon, S. & Levitan, S. (2005). Measuring the usefulness of function words for authorship attribution. *Proceedings of the 2005 ACH/ALLC Conference*.
- Kestemont, M. (2014). Function words in authorship attribution: From black magic to theory? *Proceedings of the 3rd Workshop on Computational Linguistics for Literature*, 59-66.
- Eder, M., Rybicki, J. & Kestemont, M. (2016). Stylometry with R: A Package for Computational Text Analysis. *The R Journal*, 8(1), 107-121.
- Juola, P. (2006). Authorship Attribution. *Foundations and Trends in Information Retrieval*, 1(3), 233-334.
- Koppel, M., Schler, J. & Argamon, S. (2009). Computational methods in authorship attribution. *Journal of the American Society for Information Science and Technology*, 60(1), 9-26.

Good Patterns

• Use function words over content words -- function words are topic-independent and unconsciously produced, making them the most stable authorship markers across contexts and time
• Measure distributions, not just means -- a mean sentence length of 15 words could be all-15-word sentences or a mix of 5 and 25; the distribution shape (std, skewness, kurtosis) is part of the fingerprint
• Test cross-context stability -- compute each feature across multiple independent text segments and retain only features with CV < 0.30; unstable features are noise, not signal
• Compute multiple feature types -- combine function words (lexical), sentence structure (syntactic), and punctuation (orthographic) for a multi-dimensional fingerprint that is harder to spoof or misidentify
• Establish minimum feature sets -- define which features are sufficient for replication vs. which add resolution; the core set (top 20 function words + sentence length distribution + comma rate) is the minimum viable fingerprint
• Report confidence in stability -- a fingerprint from 3 segments is less reliable than one from 10; document the evidence base
• Translate numeric profiles into prose constraints -- raw frequencies are not actionable; "use 'the' at 6.2% of words" needs context like "slightly below typical English prose (6.5-7.0%)"
• Preserve the full distribution for each feature -- store per-segment values, not just the aggregate; this enables future stability re-testing with new data

Anti-Patterns

Anti-Pattern	Why It Fails	Instead
Using content/topic words as fingerprint features	Content words change with topic; "python" appears in tech discussions, not cooking forums	Use only function words and structural features that are topic-independent
Treating a single text sample as representative	One sample captures a single context, mood, and topic; it may be atypical	Require 3+ independent samples across contexts; test stability
Ignoring context effects on style	Professional emails vs. casual Reddit posts produce different function word distributions for the same person	Segment by context; measure within-context and cross-context stability separately
Over-fitting to a small corpus	With <2,500 words, function word frequencies are dominated by sampling noise	Enforce minimum corpus size; widen confidence intervals for small corpora
Assuming all features are equally stable	Some features (article rate) are highly stable; others (question rate) vary wildly by context	Measure CV for each feature; tier by stability; exclude unstable features
Computing only point estimates (means)	A mean without a standard deviation hides critical variability information	Report mean, std, CV, and full per-segment values for every feature
Using raw counts instead of proportions	Raw counts confound feature frequency with text length	Always normalize: frequency = count / total_words (or per sentence, per 1k words)
Including stopword removal in preprocessing	Stopwords ARE the signal in stylometry; removing them destroys the fingerprint	Never apply stopword removal to stylometric analysis
Claiming the fingerprint is immutable	Writing style shifts with age, education, audience adaptation, and deliberate effort	Frame as "habitual patterns observed in this corpus" not "permanent identity markers"
Using stylometric analysis for unauthorized deanonymization	Ethical and legal risks; function word profiles can identify individuals in anonymous corpora	Obtain consent; document ethical review; do not use for surveillance

Boundaries

This skill SHOULD produce:

• Function word frequency profiles with per-feature stability metrics (CV across segments)
• Sentence structure distributions (length mean, median, std, skewness, opener patterns)
• Punctuation pattern profiles (per-sentence and per-1k-word rates)
• Supplementary features (word length, TTR/MATTR, readability scores)
• Cross-context stability classification for every feature (highly stable / stable / moderate / unstable)
• A stable fingerprint composed only of features with CV < 0.30
• Syntactic constraints translated into prose replication instructions
• Confidence assessment based on corpus size, segment count, and feature stability
• Written report at docs/analysis/18-stylometric-fingerprinting.md

This skill should NOT:

• Use stylometric fingerprints for surveillance, deanonymization, or identification of individuals without consent
• Claim perfect or forensic-grade identification accuracy from this analysis alone (use validated tools like JGAAP or stylo for forensic applications)
• Include content words or topic-specific vocabulary in the fingerprint
• Treat a single text sample or single context as sufficient for a stable fingerprint
• Ignore that writing style can and does shift over time, with audience, and with deliberate effort
• Treat the fingerprint as an immutable identity marker rather than a snapshot of habitual patterns
• Skip the cross-context stability test (Step 6) without documenting why
• Produce a fingerprint from fewer than 2,500 words
• Apply stopword removal during preprocessing (function words are the primary signal)
• Present results without confidence caveats and stability classification

Insufficient Data Handling

digraph insufficient_data {
    rankdir=TB;
    node [shape=diamond, style=filled, fillcolor="#f0f0f0"];

    start [label="Total word count?", shape=diamond];
    tiny [label="< 1,000 words", shape=box, fillcolor="#ffcccc"];
    small [label="1,000-2,500 words", shape=box, fillcolor="#fff3cc"];
    marginal [label="2,500-5,000 words", shape=box, fillcolor="#ffffcc"];
    good [label="5,000-10,000 words", shape=box, fillcolor="#ccffcc"];
    optimal [label="10,000+ words", shape=box, fillcolor="#ccffcc"];

    start -> tiny [label="< 1,000"];
    start -> small [label="1,000-2,500"];
    start -> marginal [label="2,500-5,000"];
    start -> good [label="5,000-10,000"];
    start -> optimal [label="10,000+"];

    tiny_action [label="STOP: Report insufficient data.\nDo NOT compute fingerprint.\nReport only raw word count.", shape=box, fillcolor="#ffcccc"];
    small_action [label="Compute raw feature values only.\nDo NOT test stability.\nDo NOT define constraints.\nLabel all features UNRELIABLE.", shape=box, fillcolor="#fff3cc"];
    marginal_action [label="Compute features.\nStability test if 3+ segments possible.\nWiden CV threshold to 0.35.\nLabel fingerprint PRELIMINARY.", shape=box, fillcolor="#ffffcc"];
    good_action [label="Full analysis pipeline.\nStability test with 5+ segments.\nStandard CV threshold 0.30.\nModerate confidence.", shape=box, fillcolor="#ccffcc"];
    optimal_action [label="Full analysis pipeline.\nStability test with 5-10 segments.\nHighest confidence achievable.\nDiminishing returns beyond 20k.", shape=box, fillcolor="#ccffcc"];

    tiny -> tiny_action;
    small -> small_action;
    marginal -> marginal_action;
    good -> good_action;
    optimal -> optimal_action;
}

Condition	Action
Corpus < 1,000 words	STOP. Do NOT compute a fingerprint. Report only: total word count and a statement that the corpus is too small for stylometric analysis. Function word frequencies at this scale are dominated by sampling noise.
Corpus 1,000-2,500 words	Compute raw feature values (function word frequencies, sentence lengths, punctuation rates) as a descriptive summary only. Do NOT test cross-context stability (corpus cannot be meaningfully segmented). Do NOT derive syntactic constraints. Label all output as "descriptive only, not a stable fingerprint."
Corpus 2,500-5,000 words	Compute features. Attempt stability testing if the corpus can be divided into 3+ segments of 800+ words each. Widen the stability threshold to CV < 0.35 (more lenient due to smaller samples). Label the fingerprint as "preliminary" in all outputs.
Corpus 5,000-10,000 words	Full analysis pipeline. Divide into 5+ segments for stability testing. Use standard CV < 0.30 threshold. Moderate confidence in the fingerprint.
Corpus 10,000+ words	Full analysis with highest achievable confidence. 5-10 segments for robust stability testing. Diminishing returns beyond ~20,000 words for most features.
Single-context corpus	Proceed but flag prominently: "All text comes from a single context ([name it]). The fingerprint may reflect genre or situational constraints rather than personal authorial style. Cross-context stability could not be tested." Widen confidence intervals.
High variance in key features	If >50% of function words have CV > 0.30, the "fingerprint" is too noisy to be useful. Report: "Insufficient stylometric stability for a reliable fingerprint. The author's style varies substantially across the sampled contexts." List which features ARE stable (if any) as "partial fingerprint elements."
Fewer than 50 sentences	Sentence structure features are unreliable. Compute function word and punctuation profiles only. Skip sentence length distribution analysis. Note: "Insufficient sentences for structural analysis."
Fewer than 3 segments possible	Cannot test cross-context stability. Compute feature values but do NOT classify stability tiers. Report all features as "unvalidated for cross-context stability."

Common Mistakes

Mistake	Fix
Removing stopwords before stylometric analysis	NEVER remove stopwords. Function words (a, the, of, and, but) ARE the primary features. Stopword removal destroys the fingerprint.
Using only mean sentence length	Compute the full distribution: mean, median, std, skewness, kurtosis, and the short/medium/long percentage breakdown. Two authors can have the same mean with completely different distributions.
Treating all function words as equally informative	The top 10-20 most frequent function words are the most stable. Rare function words (e.g., "upon", "nor") have high variance in short texts. Weight by stability, not assumed importance.
Reporting a fingerprint without testing stability	A fingerprint from a single sample is just a description. Without cross-context stability testing, you do not know which features are authorial vs. contextual.
Computing TTR on a large corpus without MATTR	Standard TTR decreases mechanically as text length increases. For texts >1,000 words, use Moving Average TTR (MATTR) with a fixed window instead.
Normalizing by character count instead of word count	Function word frequencies should be word-count normalized (fw_count / total_words). Character-count normalization confounds function word frequency with word length.
Including quoted or cited text in the analysis	Quoted text reflects someone else's style. Strip quotations, citations, and clearly attributed material before analysis.
Conflating the fingerprint with identity	A stylometric fingerprint is a statistical summary of writing habits, not a unique identifier. Multiple authors can have similar profiles. Frame results as "characteristic patterns" not "unique identifiers."
Skipping the segmentation step	Without segmentation, you cannot assess stability, and without stability assessment, you do not have a fingerprint -- you have a snapshot.
Using fingerprint for forensic attribution without validated tools	This skill produces an exploratory fingerprint. Forensic attribution requires validated tools (JGAAP, stylo R package), proper experimental design, and expert review.

References

• Mosteller, F. & Wallace, D.L. (1963). Inference in an Authorship Problem. JASA, 58(302), 275-309.
• Burrows, J. (2002). 'Delta': A Measure of Stylistic Difference. LLC, 17(3), 267-287.
• Stamatatos, E. (2009). A Survey of Modern Authorship Attribution Methods. JASIST, 60(3), 538-556.
• Eder, M., Rybicki, J. & Kestemont, M. (2016). Stylometry with R. The R Journal, 8(1), 107-121.
• Kestemont, M. (2014). Function words in authorship attribution: From black magic to theory?
• Argamon, S. & Levitan, S. (2005). Measuring the usefulness of function words for authorship attribution.
• Juola, P. (2006). Authorship Attribution. Foundations and Trends in IR, 1(3), 233-334.
• Koppel, M., Schler, J. & Argamon, S. (2009). Computational methods in authorship attribution. JASIST, 60(1), 9-26.
• Introduction to stylometry with Python -- Programming Historian
• Stylometry with R: stylo package documentation
• JGAAP: Java Graphical Authorship Attribution Program
• Pennebaker, J.W. & King, L.A. (1999). Linguistic styles: Language use as an individual difference. JPSP, 77(6), 1296-1312.