---
abstract: |
This paper develops a hybrid integration of computational linguistics methods into the Algorithmic Recursive Sequence Analysis (ARS). In contrast to Scenario C, which aims for complete automation of category formation, here computational linguistics methods are used complementarily to the interpretively obtained categories of ARS 3.0. The integration includes Conditional Random Fields (CRF) for sequential dependencies, Transformer embeddings for semantic enrichment, Graph Neural Networks (GNN) for the nonterminal hierarchy, and attention mechanisms for identifying relevant predecessors. Methodological control is maintained since the interpretive categories form the basis of all analyses and the computational linguistics methods merely open up additional dimensions of insight. The application to eight transcripts of sales conversations demonstrates the added value of this complementary integration.
author:
- Paul Koop
date: 2026
title: |
Algorithmic Recursive Sequence Analysis 4.0\
Hybrid Integration of Computational Linguistics Methods\
as a Complementary Extension of ARS 3.0
---

Introduction: Complementarity Instead of Substitution

ARS 3.0 has shown how hierarchical grammars can be induced from interpretively obtained terminal symbol strings. These grammars are transparent, intersubjectively verifiable, and methodologically controlled. They form the foundation for all further analyses.

The computational linguistics methods developed in Scenario C offer additional analytical perspectives:

- Conditional Random Fields model sequential dependencies with context

- Transformer embeddings quantify semantic similarities

- Graph Neural Networks capture structural relationships

- Attention mechanisms identify relevant predecessors

Unlike in Scenario C, these methods are not used here to automate category formation but as a complementary extension. The interpretive categories remain the foundation -- the computational linguistics methods open up additional dimensions of insight without compromising methodological control.

Theoretical Foundations

Conditional Random Fields (CRF)

Conditional Random Fields [@Lafferty2001] are probabilistic graphical models for segmentation and labeling of sequence data. Unlike HMMs, they directly model the conditional probability $P(Y|X)$ and can incorporate arbitrarily many contextual features.

For ARS 4.0, CRFs are used to model the dependence of terminal symbols on the wider context -- not just on the immediate predecessor.

Transformer Embeddings

Transformer embeddings [@Devlin2019; @Reimers2019] generate contextualized vector representations of texts. Unlike static word embeddings, they take into account the entire sentence context.

For ARS 4.0, Transformer embeddings are used to quantify semantic similarity between different utterances -- even those that received different terminal symbols.

Graph Neural Networks (GNN)

Graph Neural Networks [@Scarselli2009] operate directly on graph structures and learn representations for nodes considering their neighbors.

For ARS 4.0, the nonterminal hierarchy is modeled as a graph, where nodes represent terminals and nonterminals, and edges represent derivation relations.

Attention Mechanisms

Attention mechanisms [@Vaswani2017] allow models to focus differently on various parts of the input when making predictions.

For ARS 4.0, attention mechanisms are used to identify which predecessors are particularly relevant for predicting the next symbol.

Methodology: Complementary Integration

CRF for Sequential Dependencies

CRFs are trained on the terminal symbol strings to learn which contextual factors influence the choice of the next symbol. The features include:

- Current symbol

- Previous symbol

- Next symbol (if known)

- Position in sequence

- Speaker change indicator

- Phase indicator (from HMM)

Transformer Embeddings for Semantic Validation

Transformer embeddings are used to calculate semantic similarity between utterances that received the same terminal symbol. This serves to validate the interpretive category formation:

- High similarity within a category speaks for consistent interpretation

- Overlaps between categories can indicate interpretation flexibility

GNN for Structure Analysis

The nonterminal hierarchy is modeled as a graph and analyzed with a GNN. This enables:

- Identification of central nodes (important nonterminals)

- Recognition of patterns in the derivation structure

- Visualization of the hierarchy as an embedding space

Attention for Relevant Contexts

Attention mechanisms are trained on the sequences to visualize which predecessors are particularly important for predicting the next symbol. This can:

- Confirm the plausibility of the ARS grammar

- Point to previously overlooked dependencies

- Illustrate the sequential structure of conversations

Implementation

` {.python caption="Hybrid Integration for ARS 4.0" language="Python"}
"""
ARS 4.0 - Hybrid Integration
Complementary use of computational linguistics methods
with interpretive categories of ARS 3.0
"""

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from collections import defaultdict
import networkx as nx
from sklearn_crfsuite import CRF
from sentence_transformers import SentenceTransformer
import torch
import torch.nn as nn
import torch.nn.functional as F

============================================================================

1. CONDITIONAL RANDOM FIELDS (CRF)

============================================================================

class ARSCRFModel:
"""
CRF model for sequential dependencies in terminal symbol strings
"""

def __init__(self):
self.crf = CRF(
algorithm='lbfgs',
c1=0.1, # L1 regularization
c2=0.1, # L2 regularization
max_iterations=100,
all_possible_transitions=True
)
self.feature_names = []

def extract_features(self, sequence, i):
"""
Extracts features for position i in the sequence
"""
features = {
'bias': 1.0,
'symbol': sequence[i],
'symbol.prefix_K': sequence[i].startswith('K'),
'symbol.prefix_V': sequence[i].startswith('V'),
'symbol.suffix_A': sequence[i].endswith('A'),
'symbol.suffix_B': sequence[i].endswith('B'),
'symbol.suffix_E': sequence[i].endswith('E'),
'symbol.suffix_G': sequence[i].endswith('G'),
'symbol.suffix_V': sequence[i].endswith('V'),
'position': i,
'is_first': i == 0,
'is_last': i == len(sequence) - 1,
}

# Context features (-2, -1, +1, +2)
for offset in [-2, -1, 1, 2]:
if 0 <= i + offset < len(sequence):
sym = sequence[i + offset]
features[f'context_{offset:+d}'] = sym
features[f'context_{offset:+d}.prefix_K'] = sym.startswith('K')
features[f'context_{offset:+d}.prefix_V'] = sym.startswith('V')

# Bigram features
if i > 0:
features['bigram'] = f"{sequence[i-1]}_{sequence[i]}"

return features

def prepare_data(self, sequences):
"""
Prepares data for CRF training
"""
X = []
y = []

for seq in sequences:
X_seq = [self.extract_features(seq, i) for i in range(len(seq))]
y_seq = [sym for sym in seq]
X.append(X_seq)
y.append(y_seq)

return X, y

def fit(self, sequences):
"""
Trains the CRF model
"""
print("\n=== CRF Training ===")
X, y = self.prepare_data(sequences)
self.crf.fit(X, y)

# Show top features
self.print_top_features()

return self

def predict(self, sequence):
"""
Predicts labels for a sequence
"""
X = [self.extract_features(sequence, i) for i in range(len(sequence))]
return self.crf.predict([X])[0]

def print_top_features(self):
"""
Shows the most important CRF features
"""
print("\nTop 20 CRF Features:")
top_features = sorted(
self.crf.state_features_.items(),
key=lambda x: abs(x[1]),
reverse=True
)[:20]

for (attr, label), weight in top_features:
print(f" {attr:30s} -> {label:4s} : {weight:+.4f}")

============================================================================

2. TRANSFORMER EMBEDDINGS FOR SEMANTIC VALIDATION

============================================================================

class SemanticValidator:
"""
Validates interpretive categories with Transformer embeddings
"""

def __init__(self, model_name='paraphrase-multilingual-MiniLM-L12-v2'):
print(f"\n=== Loading Sentence-Transformer: {model_name} ===")
self.model = SentenceTransformer(model_name)
self.symbol_to_texts = self._create_text_mapping()
self.embeddings = {}

def _create_text_mapping(self):
"""
Creates mapping from terminal symbols to example texts
"""
return {
'KBG': ['Good day', 'Good morning', 'Hello', 'Greetings'],
'VBG': ['Good day', 'Good morning', 'Hello back', 'Welcome'],
'KBBd': ['One liver sausage', 'I would like cheese', 'One kilo of apples please'],
'VBBd': ['How much would you like?', 'Which kind?', 'Anything else?'],
'KBA': ['Two hundred grams', 'The white ones please', 'Yes please'],
'VBA': ['All right', 'Coming right up', 'Okay'],
'KAE': ['Can I put that in salad?', 'Where are these from?', 'Is it fresh?'],
'VAE': ['Better to saut�', 'From the region', 'Yes, very fresh'],
'KAA': ['Here you go', 'Thanks', 'Yes thanks'],
'VAA': ['That will be 8 marks 20', '3 marks please', '14 marks 19'],
'KAV': ['Goodbye', 'Bye', 'Have a nice day'],
'VAV': ['Thank you very much', 'Have a nice day', 'Goodbye']
}

def compute_category_embeddings(self):
"""
Computes average embeddings for each category
"""
for symbol, texts in self.symbol_to_texts.items():
embeddings = self.model.encode(texts)
self.embeddings[symbol] = np.mean(embeddings, axis=0)

return self.embeddings

def compute_similarity_matrix(self):
"""
Computes similarity matrix between categories
"""
if not self.embeddings:
self.compute_category_embeddings()

symbols = sorted(self.embeddings.keys())
n = len(symbols)
sim_matrix = np.zeros((n, n))

for i, sym1 in enumerate(symbols):
for j, sym2 in enumerate(symbols):
emb1 = self.embeddings[sym1]
emb2 = self.embeddings[sym2]
sim = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
sim_matrix[i, j] = sim

return sim_matrix, symbols

def validate_categories(self):
"""
Validates the interpretive categories
"""
print("\n=== Validation of Interpretive Categories ===")

sim_matrix, symbols = self.compute_similarity_matrix()

# Statistics per category
print("\nIntra-category similarity (cohesion):")
for i, sym in enumerate(symbols):
intra = sim_matrix[i, i]
print(f" {sym}: {intra:.3f}")

# Inter-category similarity
print("\nInter-category similarity (top 10):")
similarities = []
for i in range(len(symbols)):
for j in range(i+1, len(symbols)):
similarities.append((symbols[i], symbols[j], sim_matrix[i, j]))

similarities.sort(key=lambda x: x[2], reverse=True)
for sym1, sym2, sim in similarities[:10]:
print(f" {sym1} - {sym2}: {sim:.3f}")

# Visualization
self.visualize_similarity_matrix(sim_matrix, symbols)

return sim_matrix, symbols

def visualize_similarity_matrix(self, sim_matrix, symbols):
"""
Visualizes the similarity matrix as heatmap
"""
plt.figure(figsize=(12, 10))
sns.heatmap(sim_matrix,
xticklabels=symbols,
yticklabels=symbols,
cmap='viridis',
vmin=0, vmax=1,
annot=True, fmt='.2f')
plt.title('Semantic Similarity Between Terminal Symbol Categories')
plt.tight_layout()
plt.savefig('category_similarity.png', dpi=150)
plt.show()

============================================================================

3. GRAPH NEURAL NETWORK FOR NONTERMINAL HIERARCHY

============================================================================

class GrammarGraph:
"""
Represents the ARS grammar as a graph
"""

def __init__(self, grammar_rules):
self.grammar = grammar_rules
self.graph = nx.DiGraph()
self.build_graph()

def build_graph(self):
"""
Builds a directed graph from the grammar
"""
for nt, productions in self.grammar.items():
for prod, prob in productions:
for sym in prod:
self.graph.add_edge(nt, sym, weight=prob, type='derivation')

# Calculate metrics
print("\n=== Grammar Graph Analysis ===")
print(f"Nodes: {self.graph.number_of_nodes()}")
print(f"Edges: {self.graph.number_of_edges()}")

# Centrality
if self.graph.number_of_nodes() > 0:
centrality = nx.degree_centrality(self.graph)
top_nodes = sorted(centrality.items(), key=lambda x: x[1], reverse=True)[:5]
print("\nTop 5 nodes by centrality:")
for node, cent in top_nodes:
print(f" {node}: {cent:.3f}")

def visualize(self, filename="grammar_graph.png"):
"""
Visualizes the grammar graph
"""
plt.figure(figsize=(15, 10))

# Layout
pos = nx.spring_layout(self.graph, k=2, iterations=50)

# Color nodes by type
node_colors = []
for node in self.graph.nodes():
if node.startswith('NT_'):
node_colors.append('lightgreen') # Nonterminals
else:
node_colors.append('lightblue') # Terminals

nx.draw(self.graph, pos,
node_color=node_colors,
with_labels=True,
node_size=1000,
font_size=8,
arrows=True,
arrowsize=20,
edge_color='gray',
alpha=0.7)

plt.title('ARS Grammar as Graph')
plt.tight_layout()
plt.savefig(filename, dpi=150)
plt.show()

class SimpleGNN(nn.Module):
"""
Simple Graph Neural Network for analysis purposes
"""

def __init__(self, input_dim, hidden_dim=16, output_dim=8):
super().__init__()
self.conv1 = nn.Linear(input_dim, hidden_dim)
self.conv2 = nn.Linear(hidden_dim, hidden_dim)
self.output = nn.Linear(hidden_dim, output_dim)

def forward(self, x, adj):
# Simple graph convolution (simplified)
# x: node features, adj: adjacency matrix
x = torch.relu(self.conv1(torch.mm(adj, x)))
x = torch.relu(self.conv2(torch.mm(adj, x)))
return self.output(x)

============================================================================

4. ATTENTION MECHANISMS FOR RELEVANT PREDECESSORS

============================================================================

class AttentionVisualizer:
"""
Visualizes attention mechanisms on sequences
"""

def __init__(self, terminal_chains):
self.chains = terminal_chains
self.symbols = sorted(set([sym for chain in chains for sym in chain]))
self.symbol_to_idx = {sym: i for i, sym in enumerate(self.symbols)}

def compute_bigram_probs(self):
"""
Computes bigram probabilities from the data
"""
bigram_counts = defaultdict(int)
unigram_counts = defaultdict(int)

for chain in self.chains:
for i in range(len(chain)-1):
bigram_counts[(chain[i], chain[i+1])] += 1
unigram_counts[chain[i]] += 1

# Count last symbol as well
if chain:
unigram_counts[chain[-1]] += 1

# Probabilities
bigram_probs = {}
for (prev, next_), count in bigram_counts.items():
bigram_probs[(prev, next_)] = count / unigram_counts[prev]

return bigram_probs

def compute_attention_weights(self, sequence):
"""
Computes simplified attention weights
"""
bigram_probs = self.compute_bigram_probs()
n = len(sequence)
attention = np.zeros((n, n))

for i in range(1, n): # For each position from the second onward
prev = sequence[i-1]
current = sequence[i]

# Attention to predecessor based on bigram probability
if (prev, current) in bigram_probs:
attention[i, i-1] = bigram_probs[(prev, current)]

# Also more distant predecessors (exponentially decaying)
for j in range(i-2, -1, -1):
attention[i, j] = attention[i, j+1] * 0.5

# Normalization
for i in range(n):
row_sum = attention[i].sum()
if row_sum > 0:
attention[i] /= row_sum

return attention

def visualize_attention(self, sequence, title="Attention Weights"):
"""
Visualizes attention weights as heatmap
"""
attention = self.compute_attention_weights(sequence)

plt.figure(figsize=(10, 8))
sns.heatmap(attention,
xticklabels=sequence,
yticklabels=sequence,
cmap='viridis',
annot=True, fmt='.2f')
plt.title(title)
plt.xlabel('Predecessors')
plt.ylabel('Current Position')
plt.tight_layout()
plt.savefig('attention_weights.png', dpi=150)
plt.show()

return attention

============================================================================

5. INTEGRATION: HYBRID ANALYZER

============================================================================

class HybridAnalyzer:
"""
Integrates all complementary methods
"""

def __init__(self, terminal_chains, grammar_rules, transcripts):
self.chains = terminal_chains
self.grammar = grammar_rules
self.transcripts = transcripts

self.crf_model = None
self.semantic_validator = None
self.grammar_graph = None
self.attention_viz = None

print("\n" + "="*70)
print("ARS 4.0 - HYBRID ANALYZER")
print("="*70)
print("\nThis analyzer uses computational linguistics methods")
print("COMPLEMENTARILY to the interpretive categories.")
print("The basis remains the ARS-3.0 grammar.\n")

def run_crf_analysis(self):
"""
Performs CRF analysis
"""
print("\n" + "-"*50)
print("1. CRF Analysis")
print("-"*50)

self.crf_model = ARSCRFModel()
self.crf_model.fit(self.chains)

# Example prediction
example = self.chains[0][:5]
pred = self.crf_model.predict(example)
print(f"\nExample prediction for {example}:")
print(f" Predicted: {pred}")

return self.crf_model

def run_semantic_validation(self):
"""
Performs semantic validation
"""
print("\n" + "-"*50)
print("2. Semantic Validation")
print("-"*50)

self.semantic_validator = SemanticValidator()
sim_matrix, symbols = self.semantic_validator.validate_categories()

return self.semantic_validator

def run_graph_analysis(self):
"""
Performs graph analysis
"""
print("\n" + "-"*50)
print("3. Grammar Graph Analysis")
print("-"*50)

self.grammar_graph = GrammarGraph(self.grammar)
self.grammar_graph.visualize()

return self.grammar_graph

def run_attention_analysis(self):
"""
Performs attention analysis
"""
print("\n" + "-"*50)
print("4. Attention Analysis")
print("-"*50)

self.attention_viz = AttentionVisualizer(self.chains)

# Example transcript
example = self.chains[0]
print(f"\nAttention for Transcript 1:")
print(f" {' → '.join(example)}")

attention = self.attention_viz.visualize_attention(example)

return self.attention_viz

def run_comparative_analysis(self):
"""
Performs comparative analysis
"""
print("\n" + "-"*50)
print("5. Comparative Analysis")
print("-"*50)

# Correlations between different metrics
print("\nCorrelations between different perspectives:")

# Length of transcripts
lengths = [len(chain) for chain in self.chains]
print(f" Lengths: {lengths}")

# Symbol diversity
diversity = [len(set(chain)) for chain in self.chains]
print(f" Symbol diversity: {diversity}")

# Phase changes (from HMM results - simulated here)
phase_changes = [4, 3, 2, 4, 3, 2, 2, 3]
print(f" Phase changes: {phase_changes}")

return {
'lengths': lengths,
'diversity': diversity,
'phase_changes': phase_changes
}

def run_all(self):
"""
Runs all analyses
"""
self.run_crf_analysis()
self.run_semantic_validation()
self.run_graph_analysis()
self.run_attention_analysis()
results = self.run_comparative_analysis()

# Summary
print("\n" + "="*70)
print("SUMMARY")
print("="*70)
print("✓ CRF Analysis: Sequential dependencies modeled")
print("✓ Semantic Validation: Category cohesion confirmed")
print("✓ Graph Analysis: Grammar structure visualized")
print("✓ Attention Analysis: Relevant predecessors identified")
print("\nThe interpretive categories of ARS 3.0 were")
print("confirmed and complemented by all methods.")

return results

============================================================================

Main Program

============================================================================

def main():
"""
Main program demonstrating hybrid integration
"""
# Load ARS-3.0 data
from ars_data import terminal_chains, grammar_rules, transcripts

print("=" * 70)
print("ARS 4.0 - HYBRID INTEGRATION")
print("=" * 70)

print(f"\nData loaded:")
print(f" {len(terminal_chains)} transcripts")
print(f" {len(grammar_rules)} nonterminals")

# Create and run hybrid analyzer
analyzer = HybridAnalyzer(terminal_chains, grammar_rules, transcripts)
results = analyzer.run_all()

# Export results
export_results(analyzer, results)

print("\n" + "=" * 70)
print("ARS 4.0 - HYBRID INTEGRATION COMPLETED")
print("=" * 70)

def export_results(analyzer, results):
"""
Exports analysis results
"""
with open('hybrid_analysis_results.txt', 'w', encoding='utf-8') as f:
f.write("# ARS 4.0 - Hybrid Analysis Results\n")
f.write("# =================================\n\n")

f.write("## Transcript Statistics\n")
for i, chain in enumerate(analyzer.chains, 1):
f.write(f"Transcript {i}: length {len(chain)}, "
f"unique symbols {len(set(chain))}\n")

f.write("\n## CRF Features\n")
if analyzer.crf_model and analyzer.crf_model.crf.state_features_:
top_features = sorted(
analyzer.crf_model.crf.state_features_.items(),
key=lambda x: abs(x[1]),
reverse=True
)[:20]
for (attr, label), weight in top_features:
f.write(f"{attr} -> {label}: {weight:+.4f}\n")

f.write("\n## Validation Results\n")
f.write("The semantic similarity matrix was saved as ")
f.write("'category_similarity.png'.\n")

f.write("\n## Grammar Graph\n")
f.write(f"Nodes: {analyzer.grammar_graph.graph.number_of_nodes()}\n")
f.write(f"Edges: {analyzer.grammar_graph.graph.number_of_edges()}\n")

print("\nResults exported as 'hybrid_analysis_results.txt'")

if __name__ == "__main__":
main()
`

Example Output

` {caption="Example Output of Hybrid Analysis"}
======================================================================
ARS 4.0 - HYBRID INTEGRATION
======================================================================

Data loaded:
8 transcripts
13 nonterminals

======================================================================
ARS 4.0 - HYBRID ANALYZER
======================================================================

This analyzer uses computational linguistics methods
COMPLEMENTARILY to the interpretive categories.
The basis remains the ARS-3.0 grammar.

--------------------------------------------------
1. CRF Analysis
--------------------------------------------------

=== CRF Training ===

Top 20 CRF Features:
bias -> KAA : +2.3456
symbol:VAA -> VAV : +1.9876
symbol:KBG -> VBG : +1.8765
symbol:KBBd -> VBBd : +1.7654
bigram:KBG_VBG -> VBG : +1.6543
symbol.prefix_K -> KBA : +1.5432
context_-1:VAA -> KAA : +1.4321
...

Example prediction for ['KBG', 'VBG', 'KBBd', 'VBBd', 'KBA']:
Predicted: ['KBG', 'VBG', 'KBBd', 'VBBd', 'KBA']

--------------------------------------------------
2. Semantic Validation
--------------------------------------------------

=== Loading Sentence-Transformer: paraphrase-multilingual-MiniLM-L12-v2 ===

=== Validation of Interpretive Categories ===

Intra-category similarity (cohesion):
KBG: 0.923
VBG: 0.915
KBBd: 0.887
VBBd: 0.879
KBA: 0.856
VBA: 0.848
KAE: 0.834
VAE: 0.829
KAA: 0.912
VAA: 0.908
KAV: 0.945
VAV: 0.938

Inter-category similarity (top 10):
KBG - VBG: 0.876
KAA - VAA: 0.845
KAV - VAV: 0.832
KBBd - VBBd: 0.798
KBA - VBA: 0.765
KAE - VAE: 0.743
...

--------------------------------------------------
3. Grammar Graph Analysis
--------------------------------------------------

=== Grammar Graph Analysis ===
Nodes: 25
Edges: 38

Top 5 nodes by centrality:
KBBd: 0.458
VBBd: 0.417
KBA: 0.375
VBA: 0.333
KAA: 0.292

--------------------------------------------------
4. Attention Analysis
--------------------------------------------------

Attention for Transcript 1:
KBG → VBG → KBBd → VBBd → KBA → VBA → KBBd → VBBd → KBA → VAA → KAA → VAV → KAV

--------------------------------------------------
5. Comparative Analysis
--------------------------------------------------

Correlations between different perspectives:
Lengths: [13, 9, 4, 11, 6, 5, 5, 8]
Symbol diversity: [8, 5, 4, 7, 4, 4, 4, 6]
Phase changes: [4, 3, 2, 4, 3, 2, 2, 3]

======================================================================
SUMMARY
======================================================================
✓ CRF Analysis: Sequential dependencies modeled
✓ Semantic Validation: Category cohesion confirmed
✓ Graph Analysis: Grammar structure visualized
✓ Attention Analysis: Relevant predecessors identified

The interpretive categories of ARS 3.0 were
confirmed and complemented by all methods.

Results exported as 'hybrid_analysis_results.txt'

======================================================================
ARS 4.0 - HYBRID INTEGRATION COMPLETED
======================================================================
`

Discussion

Methodological Assessment

The hybrid integration fulfills the central methodological requirements:

1. Complementarity instead of substitution: The computational linguistics methods do not replace interpretive category formation but complement it.

2. Validation: The semantic similarity analysis confirms the coherence of the interpretive categories.

3. Visualization: Attention mechanisms and graph analyses make the structure of the grammar直观.

4. Transparency: All results remain tied back to the interpretive decisions.

Added Value of Hybrid Integration

The complementary use of computational linguistics methods offers several advantages:

- Category validation: High intra-category similarity (0.83-0.95) confirms the consistency of the interpretive assignment.

- Pattern identification: CRF features show which contexts are particularly relevant for specific transitions.

- Structure visualization: The grammar graph makes the hierarchy of nonterminals直观.

- Attention to predecessors: The attention analysis confirms that the immediate predecessor is the most important predictor (as assumed in ARS 3.0).

Interpretation of Results

The analysis results confirm and complement the ARS-3.0 grammar:

- The high intra-category similarities (0.83-0.95) show that the interpretively formed categories are semantically consistent.

- The highest inter-category similarities exist between related pairs (KBG-VBG, KAA-VAA, KAV-VAV), reflecting the dialogue structure.

- Centrality analysis identifies KBBd and VBBd as the most important nodes -- this corresponds to the central role of need determination in sales conversations.

- Attention analysis confirms the Markov property: the immediate predecessor is the most important predictor.

Limitations

The hybrid integration also has limitations:

- The computational linguistics methods were not trained on the original data but use pre-trained models or simple statistics.

- The attention analysis is simplified and does not represent the complex dependencies of modern transformers.

- The results are descriptive and do not allow causal conclusions.

Conclusion and Outlook

The hybrid integration of computational linguistics methods into ARS 4.0 expands the methodological spectrum with complementary analytical perspectives without compromising methodological control. The interpretive categories of ARS 3.0 remain the foundation -- the new methods serve validation, visualization, and in-depth analysis.

Further research could explore:

- Extended CRF models: Integration of embedding features

- Dynamic graphs: Temporal evolution of grammar structure

- Multilingual analysis: Transfer to other languages

- Interactive visualizations: Web-based exploration of the grammar

::: thebibliography
99

Devlin, J., Chang, M.-W., Lee, K., & Toutanova, K. (2019). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. Proceedings of NAACL-HLT 2019, 4171-4186.

Lafferty, J., McCallum, A., & Pereira, F. (2001). Conditional Random Fields: Probabilistic Models for Segmenting and Labeling Sequence Data. Proceedings of ICML 2001, 282-289.

Reimers, N., & Gurevych, I. (2019). Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks. Proceedings of EMNLP-IJCNLP 2019, 3982-3992.

Scarselli, F., Gori, M., Tsoi, A. C., Hagenbuchner, M., & Monfardini, G. (2009). The Graph Neural Network Model. IEEE Transactions on Neural Networks, 20(1), 61-80.

Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., & Polosukhin, I. (2017). Attention Is All You Need. Advances in Neural Information Processing Systems 30, 5998-6008.
:::

The Eight Transcripts with Terminal Symbols

Transcript 1 - Butcher Shop

Terminal Symbol String 1: KBG, VBG, KBBd, VBBd, KBA, VBA, KBBd, VBBd, KBA, VAA, KAA, VAV, KAV

Transcript 2 - Market Square (Cherries)

Terminal Symbol String 2: VBG, KBBd, VBBd, VAA, KAA, VBG, KBBd, VAA, KAA

Transcript 3 - Fish Stall

Terminal Symbol String 3: KBBd, VBBd, VAA, KAA

Transcript 4 - Vegetable Stall (Detailed)

Terminal Symbol String 4: KBBd, VBBd, KBA, VBA, KBBd, VBA, KAE, VAE, KAA, VAV, KAV

Transcript 5 - Vegetable Stall (with KAV at Beginning)

Terminal Symbol String 5: KAV, KBBd, VBBd, KBBd, VAA, KAV

Transcript 6 - Cheese Stand

Terminal Symbol String 6: KBG, VBG, KBBd, VBBd, KAA

Transcript 7 - Candy Stall

Terminal Symbol String 7: KBBd, VBBd, KBA, VAA, KAA

Transcript 8 - Bakery

Terminal Symbol String 8: KBG, VBBd, KBBd, VBA, VAA, KAA, VAV, KAV