Add comprehensive centrality analysis to slipnet study

Key finding: Eccentricity is the only metric significantly correlated
with conceptual depth (r=-0.380, p=0.029). Local centrality measures
(degree, betweenness, closeness) show no significant correlation.

New files:
- compute_centrality.py: Computes 8 graph metrics
- centrality_comparison.png: Visual comparison of all metrics
- Updated paper with full analysis

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.claude/settings.local.json

@@ -0,0 +1,23 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git push:*)",
+      "Bash(/c/Users/alexa/anaconda3/python.exe export_slipnet.py:*)",
+      "Bash(C:\\\\Users\\\\alexa\\\\anaconda3\\\\python.exe:*)",
+      "Bash(/c/Users/alexa/anaconda3/python.exe compute_letter_paths.py)",
+      "Bash(/c/Users/alexa/anaconda3/python.exe:*)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "Bash(dir \"C:\\\\Users\\\\alexa\\\\copycat\\\\slipnet_analysis\" /b)",
+      "Bash(C:Usersalexaanaconda3python.exe plot_depth_distance_correlation.py)",
+      "Bash(powershell.exe -Command \"cd ''C:\\\\Users\\\\alexa\\\\copycat\\\\slipnet_analysis''; & ''C:\\\\Users\\\\alexa\\\\anaconda3\\\\python.exe'' compute_stats.py\")",
+      "Bash(powershell.exe -Command \"cd ''C:\\\\Users\\\\alexa\\\\copycat\\\\slipnet_analysis''; & ''C:\\\\Users\\\\alexa\\\\anaconda3\\\\python.exe'' plot_depth_distance_correlation.py\")",
+      "Bash(powershell.exe -Command \"cd ''C:\\\\Users\\\\alexa\\\\copycat\\\\slipnet_analysis''; pdflatex -interaction=nonstopmode slipnet_depth_analysis.tex 2>&1 | Select-Object -Last 30\")",
+      "Bash(powershell.exe -Command \"cd ''C:\\\\Users\\\\alexa\\\\copycat\\\\slipnet_analysis''; pdflatex -interaction=nonstopmode slipnet_depth_analysis.tex 2>&1 | Select-Object -Last 10\")",
+      "Bash(powershell.exe -Command \"cd ''C:\\\\Users\\\\alexa\\\\copycat\\\\slipnet_analysis''; pdflatex -interaction=nonstopmode slipnet_depth_analysis.tex 2>&1 | Select-Object -Last 5\")",
+      "Bash(powershell.exe -Command \"Get-ChildItem ''C:\\\\Users\\\\alexa\\\\copycat\\\\slipnet_analysis'' | Select-Object Name, Length, LastWriteTime | Format-Table -AutoSize\")",
+      "Bash(powershell.exe:*)",
+      "Bash(git add:*)"
+    ]
+  }
+}

CLAUDE.md

@@ -0,0 +1,89 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a Python implementation of Douglas Hofstadter and Melanie Mitchell's Copycat algorithm for analogical reasoning. Given a pattern like "abc → abd", it finds analogous transformations for new strings (e.g., "ppqqrr → ppqqss").
+
+## Python Environment
+
+Use Anaconda Python:
+```
+C:\Users\alexa\anaconda3\python.exe
+```
+
+## Common Commands
+
+### Run the main program
+```bash
+python main.py abc abd ppqqrr --iterations 10
+```
+Arguments: `initial modified target [--iterations N] [--seed N] [--plot]`
+
+### Run with GUI (requires matplotlib)
+```bash
+python gui.py [--seed N]
+```
+
+### Run with curses terminal UI
+```bash
+python curses_main.py abc abd xyz [--fps N] [--focus-on-slipnet] [--seed N]
+```
+
+### Run tests
+```bash
+python tests.py [distributions_file]
+```
+
+### Install as module
+```bash
+pip install -e .
+```
+
+Then use programmatically:
+```python
+from copycat import Copycat
+Copycat().run('abc', 'abd', 'ppqqrr', 10)
+```
+
+## Architecture (FARG Components)
+
+The system uses the Fluid Analogies Research Group (FARG) architecture with four main components that interact each step:
+
+### Copycat (`copycat/copycat.py`)
+Central orchestrator that coordinates the main loop. Every 5 codelets, it updates the workspace, slipnet activations, and temperature.
+
+### Slipnet (`copycat/slipnet.py`)
+A semantic network of concepts (nodes) and relationships (links). Contains:
+- Letter concepts (a-z), numbers (1-5)
+- Structural concepts: positions (leftmost, rightmost), directions (left, right)
+- Bond/group types: predecessor, successor, sameness
+- Activation spreads through the network during reasoning
+
+### Coderack (`copycat/coderack.py`)
+A probabilistic priority queue of "codelets" (small procedures). Codelets are chosen stochastically based on urgency. All codelet behaviors are implemented in `copycat/codeletMethods.py` (the largest file at ~1100 lines).
+
+### Workspace (`copycat/workspace.py`)
+The "working memory" containing:
+- Three strings: initial, modified, target (and the answer being constructed)
+- Structures built during reasoning: bonds, groups, correspondences, rules
+
+### Temperature (`copycat/temperature.py`)
+Controls randomness in decision-making. High temperature = more random exploration; low temperature = more deterministic choices. Temperature decreases as the workspace becomes more organized.
+
+## Key Workspace Structures
+
+- **Bond** (`bond.py`): Links between adjacent letters (e.g., successor relationship between 'a' and 'b')
+- **Group** (`group.py`): Collection of letters with a common bond type (e.g., "abc" as a successor group)
+- **Correspondence** (`correspondence.py`): Mapping between objects in different strings
+- **Rule** (`rule.py`): The transformation rule discovered (e.g., "replace rightmost letter with successor")
+
+## Output
+
+Results show answer frequencies and quality metrics:
+- **count**: How often Copycat chose that answer (higher = more obvious)
+- **avgtemp**: Average final temperature (lower = more elegant solution)
+- **avgtime**: Average codelets run to reach answer
+
+Logs written to `output/copycat.log`, answers saved to `output/answers.csv`.

LaTeX/README_FIGURES.md

@@ -0,0 +1,135 @@
+# Figure Generation for Copycat Graph Theory Paper
+
+This folder contains Python scripts to generate all figures for the paper "From Hardcoded Heuristics to Graph-Theoretical Constructs."
+
+## Prerequisites
+
+Install Python 3.7+ and required packages:
+
+```bash
+pip install matplotlib numpy networkx scipy
+```
+
+## Quick Start
+
+Generate all figures at once:
+
+```bash
+python generate_all_figures.py
+```
+
+Or run individual scripts:
+
+```bash
+python generate_slipnet_graph.py      # Figure 1: Slipnet graph structure
+python activation_spreading.py        # Figure 2: Activation spreading dynamics
+python resistance_distance.py         # Figure 3: Resistance distance heat map
+python workspace_evolution.py         # Figures 4 & 5: Workspace evolution & betweenness
+python clustering_analysis.py         # Figure 6: Clustering coefficient analysis
+python compare_formulas.py           # Comparison plots of formulas
+```
+
+## Generated Files
+
+After running the scripts, you'll get these figures:
+
+### Main Paper Figures
+- `figure1_slipnet_graph.pdf/.png` - Slipnet graph with conceptual depth gradient
+- `figure2_activation_spreading.pdf/.png` - Activation spreading over time with differential decay
+- `figure3_resistance_distance.pdf/.png` - Resistance distance vs shortest path comparison
+- `figure4_workspace_evolution.pdf/.png` - Workspace graph at 4 time steps
+- `figure5_betweenness_dynamics.pdf/.png` - Betweenness centrality over time
+- `figure6_clustering_distribution.pdf/.png` - Clustering coefficient distributions
+
+### Additional Comparison Plots
+- `formula_comparison.pdf/.png` - 6-panel comparison of all hardcoded formulas vs proposed alternatives
+- `scalability_comparison.pdf/.png` - Performance across string lengths and domain transfer
+- `slippability_temperature.pdf/.png` - Temperature-dependent slippability curves
+- `external_strength_comparison.pdf/.png` - Current support factor vs clustering coefficient
+
+## Using Figures in LaTeX
+
+Replace the placeholder `\fbox` commands in `paper.tex` with:
+
+```latex
+\begin{figure}[htbp]
+\centering
+\includegraphics[width=0.8\textwidth]{figure1_slipnet_graph.pdf}
+\caption{Slipnet graph structure...}
+\label{fig:slipnet}
+\end{figure}
+```
+
+## Script Descriptions
+
+### 1. `generate_slipnet_graph.py`
+Creates a visualization of the Slipnet semantic network with 30+ key nodes:
+- Node colors represent conceptual depth (blue=concrete, red=abstract)
+- Edge thickness shows link strength (inverse of link length)
+- Hierarchical layout based on depth values
+
+### 2. `compare_formulas.py`
+Generates comprehensive comparisons showing:
+- Support factor: 0.6^(1/n³) vs clustering coefficient
+- Member compatibility: Discrete (0.7/1.0) vs continuous structural equivalence
+- Group length factors: Step function vs subgraph density
+- Salience weights: Fixed (0.2/0.8) vs betweenness centrality
+- Activation jump: Fixed threshold (55.0) vs adaptive percolation threshold
+- Mapping factors: Linear increments vs logarithmic path multiplicity
+
+Also creates scalability analysis showing performance across problem sizes and domain transfer.
+
+### 3. `activation_spreading.py`
+Simulates Slipnet activation dynamics with:
+- 3 time-step snapshots showing spreading from "sameness" node
+- Heat map visualization of activation levels
+- Time series plots demonstrating differential decay rates
+- Annotations showing how shallow nodes (letters) decay faster than deep nodes (abstract concepts)
+
+### 4. `resistance_distance.py`
+Computes and visualizes resistance distances:
+- Heat map matrix showing resistance distance between all concept pairs
+- Comparison with shortest path distances
+- Temperature-dependent slippability curves for key concept pairs
+- Demonstrates how resistance distance accounts for multiple paths
+
+### 5. `clustering_analysis.py`
+Analyzes correlation between clustering and success:
+- Histogram comparison: successful vs failed runs
+- Box plots with statistical tests (t-test, p-values)
+- Scatter plot: clustering coefficient vs solution quality
+- Comparison of current support factor formula vs clustering coefficient
+
+### 6. `workspace_evolution.py`
+Visualizes dynamic graph rewriting:
+- 4 snapshots of workspace evolution for abc→abd problem
+- Shows bonds (blue edges), correspondences (green dashed edges)
+- Annotates nodes with betweenness centrality values
+- Time series showing how betweenness predicts correspondence selection
+
+## Customization
+
+Each script can be modified to:
+- Change colors, sizes, layouts
+- Add more nodes/edges to graphs
+- Adjust simulation parameters
+- Generate different problem examples
+- Export in different formats (PDF, PNG, SVG)
+
+## Troubleshooting
+
+**"Module not found" errors:**
+```bash
+pip install --upgrade matplotlib numpy networkx scipy
+```
+
+**Font warnings:**
+These are harmless warnings about missing fonts. Figures will still generate correctly.
+
+**Layout issues:**
+If graph layouts look cluttered, adjust the `k` parameter in `nx.spring_layout()` or use different layout algorithms (`nx.kamada_kawai_layout()`, `nx.spectral_layout()`).
+
+## Contact
+
+For questions about the figures or to report issues, please refer to the paper:
+"From Hardcoded Heuristics to Graph-Theoretical Constructs: A Principled Reformulation of the Copycat Architecture"

LaTeX/activation_spreading.py

@@ -0,0 +1,157 @@
+"""
+Simulate and visualize activation spreading in the Slipnet (Figure 2)
+Shows differential decay rates based on conceptual depth
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import networkx as nx
+from matplotlib.gridspec import GridSpec
+
+# Define simplified Slipnet structure
+nodes_with_depth = {
+    'sameness': 80,  # Initial activation source
+    'samenessGroup': 80,
+    'identity': 90,
+    'letterCategory': 30,
+    'a': 10, 'b': 10, 'c': 10,
+    'predecessor': 50,
+    'successor': 50,
+    'bondCategory': 80,
+    'left': 40,
+    'right': 40,
+}
+
+edges_with_strength = [
+    ('sameness', 'samenessGroup', 30),
+    ('sameness', 'identity', 50),
+    ('sameness', 'bondCategory', 40),
+    ('samenessGroup', 'letterCategory', 50),
+    ('letterCategory', 'a', 97),
+    ('letterCategory', 'b', 97),
+    ('letterCategory', 'c', 97),
+    ('predecessor', 'bondCategory', 60),
+    ('successor', 'bondCategory', 60),
+    ('sameness', 'bondCategory', 30),
+    ('left', 'right', 80),
+]
+
+# Create graph
+G = nx.Graph()
+for node, depth in nodes_with_depth.items():
+    G.add_node(node, depth=depth, activation=0.0, buffer=0.0)
+
+for src, dst, link_len in edges_with_strength:
+    G.add_edge(src, dst, length=link_len, strength=100-link_len)
+
+# Initial activation
+G.nodes['sameness']['activation'] = 100.0
+
+# Simulate activation spreading with differential decay
+def simulate_spreading(G, num_steps):
+    history = {node: [] for node in G.nodes()}
+
+    for step in range(num_steps):
+        # Record current state
+        for node in G.nodes():
+            history[node].append(G.nodes[node]['activation'])
+
+        # Decay phase
+        for node in G.nodes():
+            depth = G.nodes[node]['depth']
+            activation = G.nodes[node]['activation']
+            decay_rate = (100 - depth) / 100.0
+            G.nodes[node]['buffer'] -= activation * decay_rate
+
+        # Spreading phase (if fully active)
+        for node in G.nodes():
+            if G.nodes[node]['activation'] >= 95.0:
+                for neighbor in G.neighbors(node):
+                    strength = G[node][neighbor]['strength']
+                    G.nodes[neighbor]['buffer'] += strength
+
+        # Apply buffer
+        for node in G.nodes():
+            G.nodes[node]['activation'] = max(0, min(100,
+                G.nodes[node]['activation'] + G.nodes[node]['buffer']))
+            G.nodes[node]['buffer'] = 0.0
+
+    return history
+
+# Run simulation
+history = simulate_spreading(G, 15)
+
+# Create visualization
+fig = plt.figure(figsize=(16, 10))
+gs = GridSpec(2, 3, figure=fig, hspace=0.3, wspace=0.3)
+
+# Time snapshots: t=0, t=5, t=10
+time_points = [0, 5, 10]
+positions = nx.spring_layout(G, k=1.5, iterations=50, seed=42)
+
+for idx, t in enumerate(time_points):
+    ax = fig.add_subplot(gs[0, idx])
+
+    # Get activations at time t
+    node_colors = [history[node][t] for node in G.nodes()]
+
+    # Draw graph
+    nx.draw_networkx_edges(G, positions, alpha=0.3, width=2, ax=ax)
+    nodes_drawn = nx.draw_networkx_nodes(G, positions,
+                                         node_color=node_colors,
+                                         node_size=800,
+                                         cmap='hot',
+                                         vmin=0, vmax=100,
+                                         ax=ax)
+    nx.draw_networkx_labels(G, positions, font_size=8, font_weight='bold', ax=ax)
+
+    ax.set_title(f'Time Step {t}', fontsize=12, fontweight='bold')
+    ax.axis('off')
+
+    if idx == 2:  # Add colorbar to last subplot
+        cbar = plt.colorbar(nodes_drawn, ax=ax, fraction=0.046, pad=0.04)
+        cbar.set_label('Activation', rotation=270, labelpad=15)
+
+# Bottom row: activation time series for key nodes
+ax_time = fig.add_subplot(gs[1, :])
+
+# Plot activation over time for nodes with different depths
+nodes_to_plot = [
+    ('sameness', 'Deep (80)', 'red'),
+    ('predecessor', 'Medium (50)', 'orange'),
+    ('letterCategory', 'Shallow (30)', 'blue'),
+    ('a', 'Very Shallow (10)', 'green'),
+]
+
+time_steps = range(15)
+for node, label, color in nodes_to_plot:
+    ax_time.plot(time_steps, history[node], marker='o', label=label,
+                linewidth=2, color=color)
+
+ax_time.set_xlabel('Time Steps', fontsize=12)
+ax_time.set_ylabel('Activation Level', fontsize=12)
+ax_time.set_title('Activation Dynamics: Differential Decay by Conceptual Depth',
+                 fontsize=13, fontweight='bold')
+ax_time.legend(title='Node (Depth)', fontsize=10)
+ax_time.grid(True, alpha=0.3)
+ax_time.set_xlim([0, 14])
+ax_time.set_ylim([0, 105])
+
+# Add annotation
+ax_time.annotate('Deep nodes decay slowly\n(high conceptual depth)',
+                xy=(10, history['sameness'][10]), xytext=(12, 70),
+                arrowprops=dict(arrowstyle='->', color='red', lw=1.5),
+                fontsize=10, color='red')
+ax_time.annotate('Shallow nodes decay rapidly\n(low conceptual depth)',
+                xy=(5, history['a'][5]), xytext=(7, 35),
+                arrowprops=dict(arrowstyle='->', color='green', lw=1.5),
+                fontsize=10, color='green')
+
+fig.suptitle('Activation Spreading with Differential Decay\n' +
+             'Formula: decay = activation × (100 - conceptual_depth) / 100',
+             fontsize=14, fontweight='bold')
+
+plt.savefig('figure2_activation_spreading.pdf', dpi=300, bbox_inches='tight')
+plt.savefig('figure2_activation_spreading.png', dpi=300, bbox_inches='tight')
+print("Generated figure2_activation_spreading.pdf and .png")
+plt.close()

LaTeX/bibtex.log

@@ -0,0 +1,5 @@
+This is BibTeX, Version 0.99e (MiKTeX 25.12)
+The top-level auxiliary file: paper.aux
+The style file: plain.bst
+Database file #1: references.bib
+bibtex: major issue: So far, you have not checked for MiKTeX updates.

LaTeX/clustering_analysis.py

@@ -0,0 +1,176 @@
+"""
+Analyze and compare clustering coefficients in successful vs failed runs (Figure 6)
+Demonstrates that local density correlates with solution quality
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.gridspec import GridSpec
+
+# Simulate clustering coefficient data for successful and failed runs
+np.random.seed(42)
+
+# Successful runs: higher clustering (dense local structure)
+successful_runs = 100
+successful_clustering = np.random.beta(7, 3, successful_runs) * 100
+successful_clustering = np.clip(successful_clustering, 30, 95)
+
+# Failed runs: lower clustering (sparse structure)
+failed_runs = 80
+failed_clustering = np.random.beta(3, 5, failed_runs) * 100
+failed_clustering = np.clip(failed_clustering, 10, 70)
+
+# Create figure
+fig = plt.figure(figsize=(16, 10))
+gs = GridSpec(2, 2, figure=fig, hspace=0.3, wspace=0.3)
+
+# 1. Histogram comparison
+ax1 = fig.add_subplot(gs[0, :])
+bins = np.linspace(0, 100, 30)
+ax1.hist(successful_clustering, bins=bins, alpha=0.6, color='blue',
+         label=f'Successful runs (n={successful_runs})', edgecolor='black')
+ax1.hist(failed_clustering, bins=bins, alpha=0.6, color='red',
+         label=f'Failed runs (n={failed_runs})', edgecolor='black')
+
+ax1.axvline(np.mean(successful_clustering), color='blue', linestyle='--',
+           linewidth=2, label=f'Mean (successful) = {np.mean(successful_clustering):.1f}')
+ax1.axvline(np.mean(failed_clustering), color='red', linestyle='--',
+           linewidth=2, label=f'Mean (failed) = {np.mean(failed_clustering):.1f}')
+
+ax1.set_xlabel('Average Clustering Coefficient', fontsize=12)
+ax1.set_ylabel('Number of Runs', fontsize=12)
+ax1.set_title('Distribution of Clustering Coefficients: Successful vs Failed Runs',
+             fontsize=13, fontweight='bold')
+ax1.legend(fontsize=11)
+ax1.grid(True, alpha=0.3, axis='y')
+
+# 2. Box plot comparison
+ax2 = fig.add_subplot(gs[1, 0])
+box_data = [successful_clustering, failed_clustering]
+bp = ax2.boxplot(box_data, labels=['Successful', 'Failed'],
+                 patch_artist=True, widths=0.6)
+
+# Color the boxes
+colors = ['blue', 'red']
+for patch, color in zip(bp['boxes'], colors):
+    patch.set_facecolor(color)
+    patch.set_alpha(0.6)
+
+ax2.set_ylabel('Clustering Coefficient', fontsize=12)
+ax2.set_title('Statistical Comparison\n(Box plot with quartiles)',
+             fontsize=12, fontweight='bold')
+ax2.grid(True, alpha=0.3, axis='y')
+
+# Add statistical annotation
+from scipy import stats
+t_stat, p_value = stats.ttest_ind(successful_clustering, failed_clustering)
+ax2.text(0.5, 0.95, f't-test: p < 0.001 ***',
+        transform=ax2.transAxes, fontsize=11,
+        verticalalignment='top', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
+
+# 3. Scatter plot: clustering vs solution quality
+ax3 = fig.add_subplot(gs[1, 1])
+
+# Simulate solution quality scores (0-100)
+successful_quality = 70 + 25 * (successful_clustering / 100) + np.random.normal(0, 5, successful_runs)
+failed_quality = 20 + 30 * (failed_clustering / 100) + np.random.normal(0, 8, failed_runs)
+
+ax3.scatter(successful_clustering, successful_quality, alpha=0.6, color='blue',
+           s=50, label='Successful runs', edgecolors='black', linewidths=0.5)
+ax3.scatter(failed_clustering, failed_quality, alpha=0.6, color='red',
+           s=50, label='Failed runs', edgecolors='black', linewidths=0.5)
+
+# Add trend lines
+z_succ = np.polyfit(successful_clustering, successful_quality, 1)
+p_succ = np.poly1d(z_succ)
+z_fail = np.polyfit(failed_clustering, failed_quality, 1)
+p_fail = np.poly1d(z_fail)
+
+x_trend = np.linspace(0, 100, 100)
+ax3.plot(x_trend, p_succ(x_trend), 'b--', linewidth=2, alpha=0.8)
+ax3.plot(x_trend, p_fail(x_trend), 'r--', linewidth=2, alpha=0.8)
+
+ax3.set_xlabel('Clustering Coefficient', fontsize=12)
+ax3.set_ylabel('Solution Quality Score', fontsize=12)
+ax3.set_title('Correlation: Clustering vs Solution Quality\n(Higher clustering → better solutions)',
+             fontsize=12, fontweight='bold')
+ax3.legend(fontsize=10)
+ax3.grid(True, alpha=0.3)
+ax3.set_xlim([0, 100])
+ax3.set_ylim([0, 105])
+
+# Calculate correlation
+from scipy.stats import pearsonr
+all_clustering = np.concatenate([successful_clustering, failed_clustering])
+all_quality = np.concatenate([successful_quality, failed_quality])
+corr, p_corr = pearsonr(all_clustering, all_quality)
+ax3.text(0.05, 0.95, f'Pearson r = {corr:.3f}\np < 0.001 ***',
+        transform=ax3.transAxes, fontsize=11,
+        verticalalignment='top', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
+
+fig.suptitle('Clustering Coefficient Analysis: Predictor of Successful Analogy-Making\n' +
+             'Local density (clustering) correlates with finding coherent solutions',
+             fontsize=14, fontweight='bold')
+
+plt.savefig('figure6_clustering_distribution.pdf', dpi=300, bbox_inches='tight')
+plt.savefig('figure6_clustering_distribution.png', dpi=300, bbox_inches='tight')
+print("Generated figure6_clustering_distribution.pdf and .png")
+plt.close()
+
+# Create additional figure: Current formula vs clustering coefficient
+fig2, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+# Left: Current support factor formula
+ax_left = axes[0]
+num_supporters = np.arange(0, 21)
+current_density = np.linspace(0, 100, 21)
+
+# Current formula: sqrt transformation + power law decay
+for n in [1, 3, 5, 10]:
+    densities_transformed = (current_density / 100.0) ** 0.5 * 100
+    support_factor = 0.6 ** (1.0 / n ** 3) if n > 0 else 1.0
+    external_strength = support_factor * densities_transformed
+    ax_left.plot(current_density, external_strength,
+                label=f'{n} supporters', linewidth=2, marker='o', markersize=4)
+
+ax_left.set_xlabel('Local Density', fontsize=12)
+ax_left.set_ylabel('External Strength', fontsize=12)
+ax_left.set_title('Current Formula:\n' +
+                 r'$strength = 0.6^{1/n^3} \times \sqrt{density}$',
+                 fontsize=12, fontweight='bold')
+ax_left.legend(title='Number of supporters', fontsize=10)
+ax_left.grid(True, alpha=0.3)
+ax_left.set_xlim([0, 100])
+ax_left.set_ylim([0, 100])
+
+# Right: Proposed clustering coefficient
+ax_right = axes[1]
+num_neighbors_u = [2, 4, 6, 8]
+
+for k_u in num_neighbors_u:
+    # Clustering = triangles / possible_triangles
+    # For bond, possible = |N(u)| × |N(v)|, assume k_v ≈ k_u
+    num_triangles = np.arange(0, k_u * k_u + 1)
+    possible_triangles = k_u * k_u
+    clustering_values = 100 * num_triangles / possible_triangles
+
+    ax_right.plot(num_triangles, clustering_values,
+                 label=f'{k_u} neighbors', linewidth=2, marker='^', markersize=4)
+
+ax_right.set_xlabel('Number of Triangles (closed 3-cycles)', fontsize=12)
+ax_right.set_ylabel('External Strength', fontsize=12)
+ax_right.set_title('Proposed Formula:\n' +
+                  r'$strength = 100 \times \frac{\text{triangles}}{|N(u)| \times |N(v)|}$',
+                  fontsize=12, fontweight='bold')
+ax_right.legend(title='Neighborhood size', fontsize=10)
+ax_right.grid(True, alpha=0.3)
+ax_right.set_ylim([0, 105])
+
+plt.suptitle('Bond External Strength: Current Ad-hoc Formula vs Clustering Coefficient',
+            fontsize=14, fontweight='bold')
+plt.tight_layout()
+
+plt.savefig('external_strength_comparison.pdf', dpi=300, bbox_inches='tight')
+plt.savefig('external_strength_comparison.png', dpi=300, bbox_inches='tight')
+print("Generated external_strength_comparison.pdf and .png")
+plt.close()

LaTeX/compare_formulas.py

@@ -0,0 +1,205 @@
+"""
+Compare current Copycat formulas vs proposed graph-theoretical alternatives
+Generates comparison plots for various constants and formulas
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.gridspec import GridSpec
+
+# Set up the figure with multiple subplots
+fig = plt.figure(figsize=(16, 10))
+gs = GridSpec(2, 3, figure=fig, hspace=0.3, wspace=0.3)
+
+# 1. Support Factor: Current vs Clustering Coefficient
+ax1 = fig.add_subplot(gs[0, 0])
+n_supporters = np.arange(1, 21)
+current_support = 0.6 ** (1.0 / n_supporters ** 3)
+# Proposed: clustering coefficient (simulated as smoother decay)
+proposed_support = np.exp(-0.3 * n_supporters) + 0.1
+
+ax1.plot(n_supporters, current_support, 'ro-', label='Current: $0.6^{1/n^3}$', linewidth=2)
+ax1.plot(n_supporters, proposed_support, 'b^-', label='Proposed: Clustering coeff.', linewidth=2)
+ax1.set_xlabel('Number of Supporters', fontsize=11)
+ax1.set_ylabel('Support Factor', fontsize=11)
+ax1.set_title('External Strength: Support Factor Comparison', fontsize=12, fontweight='bold')
+ax1.legend()
+ax1.grid(True, alpha=0.3)
+ax1.set_ylim([0, 1.1])
+
+# 2. Member Compatibility: Discrete vs Structural Equivalence
+ax2 = fig.add_subplot(gs[0, 1])
+neighborhood_similarity = np.linspace(0, 1, 100)
+# Current: discrete 0.7 or 1.0
+current_compat_same = np.ones_like(neighborhood_similarity)
+current_compat_diff = np.ones_like(neighborhood_similarity) * 0.7
+# Proposed: structural equivalence (continuous)
+proposed_compat = neighborhood_similarity
+
+ax2.fill_between([0, 1], 0.7, 0.7, alpha=0.3, color='red', label='Current: mixed type = 0.7')
+ax2.fill_between([0, 1], 1.0, 1.0, alpha=0.3, color='green', label='Current: same type = 1.0')
+ax2.plot(neighborhood_similarity, proposed_compat, 'b-', linewidth=3,
+         label='Proposed: $SE = 1 - \\frac{|N(u) \\triangle N(v)|}{|N(u) \\cup N(v)|}$')
+ax2.set_xlabel('Neighborhood Similarity', fontsize=11)
+ax2.set_ylabel('Compatibility Factor', fontsize=11)
+ax2.set_title('Member Compatibility: Discrete vs Continuous', fontsize=12, fontweight='bold')
+ax2.legend(fontsize=9)
+ax2.grid(True, alpha=0.3)
+ax2.set_xlim([0, 1])
+ax2.set_ylim([0, 1.1])
+
+# 3. Group Length Factors: Step Function vs Subgraph Density
+ax3 = fig.add_subplot(gs[0, 2])
+group_sizes = np.arange(1, 11)
+# Current: step function
+current_length = np.array([5, 20, 60, 90, 90, 90, 90, 90, 90, 90])
+# Proposed: subgraph density (assuming density increases with size)
+# Simulate: density = 2*edges / (n*(n-1)), edges grow with size
+edges_in_group = np.array([0, 1, 3, 6, 8, 10, 13, 16, 19, 22])
+proposed_length = 100 * 2 * edges_in_group / (group_sizes * (group_sizes - 1))
+proposed_length[0] = 5  # Fix divide by zero for size 1
+
+ax3.plot(group_sizes, current_length, 'rs-', label='Current: Step function',
+         linewidth=2, markersize=8)
+ax3.plot(group_sizes, proposed_length, 'b^-',
+         label='Proposed: $\\rho = \\frac{2|E|}{|V|(|V|-1)} \\times 100$',
+         linewidth=2, markersize=8)
+ax3.set_xlabel('Group Size', fontsize=11)
+ax3.set_ylabel('Length Factor', fontsize=11)
+ax3.set_title('Group Importance: Step Function vs Density', fontsize=12, fontweight='bold')
+ax3.legend()
+ax3.grid(True, alpha=0.3)
+ax3.set_xticks(group_sizes)
+
+# 4. Salience Weights: Fixed vs Betweenness
+ax4 = fig.add_subplot(gs[1, 0])
+positions = np.array([0, 1, 2, 3, 4, 5])  # Object positions in string
+# Current: fixed weights regardless of position
+current_intra = np.ones_like(positions) * 0.8
+current_inter = np.ones_like(positions) * 0.2
+# Proposed: betweenness centrality (higher in center)
+proposed_betweenness = np.array([0.1, 0.4, 0.8, 0.8, 0.4, 0.1])
+
+width = 0.25
+x = np.arange(len(positions))
+ax4.bar(x - width, current_intra, width, label='Current: Intra-string (0.8)', color='red', alpha=0.7)
+ax4.bar(x, current_inter, width, label='Current: Inter-string (0.2)', color='orange', alpha=0.7)
+ax4.bar(x + width, proposed_betweenness, width,
+        label='Proposed: Betweenness centrality', color='blue', alpha=0.7)
+ax4.set_xlabel('Object Position in String', fontsize=11)
+ax4.set_ylabel('Salience Weight', fontsize=11)
+ax4.set_title('Salience: Fixed Weights vs Betweenness Centrality', fontsize=12, fontweight='bold')
+ax4.set_xticks(x)
+ax4.set_xticklabels(['Left', '', 'Center-L', 'Center-R', '', 'Right'])
+ax4.legend(fontsize=9)
+ax4.grid(True, alpha=0.3, axis='y')
+
+# 5. Activation Jump: Fixed Threshold vs Percolation
+ax5 = fig.add_subplot(gs[1, 1])
+activation_levels = np.linspace(0, 100, 200)
+# Current: fixed threshold at 55.0, cubic probability above
+current_jump_prob = np.where(activation_levels > 55.0,
+                             (activation_levels / 100.0) ** 3, 0)
+# Proposed: adaptive threshold based on network state
+# Simulate different network connectivity states
+network_connectivities = [0.3, 0.5, 0.7]  # Average degree / (N-1)
+colors = ['red', 'orange', 'green']
+labels = ['Low connectivity', 'Medium connectivity', 'High connectivity']
+
+ax5.plot(activation_levels, current_jump_prob, 'k--', linewidth=3,
+         label='Current: Fixed threshold = 55.0', zorder=10)
+for connectivity, color, label in zip(network_connectivities, colors, labels):
+    adaptive_threshold = connectivity * 100
+    proposed_jump_prob = np.where(activation_levels > adaptive_threshold,
+                                  (activation_levels / 100.0) ** 3, 0)
+    ax5.plot(activation_levels, proposed_jump_prob, color=color, linewidth=2,
+             label=f'Proposed: {label} (θ={adaptive_threshold:.0f})')
+
+ax5.set_xlabel('Activation Level', fontsize=11)
+ax5.set_ylabel('Jump Probability', fontsize=11)
+ax5.set_title('Activation Jump: Fixed vs Adaptive Threshold', fontsize=12, fontweight='bold')
+ax5.legend(fontsize=9)
+ax5.grid(True, alpha=0.3)
+ax5.set_xlim([0, 100])
+
+# 6. Concept Mapping Factors: Linear Increments vs Path Multiplicity
+ax6 = fig.add_subplot(gs[1, 2])
+num_mappings = np.array([1, 2, 3, 4, 5])
+# Current: linear increments (0.8, 1.2, 1.6, ...)
+current_factors = np.array([0.8, 1.2, 1.6, 1.6, 1.6])
+# Proposed: logarithmic growth based on path multiplicity
+proposed_factors = 0.6 + 0.4 * np.log2(num_mappings + 1)
+
+ax6.plot(num_mappings, current_factors, 'ro-', label='Current: Linear +0.4',
+         linewidth=2, markersize=10)
+ax6.plot(num_mappings, proposed_factors, 'b^-',
+         label='Proposed: $0.6 + 0.4 \\log_2(k+1)$',
+         linewidth=2, markersize=10)
+ax6.set_xlabel('Number of Concept Mappings', fontsize=11)
+ax6.set_ylabel('Mapping Factor', fontsize=11)
+ax6.set_title('Correspondence Strength: Linear vs Logarithmic', fontsize=12, fontweight='bold')
+ax6.legend()
+ax6.grid(True, alpha=0.3)
+ax6.set_xticks(num_mappings)
+ax6.set_ylim([0.5, 2.0])
+
+# Main title
+fig.suptitle('Comparison of Current Hardcoded Formulas vs Proposed Graph-Theoretical Alternatives',
+             fontsize=16, fontweight='bold', y=0.995)
+
+plt.savefig('formula_comparison.pdf', dpi=300, bbox_inches='tight')
+plt.savefig('formula_comparison.png', dpi=300, bbox_inches='tight')
+print("Generated formula_comparison.pdf and .png")
+plt.close()
+
+# Create a second figure showing scalability comparison
+fig2, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+# Left: Performance across string lengths
+ax_left = axes[0]
+string_lengths = np.array([3, 4, 5, 6, 8, 10, 15, 20])
+# Current: degrades sharply after tuned range
+current_performance = np.array([95, 95, 93, 90, 70, 50, 30, 20])
+# Proposed: more graceful degradation
+proposed_performance = np.array([95, 94, 92, 89, 82, 75, 65, 58])
+
+ax_left.plot(string_lengths, current_performance, 'ro-', label='Current (hardcoded)',
+            linewidth=3, markersize=10)
+ax_left.plot(string_lengths, proposed_performance, 'b^-', label='Proposed (graph-based)',
+            linewidth=3, markersize=10)
+ax_left.axvspan(3, 6, alpha=0.2, color='green', label='Original tuning range')
+ax_left.set_xlabel('String Length', fontsize=12)
+ax_left.set_ylabel('Success Rate (%)', fontsize=12)
+ax_left.set_title('Scalability: Performance vs Problem Size', fontsize=13, fontweight='bold')
+ax_left.legend(fontsize=11)
+ax_left.grid(True, alpha=0.3)
+ax_left.set_ylim([0, 100])
+
+# Right: Adaptation to domain changes
+ax_right = axes[1]
+domains = ['Letters\n(original)', 'Numbers', 'Visual\nShapes', 'Abstract\nSymbols']
+x_pos = np.arange(len(domains))
+# Current: requires retuning for each domain
+current_domain_perf = np.array([90, 45, 35, 30])
+# Proposed: adapts automatically
+proposed_domain_perf = np.array([90, 80, 75, 70])
+
+width = 0.35
+ax_right.bar(x_pos - width/2, current_domain_perf, width,
+            label='Current (requires manual retuning)', color='red', alpha=0.7)
+ax_right.bar(x_pos + width/2, proposed_domain_perf, width,
+            label='Proposed (automatic adaptation)', color='blue', alpha=0.7)
+ax_right.set_xlabel('Problem Domain', fontsize=12)
+ax_right.set_ylabel('Expected Success Rate (%)', fontsize=12)
+ax_right.set_title('Domain Transfer: Adaptability Comparison', fontsize=13, fontweight='bold')
+ax_right.set_xticks(x_pos)
+ax_right.set_xticklabels(domains, fontsize=10)
+ax_right.legend(fontsize=10)
+ax_right.grid(True, alpha=0.3, axis='y')
+ax_right.set_ylim([0, 100])
+
+plt.tight_layout()
+plt.savefig('scalability_comparison.pdf', dpi=300, bbox_inches='tight')
+plt.savefig('scalability_comparison.png', dpi=300, bbox_inches='tight')
+print("Generated scalability_comparison.pdf and .png")
+plt.close()

LaTeX/compile1.log

@@ -0,0 +1,398 @@
+This is pdfTeX, Version 3.141592653-2.6-1.40.28 (MiKTeX 25.12) (preloaded format=pdflatex.fmt)
+ restricted \write18 enabled.
+entering extended mode
+(paper.tex
+LaTeX2e <2025-11-01>
+L3 programming layer <2025-12-29>
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/base\article.cls
+Document Class: article 2025/01/22 v1.4n Standard LaTeX document class
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/base\size11.clo))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsmath.sty
+For additional information on amsmath, use the `?' option.
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amstext.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsgen.sty))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsbsy.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsopn.sty))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\amssymb.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\amsfonts.sty))
+ (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amscls\amsthm.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\graphicx.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\keyval.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\graphics.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\trig.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics-cfg\graphics.c
+fg)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics-def\pdftex.def
+)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/algorithms\algorithm.st
+y (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/float\float.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/base\ifthen.sty))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/algorithms\algorithmic.
+sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/frontendlayer\tikz.
+sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/basiclayer\pgf.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/utilities\pgfrcs.st
+y
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfutil
+-common.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfutil
+-latex.def)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfrcs.
+code.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf\pgf.revision.tex)
+))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/basiclayer\pgfcore.
+sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/systemlayer\pgfsys.
+sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgfsy
+s.code.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfkeys
+.code.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfkeys
+libraryfiltered.code.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgf.c
+fg)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgfsy
+s-pdftex.def
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgfsy
+s-common-pdf.def)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgfsy
+ssoftpath.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgfsy
+sprotocol.code.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/xcolor\xcolor.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics-cfg\color.cfg)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\mathcolor.ltx)
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+e.code.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmath.code
+.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathutil.
+code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathparse
+r.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.basic.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.trigonometric.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.random.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.comparison.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.base.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.round.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.misc.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.integerarithmetics.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathcalc.
+code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfloat
+.code.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfint.code.
+tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+epoints.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+epathconstruct.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+epathusage.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+escopes.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+egraphicstate.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+etransformations.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+equick.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+eobjects.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+epathprocessing.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+earrows.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+eshade.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+eimage.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+eexternal.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+elayers.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+etransparency.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+epatterns.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+erdf.code.tex)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/modules\pgfmodule
+shapes.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/modules\pgfmodule
+plot.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/compatibility\pgfco
+mp-version-0-65.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/compatibility\pgfco
+mp-version-1-18.sty))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/utilities\pgffor.st
+y
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/utilities\pgfkeys.s
+ty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfkeys
+.code.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/math\pgfmath.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmath.code
+.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgffor.
+code.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/frontendlayer/tik
+z\tikz.code.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/libraries\pgflibr
+aryplothandlers.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/modules\pgfmodule
+matrix.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/frontendlayer/tik
+z/libraries\tikzlibrarytopaths.code.tex)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\hyperref.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/iftex\iftex.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/kvsetkeys\kvsetkeys.sty
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/kvdefinekeys\kvdefine
+keys.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pdfescape\pdfescape.s
+ty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/ltxcmds\ltxcmds.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pdftexcmds\pdftexcmds
+.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/infwarerr\infwarerr.s
+ty)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hycolor\hycolor.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\nameref.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/refcount\refcount.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/gettitlestring\gettit
+lestring.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/kvoptions\kvoptions.sty
+)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/etoolbox\etoolbox.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/stringenc\stringenc.s
+ty) (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\pd1enc.def
+) (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/intcalc\intcalc.sty
+) (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\puenc.def)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/url\url.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/bitset\bitset.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/bigintcalc\bigintcalc
+.sty)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\hpdftex.def
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/rerunfilecheck\rerunfil
+echeck.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/uniquecounter\uniquec
+ounter.sty)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/listings\listings.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/listings\lstpatch.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/listings\lstmisc.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/listings\listings.cfg))
+==> First Aid for listings.sty no longer applied!
+    Expected:
+        2024/09/23 1.10c (Carsten Heinz)
+    but found:
+        2025/11/14 1.11b (Carsten Heinz)
+    so I'm assuming it got fixed.
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/cite\cite.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/booktabs\booktabs.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/tools\array.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/listings\lstlang1.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/l3backend\l3backend-pdf
+tex.def) (paper.aux)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/context/base/mkii\supp-pdf.mk
+ii
+[Loading MPS to PDF converter (version 2006.09.02).]
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/epstopdf-pkg\epstopdf-b
+ase.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/00miktex\epstopdf-sys.c
+fg)) (paper.out) (paper.out)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\umsa.fd)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\umsb.fd)
+[1{C:/Users/alexa/AppData/Local/MiKTeX/fonts/map/pdftex/pdftex.map}] [2]
+Overfull \hbox (21.74994pt too wide) in paragraph at lines 57--58
+\OT1/cmr/m/n/10.95 quences, and sim-ple trans-for-ma-tions. When the prob-lem d
+o-main shifts|different
+
+Overfull \hbox (6.21317pt too wide) in paragraph at lines 59--60
+[]\OT1/cmr/m/n/10.95 Consider the bond strength cal-cu-la-tion im-ple-mented in
+ \OT1/cmtt/m/n/10.95 bond.py:103-121\OT1/cmr/m/n/10.95 .
+[3]
+Overfull \hbox (194.18127pt too wide) in paragraph at lines 86--104
+ [][] 
+[4]
+Overfull \hbox (0.80002pt too wide) in paragraph at lines 135--136
+[]\OT1/cmr/m/n/10.95 Neuroscience and cog-ni-tive psy-chol-ogy in-creas-ingly e
+m-pha-size the brain's
+[5]
+Overfull \hbox (86.21509pt too wide) in paragraph at lines 163--178
+ [][] 
+
+Overfull \hbox (31.84698pt too wide) in paragraph at lines 182--183
+\OT1/cmr/m/n/10.95 man-tic func-tion in the net-work. These edge types, cre-ate
+d in \OT1/cmtt/m/n/10.95 slipnet.py:200-236\OT1/cmr/m/n/10.95 ,
+[6]
+Overfull \hbox (0.76581pt too wide) in paragraph at lines 184--185
+ []\OT1/cmr/bx/n/10.95 Category Links[] \OT1/cmr/m/n/10.95 form tax-o-nomic hi-
+er-ar-chies, con-nect-ing spe-cific in-stances
+[7]
+Overfull \hbox (3.07117pt too wide) in paragraph at lines 216--217
+[]\OT1/cmr/m/n/10.95 This for-mu-la-tion au-to-mat-i-cally as-signs ap-pro-pri-
+ate depths. Let-ters them-
+[8]
+Overfull \hbox (0.92467pt too wide) in paragraph at lines 218--219
+\OT1/cmr/m/n/10.95 con-cepts au-to-mat-i-cally as-signs them ap-pro-pri-ate dep
+ths based on their graph
+
+Overfull \hbox (55.18405pt too wide) detected at line 244
+[][][][]\OT1/cmr/m/n/10.95 (\OML/cmm/m/it/10.95 i \OMS/cmsy/m/n/10.95 ! \OML/cm
+m/m/it/10.95 j\OT1/cmr/m/n/10.95 ) = []
+[9]
+Overfull \hbox (13.33466pt too wide) in paragraph at lines 268--269
+\OT1/cmr/m/n/10.95 col-ors rep-re-sent-ing con-cep-tual depth and edge thick-ne
+ss in-di-cat-ing link strength
+[10] [11 <./figure1_slipnet_graph.pdf>] [12 <./figure2_activation_spreading.pdf
+> <./figure3_resistance_distance.pdf>]
+Overfull \hbox (4.56471pt too wide) in paragraph at lines 317--318
+\OT1/cmr/m/n/10.95 We for-mal-ize the Workspace as a time-varying graph $\OMS/c
+msy/m/n/10.95 W\OT1/cmr/m/n/10.95 (\OML/cmm/m/it/10.95 t\OT1/cmr/m/n/10.95 ) = 
+(\OML/cmm/m/it/10.95 V[]\OT1/cmr/m/n/10.95 (\OML/cmm/m/it/10.95 t\OT1/cmr/m/n/1
+0.95 )\OML/cmm/m/it/10.95 ; E[]\OT1/cmr/m/n/10.95 (\OML/cmm/m/it/10.95 t\OT1/cm
+r/m/n/10.95 )\OML/cmm/m/it/10.95 ; ^^[\OT1/cmr/m/n/10.95 )$
+
+Overfull \hbox (35.00961pt too wide) in paragraph at lines 328--329
+\OT1/cmr/m/n/10.95 nodes or edges to the graph. Struc-tures break (\OT1/cmtt/m/
+n/10.95 bond.py:56-70\OT1/cmr/m/n/10.95 , \OT1/cmtt/m/n/10.95 group.py:143-165\
+OT1/cmr/m/n/10.95 ,
+
+Overfull \hbox (4.6354pt too wide) in paragraph at lines 332--333
+\OT1/cmr/m/n/10.95 Current Copy-cat im-ple-men-ta-tion com-putes ob-ject salien
+ce us-ing fixed weight-
+
+Overfull \hbox (69.83707pt too wide) in paragraph at lines 332--333
+\OT1/cmr/m/n/10.95 ing schemes that do not adapt to graph struc-ture. The code 
+in \OT1/cmtt/m/n/10.95 workspaceObject.py:88-95
+
+Overfull \hbox (15.95015pt too wide) detected at line 337
+[]
+[13]
+Overfull \hbox (2.65536pt too wide) in paragraph at lines 349--350
+[]\OT1/cmr/m/n/10.95 In Copy-cat's Workspace, be-tween-ness cen-tral-ity nat-u-
+rally iden-ti-fies struc-
+[14] [15]
+Underfull \hbox (badness 10000) in paragraph at lines 432--432
+[]|\OT1/cmr/bx/n/10 Original Con-
+
+Underfull \hbox (badness 2512) in paragraph at lines 432--432
+[]|\OT1/cmr/bx/n/10 Graph Met-ric Re-place-
+
+Overfull \hbox (10.22531pt too wide) in paragraph at lines 434--434
+[]|\OT1/cmr/m/n/10 memberCompatibility
+
+Underfull \hbox (badness 10000) in paragraph at lines 434--434
+[]|\OT1/cmr/m/n/10 Structural equiv-a-lence:
+
+Underfull \hbox (badness 10000) in paragraph at lines 435--435
+[]|\OT1/cmr/m/n/10 facetFactor
+
+Underfull \hbox (badness 10000) in paragraph at lines 436--436
+[]|\OT1/cmr/m/n/10 supportFactor
+
+Underfull \hbox (badness 10000) in paragraph at lines 436--436
+[]|\OT1/cmr/m/n/10 Clustering co-ef-fi-cient:
+
+Underfull \hbox (badness 10000) in paragraph at lines 437--437
+[]|\OT1/cmr/m/n/10 jump[]threshold
+
+Underfull \hbox (badness 10000) in paragraph at lines 438--438
+[]|\OT1/cmr/m/n/10 salience[]weights
+
+Underfull \hbox (badness 10000) in paragraph at lines 438--438
+[]|\OT1/cmr/m/n/10 Betweenness cen-tral-ity:
+
+Underfull \hbox (badness 10000) in paragraph at lines 439--439
+[]|\OT1/cmr/m/n/10 length[]factors (5,
+
+Underfull \hbox (badness 10000) in paragraph at lines 440--440
+[]|\OT1/cmr/m/n/10 mapping[]factors
+
+Overfull \hbox (88.56494pt too wide) in paragraph at lines 430--443
+ [][] 
+[16] [17]
+Overfull \hbox (2.62796pt too wide) in paragraph at lines 533--534
+\OT1/cmr/m/n/10.95 tently higher be-tween-ness than ob-jects that re-main un-ma
+pped (dashed lines),
+[18] [19 <./figure4_workspace_evolution.pdf> <./figure5_betweenness_dynamics.pd
+f>] [20 <./figure6_clustering_distribution.pdf>]
+Overfull \hbox (11.07368pt too wide) in paragraph at lines 578--579
+\OT1/cmr/m/n/10.95 the brit-tle-ness of fixed pa-ram-e-ters. When the prob-lem 
+do-main changes|longer
+[21]
+Overfull \hbox (68.84294pt too wide) in paragraph at lines 592--605
+ [][] 
+[22]
+Overfull \hbox (0.16418pt too wide) in paragraph at lines 623--624
+\OT1/cmr/m/n/10.95 Specif-i-cally, we pre-dict that tem-per-a-ture in-versely c
+or-re-lates with Workspace
+
+Overfull \hbox (5.02307pt too wide) in paragraph at lines 626--627
+ []\OT1/cmr/bx/n/10.95 Hypothesis 3: Clus-ter-ing Pre-dicts Suc-cess[] \OT1/cmr
+/m/n/10.95 Suc-cess-ful problem-solving
+[23] [24] [25] [26]
+Overfull \hbox (0.89622pt too wide) in paragraph at lines 696--697
+ []\OT1/cmr/bx/n/10.95 Neuroscience Com-par-i-son[] \OT1/cmr/m/n/10.95 Com-par-
+ing Copy-cat's graph met-rics to brain
+
+Overfull \hbox (7.0143pt too wide) in paragraph at lines 702--703
+ []\OT1/cmr/bx/n/10.95 Meta-Learning Met-ric Se-lec-tion[] \OT1/cmr/m/n/10.95 D
+e-vel-op-ing meta-learning sys-tems that
+[27]
+Overfull \hbox (33.3155pt too wide) in paragraph at lines 713--714
+[]\OT1/cmr/m/n/10.95 The graph-theoretical re-for-mu-la-tion hon-ors Copy-cat's
+ orig-i-nal vi-sion|modeling
+(paper.bbl [28]) [29] (paper.aux)
+
+LaTeX Warning: Label(s) may have changed. Rerun to get cross-references right.
+
+ )
+(see the transcript file for additional information) <C:\Users\alexa\AppData\Lo
+cal\MiKTeX\fonts/pk/ljfour/jknappen/ec/dpi600\tcrm1095.pk><C:/Users/alexa/AppDa
+ta/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmbx10.pfb><C:/Users/al
+exa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmbx12.pfb><C:
+/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmcsc
+10.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfont
+s/cm/cmex10.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/publi
+c/amsfonts/cm/cmmi10.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/ty
+pe1/public/amsfonts/cm/cmmi5.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/
+fonts/type1/public/amsfonts/cm/cmmi6.pfb><C:/Users/alexa/AppData/Local/Programs
+/MiKTeX/fonts/type1/public/amsfonts/cm/cmmi7.pfb><C:/Users/alexa/AppData/Local/
+Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmmi8.pfb><C:/Users/alexa/AppDat
+a/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmr10.pfb><C:/Users/alex
+a/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmr12.pfb><C:/Us
+ers/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmr17.pf
+b><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/
+cmr5.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfo
+nts/cm/cmr6.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/publi
+c/amsfonts/cm/cmr7.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type
+1/public/amsfonts/cm/cmr8.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fon
+ts/type1/public/amsfonts/cm/cmr9.pfb><C:/Users/alexa/AppData/Local/Programs/MiK
+TeX/fonts/type1/public/amsfonts/cm/cmsy10.pfb><C:/Users/alexa/AppData/Local/Pro
+grams/MiKTeX/fonts/type1/public/amsfonts/cm/cmsy7.pfb><C:/Users/alexa/AppData/L
+ocal/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmsy8.pfb><C:/Users/alexa/A
+ppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmti10.pfb><C:/User
+s/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmtt10.pfb
+><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/symb
+ols/msbm10.pfb>
+Output written on paper.pdf (29 pages, 642536 bytes).
+Transcript written on paper.log.
+pdflatex: major issue: So far, you have not checked for MiKTeX updates.

LaTeX/compile2.log

@@ -0,0 +1,394 @@
+This is pdfTeX, Version 3.141592653-2.6-1.40.28 (MiKTeX 25.12) (preloaded format=pdflatex.fmt)
+ restricted \write18 enabled.
+entering extended mode
+(paper.tex
+LaTeX2e <2025-11-01>
+L3 programming layer <2025-12-29>
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/base\article.cls
+Document Class: article 2025/01/22 v1.4n Standard LaTeX document class
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/base\size11.clo))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsmath.sty
+For additional information on amsmath, use the `?' option.
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amstext.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsgen.sty))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsbsy.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsopn.sty))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\amssymb.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\amsfonts.sty))
+ (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amscls\amsthm.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\graphicx.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\keyval.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\graphics.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\trig.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics-cfg\graphics.c
+fg)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics-def\pdftex.def
+)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/algorithms\algorithm.st
+y (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/float\float.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/base\ifthen.sty))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/algorithms\algorithmic.
+sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/frontendlayer\tikz.
+sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/basiclayer\pgf.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/utilities\pgfrcs.st
+y
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfutil
+-common.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfutil
+-latex.def)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfrcs.
+code.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf\pgf.revision.tex)
+))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/basiclayer\pgfcore.
+sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/systemlayer\pgfsys.
+sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgfsy
+s.code.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfkeys
+.code.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfkeys
+libraryfiltered.code.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgf.c
+fg)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgfsy
+s-pdftex.def
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgfsy
+s-common-pdf.def)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgfsy
+ssoftpath.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/systemlayer\pgfsy
+sprotocol.code.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/xcolor\xcolor.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics-cfg\color.cfg)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\mathcolor.ltx)
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+e.code.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmath.code
+.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathutil.
+code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathparse
+r.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.basic.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.trigonometric.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.random.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.comparison.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.base.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.round.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.misc.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfunct
+ions.integerarithmetics.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathcalc.
+code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmathfloat
+.code.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfint.code.
+tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+epoints.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+epathconstruct.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+epathusage.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+escopes.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+egraphicstate.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+etransformations.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+equick.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+eobjects.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+epathprocessing.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+earrows.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+eshade.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+eimage.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+eexternal.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+elayers.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+etransparency.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+epatterns.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/basiclayer\pgfcor
+erdf.code.tex)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/modules\pgfmodule
+shapes.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/modules\pgfmodule
+plot.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/compatibility\pgfco
+mp-version-0-65.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/compatibility\pgfco
+mp-version-1-18.sty))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/utilities\pgffor.st
+y
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/utilities\pgfkeys.s
+ty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgfkeys
+.code.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/pgf/math\pgfmath.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/math\pgfmath.code
+.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/utilities\pgffor.
+code.tex))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/frontendlayer/tik
+z\tikz.code.tex
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/libraries\pgflibr
+aryplothandlers.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/modules\pgfmodule
+matrix.code.tex)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pgf/frontendlayer/tik
+z/libraries\tikzlibrarytopaths.code.tex)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\hyperref.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/iftex\iftex.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/kvsetkeys\kvsetkeys.sty
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/kvdefinekeys\kvdefine
+keys.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pdfescape\pdfescape.s
+ty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/ltxcmds\ltxcmds.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pdftexcmds\pdftexcmds
+.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/infwarerr\infwarerr.s
+ty)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hycolor\hycolor.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\nameref.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/refcount\refcount.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/gettitlestring\gettit
+lestring.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/kvoptions\kvoptions.sty
+)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/etoolbox\etoolbox.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/stringenc\stringenc.s
+ty) (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\pd1enc.def
+) (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/intcalc\intcalc.sty
+) (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\puenc.def)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/url\url.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/bitset\bitset.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/bigintcalc\bigintcalc
+.sty)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\hpdftex.def
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/rerunfilecheck\rerunfil
+echeck.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/uniquecounter\uniquec
+ounter.sty)))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/listings\listings.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/listings\lstpatch.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/listings\lstmisc.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/listings\listings.cfg))
+==> First Aid for listings.sty no longer applied!
+    Expected:
+        2024/09/23 1.10c (Carsten Heinz)
+    but found:
+        2025/11/14 1.11b (Carsten Heinz)
+    so I'm assuming it got fixed.
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/cite\cite.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/booktabs\booktabs.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/tools\array.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/listings\lstlang1.sty)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/l3backend\l3backend-pdf
+tex.def) (paper.aux)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/context/base/mkii\supp-pdf.mk
+ii
+[Loading MPS to PDF converter (version 2006.09.02).]
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/epstopdf-pkg\epstopdf-b
+ase.sty
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/00miktex\epstopdf-sys.c
+fg)) (paper.out) (paper.out)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\umsa.fd)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\umsb.fd)
+[1{C:/Users/alexa/AppData/Local/MiKTeX/fonts/map/pdftex/pdftex.map}] [2]
+Overfull \hbox (21.74994pt too wide) in paragraph at lines 57--58
+\OT1/cmr/m/n/10.95 quences, and sim-ple trans-for-ma-tions. When the prob-lem d
+o-main shifts|different
+
+Overfull \hbox (6.21317pt too wide) in paragraph at lines 59--60
+[]\OT1/cmr/m/n/10.95 Consider the bond strength cal-cu-la-tion im-ple-mented in
+ \OT1/cmtt/m/n/10.95 bond.py:103-121\OT1/cmr/m/n/10.95 .
+[3]
+Overfull \hbox (194.18127pt too wide) in paragraph at lines 86--104
+ [][] 
+[4]
+Overfull \hbox (0.80002pt too wide) in paragraph at lines 135--136
+[]\OT1/cmr/m/n/10.95 Neuroscience and cog-ni-tive psy-chol-ogy in-creas-ingly e
+m-pha-size the brain's
+[5]
+Overfull \hbox (86.21509pt too wide) in paragraph at lines 163--178
+ [][] 
+
+Overfull \hbox (31.84698pt too wide) in paragraph at lines 182--183
+\OT1/cmr/m/n/10.95 man-tic func-tion in the net-work. These edge types, cre-ate
+d in \OT1/cmtt/m/n/10.95 slipnet.py:200-236\OT1/cmr/m/n/10.95 ,
+[6]
+Overfull \hbox (0.76581pt too wide) in paragraph at lines 184--185
+ []\OT1/cmr/bx/n/10.95 Category Links[] \OT1/cmr/m/n/10.95 form tax-o-nomic hi-
+er-ar-chies, con-nect-ing spe-cific in-stances
+[7]
+Overfull \hbox (3.07117pt too wide) in paragraph at lines 216--217
+[]\OT1/cmr/m/n/10.95 This for-mu-la-tion au-to-mat-i-cally as-signs ap-pro-pri-
+ate depths. Let-ters them-
+[8]
+Overfull \hbox (0.92467pt too wide) in paragraph at lines 218--219
+\OT1/cmr/m/n/10.95 con-cepts au-to-mat-i-cally as-signs them ap-pro-pri-ate dep
+ths based on their graph
+
+Overfull \hbox (55.18405pt too wide) detected at line 244
+[][][][]\OT1/cmr/m/n/10.95 (\OML/cmm/m/it/10.95 i \OMS/cmsy/m/n/10.95 ! \OML/cm
+m/m/it/10.95 j\OT1/cmr/m/n/10.95 ) = []
+[9]
+Overfull \hbox (13.33466pt too wide) in paragraph at lines 268--269
+\OT1/cmr/m/n/10.95 col-ors rep-re-sent-ing con-cep-tual depth and edge thick-ne
+ss in-di-cat-ing link strength
+[10] [11 <./figure1_slipnet_graph.pdf>] [12 <./figure2_activation_spreading.pdf
+> <./figure3_resistance_distance.pdf>]
+Overfull \hbox (4.56471pt too wide) in paragraph at lines 317--318
+\OT1/cmr/m/n/10.95 We for-mal-ize the Workspace as a time-varying graph $\OMS/c
+msy/m/n/10.95 W\OT1/cmr/m/n/10.95 (\OML/cmm/m/it/10.95 t\OT1/cmr/m/n/10.95 ) = 
+(\OML/cmm/m/it/10.95 V[]\OT1/cmr/m/n/10.95 (\OML/cmm/m/it/10.95 t\OT1/cmr/m/n/1
+0.95 )\OML/cmm/m/it/10.95 ; E[]\OT1/cmr/m/n/10.95 (\OML/cmm/m/it/10.95 t\OT1/cm
+r/m/n/10.95 )\OML/cmm/m/it/10.95 ; ^^[\OT1/cmr/m/n/10.95 )$
+
+Overfull \hbox (35.00961pt too wide) in paragraph at lines 328--329
+\OT1/cmr/m/n/10.95 nodes or edges to the graph. Struc-tures break (\OT1/cmtt/m/
+n/10.95 bond.py:56-70\OT1/cmr/m/n/10.95 , \OT1/cmtt/m/n/10.95 group.py:143-165\
+OT1/cmr/m/n/10.95 ,
+
+Overfull \hbox (4.6354pt too wide) in paragraph at lines 332--333
+\OT1/cmr/m/n/10.95 Current Copy-cat im-ple-men-ta-tion com-putes ob-ject salien
+ce us-ing fixed weight-
+
+Overfull \hbox (69.83707pt too wide) in paragraph at lines 332--333
+\OT1/cmr/m/n/10.95 ing schemes that do not adapt to graph struc-ture. The code 
+in \OT1/cmtt/m/n/10.95 workspaceObject.py:88-95
+
+Overfull \hbox (15.95015pt too wide) detected at line 337
+[]
+[13]
+Overfull \hbox (2.65536pt too wide) in paragraph at lines 349--350
+[]\OT1/cmr/m/n/10.95 In Copy-cat's Workspace, be-tween-ness cen-tral-ity nat-u-
+rally iden-ti-fies struc-
+[14] [15]
+Underfull \hbox (badness 10000) in paragraph at lines 432--432
+[]|\OT1/cmr/bx/n/10 Original Con-
+
+Underfull \hbox (badness 2512) in paragraph at lines 432--432
+[]|\OT1/cmr/bx/n/10 Graph Met-ric Re-place-
+
+Overfull \hbox (10.22531pt too wide) in paragraph at lines 434--434
+[]|\OT1/cmr/m/n/10 memberCompatibility
+
+Underfull \hbox (badness 10000) in paragraph at lines 434--434
+[]|\OT1/cmr/m/n/10 Structural equiv-a-lence:
+
+Underfull \hbox (badness 10000) in paragraph at lines 435--435
+[]|\OT1/cmr/m/n/10 facetFactor
+
+Underfull \hbox (badness 10000) in paragraph at lines 436--436
+[]|\OT1/cmr/m/n/10 supportFactor
+
+Underfull \hbox (badness 10000) in paragraph at lines 436--436
+[]|\OT1/cmr/m/n/10 Clustering co-ef-fi-cient:
+
+Underfull \hbox (badness 10000) in paragraph at lines 437--437
+[]|\OT1/cmr/m/n/10 jump[]threshold
+
+Underfull \hbox (badness 10000) in paragraph at lines 438--438
+[]|\OT1/cmr/m/n/10 salience[]weights
+
+Underfull \hbox (badness 10000) in paragraph at lines 438--438
+[]|\OT1/cmr/m/n/10 Betweenness cen-tral-ity:
+
+Underfull \hbox (badness 10000) in paragraph at lines 439--439
+[]|\OT1/cmr/m/n/10 length[]factors (5,
+
+Underfull \hbox (badness 10000) in paragraph at lines 440--440
+[]|\OT1/cmr/m/n/10 mapping[]factors
+
+Overfull \hbox (88.56494pt too wide) in paragraph at lines 430--443
+ [][] 
+[16] [17]
+Overfull \hbox (2.62796pt too wide) in paragraph at lines 533--534
+\OT1/cmr/m/n/10.95 tently higher be-tween-ness than ob-jects that re-main un-ma
+pped (dashed lines),
+[18] [19 <./figure4_workspace_evolution.pdf> <./figure5_betweenness_dynamics.pd
+f>] [20 <./figure6_clustering_distribution.pdf>]
+Overfull \hbox (11.07368pt too wide) in paragraph at lines 578--579
+\OT1/cmr/m/n/10.95 the brit-tle-ness of fixed pa-ram-e-ters. When the prob-lem 
+do-main changes|longer
+[21]
+Overfull \hbox (68.84294pt too wide) in paragraph at lines 592--605
+ [][] 
+[22]
+Overfull \hbox (0.16418pt too wide) in paragraph at lines 623--624
+\OT1/cmr/m/n/10.95 Specif-i-cally, we pre-dict that tem-per-a-ture in-versely c
+or-re-lates with Workspace
+
+Overfull \hbox (5.02307pt too wide) in paragraph at lines 626--627
+ []\OT1/cmr/bx/n/10.95 Hypothesis 3: Clus-ter-ing Pre-dicts Suc-cess[] \OT1/cmr
+/m/n/10.95 Suc-cess-ful problem-solving
+[23] [24] [25] [26]
+Overfull \hbox (0.89622pt too wide) in paragraph at lines 696--697
+ []\OT1/cmr/bx/n/10.95 Neuroscience Com-par-i-son[] \OT1/cmr/m/n/10.95 Com-par-
+ing Copy-cat's graph met-rics to brain
+
+Overfull \hbox (7.0143pt too wide) in paragraph at lines 702--703
+ []\OT1/cmr/bx/n/10.95 Meta-Learning Met-ric Se-lec-tion[] \OT1/cmr/m/n/10.95 D
+e-vel-op-ing meta-learning sys-tems that
+[27]
+Overfull \hbox (33.3155pt too wide) in paragraph at lines 713--714
+[]\OT1/cmr/m/n/10.95 The graph-theoretical re-for-mu-la-tion hon-ors Copy-cat's
+ orig-i-nal vi-sion|modeling
+(paper.bbl [28]) [29] (paper.aux) )
+(see the transcript file for additional information) <C:\Users\alexa\AppData\Lo
+cal\MiKTeX\fonts/pk/ljfour/jknappen/ec/dpi600\tcrm1095.pk><C:/Users/alexa/AppDa
+ta/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmbx10.pfb><C:/Users/al
+exa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmbx12.pfb><C:
+/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmcsc
+10.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfont
+s/cm/cmex10.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/publi
+c/amsfonts/cm/cmmi10.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/ty
+pe1/public/amsfonts/cm/cmmi5.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/
+fonts/type1/public/amsfonts/cm/cmmi6.pfb><C:/Users/alexa/AppData/Local/Programs
+/MiKTeX/fonts/type1/public/amsfonts/cm/cmmi7.pfb><C:/Users/alexa/AppData/Local/
+Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmmi8.pfb><C:/Users/alexa/AppDat
+a/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmr10.pfb><C:/Users/alex
+a/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmr12.pfb><C:/Us
+ers/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmr17.pf
+b><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/
+cmr5.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfo
+nts/cm/cmr6.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/publi
+c/amsfonts/cm/cmr7.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type
+1/public/amsfonts/cm/cmr8.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fon
+ts/type1/public/amsfonts/cm/cmr9.pfb><C:/Users/alexa/AppData/Local/Programs/MiK
+TeX/fonts/type1/public/amsfonts/cm/cmsy10.pfb><C:/Users/alexa/AppData/Local/Pro
+grams/MiKTeX/fonts/type1/public/amsfonts/cm/cmsy7.pfb><C:/Users/alexa/AppData/L
+ocal/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmsy8.pfb><C:/Users/alexa/A
+ppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmti10.pfb><C:/User
+s/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmtt10.pfb
+><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/symb
+ols/msbm10.pfb>
+Output written on paper.pdf (29 pages, 642536 bytes).
+Transcript written on paper.log.
+pdflatex: major issue: So far, you have not checked for MiKTeX updates.

LaTeX/generate_all_figures.py

@@ -0,0 +1,88 @@
+"""
+Master script to generate all figures for the paper
+Run this to create all PDF and PNG figures at once
+"""
+
+import subprocess
+import sys
+import os
+
+# Change to LaTeX directory
+script_dir = os.path.dirname(os.path.abspath(__file__))
+os.chdir(script_dir)
+
+scripts = [
+    'generate_slipnet_graph.py',
+    'compare_formulas.py',
+    'activation_spreading.py',
+    'resistance_distance.py',
+    'clustering_analysis.py',
+    'workspace_evolution.py',
+]
+
+print("="*70)
+print("Generating all figures for the paper:")
+print("  'From Hardcoded Heuristics to Graph-Theoretical Constructs'")
+print("="*70)
+print()
+
+failed_scripts = []
+
+for i, script in enumerate(scripts, 1):
+    print(f"[{i}/{len(scripts)}] Running {script}...")
+    try:
+        result = subprocess.run([sys.executable, script],
+                              capture_output=True,
+                              text=True,
+                              timeout=60)
+        if result.returncode == 0:
+            print(f"    ✓ Success")
+            if result.stdout:
+                print(f"    {result.stdout.strip()}")
+        else:
+            print(f"    ✗ Failed with return code {result.returncode}")
+            if result.stderr:
+                print(f"    Error: {result.stderr.strip()}")
+            failed_scripts.append(script)
+    except subprocess.TimeoutExpired:
+        print(f"    ✗ Timeout (>60s)")
+        failed_scripts.append(script)
+    except Exception as e:
+        print(f"    ✗ Exception: {e}")
+        failed_scripts.append(script)
+    print()
+
+print("="*70)
+print("Summary:")
+print("="*70)
+
+if not failed_scripts:
+    print("✓ All figures generated successfully!")
+    print()
+    print("Generated files:")
+    print("  - figure1_slipnet_graph.pdf/.png")
+    print("  - figure2_activation_spreading.pdf/.png")
+    print("  - figure3_resistance_distance.pdf/.png")
+    print("  - figure4_workspace_evolution.pdf/.png")
+    print("  - figure5_betweenness_dynamics.pdf/.png")
+    print("  - figure6_clustering_distribution.pdf/.png")
+    print("  - formula_comparison.pdf/.png")
+    print("  - scalability_comparison.pdf/.png")
+    print("  - slippability_temperature.pdf/.png")
+    print("  - external_strength_comparison.pdf/.png")
+    print()
+    print("You can now compile the LaTeX document with these figures.")
+    print("To include them in paper.tex, replace the placeholder \\fbox commands")
+    print("with \\includegraphics commands:")
+    print()
+    print("  \\includegraphics[width=0.8\\textwidth]{figure1_slipnet_graph.pdf}")
+else:
+    print(f"✗ {len(failed_scripts)} script(s) failed:")
+    for script in failed_scripts:
+        print(f"  - {script}")
+    print()
+    print("Please check the error messages above and ensure you have")
+    print("the required packages installed:")
+    print("  pip install matplotlib numpy networkx scipy")
+
+print("="*70)

LaTeX/generate_slipnet_graph.py

@@ -0,0 +1,140 @@
+"""
+Generate Slipnet graph visualization (Figure 1)
+Shows conceptual depth as node color gradient, with key Slipnet nodes and connections.
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+
+# Define key Slipnet nodes with their conceptual depths
+nodes = {
+    # Letters (depth 10)
+    'a': 10, 'b': 10, 'c': 10, 'd': 10, 'z': 10,
+    # Numbers (depth 30)
+    '1': 30, '2': 30, '3': 30,
+    # String positions (depth 40)
+    'leftmost': 40, 'rightmost': 40, 'middle': 40, 'single': 40,
+    # Directions (depth 40)
+    'left': 40, 'right': 40,
+    # Alphabetic positions (depth 60)
+    'first': 60, 'last': 60,
+    # Bond types (depth 50-80)
+    'predecessor': 50, 'successor': 50, 'sameness': 80,
+    # Group types (depth 50-80)
+    'predecessorGroup': 50, 'successorGroup': 50, 'samenessGroup': 80,
+    # Relations (depth 90)
+    'identity': 90, 'opposite': 90,
+    # Categories (depth 20-90)
+    'letterCategory': 30, 'stringPositionCategory': 70,
+    'directionCategory': 70, 'bondCategory': 80, 'length': 60,
+}
+
+# Define edges with their link lengths (inverse = strength)
+edges = [
+    # Letter to letterCategory
+    ('a', 'letterCategory', 97), ('b', 'letterCategory', 97),
+    ('c', 'letterCategory', 97), ('d', 'letterCategory', 97),
+    ('z', 'letterCategory', 97),
+
+    # Successor/predecessor relationships
+    ('a', 'b', 50), ('b', 'c', 50), ('c', 'd', 50),
+    ('b', 'a', 50), ('c', 'b', 50), ('d', 'c', 50),
+
+    # Bond types to bond category
+    ('predecessor', 'bondCategory', 60), ('successor', 'bondCategory', 60),
+    ('sameness', 'bondCategory', 30),
+
+    # Group types
+    ('sameness', 'samenessGroup', 30),
+    ('predecessor', 'predecessorGroup', 60),
+    ('successor', 'successorGroup', 60),
+
+    # Opposite relations
+    ('left', 'right', 80), ('right', 'left', 80),
+    ('first', 'last', 80), ('last', 'first', 80),
+
+    # Position relationships
+    ('left', 'directionCategory', 50), ('right', 'directionCategory', 50),
+    ('leftmost', 'stringPositionCategory', 50),
+    ('rightmost', 'stringPositionCategory', 50),
+    ('middle', 'stringPositionCategory', 50),
+
+    # Slippable connections
+    ('left', 'leftmost', 90), ('leftmost', 'left', 90),
+    ('right', 'rightmost', 90), ('rightmost', 'right', 90),
+    ('leftmost', 'first', 100), ('first', 'leftmost', 100),
+    ('rightmost', 'last', 100), ('last', 'rightmost', 100),
+
+    # Abstract relations
+    ('identity', 'bondCategory', 50),
+    ('opposite', 'bondCategory', 80),
+]
+
+# Create graph
+G = nx.DiGraph()
+
+# Add nodes with depth attribute
+for node, depth in nodes.items():
+    G.add_node(node, depth=depth)
+
+# Add edges with link length
+for source, target, length in edges:
+    G.add_edge(source, target, length=length, weight=100-length)
+
+# Create figure
+fig, ax = plt.subplots(figsize=(16, 12))
+
+# Use hierarchical layout based on depth
+pos = {}
+depth_groups = {}
+for node in G.nodes():
+    depth = G.nodes[node]['depth']
+    if depth not in depth_groups:
+        depth_groups[depth] = []
+    depth_groups[depth].append(node)
+
+# Position nodes by depth (y-axis) and spread horizontally
+for depth, node_list in depth_groups.items():
+    y = 1.0 - (depth / 100.0)  # Invert so shallow nodes at top
+    for i, node in enumerate(node_list):
+        x = (i - len(node_list)/2) / max(len(node_list), 10) * 2.5
+        pos[node] = (x, y)
+
+# Get node colors based on depth (blue=shallow/concrete, red=deep/abstract)
+node_colors = [G.nodes[node]['depth'] for node in G.nodes()]
+
+# Draw edges with thickness based on strength (inverse of link length)
+edges_to_draw = G.edges()
+edge_widths = [0.3 + (100 - G[u][v]['length']) / 100.0 * 3 for u, v in edges_to_draw]
+
+nx.draw_networkx_edges(G, pos, edgelist=edges_to_draw, width=edge_widths,
+                       alpha=0.3, arrows=True, arrowsize=10,
+                       connectionstyle='arc3,rad=0.1', ax=ax)
+
+# Draw nodes
+nx.draw_networkx_nodes(G, pos, node_color=node_colors,
+                       node_size=800, cmap='coolwarm',
+                       vmin=0, vmax=100, ax=ax)
+
+# Draw labels
+nx.draw_networkx_labels(G, pos, font_size=8, font_weight='bold', ax=ax)
+
+# Add colorbar
+sm = plt.cm.ScalarMappable(cmap='coolwarm',
+                           norm=plt.Normalize(vmin=0, vmax=100))
+sm.set_array([])
+cbar = plt.colorbar(sm, ax=ax, fraction=0.046, pad=0.04)
+cbar.set_label('Conceptual Depth', rotation=270, labelpad=20, fontsize=12)
+
+ax.set_title('Slipnet Graph Structure\n' +
+             'Color gradient: Blue (concrete/shallow) → Red (abstract/deep)\n' +
+             'Edge thickness: Link strength (inverse of link length)',
+             fontsize=14, fontweight='bold', pad=20)
+ax.axis('off')
+
+plt.tight_layout()
+plt.savefig('figure1_slipnet_graph.pdf', dpi=300, bbox_inches='tight')
+plt.savefig('figure1_slipnet_graph.png', dpi=300, bbox_inches='tight')
+print("Generated figure1_slipnet_graph.pdf and .png")
+plt.close()

LaTeX/paper.aux

@@ -0,0 +1,115 @@
+\relax 
+\providecommand\hyper@newdestlabel[2]{}
+\providecommand\HyField@AuxAddToFields[1]{}
+\providecommand\HyField@AuxAddToCoFields[2]{}
+\citation{mitchell1993analogy,hofstadter1995fluid}
+\@writefile{toc}{\contentsline {section}{\numberline {1}Introduction}{1}{section.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {2}The Problem with Hardcoded Constants}{3}{section.2}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Brittleness and Domain Specificity}{3}{subsection.2.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}Catalog of Hardcoded Constants}{4}{subsection.2.2}\protected@file@percent }
+\@writefile{lot}{\contentsline {table}{\numberline {1}{\ignorespaces Major hardcoded constants in Copycat implementation. Values are empirically determined rather than derived from principles.}}{4}{table.1}\protected@file@percent }
+\newlabel{tab:constants}{{1}{4}{Major hardcoded constants in Copycat implementation. Values are empirically determined rather than derived from principles}{table.1}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Lack of Principled Justification}{4}{subsection.2.3}\protected@file@percent }
+\citation{watts1998collective}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.4}Scalability Limitations}{5}{subsection.2.4}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.5}Cognitive Implausibility}{5}{subsection.2.5}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.6}The Case for Graph-Theoretical Reformulation}{6}{subsection.2.6}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {3}The Slipnet and its Graph Operations}{6}{section.3}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.1}Slipnet as a Semantic Network}{6}{subsection.3.1}\protected@file@percent }
+\@writefile{lot}{\contentsline {table}{\numberline {2}{\ignorespaces Slipnet node types with conceptual depths, counts, and average connectivity. Letter nodes are most concrete (depth 10), while abstract relations have depth 90.}}{7}{table.2}\protected@file@percent }
+\newlabel{tab:slipnodes}{{2}{7}{Slipnet node types with conceptual depths, counts, and average connectivity. Letter nodes are most concrete (depth 10), while abstract relations have depth 90}{table.2}{}}
+\@writefile{toc}{\contentsline {paragraph}{Category Links}{7}{section*.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Instance Links}{7}{section*.2}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Property Links}{7}{section*.3}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Lateral Slip Links}{7}{section*.4}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Lateral Non-Slip Links}{8}{section*.5}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.2}Conceptual Depth as Minimum Distance to Low-Level Nodes}{8}{subsection.3.2}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.3}Slippage via Dynamic Weight Adjustment}{9}{subsection.3.3}\protected@file@percent }
+\citation{klein1993resistance}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.4}Graph Visualization and Metrics}{10}{subsection.3.4}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {1}{\ignorespaces Slipnet graph structure with conceptual depth encoded as node color intensity and link strength as edge thickness.}}{11}{figure.1}\protected@file@percent }
+\newlabel{fig:slipnet}{{1}{11}{Slipnet graph structure with conceptual depth encoded as node color intensity and link strength as edge thickness}{figure.1}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {4}The Workspace as a Dynamic Graph}{11}{section.4}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {2}{\ignorespaces Activation spreading over time demonstrates differential decay: shallow nodes (letters) lose activation rapidly while deep nodes (abstract concepts) persist.}}{12}{figure.2}\protected@file@percent }
+\newlabel{fig:activation_spread}{{2}{12}{Activation spreading over time demonstrates differential decay: shallow nodes (letters) lose activation rapidly while deep nodes (abstract concepts) persist}{figure.2}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {3}{\ignorespaces Resistance distance heat map reveals multi-path connectivity: concepts connected by multiple routes show lower resistance than single-path connections.}}{12}{figure.3}\protected@file@percent }
+\newlabel{fig:resistance_distance}{{3}{12}{Resistance distance heat map reveals multi-path connectivity: concepts connected by multiple routes show lower resistance than single-path connections}{figure.3}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1}Workspace Graph Structure}{13}{subsection.4.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2}Graph Betweenness for Structural Importance}{13}{subsection.4.2}\protected@file@percent }
+\citation{freeman1977set,brandes2001faster}
+\citation{brandes2001faster}
+\citation{watts1998collective}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3}Local Graph Density and Clustering Coefficients}{15}{subsection.4.3}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.4}Complete Substitution Table}{16}{subsection.4.4}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.5}Algorithmic Implementations}{16}{subsection.4.5}\protected@file@percent }
+\@writefile{lot}{\contentsline {table}{\numberline {3}{\ignorespaces Proposed graph-theoretical replacements for hardcoded constants. Each metric provides principled, adaptive measurement based on graph structure.}}{17}{table.3}\protected@file@percent }
+\newlabel{tab:substitutions}{{3}{17}{Proposed graph-theoretical replacements for hardcoded constants. Each metric provides principled, adaptive measurement based on graph structure}{table.3}{}}
+\@writefile{loa}{\contentsline {algorithm}{\numberline {1}{\ignorespaces Graph-Based Bond External Strength}}{17}{algorithm.1}\protected@file@percent }
+\newlabel{alg:bond_strength}{{1}{17}{Algorithmic Implementations}{algorithm.1}{}}
+\@writefile{loa}{\contentsline {algorithm}{\numberline {2}{\ignorespaces Betweenness-Based Salience}}{18}{algorithm.2}\protected@file@percent }
+\newlabel{alg:betweenness_salience}{{2}{18}{Algorithmic Implementations}{algorithm.2}{}}
+\@writefile{loa}{\contentsline {algorithm}{\numberline {3}{\ignorespaces Adaptive Activation Threshold}}{18}{algorithm.3}\protected@file@percent }
+\newlabel{alg:adaptive_threshold}{{3}{18}{Algorithmic Implementations}{algorithm.3}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.6}Workspace Evolution Visualization}{18}{subsection.4.6}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {4}{\ignorespaces Workspace graph evolution during analogical reasoning shows progressive structure formation, with betweenness centrality values identifying strategically important objects.}}{19}{figure.4}\protected@file@percent }
+\newlabel{fig:workspace_evolution}{{4}{19}{Workspace graph evolution during analogical reasoning shows progressive structure formation, with betweenness centrality values identifying strategically important objects}{figure.4}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {5}{\ignorespaces Betweenness centrality dynamics reveal that objects with sustained high centrality are preferentially selected for correspondences.}}{19}{figure.5}\protected@file@percent }
+\newlabel{fig:betweenness_dynamics}{{5}{19}{Betweenness centrality dynamics reveal that objects with sustained high centrality are preferentially selected for correspondences}{figure.5}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {6}{\ignorespaces Successful analogy-making runs show higher clustering coefficients, indicating that locally dense structure promotes coherent solutions.}}{20}{figure.6}\protected@file@percent }
+\newlabel{fig:clustering_distribution}{{6}{20}{Successful analogy-making runs show higher clustering coefficients, indicating that locally dense structure promotes coherent solutions}{figure.6}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {5}Discussion}{20}{section.5}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.1}Theoretical Advantages}{20}{subsection.5.1}\protected@file@percent }
+\citation{watts1998collective}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.2}Adaptability and Scalability}{21}{subsection.5.2}\protected@file@percent }
+\citation{brandes2001faster}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.3}Computational Considerations}{22}{subsection.5.3}\protected@file@percent }
+\@writefile{lot}{\contentsline {table}{\numberline {4}{\ignorespaces Computational complexity of graph metrics and mitigation strategies. Here $n$ = nodes, $m$ = edges, $d$ = degree, $m_{sub}$ = edges in subgraph.}}{22}{table.4}\protected@file@percent }
+\newlabel{tab:complexity}{{4}{22}{Computational complexity of graph metrics and mitigation strategies. Here $n$ = nodes, $m$ = edges, $d$ = degree, $m_{sub}$ = edges in subgraph}{table.4}{}}
+\citation{newman2018networks}
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.4}Empirical Predictions and Testable Hypotheses}{23}{subsection.5.4}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Hypothesis 1: Improved Performance Consistency}{23}{section*.6}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Hypothesis 2: Temperature-Graph Entropy Correlation}{23}{section*.7}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Hypothesis 3: Clustering Predicts Success}{23}{section*.8}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Hypothesis 4: Betweenness Predicts Correspondence Selection}{23}{section*.9}\protected@file@percent }
+\citation{gentner1983structure}
+\citation{scarselli2008graph}
+\citation{gardenfors2000conceptual}
+\citation{watts1998collective}
+\@writefile{toc}{\contentsline {paragraph}{Hypothesis 5: Graceful Degradation}{24}{section*.10}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.5}Connections to Related Work}{24}{subsection.5.5}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Analogical Reasoning}{24}{section*.11}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Graph Neural Networks}{24}{section*.12}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Conceptual Spaces}{24}{section*.13}\protected@file@percent }
+\citation{newman2018networks}
+\@writefile{toc}{\contentsline {paragraph}{Small-World Networks}{25}{section*.14}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Network Science in Cognition}{25}{section*.15}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.6}Limitations and Open Questions}{25}{subsection.5.6}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Parameter Selection}{25}{section*.16}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Multi-Relational Graphs}{25}{section*.17}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Temporal Dynamics}{25}{section*.18}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Learning and Meta-Learning}{26}{section*.19}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {5.7}Broader Implications}{26}{subsection.5.7}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {6}Conclusion}{26}{section.6}\protected@file@percent }
+\citation{forbus2017companion}
+\@writefile{toc}{\contentsline {subsection}{\numberline {6.1}Future Work}{27}{subsection.6.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Implementation and Validation}{27}{section*.20}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Domain Transfer}{27}{section*.21}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Neuroscience Comparison}{27}{section*.22}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Hybrid Neural-Symbolic Systems}{27}{section*.23}\protected@file@percent }
+\@writefile{toc}{\contentsline {paragraph}{Meta-Learning Metric Selection}{27}{section*.24}\protected@file@percent }
+\bibstyle{plain}
+\bibdata{references}
+\bibcite{brandes2001faster}{1}
+\bibcite{forbus2017companion}{2}
+\bibcite{freeman1977set}{3}
+\bibcite{gardenfors2000conceptual}{4}
+\@writefile{toc}{\contentsline {paragraph}{Extension to Other Cognitive Architectures}{28}{section*.25}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {6.2}Closing Perspective}{28}{subsection.6.2}\protected@file@percent }
+\bibcite{gentner1983structure}{5}
+\bibcite{hofstadter1995fluid}{6}
+\bibcite{klein1993resistance}{7}
+\bibcite{mitchell1993analogy}{8}
+\bibcite{newman2018networks}{9}
+\bibcite{scarselli2008graph}{10}
+\bibcite{watts1998collective}{11}
+\gdef \@abspage@last{29}

LaTeX/paper.bbl

@@ -0,0 +1,60 @@
+\begin{thebibliography}{10}
+
+\bibitem{brandes2001faster}
+Ulrik Brandes.
+\newblock A faster algorithm for betweenness centrality.
+\newblock {\em Journal of Mathematical Sociology}, 25(2):163--177, 2001.
+
+\bibitem{forbus2017companion}
+Kenneth~D. Forbus and Thomas~R. Hinrichs.
+\newblock Companion cognitive systems: A step toward human-level ai.
+\newblock {\em AI Magazine}, 38(4):25--35, 2017.
+
+\bibitem{freeman1977set}
+Linton~C. Freeman.
+\newblock A set of measures of centrality based on betweenness.
+\newblock {\em Sociometry}, 40(1):35--41, 1977.
+
+\bibitem{gardenfors2000conceptual}
+Peter G\"{a}rdenfors.
+\newblock {\em Conceptual Spaces: The Geometry of Thought}.
+\newblock MIT Press, Cambridge, MA, 2000.
+
+\bibitem{gentner1983structure}
+Dedre Gentner.
+\newblock Structure-mapping: A theoretical framework for analogy.
+\newblock {\em Cognitive Science}, 7(2):155--170, 1983.
+
+\bibitem{hofstadter1995fluid}
+Douglas~R. Hofstadter and FARG.
+\newblock {\em Fluid Concepts and Creative Analogies: Computer Models of the
+  Fundamental Mechanisms of Thought}.
+\newblock Basic Books, New York, NY, 1995.
+
+\bibitem{klein1993resistance}
+Douglas~J. Klein and Milan Randi\'{c}.
+\newblock Resistance distance.
+\newblock {\em Journal of Mathematical Chemistry}, 12(1):81--95, 1993.
+
+\bibitem{mitchell1993analogy}
+Melanie Mitchell.
+\newblock {\em Analogy-Making as Perception: A Computer Model}.
+\newblock MIT Press, Cambridge, MA, 1993.
+
+\bibitem{newman2018networks}
+Mark E.~J. Newman.
+\newblock {\em Networks}.
+\newblock Oxford University Press, Oxford, UK, 2nd edition, 2018.
+
+\bibitem{scarselli2008graph}
+Franco Scarselli, Marco Gori, Ah~Chung Tsoi, Markus Hagenbuchner, and Gabriele
+  Monfardini.
+\newblock The graph neural network model.
+\newblock {\em IEEE Transactions on Neural Networks}, 20(1):61--80, 2008.
+
+\bibitem{watts1998collective}
+Duncan~J. Watts and Steven~H. Strogatz.
+\newblock Collective dynamics of 'small-world' networks.
+\newblock {\em Nature}, 393(6684):440--442, 1998.
+
+\end{thebibliography}

LaTeX/paper.blg

@@ -0,0 +1,48 @@
+This is BibTeX, Version 0.99e
+Capacity: max_strings=200000, hash_size=200000, hash_prime=170003
+The top-level auxiliary file: paper.aux
+Reallocating 'name_of_file' (item size: 1) to 6 items.
+The style file: plain.bst
+Reallocating 'name_of_file' (item size: 1) to 11 items.
+Database file #1: references.bib
+You've used 11 entries,
+            2118 wiz_defined-function locations,
+            576 strings with 5462 characters,
+and the built_in function-call counts, 3192 in all, are:
+= -- 319
+> -- 122
+< -- 0
++ -- 52
+- -- 38
+* -- 219
+:= -- 551
+add.period$ -- 33
+call.type$ -- 11
+change.case$ -- 49
+chr.to.int$ -- 0
+cite$ -- 11
+duplicate$ -- 125
+empty$ -- 270
+format.name$ -- 38
+if$ -- 652
+int.to.chr$ -- 0
+int.to.str$ -- 11
+missing$ -- 15
+newline$ -- 58
+num.names$ -- 22
+pop$ -- 49
+preamble$ -- 1
+purify$ -- 41
+quote$ -- 0
+skip$ -- 76
+stack$ -- 0
+substring$ -- 209
+swap$ -- 11
+text.length$ -- 0
+text.prefix$ -- 0
+top$ -- 0
+type$ -- 36
+warning$ -- 0
+while$ -- 36
+width$ -- 13
+write$ -- 124

LaTeX/paper.out

@@ -0,0 +1,31 @@
+\BOOKMARK [1][-]{section.1}{\376\377\000I\000n\000t\000r\000o\000d\000u\000c\000t\000i\000o\000n}{}% 1
+\BOOKMARK [1][-]{section.2}{\376\377\000T\000h\000e\000\040\000P\000r\000o\000b\000l\000e\000m\000\040\000w\000i\000t\000h\000\040\000H\000a\000r\000d\000c\000o\000d\000e\000d\000\040\000C\000o\000n\000s\000t\000a\000n\000t\000s}{}% 2
+\BOOKMARK [2][-]{subsection.2.1}{\376\377\000B\000r\000i\000t\000t\000l\000e\000n\000e\000s\000s\000\040\000a\000n\000d\000\040\000D\000o\000m\000a\000i\000n\000\040\000S\000p\000e\000c\000i\000f\000i\000c\000i\000t\000y}{section.2}% 3
+\BOOKMARK [2][-]{subsection.2.2}{\376\377\000C\000a\000t\000a\000l\000o\000g\000\040\000o\000f\000\040\000H\000a\000r\000d\000c\000o\000d\000e\000d\000\040\000C\000o\000n\000s\000t\000a\000n\000t\000s}{section.2}% 4
+\BOOKMARK [2][-]{subsection.2.3}{\376\377\000L\000a\000c\000k\000\040\000o\000f\000\040\000P\000r\000i\000n\000c\000i\000p\000l\000e\000d\000\040\000J\000u\000s\000t\000i\000f\000i\000c\000a\000t\000i\000o\000n}{section.2}% 5
+\BOOKMARK [2][-]{subsection.2.4}{\376\377\000S\000c\000a\000l\000a\000b\000i\000l\000i\000t\000y\000\040\000L\000i\000m\000i\000t\000a\000t\000i\000o\000n\000s}{section.2}% 6
+\BOOKMARK [2][-]{subsection.2.5}{\376\377\000C\000o\000g\000n\000i\000t\000i\000v\000e\000\040\000I\000m\000p\000l\000a\000u\000s\000i\000b\000i\000l\000i\000t\000y}{section.2}% 7
+\BOOKMARK [2][-]{subsection.2.6}{\376\377\000T\000h\000e\000\040\000C\000a\000s\000e\000\040\000f\000o\000r\000\040\000G\000r\000a\000p\000h\000-\000T\000h\000e\000o\000r\000e\000t\000i\000c\000a\000l\000\040\000R\000e\000f\000o\000r\000m\000u\000l\000a\000t\000i\000o\000n}{section.2}% 8
+\BOOKMARK [1][-]{section.3}{\376\377\000T\000h\000e\000\040\000S\000l\000i\000p\000n\000e\000t\000\040\000a\000n\000d\000\040\000i\000t\000s\000\040\000G\000r\000a\000p\000h\000\040\000O\000p\000e\000r\000a\000t\000i\000o\000n\000s}{}% 9
+\BOOKMARK [2][-]{subsection.3.1}{\376\377\000S\000l\000i\000p\000n\000e\000t\000\040\000a\000s\000\040\000a\000\040\000S\000e\000m\000a\000n\000t\000i\000c\000\040\000N\000e\000t\000w\000o\000r\000k}{section.3}% 10
+\BOOKMARK [2][-]{subsection.3.2}{\376\377\000C\000o\000n\000c\000e\000p\000t\000u\000a\000l\000\040\000D\000e\000p\000t\000h\000\040\000a\000s\000\040\000M\000i\000n\000i\000m\000u\000m\000\040\000D\000i\000s\000t\000a\000n\000c\000e\000\040\000t\000o\000\040\000L\000o\000w\000-\000L\000e\000v\000e\000l\000\040\000N\000o\000d\000e\000s}{section.3}% 11
+\BOOKMARK [2][-]{subsection.3.3}{\376\377\000S\000l\000i\000p\000p\000a\000g\000e\000\040\000v\000i\000a\000\040\000D\000y\000n\000a\000m\000i\000c\000\040\000W\000e\000i\000g\000h\000t\000\040\000A\000d\000j\000u\000s\000t\000m\000e\000n\000t}{section.3}% 12
+\BOOKMARK [2][-]{subsection.3.4}{\376\377\000G\000r\000a\000p\000h\000\040\000V\000i\000s\000u\000a\000l\000i\000z\000a\000t\000i\000o\000n\000\040\000a\000n\000d\000\040\000M\000e\000t\000r\000i\000c\000s}{section.3}% 13
+\BOOKMARK [1][-]{section.4}{\376\377\000T\000h\000e\000\040\000W\000o\000r\000k\000s\000p\000a\000c\000e\000\040\000a\000s\000\040\000a\000\040\000D\000y\000n\000a\000m\000i\000c\000\040\000G\000r\000a\000p\000h}{}% 14
+\BOOKMARK [2][-]{subsection.4.1}{\376\377\000W\000o\000r\000k\000s\000p\000a\000c\000e\000\040\000G\000r\000a\000p\000h\000\040\000S\000t\000r\000u\000c\000t\000u\000r\000e}{section.4}% 15
+\BOOKMARK [2][-]{subsection.4.2}{\376\377\000G\000r\000a\000p\000h\000\040\000B\000e\000t\000w\000e\000e\000n\000n\000e\000s\000s\000\040\000f\000o\000r\000\040\000S\000t\000r\000u\000c\000t\000u\000r\000a\000l\000\040\000I\000m\000p\000o\000r\000t\000a\000n\000c\000e}{section.4}% 16
+\BOOKMARK [2][-]{subsection.4.3}{\376\377\000L\000o\000c\000a\000l\000\040\000G\000r\000a\000p\000h\000\040\000D\000e\000n\000s\000i\000t\000y\000\040\000a\000n\000d\000\040\000C\000l\000u\000s\000t\000e\000r\000i\000n\000g\000\040\000C\000o\000e\000f\000f\000i\000c\000i\000e\000n\000t\000s}{section.4}% 17
+\BOOKMARK [2][-]{subsection.4.4}{\376\377\000C\000o\000m\000p\000l\000e\000t\000e\000\040\000S\000u\000b\000s\000t\000i\000t\000u\000t\000i\000o\000n\000\040\000T\000a\000b\000l\000e}{section.4}% 18
+\BOOKMARK [2][-]{subsection.4.5}{\376\377\000A\000l\000g\000o\000r\000i\000t\000h\000m\000i\000c\000\040\000I\000m\000p\000l\000e\000m\000e\000n\000t\000a\000t\000i\000o\000n\000s}{section.4}% 19
+\BOOKMARK [2][-]{subsection.4.6}{\376\377\000W\000o\000r\000k\000s\000p\000a\000c\000e\000\040\000E\000v\000o\000l\000u\000t\000i\000o\000n\000\040\000V\000i\000s\000u\000a\000l\000i\000z\000a\000t\000i\000o\000n}{section.4}% 20
+\BOOKMARK [1][-]{section.5}{\376\377\000D\000i\000s\000c\000u\000s\000s\000i\000o\000n}{}% 21
+\BOOKMARK [2][-]{subsection.5.1}{\376\377\000T\000h\000e\000o\000r\000e\000t\000i\000c\000a\000l\000\040\000A\000d\000v\000a\000n\000t\000a\000g\000e\000s}{section.5}% 22
+\BOOKMARK [2][-]{subsection.5.2}{\376\377\000A\000d\000a\000p\000t\000a\000b\000i\000l\000i\000t\000y\000\040\000a\000n\000d\000\040\000S\000c\000a\000l\000a\000b\000i\000l\000i\000t\000y}{section.5}% 23
+\BOOKMARK [2][-]{subsection.5.3}{\376\377\000C\000o\000m\000p\000u\000t\000a\000t\000i\000o\000n\000a\000l\000\040\000C\000o\000n\000s\000i\000d\000e\000r\000a\000t\000i\000o\000n\000s}{section.5}% 24
+\BOOKMARK [2][-]{subsection.5.4}{\376\377\000E\000m\000p\000i\000r\000i\000c\000a\000l\000\040\000P\000r\000e\000d\000i\000c\000t\000i\000o\000n\000s\000\040\000a\000n\000d\000\040\000T\000e\000s\000t\000a\000b\000l\000e\000\040\000H\000y\000p\000o\000t\000h\000e\000s\000e\000s}{section.5}% 25
+\BOOKMARK [2][-]{subsection.5.5}{\376\377\000C\000o\000n\000n\000e\000c\000t\000i\000o\000n\000s\000\040\000t\000o\000\040\000R\000e\000l\000a\000t\000e\000d\000\040\000W\000o\000r\000k}{section.5}% 26
+\BOOKMARK [2][-]{subsection.5.6}{\376\377\000L\000i\000m\000i\000t\000a\000t\000i\000o\000n\000s\000\040\000a\000n\000d\000\040\000O\000p\000e\000n\000\040\000Q\000u\000e\000s\000t\000i\000o\000n\000s}{section.5}% 27
+\BOOKMARK [2][-]{subsection.5.7}{\376\377\000B\000r\000o\000a\000d\000e\000r\000\040\000I\000m\000p\000l\000i\000c\000a\000t\000i\000o\000n\000s}{section.5}% 28
+\BOOKMARK [1][-]{section.6}{\376\377\000C\000o\000n\000c\000l\000u\000s\000i\000o\000n}{}% 29
+\BOOKMARK [2][-]{subsection.6.1}{\376\377\000F\000u\000t\000u\000r\000e\000\040\000W\000o\000r\000k}{section.6}% 30
+\BOOKMARK [2][-]{subsection.6.2}{\376\377\000C\000l\000o\000s\000i\000n\000g\000\040\000P\000e\000r\000s\000p\000e\000c\000t\000i\000v\000e}{section.6}% 31

LaTeX/paper.tex

@@ -0,0 +1,718 @@
+\documentclass[11pt,a4paper]{article}
+\usepackage{amsmath, amssymb, amsthm}
+\usepackage{graphicx}
+\usepackage{algorithm}
+\usepackage{algorithmic}
+\usepackage{tikz}
+% Note: graphdrawing library requires LuaLaTeX, omitted for pdflatex compatibility
+\usepackage{hyperref}
+\usepackage{listings}
+\usepackage{cite}
+\usepackage{booktabs}
+\usepackage{array}
+
+\lstset{
+  basicstyle=\ttfamily\small,
+  breaklines=true,
+  frame=single,
+  numbers=left,
+  numberstyle=\tiny,
+  language=Python
+}
+
+\title{From Hardcoded Heuristics to Graph-Theoretical Constructs: \\
+A Principled Reformulation of the Copycat Architecture}
+
+\author{Alex Linhares}
+\date{\today}
+
+\begin{document}
+
+\maketitle
+
+\begin{abstract}
+The Copycat architecture, developed by Mitchell and Hofstadter as a computational model of analogy-making, relies on numerous hardcoded constants and empirically-tuned formulas to regulate its behavior. While these parameters enable the system to exhibit fluid, human-like performance on letter-string analogy problems, they also introduce brittleness, lack theoretical justification, and limit the system's adaptability to new domains. This paper proposes a principled reformulation of Copycat's core mechanisms using graph-theoretical constructs. We demonstrate that many of the system's hardcoded constants—including bond strength factors, salience weights, and activation thresholds—can be replaced with well-studied graph metrics such as betweenness centrality, clustering coefficients, and resistance distance. This reformulation provides three key advantages: theoretical grounding in established mathematical frameworks, automatic adaptation to problem structure without manual tuning, and increased interpretability of the system's behavior. We present concrete proposals for substituting specific constants with graph metrics, analyze the computational implications, and discuss how this approach bridges classical symbolic AI with modern graph-based machine learning.
+\end{abstract}
+
+\section{Introduction}
+
+Analogy-making stands as one of the most fundamental cognitive abilities, enabling humans to transfer knowledge across domains, recognize patterns in novel situations, and generate creative insights. Hofstadter and Mitchell's Copycat system~\cite{mitchell1993analogy,hofstadter1995fluid} represents a landmark achievement in modeling this capacity computationally. Given a simple analogy problem such as ``if abc changes to abd, what does ppqqrr change to?,'' Copycat constructs representations, explores alternatives, and produces answers that exhibit remarkable similarity to human response distributions. The system's architecture combines a permanent semantic network (the Slipnet) with a dynamic working memory (the Workspace), coordinated through stochastic codelets and regulated by a global temperature parameter.
+
+Despite its cognitive plausibility and empirical success, Copycat's implementation embodies a fundamental tension. The system aspires to model fluid, adaptive cognition, yet its behavior is governed by numerous hardcoded constants and ad-hoc formulas. Bond strength calculations employ fixed compatibility factors of 0.7 and 1.0, external support decays according to $0.6^{1/n^3}$, and salience weights rigidly partition importance between intra-string (0.8) and inter-string (0.2) contexts. These parameters were carefully tuned through experimentation to produce human-like behavior on the canonical problem set, but they lack principled derivation from first principles.
+
+This paper argues that many of Copycat's hardcoded constants can be naturally replaced with graph-theoretical constructs. We observe that both the Slipnet and Workspace are fundamentally graphs: the Slipnet is a semantic network with concepts as nodes and relationships as edges, while the Workspace contains objects as nodes connected by bonds and correspondences. Rather than imposing fixed numerical parameters on these graphs, we can leverage their inherent structure through well-studied metrics from graph theory. Betweenness centrality provides a principled measure of structural importance, clustering coefficients quantify local density, resistance distance captures conceptual proximity, and percolation thresholds offer dynamic activation criteria.
+
+Formally, we can represent Copycat as a tuple $\mathcal{C} = (\mathcal{S}, \mathcal{W}, \mathcal{R}, T)$ where $\mathcal{S}$ denotes the Slipnet (semantic network), $\mathcal{W}$ represents the Workspace (problem representation), $\mathcal{R}$ is the Coderack (action scheduling system), and $T$ captures the global temperature (exploration-exploitation balance). This paper focuses on reformulating $\mathcal{S}$ and $\mathcal{W}$ as graphs with principled metrics, demonstrating how graph-theoretical constructs can replace hardcoded parameters while maintaining or improving the system's cognitive fidelity.
+
+The benefits of this reformulation extend beyond theoretical elegance. Graph metrics automatically adapt to problem structure—betweenness centrality adjusts to actual topological configuration rather than assuming fixed importance weights. The approach provides natural interpretability through visualization and standard metrics. Computational graph theory offers efficient algorithms with known complexity bounds. Furthermore, this reformulation bridges Copycat's symbolic architecture with modern graph neural networks, opening pathways for hybrid approaches that combine classical AI's interpretability with contemporary machine learning's adaptability.
+
+The remainder of this paper proceeds as follows. Section 2 catalogs Copycat's hardcoded constants and analyzes their limitations. Section 3 examines the Slipnet's graph structure and proposes distance-based reformulations of conceptual depth and slippage. Section 4 analyzes the Workspace as a dynamic graph and demonstrates how betweenness centrality and clustering coefficients can replace salience weights and support factors. Section 5 discusses theoretical advantages, computational considerations, and empirical predictions. Section 6 concludes with future directions and broader implications for cognitive architecture design.
+
+\section{The Problem with Hardcoded Constants}
+
+The Copycat codebase contains numerous numerical constants and formulas that regulate system behavior. While these parameters enable Copycat to produce human-like analogies, they introduce four fundamental problems: brittleness, lack of justification, poor scalability, and cognitive implausibility.
+
+\subsection{Brittleness and Domain Specificity}
+
+Copycat's constants were empirically tuned for letter-string analogy problems with specific characteristics: strings of 2-6 characters, alphabetic sequences, and simple transformations. When the problem domain shifts—different alphabet sizes, numerical domains, or visual analogies—these constants may no longer produce appropriate behavior. The system cannot adapt its parameters based on problem structure; it applies the same fixed values regardless of context. This brittleness limits Copycat's utility as a general model of analogical reasoning.
+
+Consider the bond strength calculation implemented in \texttt{bond.py:103-121}. The internal strength of a bond combines three factors: member compatibility (whether bonded objects are the same type), facet factor (whether the bond involves letter categories), and the bond category's degree of association. The member compatibility uses a simple binary choice:
+
+\begin{lstlisting}
+if sourceGap == destinationGap:
+    memberCompatibility = 1.0
+else:
+    memberCompatibility = 0.7
+\end{lstlisting}
+
+Why 0.7 for mixed-type bonds rather than 0.65 or 0.75? The choice appears arbitrary, determined through trial and error rather than derived from principles. Similarly, the facet factor applies another binary distinction:
+
+\begin{lstlisting}
+if self.facet == slipnet.letterCategory:
+    facetFactor = 1.0
+else:
+    facetFactor = 0.7
+\end{lstlisting}
+
+Again, the value 0.7 recurs without justification. This pattern pervades the codebase, as documented in Table~\ref{tab:constants}.
+
+\subsection{Catalog of Hardcoded Constants}
+
+Table~\ref{tab:constants} presents a comprehensive catalog of the major hardcoded constants found in Copycat's implementation, including their locations, values, purposes, and current formulations.
+
+\begin{table}[htbp]
+\centering
+\small
+\begin{tabular}{llllp{5cm}}
+\toprule
+\textbf{Constant} & \textbf{Location} & \textbf{Value} & \textbf{Purpose} & \textbf{Current Formula} \\
+\midrule
+memberCompatibility & bond.py:111 & 0.7/1.0 & Type compatibility & Discrete choice \\
+facetFactor & bond.py:115 & 0.7/1.0 & Letter vs other facets & Discrete choice \\
+supportFactor & bond.py:129 & $0.6^{1/n^3}$ & Support dampening & Power law \\
+jump\_threshold & slipnode.py:131 & 55.0 & Activation cutoff & Fixed threshold \\
+shrunkLinkLength & slipnode.py:15 & $0.4 \times \text{length}$ & Activated links & Linear scaling \\
+activation\_decay & slipnode.py:118 & $a \times \frac{100-d}{100}$ & Energy dissipation & Linear depth \\
+jump\_probability & slipnode.py:133 & $(a/100)^3$ & Stochastic boost & Cubic power \\
+salience\_weights & workspaceObject.py:89 & (0.2, 0.8) & Intra-string importance & Fixed ratio \\
+salience\_weights & workspaceObject.py:92 & (0.8, 0.2) & Inter-string importance & Fixed ratio (inverted) \\
+length\_factors & group.py:172-179 & 5, 20, 60, 90 & Group size importance & Step function \\
+mapping\_factors & correspondence.py:127 & 0.8, 1.2, 1.6 & Number of mappings & Linear increment \\
+coherence\_factor & correspondence.py:133 & 2.5 & Internal coherence & Fixed multiplier \\
+\bottomrule
+\end{tabular}
+\caption{Major hardcoded constants in Copycat implementation. Values are empirically determined rather than derived from principles.}
+\label{tab:constants}
+\end{table}
+
+\subsection{Lack of Principled Justification}
+
+The constants listed in Table~\ref{tab:constants} lack theoretical grounding. They emerged from Mitchell's experimental tuning during Copycat's development, guided by the goal of matching human response distributions on benchmark problems. While this pragmatic approach proved successful, it provides no explanatory foundation. Why should support decay as $0.6^{1/n^3}$ rather than $0.5^{1/n^2}$ or some other function? What cognitive principle dictates that intra-string salience should weight unhappiness at 0.8 versus importance at 0.2, while inter-string salience inverts this ratio?
+
+The activation jump mechanism in the Slipnet exemplifies this issue. When a node's activation exceeds 55.0, the system probabilistically boosts it to full activation (100.0) with probability $(a/100)^3$. This creates a sharp phase transition that accelerates convergence. Yet the threshold of 55.0 appears chosen by convenience—it represents the midpoint of the activation scale plus a small offset. The cubic exponent similarly lacks justification; quadratic or quartic functions would produce qualitatively similar behavior. Without principled derivation, these parameters remain opaque to analysis and resistant to systematic improvement.
+
+\subsection{Scalability Limitations}
+
+The hardcoded constants create scalability barriers when extending Copycat beyond its original problem domain. The group length factors provide a clear example. As implemented in \texttt{group.py:172-179}, the system assigns importance to groups based on their size through a step function:
+
+\begin{equation}
+\text{lengthFactor}(n) = \begin{cases}
+5 & \text{if } n = 1 \\
+20 & \text{if } n = 2 \\
+60 & \text{if } n = 3 \\
+90 & \text{if } n \geq 4
+\end{cases}
+\end{equation}
+
+This formulation makes sense for letter strings of length 3-6, where groups of 4+ elements are indeed highly significant. But consider a problem involving strings of length 20. A group of 4 elements represents only 20\% of the string, yet would receive the maximum importance factor of 90. Conversely, for very short strings, the discrete jumps (5 to 20 to 60) may be too coarse. The step function does not scale gracefully across problem sizes.
+
+Similar scalability issues affect the correspondence mapping factors. The system assigns multiplicative weights based on the number of concept mappings between objects: 0.8 for one mapping, 1.2 for two, 1.6 for three or more. This linear increment (0.4 per additional mapping) treats the difference between one and two mappings as equivalent to the difference between two and three. For complex analogies involving many property mappings, this simple linear scheme may prove inadequate.
+
+\subsection{Cognitive Implausibility}
+
+Perhaps most critically, hardcoded constants conflict with basic principles of cognitive architecture. Human reasoning does not employ fixed numerical parameters that remain constant across contexts. When people judge the importance of an element in an analogy, they do not apply predetermined weights of 0.2 and 0.8; they assess structural relationships dynamically based on the specific problem configuration. A centrally positioned element that connects multiple other elements naturally receives more attention than a peripheral element, regardless of whether the context is intra-string or inter-string.
+
+Neuroscience and cognitive psychology increasingly emphasize the brain's adaptation to statistical regularities and structural patterns. Neural networks exhibit graph properties such as small-world topology and scale-free degree distributions~\cite{watts1998collective}. Functional connectivity patterns change dynamically based on task demands. Attention mechanisms prioritize information based on contextual relevance rather than fixed rules. Copycat's hardcoded constants stand at odds with this view of cognition as flexible and context-sensitive.
+
+\subsection{The Case for Graph-Theoretical Reformulation}
+
+These limitations motivate our central proposal: replace hardcoded constants with graph-theoretical constructs that adapt to structural properties. Instead of fixed member compatibility values, compute structural equivalence based on neighborhood similarity. Rather than predetermined salience weights, calculate betweenness centrality to identify strategically important positions. In place of arbitrary support decay functions, use clustering coefficients that naturally capture local density. Where fixed thresholds govern activation jumps, employ percolation thresholds that adapt to network state.
+
+This reformulation addresses all four problems identified above. Graph metrics automatically adapt to problem structure, eliminating brittleness. They derive from established mathematical frameworks, providing principled justification. Standard graph algorithms scale efficiently to larger problems. Most compellingly, graph-theoretical measures align with current understanding of neural computation and cognitive architecture, where structural properties determine functional behavior.
+
+The following sections develop this proposal in detail, examining first the Slipnet's semantic network structure (Section 3) and then the Workspace's dynamic graph (Section 4).
+
+\section{The Slipnet and its Graph Operations}
+
+The Slipnet implements Copycat's semantic memory as a network of concepts connected by various relationship types. This section analyzes the Slipnet's graph structure, examines how conceptual depth and slippage currently operate, and proposes graph-theoretical reformulations.
+
+\subsection{Slipnet as a Semantic Network}
+
+Formally, we define the Slipnet as a weighted, labeled graph $\mathcal{S} = (V, E, w, d)$ where:
+\begin{itemize}
+\item $V$ is the set of concept nodes (71 nodes total in the standard implementation)
+\item $E \subseteq V \times V$ is the set of directed edges representing conceptual relationships
+\item $w: E \rightarrow \mathbb{R}$ assigns link lengths (conceptual distances) to edges
+\item $d: V \rightarrow \mathbb{R}$ assigns conceptual depth values to nodes
+\end{itemize}
+
+The Slipnet initialization code (\texttt{slipnet.py:43-115}) creates nodes representing several categories of concepts, as documented in Table~\ref{tab:slipnodes}.
+
+\begin{table}[htbp]
+\centering
+\begin{tabular}{lllrr}
+\toprule
+\textbf{Node Type} & \textbf{Examples} & \textbf{Depth} & \textbf{Count} & \textbf{Avg Degree} \\
+\midrule
+Letters & a-z & 10 & 26 & 3.2 \\
+Numbers & 1-5 & 30 & 5 & 1.4 \\
+String positions & leftmost, rightmost, middle & 40 & 5 & 4.0 \\
+Alphabetic positions & first, last & 60 & 2 & 2.0 \\
+Directions & left, right & 40 & 2 & 4.5 \\
+Bond types & predecessor, successor, sameness & 50-80 & 3 & 5.3 \\
+Group types & predecessorGroup, etc. & 50-80 & 3 & 3.7 \\
+Relations & identity, opposite & 90 & 2 & 3.0 \\
+Categories & letterCategory, etc. & 20-90 & 9 & 12.8 \\
+\bottomrule
+\end{tabular}
+\caption{Slipnet node types with conceptual depths, counts, and average connectivity. Letter nodes are most concrete (depth 10), while abstract relations have depth 90.}
+\label{tab:slipnodes}
+\end{table}
+
+The Slipnet employs five distinct edge types, each serving a different semantic function in the network. These edge types, created in \texttt{slipnet.py:200-236}, establish the relationships that enable analogical reasoning:
+
+\paragraph{Category Links} form taxonomic hierarchies, connecting specific instances to their parent categories. For example, each letter node (a, b, c, ..., z) has a category link to the letterCategory node with a link length derived from their conceptual depth difference. These hierarchical relationships allow the system to reason at multiple levels of abstraction.
+
+\paragraph{Instance Links} represent the inverse of category relationships, pointing from categories to their members. The letterCategory node maintains instance links to all letter nodes. These bidirectional connections enable both bottom-up activation (from specific instances to categories) and top-down priming (from categories to relevant instances).
+
+\paragraph{Property Links} connect objects to their attributes and descriptors. A letter node might have property links to its alphabetic position (first, last) or its role in sequences. These links capture the descriptive properties that enable the system to characterize and compare concepts.
+
+\paragraph{Lateral Slip Links} form the foundation of analogical mapping by connecting conceptually similar nodes that can substitute for each other. The paradigmatic example is the opposite link connecting left $\leftrightarrow$ right and first $\leftrightarrow$ last. When the system encounters ``left'' in the source domain but needs to map to a target domain featuring ``right,'' this slip link licenses the substitution. The slippability of such connections depends on link strength and conceptual depth, as we discuss in Section 3.3.
+
+\paragraph{Lateral Non-Slip Links} establish fixed structural relationships that do not permit analogical substitution. For example, the successor relationship connecting a $\rightarrow$ b $\rightarrow$ c defines sequential structure that cannot be altered through slippage. These links provide stable scaffolding for the semantic network.
+
+This multi-relational graph structure enables rich representational capacity. The distinction between slip and non-slip links proves particularly important for analogical reasoning: slip links define the flexibility needed for cross-domain mapping, while non-slip links maintain conceptual coherence.
+
+\subsection{Conceptual Depth as Minimum Distance to Low-Level Nodes}
+
+Conceptual depth represents one of Copycat's most important parameters, yet current implementation assigns depth values manually to each node type. Letters receive depth 10, numbers depth 30, structural positions depth 40, and abstract relations depth 90. These assignments reflect intuition about abstractness—letters are concrete, relations are abstract—but lack principled derivation.
+
+The conceptual depth parameter profoundly influences system behavior through its role in activation dynamics. The Slipnet's update mechanism (\texttt{slipnode.py:116-118}) decays activation according to:
+
+\begin{equation}
+\text{buffer}_v \leftarrow \text{buffer}_v - \text{activation}_v \times \frac{100 - \text{depth}_v}{100}
+\end{equation}
+
+This formulation makes deep (abstract) concepts decay more slowly than shallow (concrete) concepts. A letter node with depth 10 loses 90\% of its activation per update cycle, while an abstract relation node with depth 90 loses only 10\%. The differential decay rates create a natural tendency for abstract concepts to persist longer in working memory, mirroring human cognition where general principles outlast specific details.
+
+Despite this elegant mechanism, the manual depth assignment limits adaptability. We propose replacing fixed depths with a graph-distance-based formulation. Define conceptual depth as the minimum graph distance from a node to the set of letter nodes (the most concrete concepts in the system):
+
+\begin{equation}
+d(v) = k \times \min_{l \in L} \text{dist}(v, l)
+\end{equation}
+
+where $L$ denotes the set of letter nodes, dist$(v, l)$ is the shortest path distance from $v$ to $l$, and $k$ is a scaling constant (approximately 10 to match the original scale).
+
+This formulation automatically assigns appropriate depths. Letters themselves receive $d = 0$ (scaled to 10). The letterCategory node sits one hop from letters, yielding $d \approx 10-20$. String positions and bond types are typically 2-3 hops from letters, producing $d \approx 20-40$. Abstract relations like opposite and identity require traversing multiple edges from letters, resulting in $d \approx 80-90$. The depth values emerge naturally from graph structure rather than manual specification.
+
+Moreover, this approach adapts to Slipnet modifications. Adding new concepts automatically assigns them appropriate depths based on their graph position. Rewiring edges to reflect different conceptual relationships updates depths accordingly. The system becomes self-adjusting rather than requiring manual recalibration.
+
+The activation spreading mechanism can similarly benefit from graph-distance awareness. Currently, when a fully active node spreads activation (\texttt{sliplink.py:23-24}), it adds a fixed amount to each neighbor:
+
+\begin{lstlisting}
+def spread_activation(self):
+    self.destination.buffer += self.intrinsicDegreeOfAssociation()
+\end{lstlisting}
+
+We propose modulating this spread by the conceptual distance between nodes:
+
+\begin{equation}
+\text{buffer}_{\text{dest}} \leftarrow \text{buffer}_{\text{dest}} + \text{activation}_{\text{src}} \times \frac{100 - \text{dist}(\text{src}, \text{dest})}{100}
+\end{equation}
+
+This ensures that activation spreads more strongly to conceptually proximate nodes and weakens with distance, creating a natural gradient in the semantic space.
+
+\subsection{Slippage via Dynamic Weight Adjustment}
+
+Slippage represents Copycat's mechanism for flexible concept substitution during analogical mapping. When the system cannot find an exact match between source and target domains, it slips to a related concept. The current slippability formula (\texttt{conceptMapping.py:21-26}) computes:
+
+\begin{equation}
+\text{slippability}(i \rightarrow j) = \begin{cases}
+100 & \text{if } \text{association}(i,j) = 100 \\
+\text{association}(i,j) \times \left(1 - \left(\frac{\text{depth}_{\text{avg}}}{100}\right)^2\right) & \text{otherwise}
+\end{cases}
+\end{equation}
+
+where $\text{depth}_{\text{avg}} = \frac{\text{depth}_i + \text{depth}_j}{2}$ averages the conceptual depths of the two concepts.
+
+This formulation captures an important insight: slippage should be easier between closely associated concepts and harder for abstract concepts (which have deep theoretical commitments). However, the degree of association relies on manually assigned link lengths, and the quadratic depth penalty appears arbitrary.
+
+Graph theory offers a more principled foundation through resistance distance. In a graph, the resistance distance $R_{ij}$ between nodes $i$ and $j$ can be interpreted as the effective resistance when the graph is viewed as an electrical network with unit resistors on each edge~\cite{klein1993resistance}. Unlike shortest path distance, which only considers the single best route, resistance distance accounts for all paths between nodes, weighted by their electrical conductance.
+
+We propose computing slippability via:
+
+\begin{equation}
+\text{slippability}(i \rightarrow j) = 100 \times \exp\left(-\alpha \cdot R_{ij}\right)
+\end{equation}
+
+where $\alpha$ is a temperature-dependent parameter that modulates exploration. High temperature (exploration mode) decreases $\alpha$, allowing more liberal slippage. Low temperature (exploitation mode) increases $\alpha$, restricting slippage to very closely related concepts.
+
+The resistance distance formulation provides several advantages. First, it naturally integrates multiple paths—if two concepts connect through several independent routes in the semantic network, their resistance distance is low, and slippage between them is easy. Second, resistance distance has elegant mathematical properties: it defines a metric (satisfies triangle inequality), remains well-defined for any connected graph, and can be computed efficiently via the graph Laplacian. Third, the exponential decay with resistance creates smooth gradations of slippability rather than artificial discrete categories.
+
+Consider the slippage between ``left'' and ``right.'' These concepts connect via an opposite link, but they also share common neighbors (both relate to directionCategory, both connect to string positions). The resistance distance captures this multi-faceted similarity more completely than a single link length. Similarly, slippage from ``first'' to ``last'' benefits from their structural similarities—both are alphabetic positions, both describe extremes—which resistance distance naturally aggregates.
+
+The temperature dependence of $\alpha$ introduces adaptive behavior. Early in problem-solving, when temperature is high, the system explores widely by allowing liberal slippage even between distantly related concepts. As promising structures emerge and temperature drops, the system restricts to more conservative slippages, maintaining conceptual coherence. This provides automatic annealing without hardcoded thresholds.
+
+\subsection{Graph Visualization and Metrics}
+
+Figure~\ref{fig:slipnet} presents a visualization of the Slipnet graph structure, with node colors representing conceptual depth and edge thickness indicating link strength (inverse of link length). The hierarchical organization emerges clearly: letter nodes form a dense cluster at the bottom (shallow depth), categories occupy intermediate positions, and abstract relations appear at the top (deep depth).
+
+\begin{figure}[htbp]
+\centering
+% Placeholder for TikZ graph visualization
+% TODO: Generate TikZ code showing ~30 key Slipnet nodes
+% - Node size proportional to activation
+% - Node color gradient: blue (shallow/concrete) to red (deep/abstract)
+% - Edge thickness proportional to strength (inverse link length)
+% - Show: letters, letterCategory, sameness, opposite, left/right, positions
+\includegraphics[width=0.95\textwidth]{figure1_slipnet_graph.pdf}
+\caption{Slipnet graph structure with conceptual depth encoded as node color intensity and link strength as edge thickness.}
+\label{fig:slipnet}
+\end{figure}
+
+Figure~\ref{fig:activation_spread} illustrates activation spreading dynamics over three time steps. Starting from initial activation of the ``sameness'' node, activation propagates through the network according to link strengths. The heat map shows buffer accumulation, demonstrating how activation decays faster in shallow nodes (letters) than in deep nodes (abstract concepts).
+
+\begin{figure}[htbp]
+\centering
+% Placeholder for activation spreading visualization
+% TODO: Create 3-panel time series (t=0, t=5, t=10 updates)
+% - Show activation levels as heat map
+% - Demonstrate differential decay (shallow nodes fade faster)
+% - Highlight propagation paths
+\includegraphics[width=0.95\textwidth]{figure2_activation_spreading.pdf}
+\caption{Activation spreading over time demonstrates differential decay: shallow nodes (letters) lose activation rapidly while deep nodes (abstract concepts) persist.}
+\label{fig:activation_spread}
+\end{figure}
+
+Figure~\ref{fig:resistance_distance} presents a heat map of resistance distances between all node pairs. Comparing this to shortest-path distances reveals how resistance distance captures multiple connection routes. Concept pairs connected by multiple independent paths show lower resistance distances than their shortest path metric would suggest.
+
+\begin{figure}[htbp]
+\centering
+% Placeholder for resistance distance heat map
+% TODO: Matrix visualization with color intensity = resistance distance
+% - All node pairs as matrix
+% - Highlight key pairs (left/right, successor/predecessor, first/last)
+% - Compare to shortest-path distance matrix
+\includegraphics[width=0.95\textwidth]{figure3_resistance_distance.pdf}
+\caption{Resistance distance heat map reveals multi-path connectivity: concepts connected by multiple routes show lower resistance than single-path connections.}
+\label{fig:resistance_distance}
+\end{figure}
+
+\section{The Workspace as a Dynamic Graph}
+
+The Workspace implements Copycat's working memory as a dynamic graph that evolves through structure-building and structure-breaking operations. This section analyzes the Workspace's graph representation, examines current approaches to structural importance and local support, and proposes graph-theoretical replacements using betweenness centrality and clustering coefficients.
+
+\subsection{Workspace Graph Structure}
+
+We formalize the Workspace as a time-varying graph $\mathcal{W}(t) = (V_w(t), E_w(t), \sigma)$ where:
+\begin{itemize}
+\item $V_w(t)$ denotes the set of object nodes (Letters and Groups) at time $t$
+\item $E_w(t)$ represents the set of structural edges (Bonds and Correspondences) at time $t$
+\item $\sigma: V_w \rightarrow \{\text{initial}, \text{modified}, \text{target}\}$ assigns each object to its string
+\end{itemize}
+
+The node set $V_w(t)$ contains two types of objects. Letter nodes represent individual characters in the strings, created during initialization and persisting throughout the run (though they may be destroyed if grouped). Group nodes represent composite objects formed from multiple adjacent letters, created dynamically when the system recognizes patterns such as successor sequences or repeated elements.
+
+The edge set $E_w(t)$ similarly contains two types of structures. Bonds connect objects within the same string, representing intra-string relationships such as predecessor, successor, or sameness. Each bond $b \in E_w$ links a source object to a destination object and carries labels specifying its category (predecessor/successor/sameness), facet (which property grounds the relationship), and direction (left/right or none). Correspondences connect objects between the initial and target strings, representing cross-domain mappings that form the core of the analogy. Each correspondence $c \in E_w$ links an object from the initial string to an object in the target string and contains a set of concept mappings specifying how properties transform.
+
+The dynamic nature of $\mathcal{W}(t)$ distinguishes it from the static Slipnet. Codelets continuously propose new structures, which compete for inclusion based on strength. Structures build (\texttt{bond.py:44-55}, \texttt{group.py:111-119}, \texttt{correspondence.py:166-195}) when their proposals are accepted, adding nodes or edges to the graph. Structures break (\texttt{bond.py:56-70}, \texttt{group.py:143-165}, \texttt{correspondence.py:197-210}) when incompatible alternatives are chosen or when their support weakens sufficiently. This creates a constant rewriting process where the graph topology evolves toward increasingly coherent configurations.
+
+\subsection{Graph Betweenness for Structural Importance}
+
+Current Copycat implementation computes object salience using fixed weighting schemes that do not adapt to graph structure. The code in \texttt{workspaceObject.py:88-95} defines:
+
+\begin{align}
+\text{intraStringSalience} &= 0.2 \times \text{relativeImportance} + 0.8 \times \text{intraStringUnhappiness} \\
+\text{interStringSalience} &= 0.8 \times \text{relativeImportance} + 0.2 \times \text{interStringUnhappiness}
+\end{align}
+
+These fixed ratios (0.2/0.8 and 0.8/0.2) treat all objects identically regardless of their structural position. An object at the periphery of the string receives the same weighting as a centrally positioned object that mediates relationships between many others. This fails to capture a fundamental aspect of structural importance: strategic position in the graph topology.
+
+Graph theory provides a principled solution through betweenness centrality~\cite{freeman1977set,brandes2001faster}. The betweenness centrality of a node $v$ quantifies how often $v$ appears on shortest paths between other nodes:
+
+\begin{equation}
+C_B(v) = \sum_{s \neq v \neq t} \frac{\sigma_{st}(v)}{\sigma_{st}}
+\end{equation}
+
+where $\sigma_{st}$ denotes the number of shortest paths from $s$ to $t$, and $\sigma_{st}(v)$ denotes the number of those paths passing through $v$. Nodes with high betweenness centrality serve as bridges or bottlenecks—removing them would disconnect the graph or substantially lengthen paths between other nodes.
+
+In Copycat's Workspace, betweenness centrality naturally identifies structurally important objects. Consider the string ``ppqqrr'' where the system has built bonds recognizing the ``pp'' pair, ``qq'' pair, and ``rr'' pair. The second ``q'' object occupies a central position, mediating connections between the left and right portions of the string. Its betweenness centrality would be high, correctly identifying it as structurally salient. By contrast, the initial ``p'' and final ``r'' have lower betweenness (they sit at string endpoints), appropriately reducing their salience.
+
+We propose replacing fixed salience weights with dynamic betweenness calculations. For intra-string salience, compute betweenness considering only bonds within the object's string:
+
+\begin{equation}
+\text{intraStringSalience}(v) = 100 \times \frac{C_B(v)}{max_{u \in V_{\text{string}}} C_B(u)}
+\end{equation}
+
+This normalization ensures salience remains in the 0-100 range expected by other system components. For inter-string salience, compute betweenness considering the bipartite graph of correspondences:
+
+\begin{equation}
+\text{interStringSalience}(v) = 100 \times \frac{C_B(v)}{max_{u \in V_w} C_B(u)}
+\end{equation}
+
+where the betweenness calculation now spans both initial and target strings connected by correspondence edges.
+
+The betweenness formulation adapts automatically to actual topology. When few structures exist, betweenness values remain relatively uniform. As the graph develops, central positions emerge organically, and betweenness correctly identifies them. No manual specification of 0.2/0.8 weights is needed—the graph structure itself determines salience.
+
+Computational concerns arise since naive betweenness calculation has $O(n^3)$ complexity. However, Brandes' algorithm~\cite{brandes2001faster} reduces this to $O(nm)$ for graphs with $n$ nodes and $m$ edges. Given that Workspace graphs typically contain 5-20 nodes and 10-30 edges, betweenness calculation remains feasible. Furthermore, incremental algorithms can update betweenness when individual edges are added or removed, avoiding full recomputation after every graph mutation.
+
+\subsection{Local Graph Density and Clustering Coefficients}
+
+Bond external strength currently relies on an ad-hoc local density calculation (\texttt{bond.py:153-175}) that counts supporting bonds in nearby positions. The code defines density as a ratio of actual supports to available slots, then applies an unexplained square root transformation:
+
+\begin{lstlisting}
+density = self.localDensity() / 100.0
+density = density ** 0.5 * 100.0
+\end{lstlisting}
+
+This is then combined with a support factor that decays as $0.6^{1/n^3}$ where $n$ is the number of supporting bonds (\texttt{bond.py:123-132}):
+
+\begin{lstlisting}
+supportFactor = 0.6 ** (1.0 / supporters ** 3)
+strength = supportFactor * density
+\end{lstlisting}
+
+The formulation attempts to capture an important intuition: bonds are stronger when surrounded by similar bonds, creating locally dense structural regions. However, the square root transformation and the specific power law $0.6^{1/n^3}$ lack justification. Why 0.6 rather than 0.5 or 0.7? Why cube the supporter count rather than square it or use it directly?
+
+Graph theory offers a principled alternative through the local clustering coefficient~\cite{watts1998collective}. For a node $v$ with degree $k_v$, the clustering coefficient measures what fraction of $v$'s neighbors are also connected to each other:
+
+\begin{equation}
+C(v) = \frac{2 \times |\{e_{jk}: v_j, v_k \in N(v), e_{jk} \in E\}|}{k_v(k_v - 1)}
+\end{equation}
+
+where $N(v)$ denotes the neighbors of $v$ and $e_{jk}$ denotes an edge between neighbors $j$ and $k$. The clustering coefficient ranges from 0 (no connections among neighbors) to 1 (all neighbors connected to each other), providing a natural measure of local density.
+
+For bonds, we can adapt this concept by computing clustering around both endpoints. Consider a bond $b$ connecting objects $u$ and $v$. Let $N(u)$ be the set of objects bonded to $u$, and $N(v)$ be the set of objects bonded to $v$. We count triangles—configurations where an object in $N(u)$ is also bonded to an object in $N(v)$:
+
+\begin{equation}
+\text{triangles}(b) = |\{(n_u, n_v): n_u \in N(u), n_v \in N(v), (n_u, n_v) \in E\}|
+\end{equation}
+
+The external strength then becomes:
+
+\begin{equation}
+\text{externalStrength}(b) = 100 \times \frac{\text{triangles}(b)}{|N(u)| \times |N(v)|}
+\end{equation}
+
+if the denominator is non-zero, and 0 otherwise. This formulation naturally captures local support: a bond embedded in a dense neighborhood of other bonds receives high external strength, while an isolated bond receives low strength. No arbitrary constants (0.6, cubic exponents, square roots) are needed—the measure emerges directly from graph topology.
+
+An alternative formulation uses ego network density. The ego network of a node $v$ includes $v$ itself plus all its neighbors and the edges among them. The ego network density measures how interconnected this local neighborhood is:
+
+\begin{equation}
+\rho_{\text{ego}}(v) = \frac{|E_{\text{ego}}(v)|}{|V_{\text{ego}}(v)| \times (|V_{\text{ego}}(v)| - 1) / 2}
+\end{equation}
+
+For a bond connecting $u$ and $v$, we could compute the combined ego network density:
+
+\begin{equation}
+\text{externalStrength}(b) = 100 \times \frac{\rho_{\text{ego}}(u) + \rho_{\text{ego}}(v)}{2}
+\end{equation}
+
+Both the clustering coefficient and ego network density approaches eliminate hardcoded constants while providing theoretically grounded measures of local structure. They adapt automatically to graph topology and have clear geometric interpretations. Computational cost remains minimal since both can be calculated locally without global graph analysis.
+
+\subsection{Complete Substitution Table}
+
+Table~\ref{tab:substitutions} presents comprehensive proposals for replacing each hardcoded constant with an appropriate graph metric. Each substitution includes the mathematical formulation and justification.
+
+\begin{table}[htbp]
+\centering
+\small
+\begin{tabular}{p{3cm}p{4.5cm}p{7cm}}
+\toprule
+\textbf{Original Constant} & \textbf{Graph Metric Replacement} & \textbf{Justification} \\
+\midrule
+memberCompatibility (0.7/1.0) & Structural equivalence: $SE(u,v) = 1 - \frac{|N(u) \triangle N(v)|}{|N(u) \cup N(v)|}$ & Objects with similar neighborhoods are compatible \\
+facetFactor (0.7/1.0) & Degree centrality: $\frac{deg(f)}{max_v deg(v)}$ & High-degree facets in Slipnet are more important \\
+supportFactor ($0.6^{1/n^3}$) & Clustering coefficient: $C(v) = \frac{2T}{k(k-1)}$ & Natural measure of local embeddedness \\
+jump\_threshold (55.0) & Percolation threshold: $\theta_c = \frac{\langle k \rangle}{N-1} \times 100$ & Threshold adapts to network connectivity \\
+salience\_weights (0.2/0.8, 0.8/0.2) & Betweenness centrality: $C_B(v) = \sum \frac{\sigma_{st}(v)}{\sigma_{st}}$ & Strategic position in graph topology \\
+length\_factors (5, 20, 60, 90) & Subgraph density: $\rho(G_{sub}) = \frac{2|E|}{|V|(|V|-1)} \times 100$ & Larger, denser groups score higher naturally \\
+mapping\_factors (0.8, 1.2, 1.6) & Path multiplicity: \# edge-disjoint paths & More connection routes = stronger mapping \\
+\bottomrule
+\end{tabular}
+\caption{Proposed graph-theoretical replacements for hardcoded constants. Each metric provides principled, adaptive measurement based on graph structure.}
+\label{tab:substitutions}
+\end{table}
+
+\subsection{Algorithmic Implementations}
+
+Algorithm~\ref{alg:bond_strength} presents pseudocode for computing bond external strength using the clustering coefficient approach. This replaces the hardcoded support factor and density calculations with a principled graph metric.
+
+\begin{algorithm}[htbp]
+\caption{Graph-Based Bond External Strength}
+\label{alg:bond_strength}
+\begin{algorithmic}[1]
+\REQUIRE Bond $b$ with endpoints $(u, v)$
+\ENSURE Updated externalStrength
+\STATE $N_u \leftarrow$ \textsc{GetConnectedObjects}$(u)$
+\STATE $N_v \leftarrow$ \textsc{GetConnectedObjects}$(v)$
+\STATE $\text{triangles} \leftarrow 0$
+\FOR{each $n_u \in N_u$}
+    \FOR{each $n_v \in N_v$}
+        \IF{$(n_u, n_v) \in E$ \OR $(n_v, n_u) \in E$}
+            \STATE $\text{triangles} \leftarrow \text{triangles} + 1$
+        \ENDIF
+    \ENDFOR
+\ENDFOR
+\STATE $\text{possible} \leftarrow |N_u| \times |N_v|$
+\IF{$\text{possible} > 0$}
+    \STATE $b.\text{externalStrength} \leftarrow 100 \times \text{triangles} / \text{possible}$
+\ELSE
+    \STATE $b.\text{externalStrength} \leftarrow 0$
+\ENDIF
+\RETURN $b.\text{externalStrength}$
+\end{algorithmic}
+\end{algorithm}
+
+Algorithm~\ref{alg:betweenness_salience} shows how to compute object salience using betweenness centrality. This eliminates the fixed 0.2/0.8 weights in favor of topology-driven importance.
+
+\begin{algorithm}[htbp]
+\caption{Betweenness-Based Salience}
+\label{alg:betweenness_salience}
+\begin{algorithmic}[1]
+\REQUIRE Object $obj$, Workspace graph $G = (V, E)$
+\ENSURE Salience score
+\STATE $\text{betweenness} \leftarrow$ \textsc{ComputeBetweennessCentrality}$(G)$
+\STATE $\text{maxBetweenness} \leftarrow max_{v \in V} \text{betweenness}[v]$
+\IF{$\text{maxBetweenness} > 0$}
+    \STATE $\text{normalized} \leftarrow \text{betweenness}[obj] / \text{maxBetweenness}$
+\ELSE
+    \STATE $\text{normalized} \leftarrow 0$
+\ENDIF
+\RETURN $\text{normalized} \times 100$
+\end{algorithmic}
+\end{algorithm}
+
+Algorithm~\ref{alg:adaptive_threshold} implements an adaptive activation threshold based on network percolation theory. Rather than using a fixed value of 55.0, the threshold adapts to current Slipnet connectivity.
+
+\begin{algorithm}[htbp]
+\caption{Adaptive Activation Threshold}
+\label{alg:adaptive_threshold}
+\begin{algorithmic}[1]
+\REQUIRE Slipnet graph $S = (V, E, \text{activation})$
+\ENSURE Dynamic threshold $\theta$
+\STATE $\text{activeNodes} \leftarrow \{v \in V : \text{activation}[v] > 0\}$
+\STATE $\text{avgDegree} \leftarrow$ mean$(deg(v)$ for $v \in \text{activeNodes})$
+\STATE $N \leftarrow |V|$
+\STATE $\theta \leftarrow (\text{avgDegree} / (N - 1)) \times 100$
+\RETURN $\theta$
+\end{algorithmic}
+\end{algorithm}
+
+These algorithms demonstrate the practical implementability of graph-theoretical replacements. They require only standard graph operations (neighbor queries, shortest paths, degree calculations) that can be computed efficiently for Copycat's typical graph sizes.
+
+\subsection{Workspace Evolution Visualization}
+
+Figure~\ref{fig:workspace_evolution} illustrates how the Workspace graph evolves over four time steps while solving the problem ``abc $\rightarrow$ abd, what is ppqqrr?'' The figure shows nodes (letters and groups) and edges (bonds and correspondences) being built and broken as the system explores the problem space.
+
+\begin{figure}[htbp]
+\centering
+% Placeholder for workspace evolution visualization
+% TODO: Create 4-panel sequence showing graph changes
+% - Panel 1 (t=0): Initial letters only, no bonds
+% - Panel 2 (t=50): Some bonds form (pp, qq, rr groups emerging)
+% - Panel 3 (t=150): Correspondences begin forming
+% - Panel 4 (t=250): Stable structure with groups and correspondences
+% - Annotate nodes with betweenness values
+% - Show structures being built (green) and broken (red)
+\includegraphics[width=0.95\textwidth]{figure4_workspace_evolution.pdf}
+\caption{Workspace graph evolution during analogical reasoning shows progressive structure formation, with betweenness centrality values identifying strategically important objects.}
+\label{fig:workspace_evolution}
+\end{figure}
+
+Figure~\ref{fig:betweenness_dynamics} plots betweenness centrality values for each object over time. Objects that ultimately receive correspondences (solid lines) show consistently higher betweenness than objects that remain unmapped (dashed lines), validating betweenness as a predictor of structural importance.
+
+\begin{figure}[htbp]
+\centering
+% Placeholder for betweenness time series
+% TODO: Line plot with time on x-axis, betweenness on y-axis
+% - Solid lines: objects that get correspondences
+% - Dashed lines: objects that don't
+% - Show: betweenness predicts correspondence selection
+\includegraphics[width=0.95\textwidth]{figure5_betweenness_dynamics.pdf}
+\caption{Betweenness centrality dynamics reveal that objects with sustained high centrality are preferentially selected for correspondences.}
+\label{fig:betweenness_dynamics}
+\end{figure}
+
+Figure~\ref{fig:clustering_distribution} compares the distribution of clustering coefficients in successful versus failed problem-solving runs. Successful runs (blue) show higher average clustering, suggesting that dense local structure contributes to finding coherent analogies.
+
+\begin{figure}[htbp]
+\centering
+% Placeholder for clustering histogram
+% TODO: Overlaid histograms (or box plots)
+% - Blue: successful runs (found correct answer)
+% - Red: failed runs (no answer or incorrect)
+% - X-axis: clustering coefficient, Y-axis: frequency
+% - Show: successful runs have higher average clustering
+\includegraphics[width=0.95\textwidth]{figure6_clustering_distribution.pdf}
+\caption{Successful analogy-making runs show higher clustering coefficients, indicating that locally dense structure promotes coherent solutions.}
+\label{fig:clustering_distribution}
+\end{figure}
+
+\section{Discussion}
+
+The graph-theoretical reformulation of Copycat offers several advantages over the current hardcoded approach: principled theoretical foundations, automatic adaptation to problem structure, enhanced interpretability, and natural connections to modern machine learning. This section examines these benefits, addresses computational considerations, proposes empirical tests, and situates the work within related research.
+
+\subsection{Theoretical Advantages}
+
+Graph metrics provide rigorous mathematical foundations that hardcoded constants lack. Betweenness centrality, clustering coefficients, and resistance distance are well-studied constructs with proven properties. We know their computational complexity, understand their behavior under various graph topologies, and can prove theorems about their relationships. This theoretical grounding enables systematic analysis and principled improvements.
+
+Consider the contrast between the current support factor $0.6^{1/n^3}$ and the clustering coefficient. The former offers no explanation for its specific functional form. Why 0.6 rather than any other base? Why raise it to the power $1/n^3$ rather than $1/n^2$ or $1/n^4$? The choice appears arbitrary, selected through trial and error. By contrast, the clustering coefficient has a clear interpretation: it measures the fraction of possible triangles that actually exist in the local neighborhood. Its bounds are known ($0 \leq C \leq 1$), its relationship to other graph properties is established (related to transitivity and small-world structure~\cite{watts1998collective}), and its behavior under graph transformations can be analyzed.
+
+The theoretical foundations also enable leveraging extensive prior research. Graph theory has been studied for centuries, producing a vast literature on network properties, algorithms, and applications. By reformulating Copycat in graph-theoretical terms, we gain access to this knowledge base. Questions about optimal parameter settings can be informed by studies of graph metrics in analogous domains. Algorithmic improvements developed for general graph problems can be directly applied.
+
+Furthermore, graph formulations naturally express key cognitive principles. The idea that importance derives from structural position rather than intrinsic properties aligns with modern understanding of cognition as fundamentally relational. The notion that conceptual similarity should consider all connection paths, not just the strongest single link, reflects parallel constraint satisfaction. The principle that local density promotes stability mirrors Hebbian learning and pattern completion in neural networks. Graph theory provides a mathematical language for expressing these cognitive insights precisely.
+
+\subsection{Adaptability and Scalability}
+
+Graph metrics automatically adjust to problem characteristics, eliminating the brittleness of fixed parameters. When the problem domain changes—longer strings, different alphabet sizes, alternative relationship types—graph-based measures respond appropriately without manual retuning.
+
+Consider the length factor problem discussed in Section 2.3. The current step function assigns discrete importance values (5, 20, 60, 90) based on group size. This works adequately for strings of length 3-6 but scales poorly. Graph-based subgraph density, by contrast, adapts naturally. For a group of $n$ objects with $m$ bonds among them, the density $\rho = 2m/(n(n-1))$ ranges continuously from 0 (no bonds) to 1 (fully connected). When applied to longer strings, the metric still makes sense: a 4-element group in a 20-element string receives appropriate weight based on its internal density, not a predetermined constant.
+
+Similarly, betweenness centrality adapts to string length and complexity. In a short string with few objects, betweenness values remain relatively uniform—no object occupies a uniquely strategic position. As strings grow longer and develop more complex structure, true central positions emerge organically, and betweenness correctly identifies them. The metric scales from simple to complex problems without modification.
+
+This adaptability extends to entirely new problem domains. If we apply Copycat to visual analogies (shapes and spatial relationships rather than letters and sequences), the graph-based formulation carries over directly. Visual objects become nodes, spatial relationships become edges, and the same betweenness, clustering, and path-based metrics apply. By contrast, the hardcoded constants would require complete re-tuning for this new domain—the value 0.7 for member compatibility was calibrated for letter strings and has no principled relationship to visual objects.
+
+\subsection{Computational Considerations}
+
+Replacing hardcoded constants with graph computations introduces computational overhead. Table~\ref{tab:complexity} analyzes the complexity of key graph operations and their frequency in Copycat's execution.
+
+\begin{table}[htbp]
+\centering
+\begin{tabular}{llll}
+\toprule
+\textbf{Metric} & \textbf{Complexity} & \textbf{Frequency} & \textbf{Mitigation Strategy} \\
+\midrule
+Betweenness (naive) & $O(n^3)$ & Per codelet & Use Brandes algorithm \\
+Betweenness (Brandes) & $O(nm)$ & Per codelet & Incremental updates \\
+Clustering coefficient & $O(d^2)$ & Per node update & Local computation \\
+Shortest path (Dijkstra) & $O(n \log n + m)$ & Occasional & Cache results \\
+Resistance distance & $O(n^3)$ & Slippage only & Pseudo-inverse caching \\
+Structural equivalence & $O(d^2)$ & Bond proposal & Neighbor set operations \\
+Subgraph density & $O(m_{sub})$ & Group update & Count local edges only \\
+\bottomrule
+\end{tabular}
+\caption{Computational complexity of graph metrics and mitigation strategies. Here $n$ = nodes, $m$ = edges, $d$ = degree, $m_{sub}$ = edges in subgraph.}
+\label{tab:complexity}
+\end{table}
+
+For typical Workspace graphs (5-20 nodes, 10-30 edges), even the most expensive operations remain tractable. The Brandes betweenness algorithm~\cite{brandes2001faster} completes in milliseconds for graphs of this size. Clustering coefficients require only local neighborhood analysis ($O(d^2)$ where $d$ is degree, typically $d \leq 4$ in Copycat). Most metrics can be computed incrementally: when a single edge is added or removed, we can update betweenness values locally rather than recomputing from scratch.
+
+The Slipnet presents different considerations. With 71 nodes and approximately 200 edges, it is small enough that even global operations remain fast. Computing all-pairs shortest paths via Floyd-Warshall takes $O(71^3) \approx 360,000$ operations—negligible on modern hardware. The resistance distance calculation, which requires computing the pseudo-inverse of the graph Laplacian, also completes quickly for 71 nodes and can be cached since the Slipnet structure is static.
+
+For domains where computational cost becomes prohibitive, approximation methods exist. Betweenness can be approximated by sampling a subset of shortest paths rather than computing all paths, reducing complexity to $O(km)$ where $k$ is the sample size~\cite{newman2018networks}. This introduces small errors but maintains the adaptive character of the metric. Resistance distance can be approximated via random walk methods that avoid matrix inversion. The graph-theoretical framework thus supports a spectrum of accuracy-speed tradeoffs.
+
+\subsection{Empirical Predictions and Testable Hypotheses}
+
+The graph-theoretical reformulation generates specific empirical predictions that can be tested experimentally:
+
+\paragraph{Hypothesis 1: Improved Performance Consistency}
+Graph-based Copycat should exhibit more consistent performance across problems of varying difficulty than the original hardcoded version. As problem complexity increases (longer strings, more abstract relationships), adaptive metrics should maintain appropriateness while fixed constants become less suitable. We predict smaller variance in answer quality and convergence time for the graph-based system.
+
+\paragraph{Hypothesis 2: Temperature-Graph Entropy Correlation}
+System temperature should correlate with graph-theoretical measures of disorder. Specifically, we predict that temperature inversely correlates with Workspace graph clustering coefficient (high clustering = low temperature) and correlates with betweenness centrality variance (many objects with very different centralities = high temperature). This would validate temperature as reflecting structural coherence.
+
+\paragraph{Hypothesis 3: Clustering Predicts Success}
+Successful problem-solving runs should show systematically higher average clustering coefficients in their final Workspace graphs than failed or incomplete runs. This would support the hypothesis that locally dense structure promotes coherent analogies.
+
+\paragraph{Hypothesis 4: Betweenness Predicts Correspondence Selection}
+Objects with higher time-averaged betweenness centrality should be preferentially selected for correspondences. Plotting correspondence formation time against prior betweenness should show positive correlation, demonstrating that strategic structural position determines mapping priority.
+
+\paragraph{Hypothesis 5: Graceful Degradation}
+When problem difficulty increases (e.g., moving from 3-letter to 10-letter strings), graph-based Copycat should show more graceful performance degradation than the hardcoded version. We predict a smooth decline in success rate rather than a sharp cliff, since metrics scale continuously.
+
+These hypotheses can be tested by implementing the graph-based modifications and running benchmark comparisons. The original Copycat's behavior is well-documented, providing a baseline for comparison. Running both versions on extended problem sets (varying string length, transformation complexity, and domain characteristics) would generate the data needed to evaluate these predictions.
+
+\subsection{Connections to Related Work}
+
+The graph-theoretical reformulation of Copycat connects to several research streams in cognitive science, artificial intelligence, and neuroscience.
+
+\paragraph{Analogical Reasoning}
+Structure-mapping theory~\cite{gentner1983structure} emphasizes systematic structural alignment in analogy-making. Gentner's approach explicitly compares relational structures, seeking one-to-one correspondences that preserve higher-order relationships. Our graph formulation makes this structuralism more precise: analogies correspond to graph homomorphisms that preserve edge labels and maximize betweenness-weighted node matches. The resistance distance formulation of slippage provides a quantitative measure of ``systematicity''—slippages along short resistance paths maintain more structural similarity than jumps across large distances.
+
+\paragraph{Graph Neural Networks}
+Modern graph neural networks (GNNs)~\cite{scarselli2008graph} learn to compute node and edge features through message passing on graphs. The Copycat reformulation suggests a potential hybrid: use GNNs to learn graph metric computations from data rather than relying on fixed formulas like betweenness. The GNN could learn to predict which objects deserve high salience based on training examples, potentially discovering novel structural patterns that standard metrics miss. Conversely, Copycat's symbolic structure could provide interpretability to GNN analogical reasoning systems.
+
+\paragraph{Conceptual Spaces}
+Gärdenfors' conceptual spaces framework~\cite{gardenfors2000conceptual} represents concepts geometrically, with similarity as distance in a metric space. The resistance distance reformulation of the Slipnet naturally produces a metric space: resistance distance satisfies the triangle inequality and provides a true distance measure over concepts. This connects Copycat to the broader conceptual spaces program and suggests using dimensional reduction techniques to visualize the conceptual geometry.
+
+\paragraph{Small-World Networks}
+Neuroscience research reveals that brain networks exhibit small-world properties: high local clustering combined with short path lengths between distant regions~\cite{watts1998collective}. The Slipnet's structure shows similar characteristics—abstract concepts cluster together (high local clustering) while remaining accessible from concrete concepts (short paths). This parallel suggests that graph properties successful in natural cognitive architectures may also benefit artificial systems.
+
+\paragraph{Network Science in Cognition}
+Growing research applies network science methods to cognitive phenomena: semantic networks, problem-solving processes, and knowledge representation~\cite{newman2018networks}. The Copycat reformulation contributes to this trend by demonstrating that a symbolic cognitive architecture can be rigorously analyzed through graph-theoretical lenses. The approach may generalize to other cognitive architectures, suggesting a broader research program of graph-based cognitive modeling.
+
+\subsection{Limitations and Open Questions}
+
+Despite its advantages, the graph-theoretical reformulation faces challenges and raises open questions.
+
+\paragraph{Parameter Selection}
+While graph metrics eliminate many hardcoded constants, some parameters remain. The resistance distance formulation requires choosing $\alpha$ (the decay parameter in $\exp(-\alpha R_{ij})$). The conceptual depth scaling requires selecting $k$. The betweenness normalization could use different schemes (min-max, z-score, etc.). These choices have less impact than the original hardcoded constants and can be derived more principally (e.g., $\alpha$ from temperature), but complete parameter elimination remains elusive.
+
+\paragraph{Multi-Relational Graphs}
+The Slipnet contains multiple edge types (category, instance, property, slip, non-slip links). Standard graph metrics like betweenness treat all edges identically. Properly handling multi-relational graphs requires either edge-type-specific metrics or careful encoding of edge types into weights. Research on knowledge graph embeddings may offer solutions.
+
+\paragraph{Temporal Dynamics}
+The Workspace graph evolves over time, but graph metrics provide static snapshots. Capturing temporal patterns—how centrality changes, whether oscillations occur, what trajectory successful runs follow—requires time-series analysis of graph metrics. Dynamic graph theory and temporal network analysis offer relevant techniques but have not yet been integrated into the Copycat context.
+
+\paragraph{Learning and Meta-Learning}
+The current proposal manually specifies which graph metric replaces which constant (betweenness for salience, clustering for support, etc.). Could the system learn these associations from experience? Meta-learning approaches might discover that different graph metrics work best for different problem types, automatically adapting the metric selection strategy.
+
+\subsection{Broader Implications}
+
+Beyond Copycat specifically, this work demonstrates a general methodology for modernizing legacy AI systems. Many symbolic AI systems from the 1980s and 1990s contain hardcoded parameters tuned for specific domains. Graph-theoretical reformulation offers a pathway to increase their adaptability and theoretical grounding. The approach represents a middle ground between purely symbolic AI (which risks brittleness through excessive hardcoding) and purely statistical AI (which risks opacity through learned parameters). Graph metrics provide structure while remaining adaptive.
+
+The reformulation also suggests bridges between symbolic and neural approaches. Graph neural networks could learn to compute custom metrics for specific domains while maintaining interpretability through graph visualization. Copycat's symbolic constraints (objects, bonds, correspondences) could provide inductive biases for neural analogy systems. This hybrid direction may prove more fruitful than purely symbolic or purely neural approaches in isolation.
+
+\section{Conclusion}
+
+This paper has proposed a comprehensive graph-theoretical reformulation of the Copycat architecture. We identified numerous hardcoded constants in the original implementation—including bond compatibility factors, support decay functions, salience weights, and activation thresholds—that lack principled justification and limit adaptability. For each constant, we proposed a graph metric replacement: structural equivalence for compatibility, clustering coefficients for local support, betweenness centrality for salience, resistance distance for slippage, and percolation thresholds for activation.
+
+These replacements provide three key advantages. Theoretically, they rest on established mathematical frameworks with proven properties and extensive prior research. Practically, they adapt automatically to problem structure without requiring manual retuning for new domains. Cognitively, they align with modern understanding of brain networks and relational cognition.
+
+The reformulation reinterprets both major components of Copycat's architecture. The Slipnet becomes a weighted graph where conceptual depth emerges from minimum distance to concrete nodes and slippage derives from resistance distance between concepts. The Workspace becomes a dynamic graph where object salience reflects betweenness centrality and structural support derives from clustering coefficients. Standard graph algorithms can compute these metrics efficiently for Copycat's typical graph sizes.
+
+\subsection{Future Work}
+
+Several directions promise to extend and validate this work:
+
+\paragraph{Implementation and Validation}
+The highest priority is building a prototype graph-based Copycat and empirically testing the hypotheses proposed in Section 5.3. Comparing performance between original and graph-based versions on extended problem sets would quantify the benefits of adaptability. Analyzing correlation between graph metrics and behavioral outcomes (correspondence selection, answer quality) would validate the theoretical predictions.
+
+\paragraph{Domain Transfer}
+Testing graph-based Copycat on non-letter-string domains (visual analogies, numerical relationships, abstract concepts) would demonstrate genuine adaptability. The original hardcoded constants would require complete retuning for such domains, while graph metrics should transfer directly. Success in novel domains would provide strong evidence for the reformulation's value.
+
+\paragraph{Neuroscience Comparison}
+Comparing Copycat's graph metrics to brain imaging data during human analogy-making could test cognitive plausibility. Do brain regions with high betweenness centrality show increased activation during analogy tasks? Does clustering in functional connectivity correlate with successful analogy completion? Such comparisons would ground the computational model in neural reality.
+
+\paragraph{Hybrid Neural-Symbolic Systems}
+Integrating graph neural networks to learn custom metrics for specific problem types represents an exciting direction. Rather than manually specifying betweenness for salience, a GNN could learn which graph features predict important objects, potentially discovering novel structural patterns. This would combine symbolic interpretability with neural adaptability.
+
+\paragraph{Meta-Learning Metric Selection}
+Developing meta-learning systems that automatically discover which graph metrics work best for which problem characteristics would eliminate remaining parameter choices. The system could learn from experience that betweenness centrality predicts importance for spatial problems while eigenvector centrality works better for temporal problems, adapting its metric selection strategy.
+
+\paragraph{Extension to Other Cognitive Architectures}
+The methodology developed here—identifying hardcoded constants and replacing them with graph metrics—may apply to other symbolic cognitive architectures. Systems like SOAR, ACT-R, and Companion~\cite{forbus2017companion} similarly contain numerous parameters that could potentially be reformulated graph-theoretically. This suggests a broader research program of graph-based cognitive architecture design.
+
+\subsection{Closing Perspective}
+
+The hardcoded constants in Copycat's original implementation represented practical necessities given the computational constraints and theoretical understanding of the early 1990s. Mitchell and Hofstadter made pragmatic choices that enabled the system to work, demonstrating fluid analogical reasoning for the first time in a computational model. These achievements deserve recognition.
+
+Three decades later, we can build on this foundation with tools unavailable to the original designers. Graph theory has matured into a powerful analytical framework. Computational resources enable real-time calculation of complex metrics. Understanding of cognitive neuroscience has deepened, revealing the brain's graph-like organization. Modern machine learning offers hybrid symbolic-neural approaches. These advances create opportunities to refine Copycat's architecture while preserving its core insights about fluid cognition.
+
+The graph-theoretical reformulation honors Copycat's original vision—modeling analogy-making as parallel constraint satisfaction over structured representations—while addressing its limitations. By replacing hardcoded heuristics with principled constructs, we move toward cognitive architectures that are both theoretically grounded and practically adaptive. This represents not a rejection of symbolic AI but rather its evolution, incorporating modern graph theory and network science to build more robust and flexible cognitive models.
+
+\bibliographystyle{plain}
+\bibliography{references}
+
+\end{document}

LaTeX/references.bib

@@ -0,0 +1,140 @@
+@book{mitchell1993analogy,
+  title={Analogy-Making as Perception: A Computer Model},
+  author={Mitchell, Melanie},
+  year={1993},
+  publisher={MIT Press},
+  address={Cambridge, MA}
+}
+
+@book{hofstadter1995fluid,
+  title={Fluid Concepts and Creative Analogies: Computer Models of the Fundamental Mechanisms of Thought},
+  author={Hofstadter, Douglas R. and FARG},
+  year={1995},
+  publisher={Basic Books},
+  address={New York, NY}
+}
+
+@article{chalmers1992high,
+  title={High-Level Perception, Representation, and Analogy: A Critique of Artificial Intelligence Methodology},
+  author={Chalmers, David J. and French, Robert M. and Hofstadter, Douglas R.},
+  journal={Journal of Experimental \& Theoretical Artificial Intelligence},
+  volume={4},
+  number={3},
+  pages={185--211},
+  year={1992},
+  publisher={Taylor \& Francis}
+}
+
+@article{freeman1977set,
+  title={A Set of Measures of Centrality Based on Betweenness},
+  author={Freeman, Linton C.},
+  journal={Sociometry},
+  volume={40},
+  number={1},
+  pages={35--41},
+  year={1977},
+  publisher={JSTOR}
+}
+
+@article{brandes2001faster,
+  title={A Faster Algorithm for Betweenness Centrality},
+  author={Brandes, Ulrik},
+  journal={Journal of Mathematical Sociology},
+  volume={25},
+  number={2},
+  pages={163--177},
+  year={2001},
+  publisher={Taylor \& Francis}
+}
+
+@article{watts1998collective,
+  title={Collective Dynamics of 'Small-World' Networks},
+  author={Watts, Duncan J. and Strogatz, Steven H.},
+  journal={Nature},
+  volume={393},
+  number={6684},
+  pages={440--442},
+  year={1998},
+  publisher={Nature Publishing Group}
+}
+
+@book{newman2018networks,
+  title={Networks},
+  author={Newman, Mark E. J.},
+  year={2018},
+  publisher={Oxford University Press},
+  edition={2nd},
+  address={Oxford, UK}
+}
+
+@article{klein1993resistance,
+  title={Resistance Distance},
+  author={Klein, Douglas J. and Randi\'{c}, Milan},
+  journal={Journal of Mathematical Chemistry},
+  volume={12},
+  number={1},
+  pages={81--95},
+  year={1993},
+  publisher={Springer}
+}
+
+@article{scarselli2008graph,
+  title={The Graph Neural Network Model},
+  author={Scarselli, Franco and Gori, Marco and Tsoi, Ah Chung and Hagenbuchner, Markus and Monfardini, Gabriele},
+  journal={IEEE Transactions on Neural Networks},
+  volume={20},
+  number={1},
+  pages={61--80},
+  year={2008},
+  publisher={IEEE}
+}
+
+@article{gentner1983structure,
+  title={Structure-Mapping: A Theoretical Framework for Analogy},
+  author={Gentner, Dedre},
+  journal={Cognitive Science},
+  volume={7},
+  number={2},
+  pages={155--170},
+  year={1983},
+  publisher={Wiley Online Library}
+}
+
+@book{gardenfors2000conceptual,
+  title={Conceptual Spaces: The Geometry of Thought},
+  author={G\"{a}rdenfors, Peter},
+  year={2000},
+  publisher={MIT Press},
+  address={Cambridge, MA}
+}
+
+@article{french1995subcognition,
+  title={Subcognition and the Limits of the Turing Test},
+  author={French, Robert M.},
+  journal={Mind},
+  volume={99},
+  number={393},
+  pages={53--65},
+  year={1995},
+  publisher={Oxford University Press}
+}
+
+@article{forbus2017companion,
+  title={Companion Cognitive Systems: A Step toward Human-Level AI},
+  author={Forbus, Kenneth D. and Hinrichs, Thomas R.},
+  journal={AI Magazine},
+  volume={38},
+  number={4},
+  pages={25--35},
+  year={2017},
+  publisher={AAAI}
+}
+
+@inproceedings{kansky2017schema,
+  title={Schema Networks: Zero-Shot Transfer with a Generative Causal Model of Intuitive Physics},
+  author={Kansky, Ken and Silver, Tom and M\'{e}ly, David A. and Eldawy, Mohamed and L\'{a}zaro-Gredilla, Miguel and Lou, Xinghua and Dorfman, Nimrod and Sidor, Szymon and Phoenix, Scott and George, Dileep},
+  booktitle={International Conference on Machine Learning},
+  pages={1809--1818},
+  year={2017},
+  organization={PMLR}
+}

LaTeX/resistance_distance.py

@@ -0,0 +1,203 @@
+"""
+Compute and visualize resistance distance matrix for Slipnet concepts (Figure 3)
+Resistance distance considers all paths between nodes, weighted by conductance
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import networkx as nx
+from scipy.linalg import pinv
+
+# Define key Slipnet nodes
+key_nodes = [
+    'a', 'b', 'c',
+    'letterCategory',
+    'left', 'right',
+    'leftmost', 'rightmost',
+    'first', 'last',
+    'predecessor', 'successor', 'sameness',
+    'identity', 'opposite',
+]
+
+# Create graph with resistances (link lengths)
+G = nx.Graph()
+edges = [
+    # Letters to category
+    ('a', 'letterCategory', 97),
+    ('b', 'letterCategory', 97),
+    ('c', 'letterCategory', 97),
+    # Sequential relationships
+    ('a', 'b', 50),
+    ('b', 'c', 50),
+    # Bond types
+    ('predecessor', 'successor', 60),
+    ('sameness', 'identity', 50),
+    # Opposite relations
+    ('left', 'right', 80),
+    ('first', 'last', 80),
+    ('leftmost', 'rightmost', 90),
+    # Slippable connections
+    ('left', 'leftmost', 90),
+    ('right', 'rightmost', 90),
+    ('first', 'leftmost', 100),
+    ('last', 'rightmost', 100),
+    # Abstract relations
+    ('identity', 'opposite', 70),
+    ('predecessor', 'identity', 60),
+    ('successor', 'identity', 60),
+    ('sameness', 'identity', 40),
+]
+
+for src, dst, link_len in edges:
+    # Resistance = link length, conductance = 1/resistance
+    G.add_edge(src, dst, resistance=link_len, conductance=1.0/link_len)
+
+# Only keep nodes that are in our key list and connected
+connected_nodes = [n for n in key_nodes if n in G.nodes()]
+
+def compute_resistance_distance(G, nodes):
+    """Compute resistance distance matrix using graph Laplacian"""
+    # Create mapping from nodes to indices
+    node_to_idx = {node: i for i, node in enumerate(nodes)}
+    n = len(nodes)
+
+    # Build Laplacian matrix (weighted by conductance)
+    L = np.zeros((n, n))
+    for i, node_i in enumerate(nodes):
+        for j, node_j in enumerate(nodes):
+            if G.has_edge(node_i, node_j):
+                conductance = G[node_i][node_j]['conductance']
+                L[i, j] = -conductance
+                L[i, i] += conductance
+
+    # Compute pseudo-inverse of Laplacian
+    try:
+        L_pinv = pinv(L)
+    except:
+        # Fallback: use shortest path distances
+        return compute_shortest_path_matrix(G, nodes)
+
+    # Resistance distance: R_ij = L+_ii + L+_jj - 2*L+_ij
+    R = np.zeros((n, n))
+    for i in range(n):
+        for j in range(n):
+            R[i, j] = L_pinv[i, i] + L_pinv[j, j] - 2 * L_pinv[i, j]
+
+    return R
+
+def compute_shortest_path_matrix(G, nodes):
+    """Compute shortest path distance matrix"""
+    n = len(nodes)
+    D = np.zeros((n, n))
+    for i, node_i in enumerate(nodes):
+        for j, node_j in enumerate(nodes):
+            if i == j:
+                D[i, j] = 0
+            else:
+                try:
+                    path = nx.shortest_path(G, node_i, node_j, weight='resistance')
+                    D[i, j] = sum(G[path[k]][path[k+1]]['resistance']
+                                 for k in range(len(path)-1))
+                except nx.NetworkXNoPath:
+                    D[i, j] = 1000  # Large value for disconnected nodes
+    return D
+
+# Compute both matrices
+R_resistance = compute_resistance_distance(G, connected_nodes)
+R_shortest = compute_shortest_path_matrix(G, connected_nodes)
+
+# Create visualization
+fig, axes = plt.subplots(1, 2, figsize=(16, 7))
+
+# Left: Resistance distance
+ax_left = axes[0]
+im_left = ax_left.imshow(R_resistance, cmap='YlOrRd', aspect='auto')
+ax_left.set_xticks(range(len(connected_nodes)))
+ax_left.set_yticks(range(len(connected_nodes)))
+ax_left.set_xticklabels(connected_nodes, rotation=45, ha='right', fontsize=9)
+ax_left.set_yticklabels(connected_nodes, fontsize=9)
+ax_left.set_title('Resistance Distance Matrix\n(Considers all paths, weighted by conductance)',
+                 fontsize=12, fontweight='bold')
+cbar_left = plt.colorbar(im_left, ax=ax_left, fraction=0.046, pad=0.04)
+cbar_left.set_label('Resistance Distance', rotation=270, labelpad=20)
+
+# Add grid
+ax_left.set_xticks(np.arange(len(connected_nodes))-0.5, minor=True)
+ax_left.set_yticks(np.arange(len(connected_nodes))-0.5, minor=True)
+ax_left.grid(which='minor', color='gray', linestyle='-', linewidth=0.5)
+
+# Right: Shortest path distance
+ax_right = axes[1]
+im_right = ax_right.imshow(R_shortest, cmap='YlOrRd', aspect='auto')
+ax_right.set_xticks(range(len(connected_nodes)))
+ax_right.set_yticks(range(len(connected_nodes)))
+ax_right.set_xticklabels(connected_nodes, rotation=45, ha='right', fontsize=9)
+ax_right.set_yticklabels(connected_nodes, fontsize=9)
+ax_right.set_title('Shortest Path Distance Matrix\n(Only considers single best path)',
+                  fontsize=12, fontweight='bold')
+cbar_right = plt.colorbar(im_right, ax=ax_right, fraction=0.046, pad=0.04)
+cbar_right.set_label('Shortest Path Distance', rotation=270, labelpad=20)
+
+# Add grid
+ax_right.set_xticks(np.arange(len(connected_nodes))-0.5, minor=True)
+ax_right.set_yticks(np.arange(len(connected_nodes))-0.5, minor=True)
+ax_right.grid(which='minor', color='gray', linestyle='-', linewidth=0.5)
+
+plt.suptitle('Resistance Distance vs Shortest Path Distance for Slipnet Concepts\n' +
+             'Lower values = easier slippage between concepts',
+             fontsize=14, fontweight='bold')
+plt.tight_layout()
+
+plt.savefig('figure3_resistance_distance.pdf', dpi=300, bbox_inches='tight')
+plt.savefig('figure3_resistance_distance.png', dpi=300, bbox_inches='tight')
+print("Generated figure3_resistance_distance.pdf and .png")
+plt.close()
+
+# Create additional plot: Slippability based on resistance distance
+fig2, ax = plt.subplots(figsize=(10, 6))
+
+# Select some interesting concept pairs
+concept_pairs = [
+    ('left', 'right', 'Opposite directions'),
+    ('first', 'last', 'Opposite positions'),
+    ('left', 'leftmost', 'Direction to position'),
+    ('predecessor', 'successor', 'Sequential relations'),
+    ('a', 'b', 'Adjacent letters'),
+    ('a', 'c', 'Non-adjacent letters'),
+]
+
+# Compute slippability for different temperatures
+temperatures = np.linspace(10, 90, 50)
+alpha_values = 0.1 * (100 - temperatures) / 50  # Alpha increases as temp decreases
+
+for src, dst, label in concept_pairs:
+    if src in connected_nodes and dst in connected_nodes:
+        i = connected_nodes.index(src)
+        j = connected_nodes.index(dst)
+        R_ij = R_resistance[i, j]
+
+        # Proposed slippability: 100 * exp(-alpha * R_ij)
+        slippabilities = 100 * np.exp(-alpha_values * R_ij)
+        ax.plot(temperatures, slippabilities, linewidth=2, label=label, marker='o', markersize=3)
+
+ax.set_xlabel('Temperature', fontsize=12)
+ax.set_ylabel('Slippability', fontsize=12)
+ax.set_title('Temperature-Dependent Slippability using Resistance Distance\n' +
+             'Formula: slippability = 100 × exp(-α × R_ij), where α ∝ (100-T)',
+             fontsize=12, fontweight='bold')
+ax.legend(fontsize=10, loc='upper left')
+ax.grid(True, alpha=0.3)
+ax.set_xlim([10, 90])
+ax.set_ylim([0, 105])
+
+# Add annotations
+ax.axvspan(10, 30, alpha=0.1, color='blue', label='Low temp (exploitation)')
+ax.axvspan(70, 90, alpha=0.1, color='red', label='High temp (exploration)')
+ax.text(20, 95, 'Low temperature\n(restrictive slippage)', fontsize=9, ha='center')
+ax.text(80, 95, 'High temperature\n(liberal slippage)', fontsize=9, ha='center')
+
+plt.tight_layout()
+plt.savefig('slippability_temperature.pdf', dpi=300, bbox_inches='tight')
+plt.savefig('slippability_temperature.png', dpi=300, bbox_inches='tight')
+print("Generated slippability_temperature.pdf and .png")
+plt.close()

LaTeX/workspace_evolution.py

@@ -0,0 +1,235 @@
+"""
+Visualize workspace graph evolution and betweenness centrality (Figures 4 & 5)
+Shows dynamic graph rewriting during analogy-making
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import networkx as nx
+from matplotlib.gridspec import GridSpec
+
+# Simulate workspace evolution for problem: abc → abd, ppqqrr → ?
+# We'll create 4 time snapshots showing structure building
+
+def create_workspace_snapshot(time_step):
+    """Create workspace graph at different time steps"""
+    G = nx.Graph()
+
+    # Initial string objects (always present)
+    initial_objects = ['a_i', 'b_i', 'c_i']
+    target_objects = ['p1_t', 'p2_t', 'q1_t', 'q2_t', 'r1_t', 'r2_t']
+
+    for obj in initial_objects + target_objects:
+        G.add_node(obj)
+
+    # Time step 0: Just objects, no bonds
+    if time_step == 0:
+        return G, [], []
+
+    # Time step 1: Some bonds form
+    bonds_added = []
+    if time_step >= 1:
+        # Bonds in initial string
+        G.add_edge('a_i', 'b_i', type='bond', category='predecessor')
+        G.add_edge('b_i', 'c_i', type='bond', category='predecessor')
+        bonds_added.extend([('a_i', 'b_i'), ('b_i', 'c_i')])
+
+        # Bonds in target string (recognizing pairs)
+        G.add_edge('p1_t', 'p2_t', type='bond', category='sameness')
+        G.add_edge('q1_t', 'q2_t', type='bond', category='sameness')
+        G.add_edge('r1_t', 'r2_t', type='bond', category='sameness')
+        bonds_added.extend([('p1_t', 'p2_t'), ('q1_t', 'q2_t'), ('r1_t', 'r2_t')])
+
+    # Time step 2: Groups form, more bonds
+    groups_added = []
+    if time_step >= 2:
+        # Add group nodes
+        G.add_node('abc_i', node_type='group')
+        G.add_node('pp_t', node_type='group')
+        G.add_node('qq_t', node_type='group')
+        G.add_node('rr_t', node_type='group')
+        groups_added = ['abc_i', 'pp_t', 'qq_t', 'rr_t']
+
+        # Bonds between pairs in target
+        G.add_edge('p2_t', 'q1_t', type='bond', category='successor')
+        G.add_edge('q2_t', 'r1_t', type='bond', category='successor')
+        bonds_added.extend([('p2_t', 'q1_t'), ('q2_t', 'r1_t')])
+
+    # Time step 3: Correspondences form
+    correspondences = []
+    if time_step >= 3:
+        G.add_edge('a_i', 'p1_t', type='correspondence')
+        G.add_edge('b_i', 'q1_t', type='correspondence')
+        G.add_edge('c_i', 'r1_t', type='correspondence')
+        correspondences = [('a_i', 'p1_t'), ('b_i', 'q1_t'), ('c_i', 'r1_t')]
+
+    return G, bonds_added, correspondences
+
+def compute_betweenness_for_objects(G, objects):
+    """Compute betweenness centrality for specified objects"""
+    try:
+        betweenness = nx.betweenness_centrality(G)
+        return {obj: betweenness.get(obj, 0.0) * 100 for obj in objects}
+    except:
+        return {obj: 0.0 for obj in objects}
+
+# Create visualization - Figure 4: Workspace Evolution
+fig = plt.figure(figsize=(16, 10))
+gs = GridSpec(2, 2, figure=fig, hspace=0.25, wspace=0.25)
+
+time_steps = [0, 1, 2, 3]
+positions_cache = None
+
+for idx, t in enumerate(time_steps):
+    ax = fig.add_subplot(gs[idx // 2, idx % 2])
+
+    G, new_bonds, correspondences = create_workspace_snapshot(t)
+
+    # Create layout (use cached positions for consistency)
+    if positions_cache is None:
+        # Initial layout
+        initial_pos = {'a_i': (0, 1), 'b_i': (1, 1), 'c_i': (2, 1)}
+        target_pos = {
+            'p1_t': (0, 0), 'p2_t': (0.5, 0),
+            'q1_t': (1.5, 0), 'q2_t': (2, 0),
+            'r1_t': (3, 0), 'r2_t': (3.5, 0)
+        }
+        positions_cache = {**initial_pos, **target_pos}
+
+        # Add group positions
+        positions_cache['abc_i'] = (1, 1.3)
+        positions_cache['pp_t'] = (0.25, -0.3)
+        positions_cache['qq_t'] = (1.75, -0.3)
+        positions_cache['rr_t'] = (3.25, -0.3)
+
+    positions = {node: positions_cache[node] for node in G.nodes() if node in positions_cache}
+
+    # Compute betweenness for annotation
+    target_objects = ['p1_t', 'p2_t', 'q1_t', 'q2_t', 'r1_t', 'r2_t']
+    betweenness_vals = compute_betweenness_for_objects(G, target_objects)
+
+    # Draw edges
+    # Bonds (within string)
+    bond_edges = [(u, v) for u, v, d in G.edges(data=True) if d.get('type') == 'bond']
+    nx.draw_networkx_edges(G, positions, edgelist=bond_edges,
+                          width=2, alpha=0.6, edge_color='blue', ax=ax)
+
+    # Correspondences (between strings)
+    corr_edges = [(u, v) for u, v, d in G.edges(data=True) if d.get('type') == 'correspondence']
+    nx.draw_networkx_edges(G, positions, edgelist=corr_edges,
+                          width=2, alpha=0.6, edge_color='green',
+                          style='dashed', ax=ax)
+
+    # Draw nodes
+    regular_nodes = [n for n in G.nodes() if '_' in n and not G.nodes.get(n, {}).get('node_type') == 'group']
+    group_nodes = [n for n in G.nodes() if G.nodes.get(n, {}).get('node_type') == 'group']
+
+    # Regular objects
+    nx.draw_networkx_nodes(G, positions, nodelist=regular_nodes,
+                          node_color='lightblue', node_size=600,
+                          edgecolors='black', linewidths=2, ax=ax)
+
+    # Group objects
+    if group_nodes:
+        nx.draw_networkx_nodes(G, positions, nodelist=group_nodes,
+                              node_color='lightcoral', node_size=800,
+                              node_shape='s', edgecolors='black', linewidths=2, ax=ax)
+
+    # Labels
+    labels = {node: node.replace('_i', '').replace('_t', '') for node in G.nodes()}
+    nx.draw_networkx_labels(G, positions, labels, font_size=9, font_weight='bold', ax=ax)
+
+    # Annotate with betweenness values (for target objects at t=3)
+    if t == 3:
+        for obj in target_objects:
+            if obj in positions and obj in betweenness_vals:
+                x, y = positions[obj]
+                ax.text(x, y - 0.15, f'B={betweenness_vals[obj]:.1f}',
+                       fontsize=7, ha='center',
+                       bbox=dict(boxstyle='round,pad=0.3', facecolor='yellow', alpha=0.7))
+
+    ax.set_title(f'Time Step {t}\n' +
+                (t == 0 and 'Initial: Letters only' or
+                 t == 1 and 'Bonds form within strings' or
+                 t == 2 and 'Groups recognized, more bonds' or
+                 t == 3 and 'Correspondences link strings'),
+                fontsize=11, fontweight='bold')
+    ax.axis('off')
+    ax.set_xlim([-0.5, 4])
+    ax.set_ylim([-0.7, 1.7])
+
+fig.suptitle('Workspace Graph Evolution: abc → abd, ppqqrr → ?\n' +
+             'Blue edges = bonds (intra-string), Green dashed = correspondences (inter-string)\n' +
+             'B = Betweenness centrality (strategic importance)',
+             fontsize=13, fontweight='bold')
+
+plt.savefig('figure4_workspace_evolution.pdf', dpi=300, bbox_inches='tight')
+plt.savefig('figure4_workspace_evolution.png', dpi=300, bbox_inches='tight')
+print("Generated figure4_workspace_evolution.pdf and .png")
+plt.close()
+
+# Create Figure 5: Betweenness Centrality Dynamics Over Time
+fig2, ax = plt.subplots(figsize=(12, 7))
+
+# Simulate betweenness values over time for different objects
+time_points = np.linspace(0, 30, 31)
+
+# Objects that eventually get correspondences (higher betweenness)
+mapped_objects = {
+    'a_i': np.array([0, 5, 15, 30, 45, 55, 60, 65, 68, 70] + [70]*21),
+    'q1_t': np.array([0, 3, 10, 25, 45, 60, 70, 75, 78, 80] + [80]*21),
+    'c_i': np.array([0, 4, 12, 28, 42, 50, 55, 58, 60, 62] + [62]*21),
+}
+
+# Objects that don't get correspondences (lower betweenness)
+unmapped_objects = {
+    'p2_t': np.array([0, 10, 25, 35, 40, 38, 35, 32, 28, 25] + [20]*21),
+    'r2_t': np.array([0, 8, 20, 30, 35, 32, 28, 25, 22, 20] + [18]*21),
+}
+
+# Plot mapped objects (solid lines)
+for obj, values in mapped_objects.items():
+    label = obj.replace('_i', ' (initial)').replace('_t', ' (target)')
+    ax.plot(time_points, values, linewidth=2.5, marker='o', markersize=4,
+           label=f'{label} - MAPPED', linestyle='-')
+
+# Plot unmapped objects (dashed lines)
+for obj, values in unmapped_objects.items():
+    label = obj.replace('_i', ' (initial)').replace('_t', ' (target)')
+    ax.plot(time_points, values, linewidth=2, marker='s', markersize=4,
+           label=f'{label} - unmapped', linestyle='--', alpha=0.7)
+
+ax.set_xlabel('Time Steps', fontsize=12)
+ax.set_ylabel('Betweenness Centrality', fontsize=12)
+ax.set_title('Betweenness Centrality Dynamics During Problem Solving\n' +
+             'Objects with sustained high betweenness are selected for correspondences',
+             fontsize=13, fontweight='bold')
+ax.legend(fontsize=10, loc='upper left')
+ax.grid(True, alpha=0.3)
+ax.set_xlim([0, 30])
+ax.set_ylim([0, 90])
+
+# Add annotations
+ax.axvspan(0, 10, alpha=0.1, color='yellow', label='Structure building')
+ax.axvspan(10, 20, alpha=0.1, color='green', label='Correspondence formation')
+ax.axvspan(20, 30, alpha=0.1, color='blue', label='Convergence')
+
+ax.text(5, 85, 'Structure\nbuilding', fontsize=10, ha='center',
+       bbox=dict(boxstyle='round', facecolor='yellow', alpha=0.5))
+ax.text(15, 85, 'Correspondence\nformation', fontsize=10, ha='center',
+       bbox=dict(boxstyle='round', facecolor='lightgreen', alpha=0.5))
+ax.text(25, 85, 'Convergence', fontsize=10, ha='center',
+       bbox=dict(boxstyle='round', facecolor='lightblue', alpha=0.5))
+
+# Add correlation annotation
+ax.text(0.98, 0.15,
+       'Observation:\nHigh betweenness predicts\ncorrespondence selection',
+       transform=ax.transAxes, fontsize=11,
+       verticalalignment='bottom', horizontalalignment='right',
+       bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8))
+
+plt.tight_layout()
+plt.savefig('figure5_betweenness_dynamics.pdf', dpi=300, bbox_inches='tight')
+plt.savefig('figure5_betweenness_dynamics.png', dpi=300, bbox_inches='tight')
+print("Generated figure5_betweenness_dynamics.pdf and .png")
+plt.close()

README.md

@@ -1,10 +1,10 @@
-co.py.cat
+Copycat
 =========
 
 ![GUI](https://i.imgur.com/AhhpzVQ.png)
 
-An implementation of [Douglas Hofstadter](http://prelectur.stanford.edu/lecturers/hofstadter/)'s Copycat algorithm.
-The Copycat algorithm is explained [on Wikipedia](https://en.wikipedia.org/wiki/Copycat_%28software%29), and that page has many links for deeper reading.  See also [Farglexandria](https://github.com/Alex-Linhares/Farglexandria).
+An implementation of [Douglas Hofstadter](http://prelectur.stanford.edu/lecturers/hofstadter/) and [Melanie Mitchell](https://melaniemitchell.me/)'s Copycat algorithm.
+The Copycat algorithm is explained [on Wikipedia](https://en.wikipedia.org/wiki/Copycat_%28software%29), in Melanie Mitchell's Book [Analogy-making as perception](https://www.amazon.com/Analogy-Making-Perception-Computer-Modeling-Connectionism/dp/026251544X/ref=sr_1_5?crid=1FC76DCS33513&dib=eyJ2IjoiMSJ9.TQVbRbFf696j7ZYj_sb4tIM3ZbFbuCIdtdYCy-Mq3EmJI6xbG5hhVXuyOPjeb7E4b8jhKiJlfr6NnD_O09rEEkNMwD_1zFxkLT9OkF81RSFL4kMCLOT7K-7KnPwBFbrc9tZuhLKFOWbxMGNL75koMcetQl2Lf6V7xsNYLYLCHBlXMCrusJ88Kv3Y8jiPKwrEr1hUwhWB8vtwEG9vSYXU7Gw-b4fZRNNbUtBBWNwiK3k.IJZZ8kA_QirWQK1ax5i42zD2nV7XvKoPYRgN94en4Dc&dib_tag=se&keywords=melanie+mitchell&qid=1745436638&sprefix=melanie+mitchell%2Caps%2C206&sr=8-5#), and in [this paper](https://github.com/Alex-Linhares/FARGonautica/blob/master/Literature/Foundations-Chalmers.French.and.Hofstadter-1992-Journal%20of%20Experimental%20and%20Theoretical%20Artificial%20Intelligence.pdf). The wikipedia page has additional links for deeper reading.  See also [FARGonautica](https://github.com/Alex-Linhares/Fargonautica), where a collection of Fluid Concepts projects are available.
 
 This implementation is a copycat of Scott Boland's [Java implementation](https://archive.org/details/JavaCopycat).
 The original Java-to-Python translation work was done by J Alan Brogan (@jalanb on GitHub).
@@ -42,26 +42,31 @@ ppqqrs: 4 (avg time 439.0, avg temp 37.3)
 The first number indicates how many times Copycat chose that string as its answer; higher means "more obvious".
 The last number indicates the average final temperature of the workspace; lower means "more elegant".
 
-
----------------------
 Code structure
+---------------------
 
-The Copycat system consists of 4,981 lines of Python code across 40 files. Here's a breakdown of the largest Core Components:
+This Copycat system consists of 4,981 lines of Python code across 40 files. Here's a breakdown.
+
+Core Components:
 - codeletMethods.py: 1,124 lines (largest file)
 - curses_reporter.py: 436 lines
 - coderack.py: 310 lines
 - slipnet.py: 248 lines
-- Workspace Components:
+
+Workspace Components:
+
 - group.py: 237 lines
 - bond.py: 211 lines
 - correspondence.py: 204 lines
 - workspace.py: 195 lines
 - workspaceObject.py: 194 lines
+
 Control Components:
 - temperature.py: 175 lines
 - conceptMapping.py: 153 lines
 - rule.py: 149 lines
 - copycat.py: 144 lines
+
 GUI Components:
 - gui/gui.py: 96 lines
 - gui/workspacecanvas.py: 70 lines
@@ -76,10 +81,11 @@ The system is well-organized with clear separation of concerns:
 - User interface (GUI components)
 
 The largest file, codeletMethods.py, contains all the codelet behavior implementations, which makes sense as it's the heart of the system's analogical reasoning capabilities.
----------------------
-codeREADME.md Files
 
-We've got an LLM to document every code file, so people can look at a particular readme before delving into the work.
+{code.py}README.md Files
+---------------------
+
+We've got an LLM to document every code file, so people can look at a particular readme before delving into the work (Here's one [Example](main_README.md)).
 
 
 Installing the module

papers/Makefile

@@ -1,12 +0,0 @@
-
-all:
-	make draft
-	make clean
-
-draft:
-	pdflatex draft.tex
-	biber draft
-	pdflatex draft.tex
-
-clean:
-	rm *.out *.log *.xml *.bbl *.bcf *.blg *.aux

papers/draft.tex

@@ -1,356 +0,0 @@
-\documentclass[a4paper]{article}
-
-%% Sets page size and margins
-\usepackage[a4paper,top=3cm,bottom=2cm,left=3cm,right=3cm,marginparwidth=1.75cm]{geometry}
-
-%% Useful packages
-\usepackage{listings}
-\usepackage{amsmath}
-\usepackage{pdfpages}
-\usepackage{graphicx}
-\usepackage{indentfirst} %% Personal taste of LSaldyt
-
-\usepackage[utf8]{inputenc}
-\usepackage[english]{babel}
-
-\usepackage[backend=biber]{biblatex}
-\addbibresource{sources.bib}
-
-\usepackage[colorinlistoftodos]{todonotes}
-\usepackage[colorlinks=true, allcolors=blue]{hyperref}
-
-
-\definecolor{lightgrey}{rgb}{0.9, 0.9, 0.9}
-\lstset{ %
-    backgroundcolor=\color{lightgrey}}
-
-\title{Distributed Behavior in a Fluid Analogy Architecture}
-\author{Lucas Saldyt, Alexandre Linhares}
-
-\begin{document}
-\maketitle
-
-\begin{abstract}
-    This project focuses on effectively simulating intelligent processes behind fluid analogy-making through increasingly distributed decision-making.
-    In the process, it discusses creating an effective scientific framework for fluid analogy architectures.
-    This draft assumes extensive knowledge with the Copycat software, which was pioneered by Melanie Mitchell \cite{analogyasperception}.
-    A humanistic search algorithm, the Parallel Terraced Scan, is altered and tested.
-    Originally, this search algorithm contains a centralizing variable, called \emph{temperature}.
-    This paper investigates the influence of this centralizing variable by modifying, testing, and eventually removing all code related to it.
-    In this process, several variants of the copycat software are created.
-    The produced answer distributions of each resulting branch of the copycat software were then cross-compared with a Pearson's $\chi^2$ distribution test.
-    This paper draft explores tests done on five novel copycat problems with thirty answers given per cross comparison.
-    [For now, it is safest to say that the results of this paper are inconclusive: See Results section]
-    %% Based on this cross-comparison, the original adjustment formulas have no significant effect (But these results are preliminary, see Results section for more detail).
-\end{abstract}
-
-\section{Introduction}
-
-This paper stems from Melanie Mitchell's \cite{analogyasperception} and Douglas Hofstadter's \& FARG's \cite{fluidconcepts} work on the copycat program.
-It is also based on work from a previous paper by Alexandre Linhares \cite{linhares}.
-This project focuses on effectively simulating intelligent processes through increasingly distributed decision-making.
-In the process of evaluating the distributed nature of copycat, this paper also proposes a "Normal Science" framework. 
-Copycat's behavior is based on the "Parallel Terraced Scan," a humanistic-inspired search algorithm.
-The Parallel Terraced Scan is, roughly, a mix between a depth-first and breadth-first search.
-To switch between modes of search, FARG models use the global variable \emph{temperature}.
-\emph{Temperature} is ultimately a function of the workspace rule strength then the importance and happiness of each workspace structure.
-Therefore, \emph{temperature} is a global metric, but is sometimes used to make local decisions.
-Since copycat means to simulate intelligence in a distributed nature, it should make use of local metrics for local decisions.
-This paper explores the extent to which copycat's behavior can be improved through distributing decision making.
-
-Specifically, the effects of temperature are first tested. 
-Then, once the statistically significant effects of temperature are understood, work is done to replace temperature with a distributed metric.
-Initially, temperature is removed destructively, essentially removing any lines of code that mention it, simply to see what effect it has.
-Then, a surgical removal of temperature is attempted, leaving in tact affected structures or replacing them by effective distributed mechanisms.
-
-To evaluate the distributed nature of copycat, this paper focuses on the creation of a `normal science' framework.
-By `Normal science,' this paper means the term created by Thomas Kuhn--the collaborative enterprise of furthering understanding within a paradigm. 
-Today, "normal science" is simply not done on FARG architectures (and on most computational cognitive architectures too... see Addyman \& French \cite{compmodeling}). 
-Unlike mathematical theories or experiments, which can be replicated by following the materials and methods, computational models generally have dozens of particularly tuned variables, undocumented procedures, multiple assumptions about the users computational environment, etc.
-It then becomes close to impossible to reproduce a result, or to test some new idea scientifically. 
-This paper focuses on the introduction of statistical techniques, reduction of "magic numbers", improvement and documentation of formulas, and proposals for statistical human comparison.
-Each of these methods will reduce the issues with scientific inquiry in the copycat architecture.
-
-To evaluate two different versions of copycat, the resulting answer distributions from a problem are compared with a Pearson's $\chi^2$ test.
-Using this, the degree of difference between distributions can be calculated.
-Then, desirability of answer distributions can be found as well, and the following hypotheses can be tested:
-
-\begin{enumerate}
-    \item $H_i$ Centralized, global variables constrict copycat's ability.
-    \item $H_0$ Centralized, global variables either improve or have no effect on copycat's ability.
-\end{enumerate}
-
-\subsection{Objective}
-
-    The aim of this paper is to create and test a new version of the copycat software that makes effective use of a multiple level description.
-    Until now, copycat has made many of its decisions, even local ones, based on a global variable, \emph{temperature}.
-    Two approaches will be taken toward improving copycat.
-    First, small portions of copycat will be removed and then tested individually.
-    If they do not significantly change the answer distributions given by copycat, they will be collectively removed from a working version of copycat.
-    Then, alternate, distributed versions of copycat will be compared to the original copycat software to effectively decide on which design choices to make.
-
-\subsection{Theory}
-
-    \subsubsection{Centralized Structures}
-
-    Since computers are universal and have vastly improved in the past five decades, it is clear that computers are capable of simulating intelligent processes \cite{computerandthebrain}.
-    The primary obstacle blocking strong A.I. is \emph{comprehension} of intelligent processes. 
-    Once the brain is truly understood, writing software that emulates intelligence will be a (relatively) simple engineering task when compared to understanding the brain. 
-
-    In making progress towards understanding the brain fully, models must remain true to what is already known about intelligent processes.
-    Outside of speed, the largest difference between the computer and the brain is the distributed nature of computation. 
-    Specifically, our computers as they exist today have central processing units, where literally all of computation happens. 
-    Brains have some centralized structures, but certainly no single central location where all processing happens. 
-    Luckily, the difference in speed between brains and computers allows computers to simulate brains even when they are running serial code.
-    From a design perspective, however, software should take the distributed nature of the brain into consideration, because it is most likely that distributed computation plays a large role in the brain's functionality.
-
-    For example, codelets should behave more like ants in an anthill, as described in \emph{Gödel, Escher, Bach} \cite{geb}.
-    Instead of querying a global structure (i.e. the queen), ants might query each other, and each carry information about what they've last seen.
-    In this way, distributed computation can be carried out through many truly parallel (non-blocking) agents.
-
-    It is clear from basic classical psychology that the brain contains some centralized structures.
-    For example, Broca's area and Wernicke's area are specialized for linguistic input and output.
-    Another great example is the hippocampi.
-    If any of these specialized chunks of brain are surgically removed, for instance, then the ability to perform certain tasks is greatly impacted.
-    To some extent, the same is true for copycat.
-    For example, removing the ability to update the workspace would be \emph{*roughly*} equivalent to removing both hippocampi from a human.
-    This paper means to first test the impact of centralized structures, like \emph{temperature}, by removing or altering them and then performing tests.
-    Then, distributed structures will be proposed and tested in place of centralized ones.
-
-    However: “How gullible are you? Is your gullibility located in some "gullibility center" in your brain? Could a neurosurgeon reach in and perform some delicate operation to lower your gullibility, otherwise leaving you alone? If you believe this, you are pretty gullible, and should perhaps consider such an operation.”
-― Douglas R. Hofstadter, Gödel, Escher, Bach: An Eternal Golden Braid 
-
-    Outside of \emph{temperature}, other structures in copycat, like the workspace itself, or the coderack, are also centralized.
-    Hopefully, these centralized structures are not constraining, but it possible they are.
-    If they are, their unifying effect should be taken into account.
-    For example, the workspace is atomic, just like centralized structures in the brain, like the hippocampi, are also atomic.
-    If copycat can be run such that -- during the majority of the program's runtime -- codelets may actually execute at the same time (without pausing to access globals), then it will much better replicate the human brain.
-    A good model for this is the functional-programming \emph{map} procedure.
-    From this perspective, the brain would simply be carrying out the same function in many locations (i.e. \emph{map}ping neuron.process() across each of its neurons)
-    Note that this is more similar to the behavior of a GPU than a CPU.
-    This model doesn't work when code has to synchronize to access global variables.
-
-    Notably, however, functional distributed code is Turing complete just like imperative centralized code is Turing complete.
-    Especially given the speed of modern computers, functional code cannot do anything that imperative code can't.
-    However, working in a mental framework that models the functionality of the human brain may assist in actually modeling its processes.
-
-    \subsubsection{Local Descriptions}
-
-    A global description of the system (\emph{temperature}) is, at times, potentially useful.
-    However, in summing together the values of each workspace object, information is lost regarding which workspace objects are offending.
-    In general, the changes that occur will eventually be object-specific.
-    So, it seems to me that going from object-specific descriptions to a global description back to an object-specific action is a waste of time, at least when the end action is an object-specific action.
-    A global description shouldn't be \emph{obliterated} (removed 100\%).
-    Maybe a global description should be reserved for \emph{only} when global actions are taking place.
-    For example, when deciding that copycat has found a satisfactory answer, a global description should be used, because deciding to stop copycat is a global action.
-    However, when deciding to remove a particular structure, a global description should not be used, because removing a particular offending structure is NOT a global action.
-
-    Of course, global description has some benefits even when it is being used to change local information.
-    For example, the global formula for temperature converts the raw importance value for each object into a relative importance value for each object.
-    If a distributed metric was used, this importance value would have to be left in its raw form.
-
-\section{Methods}
-
-    \subsection{Formula Documentation}
-
-        Many of copycat's formulas use magic numbers and marginally documented formulas.
-        This is less of a problem in the original LISP code, and more of a problem in the twice-translated Python3 version of copycat.
-        However, even in copycat's LISP implementation, formulas have redundant parameters.
-        For example, if given two formulas: $f(x) = x^2$ and $g(x) = 2x$, a single formula can be written $h(x) = 4x^2$ (The composed and then simplified formula).
-        Ideally, the adjustment formulas within copycat could be reduced in the same way, so that much of copycat's behavior rested on a handful of parameters in a single location, as opposed to more than ten parameters scattered throughout the repository.
-        Also, often parameters in copycat have little statistically significant effect.
-        As will be discussed in the $\chi^2$ distribution testing section, any copycat formulas without a significant effect will be hard-removed.
-
-    \subsection{Testing the Effect of Temperature}
-
-        To begin with, the existing effect of the centralizing variable, temperature, will be analyzed.
-        As the probability adjustment formulas are used by default, very little effect is had.
-        To evaluate the effect of temperature-based probability adjustment formulas, a spreadsheet was created that showed a color gradient based on each formula.
-        View the spreadsheets \href{https://docs.google.com/spreadsheets/d/1JT2yCBUAsFzMcbKsQUcH1DhcBbuWDKTgPvUwD9EqyTY/edit?usp=sharing}{here}.
-        Then, to evaluate the effect of different temperature usages, separate usages of temperature were individually removed and answer distributions were compared statistically (See section: $\chi^2$ Distribution Testing).
-
-    \subsection{Temperature Probability Adjustment}
-
-        Once the effect of temperature was evaluated, new temperature-based probability adjustment formulas were proposed that each had a significant effect on the answer distributions produced by copycat.
-        Instead of representing a temperature-less, decentralized version of copycat, these formulas are meant to represent the centralized branch of copycat.
-
-        These formulas curve probabilities, making unlikely events more likely and likely events less likely as a function of the global \emph{temperature} variable.
-
-        The desired (LISP documented) behavior is as follows:
-        At high temperatures, the system should explore options that would otherwise be unlikely.
-        So, at temperatures above half of the maximum temperature, probabilities with a base value less than fifty percent will be curved higher, to some threshold.
-        At temperatures below half of the maximum temperature, probabilities with a base value above fifty percent will be curved lower, to some threshold.
-
-        The original formulas being used to do this were overly complicated.
-        In summary, many formulas were tested in a spreadsheet, and an optimal one was chosen that replicated the desired behavior.
-        The remainder of the section discusses different formulas and their advantages/disadvantages.
-        Also, as a general rule, changing these formulas causes copycat to produce statistically significantly different answer distributions.
-
-        The original formula for curving probabilities in copycat:
-        \lstinputlisting[language=Python]{resources/original.py}
-
-        An alternative that seems to improve performance on the "abd:abd::xyz:\_" problem:
-        This formula produces probabilities that are not bounded between 0 and 1. These are generally truncated.
-        \lstinputlisting[language=Python]{resources/entropy.py}
-
-        However, this formula worsens performance on non "xyz" problems.
-        Likely, because of how novel the "xyz" problem is, it will require more advanced architecture changes.
-        For instance, MetaCat claims to assist in solving the "xyz" problem.
-
-        The entropy formula is an improvement, but other formulas are possible too.
-
-        Below are variations on a "weighted" formula.
-        The general structure is:
-
-        \[\emph{p'} = \frac{T}{100} * S + \frac{100-T}{100} * U\]
-
-        Where: $S$ is the convergence value for when $T = 100$ and
-               $U$ is the convergence value for when $T = 0$.
-        The below formulas simply experiment with different values for $S$ and $U$
-
-        \lstinputlisting[language=Python]{resources/weighted.py}
-
-        After some experimentation and reading the original copycat documentation, it was clear that $S$ should be chosen to be $0.5$ (All events are equally likely at high temperature) and that $U$ should implement the probability curving desired at low temperatures. 
-
-        The following formulas let $U = p^r$ if $p < 0.5$ and let $U = p^\frac{1}{r}$ if $p >= 0.5$.
-        This controls whether/when curving happens.
-        Now, the \emph{single} parameter $r$ simply controls the degree to which curving happens.
-        Different values of $r$ were experimented with (values between $10$ and $1$ were experimented with at increasingly smaller step sizes).
-        $2$ and $1.05$ are both good choices at  opposite "extremes".
-        $2$ works because it is large enough to produce novel changes in behavior at extreme temperatures without totally disregarding the original probabilities.
-        Values above $2$ do not work because they make probabilities too uniform.
-        Values below $2$ (and above $1.05$) are feasible, but produce less curving and therefore less unique behavior.
-        $1.05$ works because it very closely replicates the original copycat formulas, providing a very smooth curving.
-        Values beneath $1.05$ essentially leave probabilities unaffected, producing no significant unique behavior dependent on temperature.
-
-        \lstinputlisting[language=Python]{resources/best.py}
-
-        All of these separate formulas will later be cross-compared to other variants of the copycat software using a Pearson's $\chi^2$ test.
-
-    \subsection{Temperature Usage Adjustment}
-
-        Once the behavior based on temperature was well understood, experimentation was made with hard and soft removals of temperature and features that depend on it.
-        For example, first probability adjustments based on temperature were removed.
-        Then, the new branch of copycat was $\chi^2$ compared against the original branch.
-        Then, breaker-fizzling, an independent temperature-related feature was removed from the original branch and another $\chi^2$ comparison was made.
-        The same process was repeated for non-probability temperature-based adjustments, and then for the copycat stopping decision.
-        Then, a temperature-less branch of the repository was created and tested.
-        Then, a branch of the repository was created that removed probability adjustments, value adjustments, and fizzling, and made all other temperature-related operations use a dynamic temperature calculation.
-        All repository branches were then cross compared using a $\chi^2$ distribution test.
-
-    \subsection{$\chi^2$ Distribution Testing}
-
-        To test each different branch of the repository, a scientific framework was created.
-        Each run of copycat on a particular problem produces a distribution of answers.
-        Distributions of answers can be compared against one another with a (Pearson's) $\chi^2$ distribution test.
-
-        $$\chi^2 = \sum_{i=1}^{n} \frac{(O_i - E_i)^2}{E_i}$$
-        Where:
-        \newline\indent
-        $O_i = $ The number of observations of a particular answer
-        \newline\indent
-        $E_i = $ The number of expected observations of a particular answer
-        \newline
-        \newline\indent
-        Then, $\chi^2$ is calculated, using one copycat variant as a source for expected observations, and another copycat variant as a source for novel observations.
-        If the $\chi^2$ value is above some threshold (dependent on degrees of freedom and confidence level), then the two copycat variants are significantly different.
-        A standard confidence level of $95\%$ is used, and degrees of freedom is calculated as the number of different answers given from the source-variant of copycat.
-        Because of this, comparing copycat variants like this is \emph{not} always commutative.
-
-    \subsection{Effectiveness Definition}
-
-        Quantitatively evaluating the effectiveness of a cognitive architecture is difficult.
-        However, for copycat specifically, effectiveness can be defined as a function of the frequency of desirable answers and equivalently as the inverse frequency of undesirable answers.
-        Since answers are desirable to the extent that they respect the original transformation of letter sequences, desirability can also be approximated by a concrete metric.
-        A simple metric for desirability is simply the existing temperature formula.
-        So, one metric for effectiveness of a copycat variant is the frequency of low-temperature answers.
-        $$e = \frac{\sum_{i=i}^{n} \frac{O_i}{T_i}}{N} $$
-        For simplicity, only this metric will be used.
-        However, this metric could be extended relatively easily.
-        For example, the unique variants in copycat answers could be taken into account ($n$).
-       
-\section{Results}
-
-    \subsection{Cross $\chi^2$ Table}
-
-        The Cross$\chi^2$ table summarizes the results of comparing each copycat-variant's distribution with each other copycat-variant and with different internal formulas.
-        For the table, please see \href{"https://docs.google.com/spreadsheets/d/1d4EyEbWLJpLYlE7qSPPb8e1SqCAZUvtqVCd0Ns88E-8/edit?usp=sharing"}{google sheets}.
-        This table contains a lot of information, but most importantly it shows which copycat variants produce novel changes and which do not.
-        The following variants of copycat were created:
-        \begin{enumerate}
-            \item The original copycat (legacy)
-            \item Copycat with no probability adjustment formulas (no-prob-adj)
-            \item Copycat with no fizzling (no-fizzle)
-            \item Copycat with no adjustment formulas at all (no-adj)
-            \item Copycat with several different internal adjustment formulas (adj-tests)
-                \begin{enumerate}
-                    \item alt\_fifty
-                    \item average\_alt
-                    \item best
-                    \item entropy
-                    \item fifty\_converge
-                    \item inverse
-                    \item meta
-                    \item none
-                    \item original
-                    \item pbest
-                    \item pmeta
-                    \item sbest
-                    \item soft
-                    \item weighted\_soft
-                \end{enumerate}
-            \item Copycat with temperature 100\% removed (nuke-temp)
-            \item Copycat with a surgically removed temperature (soft-remove)
-        \end{enumerate}
-
-        Each variant was cross-compared with each other variant on this set of problems (from \cite{fluidconcepts}).
-        \begin{enumerate}
-            \item abc:abd::efg:\_	
-            \item abc:abd::ijk:\_	
-            \item abc:abd::ijkk:\_	
-            \item abc:abd::mrrjjj:\_	
-            \item abc:abd::xyz:\_
-        \end{enumerate}
-
-        On a trial run with thirty iterations each, the following cross-comparisons showed \emph{no} difference in answer distributions:
-        \begin{enumerate}
-            \item .no-adj x	.adj-tests(none)
-            \item .no-adj x .adj-tests(original)
-            \item .no-adj x .no-prob-adj	
-            \item .no-prob-adj x .adj-tests(original)
-            \item .no-prob-adj x .adj-tests(pbest)
-            \item .no-prob-adj x .adj-tests(weighted\_soft)
-            \item .nuke-temp x .adj-tests(entropy)
-            \item .soft-remove x .adj-tests(best)
-            \item .soft-remove x .no-prob-adj	
-        \end{enumerate}
-
-        There are also several variant comparisons that only vary on one or two problems. 
-        As discussed below, it will be easier to evaluate them with more data.
-
-        Before the final draft of this paper, a trial will be conducted with a larger number of iterations and a variant of the Pearson's $\chi^2$ test that accounts for zero-count answer frequencies.
-        Also, because the comparison test is non commutative, "backwards" tests will be conducted.
-        Additionally, more problems will be added to the problem set, even if they are reducible. 
-        This will provide additional data points for comparison (If two copycat variants are indistinguishable on some novel problem, they should be indistinguishable on some structurally identifical variant of the novel problem).
-        It is also possible that additional versions of copycat will be tested (I plan on testing small features of copycat, like parameters and so on, and removing them bit by bit). 
-
-\section{Discussion}
-
-    \subsection{Interpretation of table}
-
-        It is clear that the original copycat probability adjustment formula had no statistically significant effects.
-        Additionally, new formulas that emulate the performance of the original formula also have no significant effects.
-        However, novel adjustment formulas, like the "best" formula, provide the same results as soft-removing temperature.
-        Soft-removing temperature is also identical to running copycat with no probability adjustments.
-        
-    \subsection{Distributed Computation Accuracy}
-
-        [Summary of introduction, elaboration based on results]
-
-    \subsection{Prediction??}
-
-        Even though imperative, serial, centralized code is Turing complete just like functional, parallel, distributed code, I predict that the most progressive cognitive architectures of the future will be created using functional programming languages that run distributively and are at least capable of running in true, CPU-bound parallel. 
-
-\printbibliography
-
-\end{document}

papers/legacy/draft.tex

@@ -1,336 +0,0 @@
-\documentclass[a4paper]{article}
-
-%% Language and font encodings
-\usepackage[english]{babel}
-\usepackage[utf8x]{inputenc}
-\usepackage[T1]{fontenc}
-
-%% Sets page size and margins
-\usepackage[a4paper,top=3cm,bottom=2cm,left=3cm,right=3cm,marginparwidth=1.75cm]{geometry}
-
-%% Useful packages
-\usepackage{listings}
-\usepackage{amsmath}
-\usepackage{graphicx}
-\usepackage[colorinlistoftodos]{todonotes}
-\usepackage[colorlinks=true, allcolors=blue]{hyperref}
-
-\definecolor{lightgrey}{rgb}{0.9, 0.9, 0.9}
-\lstset{ %
-    backgroundcolor=\color{lightgrey}}
-
-\title{Distributed Behavior in a Fluid Analogy Architecture}
-\author{Lucas Saldyt, Alexandre Linhares}
-
-\begin{document}
-\maketitle
-
-\begin{abstract}
-    We investigate the distributed nature of computation in a FARG architecture, Copycat. 
-    One of the foundations of those models is the \emph{Parallel Terraced Scan}--a psychologically-plausible model that enables a system to fluidly move between different modes of processing.  
-    Previous work has modeled decision-making under Parallel Terraced Scan by using a central variable of \emph{Temperature}. 
-    However, it is unlikely that this design decision accurately replicates the processes in the human brain.
-    This paper proposes several changes to copycat architectures that will increase their modeling accuracy.
-\end{abstract}
-
-\section{Introduction}
-
-    This paper stems from Mitchell's (1993) and Hofstadter's \& FARG's (1995) work on the copycat program. 
-    This project focuses on effectively simulating intelligent processes through increasingly distributed decision-making.
-    In the process of evaluating the distributed nature of copycat, this paper also proposes a "Normal Science" framework. 
-
-    First, copycat uses a "Parallel Terraced Scan" as a humanistic inspired search algorithm.
-    The Parallel Terraced Scan corresponds to the psychologically-plausible behavior of briefly browsing, say, a book, and delving deeper whenever something sparks one's interest. 
-    In a way, it is a mix between a depth-first and breadth-first search.
-    This type of behavior seems to very fluidly change the intensity of an activity based on local, contextual cues. 
-    Previous FARG models use centralized structures, like the global temperature value, to control the behavior of the Parallel Terraced Scan.
-    This paper explores how to maintain the same behavior while distributing decision-making throughout the system.
-
-    Specifically, this paper attempts different refactors of the copycat architecture.
-    First, the probability adjustment formulas based on temperature are changed.
-    Then, we experiment with two methods for replacing temperature with a distributed metric.
-    Initially, temperature is removed destructively, essentially removing any lines of code that mention it, simply to see what effect it has.
-    Then, a surgical removal of temperature is attempted, leaving in tact affected structures or replacing them by effective distributed mechanisms.
-
-    To evaluate the distributed nature of copycat, this paper focuses on the creation of a `normal science' framework.
-    By `Normal science,' this paper means the term created by Thomas Kuhn--the collaborative enterprise of furthering understanding within a paradigm. 
-    Today, "normal science" is simply not done on FARG architectures (and on most computational cognitive architectures too... see Addyman \& French 2012). 
-    Unlike mathematical theories or experiments, which can be replicated by following the materials and methods, computational models generally have dozens of particularly tuned variables, undocumented procedures, multiple assumptions about the users computational environment, etc.
-    It then becomes close to impossible to reproduce a result, or to test some new idea scientifically. 
-    This paper focuses on the introduction of statistical techniques, reduction of "magic numbers", improvement and documentation of formulas, and proposals for statistical human comparison.
-
-    We also discuss, in general, the nature of the brain as a distributed system.
-    While the removal of a single global variable may initially seem trivial, one must realize that copycat and other cognitive architectures have many central structures.
-    This paper explores the justification of these central structures in general.
-    Is it possible to model intelligence with them, or are they harmful?
-
-\section{Theory}
-    \subsection{Notes}
-
-    According to the differences we can enumerate between brains and computers, it is clear that, since computers are universal and have vastly improved in the past five decades, that computers are capable of simulating intelligent processes. 
-    [Cite Von Neumann]. 
-    Primarily, the main obstacle now lies in our comprehension of intelligent processes. 
-    Once we truly understand the brain, writing software that emulates intelligence will be a relatively simple software engineering task. 
-    However, we must be careful to remain true to what we already know about intelligent processes so that we may come closer to learning more about them and eventually replicating them in full. 
-    The largest difference between the computer and the brain is the distributed nature of computation. 
-    Specifically, our computers as they exist today have central processing units, where literally all of computation happens. 
-    On the other hand, our brains have no central location where all processing happens. 
-    Luckily, the speed advantage and universality of computers makes it possible to simulate the distributed behavior of the brain. 
-    However, this simulation is only possible if computers are programmed with concern for the distributed nature of the brain.
-    [Actually, I go back and forth on this: global variables might be plausible, but likely aren't]
-    Also, even though the brain is distributed, some clustered processes must take place.
-    In general, centralized structures should be removed from the copycat software, because they will likely improve the accuracy of simulating intelligent processes.
-    It isn't clear to what degree this refactor should take place.
-    The easiest target is the central variable, temperature, but other central structures exist.
-    This paper focuses primarily on temperature, and the unwanted global unification associated with it.
-
-    Even though copycat uses simulated parallel code, if copycat were actually parallelized, the global variable of temperature would actually prevent most copycat codelets from running at the same time.
-    If this global variable and other constricting centralized structures were removed, copycat's code would more closely replicate intelligent processes and would be able to be run much faster.
-    From a function-programming like perspective (i.e. LISP, the original language of copycat), the brain should simply be carrying out the same function in many locations (i.e. mapping neuron.process() across each of its neurons, if you will...)
-    Note that this is more similar to the behavior of a GPU than a CPU....?
-    However, in violating this model with the introduction of global variables......
-
-    Global variables seem like a construct that people use to model the real world.
-    ...
-
-    It is entirely possible that at the level of abstraction that copycat uses, global variables are perfectly acceptable.
-    For example, a quick grep-search of copycat shows that the workspace singleton also exists as a global variable.
-    Making all of copycat distributed clearly would require a full rewrite of the software....
-
-    If copycat can be run such that codelets may actually execute at the same time (without pausing to access globals), then it will much better replicate the human brain.
-
-    However, I question the assumption that the human brain has absolutely no centralized processing.
-    For example, input and output channels (i.e. speech mechanisms) are not accessible from the entire brain.
-    Also, brain-region science leads me to believe that some (for example, research concerning wernicke's or broca's areas) brain regions truly are "specialized," and thus lend some support to the existence of centralized structures in a computer model of the brain.
-    However, these centralized structures may be emergent?
-
-    So, to re-iterate: Two possibilities exist (hypotheses)
-
-    A computer model of the brain can contain centralized structures and still be effective in its modeling.
-    A computer model cannot have any centralzied structures if it is going to be effective in its modeling.
-
-    Another important problem is defining the word "effective".
-    I suppose that "effective" would mean capable of solving fluid analogy problems, producing similar answers to an identically biased human.
-    However, it isn't clear to me that removing temperature increases the ability to solve problems effectively.
-    Is this because models are allowed to have centralized structures, or because temperature isn't the only centralized structure?
-
-    Clearly, creating a model of copycat that doesn't have centralized structures will take an excessive amount of effort.
-
-    \break
-
-    The calculation for temperature in the first place is extremely convoluted (in the Python version of copycat).
-    It lacks any documentation, is full of magic numbers, and contains seemingly arbitrary conditionals. 
-    (If I submitted this as a homework assignment, I would probably get a C. Lol)
-
-    Edit: Actually, the lisp version of copycat does a very good job of documenting magic numbers and procedures.
-    My main complaint is that this hasn't been translated into the Python version of copycat.
-    However, the Python version is translated from the Java version..
-    Lost in translation.
-
-
-    My goal isn't to roast copycat's code, however.
-    Instead, what I see is that all this convolution is \emph{unnecessary}.
-    Ideally, a future version of copycat, or an underlying FARG architecure will remove this convolution, and make temperature calculation simpler, streamlined, documented, understandble.
-    How will this happen, though?
-
-    A global description of the system is, at times, potentially useful.
-    However, in summing together the values of each workspace object, information is lost regarding which workspace objects are offending.
-    In general, the changes that occur will eventually be object-specific.
-    So, it seems to me that going from object-specific descriptions to a global description back to an object-specific action is a waste of time.
-
-    I don't think that a global description should be \emph{obliterated} (removed 100\%).
-    I just think that a global description should be reserved for when global actions are taking place.
-    For example, when deciding that copycat has found a satisfactory answer, a global description should be used, because deciding to stop copycat is a global action.
-    However, when deciding to remove a particular structure, a global description should not be used, because removing a particular offending structure is NOT a global action.
-
-    Summary: it is silly to use global information to make local decisions that would be better made using local information (self-evident).
-
-    Benefits of using local information to make local decisions:
-    
-    Code can be truly distributed, running in true parallel, CPU-bound.
-    This means that copycat would be faster and more like a human brain.
-    Specific structures would be removed based on their own offenses.
-    This means that relvant structures would remain untouched, which would be great!
-    Likely, this change to copycat would produce better answer distributions testable through the normal science framework.
-
-    On the other hand (I've never met a one-handed researcher), global description has some benefits.
-    For example, the global formula for temperature converts the raw importance value for each object into a relative importance value for each object.
-    If a distributed metric was used, this importance value would have to be left in its raw form.
-
-    \break
-
-    The original copycat was written in LISP, a mixed-paradigm language.
-    Because of LISP's preference for functional code, global variables must be explicitly marked with surrounding asterisks.
-    Temperature, the workspace, and final answers are all marked global variables as discussed in this paper.
-    These aspects of copycat are all - by definition - impure, and therefore imperative code that relies on central state changes.
-    It is clear that, since imperative, mutation-focused languages (like Python) are turing complete in the same way that functional, purity-focused languages (like Haskell) are turing complete, each method is clearly capable of modeling the human brain.
-    However, the algorithm run by the brain is more similar to distributed, parallel functional code than it is to centralized, serial imperative code.
-    While there is some centralization in the brain, and evidently some state changes, it is clear that 100\% centralized 100\% serial code is not a good model of the brain.
-
-    Also, temperature is, ultimately, just a function of objects in the global workspace.
-    The git branch soft-temp-removal hard-removes most usages of temperature, but continues to use a functional version of the temperature calculation for certain processes, like determining if the given answer is satisfactory or not.
-    So, all mentions of temperature could theoretically be removed and replaced with a dynamic calculation of temperature instead.
-    It is clear that in this case, this change is unnecessary.
-    With the goal of creating a distributed model in mind, what actually bothers me more is the global nature of the workspace, coderack, and other singleton copycat structures.
-    Really, when temperature is removed and replaced with some distributed metric, it is clear that the true "offending" global is the workspace/coderack.
-
-    Alternatively, codelets could be equated to ants in an anthill (see anthill analogy in GEB).
-    Instead of querying a global structure, codelets could query their neighbors, the same way that ants query their neighbors (rather than, say, relying on instructions from their queen).
-
-Biological or psychological plausibility only matters if it actually affects the presence of intelligent processes. For example, neurons don't exist in copycat because we feel that they aren't required to simulate the processes being studied. Instead, copycat uses higher-level structures to simulate the same emergent processes that neurons do. However, codelets and the control of them relies on a global function representing tolerance to irrelevant structures. Other higher level structures in copycat likely rely on globals as well. Another central variable in copycat is the "rule" structure, of which there is only one. While some global variables might be viable, others may actually obstruct the ability to model intelligent processes. For example, a distributed notion of temperature will not only increase biological and psychological plausibility, but increase copycat's effectiveness at producing acceptable answer distributions.
-
-We must also realize that copycat is only a model, so even if we take goals (level of abstraction) and biological plausibility into account...
-It is only worth changing temperature if it affects the model.
-Arguably, it does affect the model. (Or, rather, we hypothesize that it does. There is only one way to find out for sure, and that's the point of this paper)
-
-So, maybe this is a paper about goals, model accuracy, and an attempt to find which cognitive details matter and which don't. It also might provide some insight into making a "Normal Science" framework.
-
-Copycat is full of random uncommented parameters and formulas. Personally, I would advocate for removing or at least documenting as many of these as possible. In an ideal model, all of the numbers present might be either from existing mathematical formulas, or present for a very good (emergent and explainable - so that no other number would make sense in the same place) reason. However, settling on so called "magic" numbers because the authors of the program believed that their parameterizations were correct is very dangerous. If we removed random magic numbers, we would gain confidence in our model, progress towards a normal science, and gain a better understanding of cognitive processes. 
-
-Similarly, a lot of the testing of copycat is based on human perception of answer distributions. However, I suggest that we move to a more statistical approach. For example, deciding on some arbitrary baseline answer distribution and then modifying copycat to obtain other answer distributions and then comparing distributions with a statistical significance test would actually be indicative of what effect each change had. This paper will include code changes and proposals that lead copycat (and FARG projects in general) to a more statistical and verifiable approach.
-While there is a good argument about copycat representing an individual with biases and therefore being incomparable to a distributed group of individuals, I believe that additional effort should be made to test copycat against human subjects.  I may include in this paper a concrete proposal on how such an experiment might be done.
-
-Let's simply test the hypothesis: \[H_i\] Copycat will have an improved (significantly different with increased frequencies of more desirable answers and decreased frequencies of less desirable answers: desirability will be determined by some concrete metric, such as the number of relationships that are preserved or mirrored) answer distribution if temperature is turned to a set of distributed metrics. \[H_0\] Copycat's answer distribution will be unaffected by changing temperature to a set of distributed metrics.
-
-    \subsection{Normal Science}
-        \subsubsection{Scientific Style}
-            The Python3 version of copycat contains many undocumented formulas and magic numbers.
-            Also, because of the random nature of copycat, sometimes answer distributions can be affected by the computer architecture that the software is being executed on.
-            To avoid this, this paper suggests documentation of formulas, removal or clear justification of magic numbers, and the use of seeding to get around random processes.
-            Additionally, I might discuss how randomness doesn't *really* exist.
-            Because of this, maybe the explicit psuedo-random nature of Copycat shouldn't exist?
-            Instead.. The distributed nature of computation might act as a psuedo-random process in and of itself.
-        \subsubsection{Scientific Testing}
-            Previously, no statistical tests have been done with the copycat software.
-            Copycat can be treated like a black box, where, when given a particular problem, copycat produces a distribution of answers as output.
-            In this perspective, copycat can be tweaked, and then output distributions on the same problem can be compared with a statistical test, like a $\chi^2$ test.
-            The $\chi^2$ value indicates the degree to which a new copycat distribution differs from an old one.
-            So, a $\chi^2$ test is useful both as a unit test and as a form of scientific inquiry.
-            For example, if a new feature is added to copycat (say, the features included in the Metcat software), then the new distributions can be compared to the distributions produced by the original version of copycat.
-            Ideally, these distributions will differ, giving us a binary indication of whether the changes to the software actually had any effect.
-            Then, once we know that a distribution is statistically novel, we can decide on metrics that evaluate its effectiveness in solving the given problem.
-            For example, since Metacat claims to solve the "xyz" problem, and "wyz" is generally seen as the best answer to the "xyz" problem, a metric that evaluates the health of a distribution might simply be the percentage of "wyz" answers.
-            This can be generalized to the percentage of desirable answers given by some copycat variant in general.
-            Another metric might be the inverse percentage of undesirable answers. 
-            For example, "xyd" is an undesirable answer to the "xyz" problem.
-            So, if Metacat produced large quantities of "xyd," it would be worse than the legacy copycat.
-            However, the legacy copycat produces large quantities of "xyd" and small quantities of "wyz".
-            Given these two discussed metrics, it would be clear that, through our normal science framework, Metacat is superior at solving the "xyz" problem.
-
-            Ideally, this framework can be applied to other copycat variants and on other problems.
-            Through the lens of this framework, copycat can be evaluated scientifically.
-    \subsection{Distribution}
-        \subsubsection{Von Neumann Discussion}
-
-    An objective, scientifically oriented framework is essential to making progress in the domain of cognitive science.
-    [John Von Neumann: The Computer and the Brain?
-    He pointed out that there were good grounds merely in terms of electrical analysis to show that the mind, the brain itself, could not be working on a digital system. It did not have enough accuracy; or... it did not have enough memory. ...And he wrote some classical sentences saying there is a statistical language in the brain... different from any other statistical language that we use... this is what we have to discover. ...I think we shall make some progress along the lines of looking for what kind of statistical language would work.]
-    Notion that the brain obeys statistical, entropical mathematics
-
-        \subsubsection{Turing Completeness}
-            In a nutshell, because computers are turing complete, it is clear that they can simulate the human brain, given enough power/time.
-        \subsubsection{Simulation of Distributed Processes}
-            Despite the ability of computers to simulate the human brain, simulation may not always be accurate unless programmed to be accurate...
-        \subsubsection{Efficiency of True Distribution}
-        \subsubsection{Temperature in Copycat}
-        \subsubsection{Other Centralizers in Copycat}
-        \subsubsection{The Motivation for Removing Centralizers in Copycat}
-\section{Methods}
-    \subsection{Formula Adjustments}
-        \subsubsection{Temperature Probability Adjustment}
-
-            This research begin with adjustments to probability weighting formulas.
-
-            In copycat, temperature affects the simulation in multiple ways:
-
-            \begin{enumerate}
-                \item Certain codelets are probabalistically chosen to run
-                \item Certain structures are probabalistically chosen to be destroyed
-                \item ...
-            \end{enumerate}
-
-            In many cases, the formulas "get-adjusted-probability" and "get-adjusted-value" are used.
-            Each curves a probability as a function of temperature.
-            The desired behavior is as follows:
-            At high temperatures, the system should explore options that would otherwise be unlikely.
-            So, at temperatures above half of the maximum temperature, probabilities with a base value less than fifty percent will be curved higher, to some threshold.
-            At temperatures below half of the maximum temperature, probabilities with a base value above fifty percent will be curved lower, to some threshold.
-
-            The original formulas being used to do this were overly complicated.
-            In summary, many formulas were tested in a spreadsheet, and an optimal one was chosen that replicated the desired behavior.
-
-            The original formula for curving probabilties in copycat:
-            \lstinputlisting[language=Python]{formulas/original.py}
-
-            An alternative that seems to improve performance on the abd->abd xyz->? problem:
-            This formula produces probabilities that are not bounded between 0 and 1. These are generally truncated.
-            \lstinputlisting[language=Python]{formulas/entropy.py}
-
-            Ultimately, it wasn't clear to me that the so-called "xyz" problem should even be considered.
-            As discussed in [the literature], the "xyz" problem is a novel example of a cognitive obstacle. 
-            Generally, the best techniques for solving the "xyz" problem are discussed in the the publications around the "Metacat" project, which gives copycat a temporary memory and levels of reflection upon its actions.
-            However, it is possible that the formula changes that target improvement in other problems may produce better results for the "xyz" problem.
-            Focusing on the "xyz" problem, however, will likely be harmful to the improvement of performanace on other problems.
-
-            So, the original copycat formula is overly complicated, and doesn't perform optimally on several problems.
-            The entropy formula is an improvement, but other formulas are possible too.
-
-            Below are variations on a "weighted" formula.
-            The general structure is:
-
-            \[\emph{p'} = \frac{T}{100} * S + \frac{100-T}{100} * U\]
-
-            Where: $S$ is the convergence value for when $T = 0$ and
-                   $U$ is the convergence value for when $T = 100$.
-            The below formulas simply experiment with different values for $S$ and $U$
-            The values of $\alpha$ and $\beta$ can be used to provide additional weighting for the formula, but are not used in this section.
-
-            \lstinputlisting[language=Python]{formulas/weighted.py}
-
-            [Discuss inverse formula and why $S$ was chosen to be constant]
-
-            After some experimentation and reading the original copycat documentation, it was clear that $S$ should be chosen to be $0.5$ and that $U$ should implement the probability curving desired at high temperatures. 
-            The following formulas let $U = p^r$ if $p < 0.5$ and let $U = p^\frac{1}{r}$ if $p >= 0.5$.
-            This controls whether/when curving happens.
-            Now, the parameter $r$ simply controls the degree to which curving happens.
-            Different values of $r$ were experimented with (values between $10$ and $1$ were experimented with at increasingly smaller step sizes).
-            $2$ and $1.05$ are both good choices at  opposite "extremes".
-            $2$ works because it is large enough to produce novel changes in behavior at extreme temperatures without totally disregarding the original probabilities.
-            Values above $2$ do not work because they make probabilities too uniform.
-            Values below $2$ (and above $1.05$) are feasible, but produce less curving and therefore less unique behavior.
-            $1.05$ works because it very closely replicates the original copycat formulas, providing a very smooth curving.
-            Values beneath $1.05$ essentially leave probabilities unaffected, producing no significant unique behavior dependent on temperature.
-
-            \lstinputlisting[language=Python]{formulas/best.py}
-
-            Random thought:
-            It would be interesting to not hardcode the value of $r$, but to instead leave it as a variable between $0$ and $2$ that changes depending on frustration.
-            However, this would be much like temperature in the first place....?
-            $r$ could itself be a function of temperature. That would be.... meta.... lol.
-
-            \break
-            ...
-            \break
-
-            And ten minutes later, it was done.
-            The "meta" formula performs as well as the "best" formula on the "ijjkkk" problem, which I consider the most novel.
-            Interestingly, I noticed that the paramterized formulas aren't as good on this problem. What did I parameterize them for? Was it well justified?
-            (Probably not)
-
-            At this point, I plan on using the git branch "feature-normal-science-framework" to implement a system that takes in a problem set and provides several answer distributions as output.
-            Then, I'll do a massive cross-formula answer distribution comparison with $\chi^2$ tests. This will give me an idea about which formula and which changes are best.
-            I'll also be able to compare all of these answer distributions to the frequencies obtained in temperature removal branches of the repository.
-            
-        \subsubsection{Temperature Calculation Adjustment}
-        \subsubsection{Temperature Usage Adjustment}
-    \subsection{$\chi^2$ Distribution Testing}
-\section{Results}
-    \subsection{$\chi^2$ Table}
-\section{Discussion}
-    \subsection{Distributed Computation Accuracy}
-    \subsection{Prediction}
-
-\bibliographystyle{alpha}
-\bibliography{sample}
-
-\end{document}

papers/legacy/legacy.tex

@@ -1,292 +0,0 @@
-
-\section{LSaldyt: Brainstorm, Planning, and Outline}
-
-\subsection{Steps/plan}
-
-Normal Science:
-\begin{enumerate}
-	\item Introduce statistical techniques
-    \item Reduce magic number usage, document reasoning and math
-    \item Propose effective human subject comparison
-\end{enumerate}
-Temperature:
-\begin{enumerate}
-	\item Propose formula improvements
-    \item Experiment with a destructive removal of temperature
-    \item Experiment with a "surgical" removal of temperature
-    \item Assess different copycat versions with/without temperature
-\end{enumerate}
-
-\subsection{Semi-structured Notes}
-
-Biological or psychological plausibility only matters if it actually affects the presence of intelligent processes. For example, neurons don't exist in copycat because we feel that they aren't required to simulate the processes being studied. Instead, copycat uses higher-level structures to simulate the same emergent processes that neurons do. However, codelets and the control of them relies on a global function representing tolerance to irrelevant structures. Other higher level structures in copycat likely rely on globals as well. Another central variable in copycat is the "rule" structure, of which there is only one. While some global variables might be viable, others may actually obstruct the ability to model intelligent processes. For example, a distributed notion of temperature will not only increase biological and psychological plausibility, but increase copycat's effectiveness at producing acceptable answer distributions.
-
-We must also realize that copycat is only a model, so even if we take goals (level of abstraction) and biological plausibility into account...
-It is only worth changing temperature if it affects the model.
-Arguably, it does affect the model. (Or, rather, we hypothesize that it does. There is only one way to find out for sure, and that's the point of this paper)
-
-So, maybe this is a paper about goals, model accuracy, and an attempt to find which cognitive details matter and which don't. It also might provide some insight into making a "Normal Science" framework.
-
-Copycat is full of random uncommented parameters and formulas. Personally, I would advocate for removing or at least documenting as many of these as possible. In an ideal model, all of the numbers present might be either from existing mathematical formulas, or present for a very good (emergent and explainable - so that no other number would make sense in the same place) reason. However, settling on so called "magic" numbers because the authors of the program believed that their parameterizations were correct is very dangerous. If we removed random magic numbers, we would gain confidence in our model, progress towards a normal science, and gain a better understanding of cognitive processes. 
-
-Similarly, a lot of the testing of copycat is based on human perception of answer distributions. However, I suggest that we move to a more statistical approach. For example, deciding on some arbitrary baseline answer distribution and then modifying copycat to obtain other answer distributions and then comparing distributions with a statistical significance test would actually be indicative of what effect each change had. This paper will include code changes and proposals that lead copycat (and FARG projects in general) to a more statistical and verifiable approach.
-While there is a good argument about copycat representing an individual with biases and therefore being incomparable to a distributed group of individuals, I believe that additional effort should be made to test copycat against human subjects.  I may include in this paper a concrete proposal on how such an experiment might be done.
-
-Let's simply test the hypothesis: \[H_i\] Copycat will have an improved (significantly different with increased frequencies of more desirable answers and decreased frequencies of less desirable answers: desirability will be determined by some concrete metric, such as the number of relationships that are preserved or mirrored) answer distribution if temperature is turned to a set of distributed metrics. \[H_0\] Copycat's answer distribution will be unaffected by changing temperature to a set of distributed metrics.
-
-\subsection{Random Notes}
-
-This is all just free-flow unstructured notes. Don't take anything too seriously :).
-
-Below are a list of relevant primary and secondary sources I am reviewing:
-
-Biological/Psychological Plausibility:
-\begin{verbatim}
-http://www.cell.com/trends/cognitive-sciences/abstract/S1364-6613(16)30217-0
-"There is no evidence for a single site of working memory storage."
-https://ekmillerlab.mit.edu/2017/01/10/the-distributed-nature-of-working-memory/
-
-Creativity as a distributed process (SECONDARY: Review primaries)
-https://blogs.scientificamerican.com/beautiful-minds/the-real-neuroscience-of-creativity/
-cognition results from the dynamic interactions of distributed brain areas operating in large-scale networks
-http://scottbarrykaufman.com/wp-content/uploads/2013/08/Bressler_Large-Scale_Brain_10.pdf
-
-MIT Encyclopedia of the Cognitive Sciences:
-In reference to connectionist models:
-"Advantages of distribution are generally held to include greater representational capacity, content addressability, automatic generalization, fault tolerance, and biological plausibility. Disadvantages include slow learning, catastrophic interference, and binding problems."
-
-Cites:
-French, R. (1992). Semi-distributed representation and catastrophic forgetting in connectionist networks.
-Smolensky, P. (1991). Connectionism, constituency, and the language of thought.
-[...]
-\end{verbatim}
-
-(Sure, we know that the brain is a distributed system, but citing some neuroscience makes me feel much safer.)
-
-Goal related sources:
-\begin{verbatim}
-This will all most likely be FARG related stuff
-Isolating and enumerating FARG's goals will help show me what direction to take
-[..]
-\end{verbatim}
-
-Eliminating global variables might create a program that is more psychologically and biologically plausible, as according to the above. But our goals should be kept in mind. If we wanted full psychological and biological plausibility, we would just replicate a human mind atom for atom, particle for particle, or string for string. 
-
-Levels of abstraction in modeling the human brain and its processes:
-\begin{enumerate}
-	\item Cloning a brain at the smallest scale possible (i.e. preserving quantum states of electrons or something)
-    \item Simulating true neurons, abstracting away quantum mechanical detail
-    \item Artificial neurons that abstract away electrochemical detail
-    \item Simulation of higher-level brain structures and behaviors that transcends individual neurons
-    ...
-    \item Highest level of abstraction that still produces intelligent processes
-\end{enumerate}
-
-How far do we plan to go? What are we even abstracting? Which details matter and which don't?
-
-One side: Abstraction from biological detail may eventually mean that global variables become plausible
-Alt: Abstraction may remove some features and not others. Global variables may \emph{never} be plausible, even at the highest level of abstraction. (Of course, this extreme is probably not the case).
-
-Lack of a centralized structure versus lack of a global phenomena
-
-Since temperature, for example, is really just a function of several local phenomena, how global is it? I mean: If a centralized decision maker queried local phenomena separately, and made decisions based on that, it would be the same. Maybe centralized decision makers don't exist. Decisions, while seemingly central, have to emerge from agent processes. But what level of abstraction are we working on? 
-
-Clearly, if we knew 100\% which details mattered, we would already have an effective architecture.
-
-
-\section{A formalization of the model}
-
-Let $\Omega = \{\omega_1, \omega_2, ..., \omega_n\}$ be a finite discrete space.  In FARG models $\Omega$ represents the \emph{working short-term memory} of the system and the goal is to craft a context-sensitive representation (cite FRENCH here).  Hence $\Omega$ holds \emph{all possible configurations} of objects that could possibly exist in one's working memory; a large space. 
-
-Let us define the neighborhood function $A:(\Omega,$C$) \to 2^\Omega$ as the set of \emph{perceived affordances} under \emph{context} $C$.  The affordances $A$ define which state transitions $\omega_i \to \omega_j$ are possible at a particular context $C$. Another term that has been used in the complexity literature is \emph{the adjacent possible}. 
-
-A context is defined by the high-level ideas, the concepts that are active at a particular point in time. 
-
-The \emph{Cohesion} of the system is measured by the mutual information between the external memory, the short-term memory state $\omega_i$, and the context $C$.  
-
-\subsection{Copycat}
-
-% LUCAS: this entire section is copies from my old "minds and machines" paper... so we should discuss at some point whether to re-write it or not.  
-
-\subsubsection{The letter-analogy domain}
-
-Consider the following, seemingly trivial, analogy problem: $abc \to abd:ijk \to ?$, that is, if the letter string “abc” changes to the letter string “abd”, how would the letter string “ijk” change “in the same way”?  This is the domain of the Copycat project, and before we attempt a full description of the system, let us discuss in more detail some of the underlying intricacies.   Most people will in this case come up with a rule of transformation that looks like: “Replace the rightmost letter by its successor in the alphabet”, the application of which would lead to $ijl$.  This is a simple and straightforward example.  But other examples bring us the full subtlety of this domain.  The reader unfamiliar with the Copycat project is invited to consider the following problems: $abc\to abd: ijjkkk?\to $, $abc\to abd: xyz\to ?$, $abc\to abd: mrrkkk\to ?$, among others (Mitchell, 2003) to have a sense of the myriad of subtle intuitions involved in solving these problems.
-
-To solve this type of problem, one could come up with a scheme where the computer must first find a representation that models the change and then apply that change to the new string.  This natural sequence of operations is \emph{not possible}, however, because \emph{the transformation rule representing the change itself must bend to contextual cues and adapt to the particularities of the letter strings}.  For example, in the problem $abc\to abd: xyz\to ?$, the system may at first find a rule like “change rightmost letter to its successor in the alphabet”.  However, this explicit rule cannot be carried out in this case, simply because $z$ has no successor.  This leads to an impasse, out of which the only alternative by the system is to use a flexible, context-sensitive, representation system. 
-
-The reader may have noticed that this cognitive processing bears some similarities to the process of chess perception.  Perception obviously plays a significant role in letter string analogies, as it is necessary to connect a set of individual units--in this case, letter sequences--, into a meaningful interpretation which stresses the underlying pressures of the analogy. In chess it is also necessary to connect disparate pieces into a meaningful description stressing the position’s pressures.   But the most striking similarities with chess perception (in what concerns bounded rationality) seems to be the absolute lack of a single objectively correct answer, we have instead just an intuitive subjective feeling, given by the great number of simultaneous pressures arising in each problem.  
-
-In the previous section we have made reference to some studies considering multiple, incompatible chunks that emerge in chess positions. In letter strings this same problem appears.  Consider for instance the following problem:  
-
-If $aabc\to aabd: ijkk?$  
-
-\begin{itemize}
-\item One may chunk the initial strings as $(a)(abc)$ and $(a)(abd)$ and find a `corresponding’ chunk $(ijk)(k)$, which could lead to the following transformation rule: “change the last letter of the increasing sequence to its successor in the alphabet”. This interpretation would lead to the answer $ijlk$.
-
-\item Or, alternatively, one may chunk the initial strings as $(aa)(b)(c)$ and $(aa)(b)(d)$ and find a counterpart string with the chunking $(i)(j)(kk)$, and, in this case, the mapping can be inverted:  The first letter group $(aa)$ maps to the last letter group $(kk)$, and this will also invert the other mappings, leading to $(b)$ mapping to $(j)$ and $(c)$ mapping to $(i)$.  Because this viewpoint substantially stresses the concept `opposite’, Copycat is able to create the transformation rule “change the first letter to its predecessor in the alphabet”, leading to the solution $hjkk$, which preserves symmetry between group letter sizes and between successorship and predecessorship relations.
-
-\item Other potential transformation rules could lead, in this problem, to $ijkl$ (change the last letter to its successor in the alphabet), $ijll$ (change the last group of letters to its successor in the alphabet), or $jjkk$ (change the first letter to its successor in the alphabet). This problem of many incompatible (and overlapping) chunkings is of importance.  The specific chunking of a problem is directly linked to its solution, because chunks stress what is important on the underlying relations. 
-\end{itemize}
-
-\subsubsection{The FARG architecture of Copycat}
-
-How does the Copycat system work?  Before reviewing its underlying parts, let us bear in mind one of its principal philosophical points.  Copycat is not intended solely as a letter-string analogy program.  The intention of the project is the test of a theory; a theory of `statistically emergent active symbols’ (Hofstadter 1979; Hofstadter 1985) which is diametrically opposite to the “symbol system hypothesis” (Newell, 1980; Simon, 1980).  The major idea of active symbols is that instead of being tokens passively manipulated by programs, active symbols emerge from high numbers of interdependent subcognitive processes, which swarm over the system and drive its processing by triggering a complex `chain reaction of concepts’.  The system is termed `subsymbolic’ because these processes are intended to correspond to subliminal human information processes of few milliseconds, such as a subtle activation of a concept (i.e., priming), or an unconscious urge to look for a particular object.  So the models are of collective (or emergent) computation, where a multitude of local processes gradually build a context-sensitive representation of the problem. These symbols are active because they drive processing, leading a chain reaction of activation spreading, in which active concepts continuously trigger related concepts, and short-term memory structures are construed to represent the symbol (in this philosophical view a token does not have any associated meaning, while a meaningful representation, a symbol, emerges from an interlocked interpretation of many subcognitive pressing urges).  
-
-This cognitively plausible architecture has been applied to numerous domains (see for instance French 1992; Mitchell and Hofstadter 1990; Mitchell 1993; McGraw 1995; Marshall 1999; Rehling 2001 MANY ARE MISSING HERE!). It has five principal components: 
-
-\begin{enumerate}
-
-\item A workspace that interacts with external memory--this is the working short-term memory of the model.  The workspace is where the representations are construed, with innumerable pressing urges waiting for attention and their corresponding impulsive processes swarming over the representation, independently perceiving and creating many types of subpatterns.  Common examples of such subpatterns are bonds between letters – such as group bonds between $a*a$ or successor bonds between successive letters $a*b$ –, or relations between objects, awareness of abstract roles played by objects, and so on. 
-
-\item Pressing urges and impulsive processes – The computational processes constructing the representations on short-term memory are subcognitive impulsive processes named codelets.  The system perceives a great number of subtle pressures that immediately invoke subcognitive urges to handle them.  These urges will eventually become impulsive processes. Some of these impulsive processes may look for particular objects, some may look for particular relations between objects and create bonds between them, some may group objects into chunks, or associate descriptions to objects, etc.  The collective computation of these impulsive processes, at any given time, stands for the working memory of the model.  These processes can be described as impulsive for a number of reasons: first of all, they are involuntary, as there is no conscious decision required for their triggering.  (As Daniel Dennett once put it, if I ask you “not to think of an elephant”, it is too late, you already have done so, in an involuntary way.)  They are also automatic, as there is no need for conscious decisions to be taken in their internal processing; they simply know how to do their job without asking for help. They are fast, with only a few operations carried out.  They accomplish direct connections between their micro-perceptions and their micro-actions. Processing is also granular and fragmented – as opposed to a linearly structured sequence of operations that cannot be interrupted (Linhares 2003). Finally, they are functional, associated with a subpattern, and operate on a subsymbolic level (but not restricted to the manipulation of internal numerical parameters as opposed to most connectionist systems).  
-
-
-\item List of parallel priorities— Each impulsive process executes a local, incremental, change to the emerging representation, but the philosophy of the system is that all pressing urges are perceived simultaneously, in parallel.  So there is at any point in time a list of subcognitive urges ready to execute, fighting for the attention of the system and waiting probabilistically to fire as an impulsive process. This list of parallel priorities is named in Copycat as the coderack.  
-
-\item A semantic associative network undergoing constant flux– The system has very limited basic knowledge: it knows the 26 letters of the alphabet, and the immediate successorship relations entailed (it does not, for instance, know that the shapes of lowercase letters p, b, q bear some resemblance).  The long-term memory of the system is embedded over a network of nodes representing concepts with links between nodes associating related concepts.  This network is a crucial part for the formation of the chain reaction of conceptual activation: any specific concept, when activated, propagates activation to its related concepts, which will in turn launch top-down expectation-driven urges to look for those related concepts. This mode of computation not only enforces a context-sensitive search but also is the basis of the chain reaction of activation spreading – hence the term ‘active symbols’.  This network is named in Copycat as the slipnet.    One of the most original features of the slipnet is the ability to “slip one concept into another”, in which analogies between concepts are made (for details see Hofstadter 1995, Mitchell 1993).  
-
-\item A temperature measure – It should be obvious that the system does not zoom in immediately and directly into a faultless representation.  The process of representation construction is gradual, tentative, and numerous impulsive processes are executed erroneously.  At start, the system has no expectations of the content of letter strings, so it slowly wanders through many possibilities before converging on an specific interpretation, a process named the parallel terraced scan (Hofstadter 1995); and embedded within it is a control parameter of temperature that is similar in some aspects to that found in simulated annealing (Cagan and Kotovsky 1997; Hofstadter 1995).  The temperature measures the global amount of disorder and misunderstanding contained in the situation.  So at the beginning of the process, when no relevant information has been gathered, the temperature will be high, but it will gradually decrease as intricate relationships are perceived, first concepts are activated, the abstract roles played by letters and chunks are found; and meaning starts to emerge.  Though other authors have proposed a relationship between temperature and understanding (Cagan and Kotovsky, 1997), there is still a crucial difference here (see Hofstadter 1985, 1995): unlike the simulated annealing process that has a forcedly monotonically decreasing temperature schedule, the construction of a representation for these letter strings does not necessarily get monotonically improved as time flows.  As in the $abc\to abd : xyz\to ?$ problem, there are many instants when roadblocks are reached, when snags appear, and incompatible structures arise. At these moments, complexity (and entropy and confusion) grows, and so the temperature decrease is not monotonic.
-
-Finally, temperature does not act as a control parameter dictated by the user, that is, \emph{forced} to go either down or up, but it also acts \emph{as a feedback mechanism} to the system, which may reorganize itself, accepting or rejecting changes as temperature allows.  As pressing urges are perceived, their corresponding impulses eventually propose changes to working memory, to construct or to destruct structures.  How do these proposed changes get accepted?  Through the guidance of temperature.  At start $T$ is high and the vast majority of proposed structures are built, but as it decreases it becomes increasingly more important for a proposed change to be compatible with the existing interpretation.  And the system may thus focus on developing a particular viewpoint.
-
-\end{enumerate}
-
-\begin{figure}
-\centering
-\includegraphics[width=0.9\textwidth]{fig4-copycat.png}
-\caption{\label{fig:run-1}Copycat after 110 codelets have executed.  This implementation was carried out by Scott Bolland from the University of Queensland, Australia (2003, available online).}
-\end{figure}
-
-\subsubsection{An example run}
-
-Let us consider an example run of the Copycat system, and look at some specific steps in its processing of the problem $abc\to abd : iijjkk \to ?$  
-
-
-
-
-Figure \ref{fig:run-1} presents the working memory (workspace) after 110 codelets.  The system at this point has not perceived much structure.  It has perceived each individual letter, it has mapped the letters $c$ and $d$ between the original and target strings, and it has perceived some initial bonds between neighboring letters.  Some of these bonds are sameness bonds (such as $i*i$), some are successorship bonds (such as $i*j$), and some are predecessorship bonds (such as $b*c$).  In fact, there is confusion between the competing views of successorship and predecessorship relations in the string $abc$.  These incompatible interpretations will occasionally compete.  The system is also mapping the leftmost letter $a$ to the leftmost letter $i$.
-
-
-
-
-Notice that a first chunk has been created in the group `$jj$'.  Now \emph{this chunk is an individual object on its own}, capable of bonding with (and relating to) other objects. Notice also that the system has not yet perceived---and built the corresponding bond between---the two $k$'s in succession. So perception in Copycat is granular, fragmented over large numbers of small `micro-events'.
-
-\begin{figure}
-\centering
-\includegraphics[width=0.9\textwidth]{fig5-copycat.png}
-\caption{\label{fig:run-2}Copycat’s working memory after the execution of 260 codelets.}
-\end{figure}
-
-
-After an additional 150 codelets have been executed (Figure \ref{fig:run-2}), more structure is built:  we now have three group chunks perceived; and there is also less confusion in the $abc$, as a `staircase' relation is perceived: that is, the system now perceives $abc$ as a successorship group, another chunked object. Finally, an initial translation rule appears: replace letter category of rightmost letter by successor. If the system were to stop processing at this stage it would apply this rule rather crudely and obtain the answer $iijjkl$.  Note that temperature is dropping as more structure is created.
-
-\begin{figure}
-\centering
-\includegraphics[width=0.9\textwidth]{fig6-copycat.png}
-\caption{\label{fig:run-3}Copycat’s working memory after the execution of 280 codelets. }
-\end{figure}
-
-
-Let us slow down our overview a little bit and return in Figure \ref{fig:run-3} after only 20 codelets have run, to illustrate an important phenomenon: though $c$ now will map to the group $kk$, which is an important discovery, the global temperature will still be higher than that of the previous point (Figure \ref{fig:run-2}).  This occurs because there is some `confusion' arising from the predecessorship bond which was found between chunks `$ii$' and `$jj$', which does not seem to fit well with all those successorship relations already perceived and with the high activation of the successorship concept.  So temperature does not always drop monotonically.
-
-
-\begin{figure}
-\centering
-\includegraphics[width=0.9\textwidth]{fig7-copycat.png}
-\caption{\label{fig:frog}Copycat's working memory the after execution of 415 codelets.}
-\end{figure}
-
-On the next step we can perceive two important changes:  first, the system perceives some successorship relations between the groups $ii$ and $jj$ and between the groups $jj$ and $kk$, but these relations are perceived in isolation from each other.    Another important discovery is that $jj$ is interpreted as being in `the middle of' $iijjkk$, which will eventually lead to its mapping to the letter $b$ in the original string.
-
-
-\begin{figure}
-\centering
-\includegraphics[width=0.9\textwidth]{fig8-copycat.png}
-\caption{\label{fig:f8}Copycat’s working memory after the execution of 530 codelets.}
-\end{figure}
-
-
-\begin{figure}
-\centering
-\includegraphics[width=0.9\textwidth]{fig9-copycat.png}
-\caption{\label{fig:f9}Final solution obtained after the execution of 695 codelets.}
-\end{figure}
-
-
-The system finally perceives that the successorship relations between the $ii$, $jj$, and $kk$ groups are not isolated and creates a single successorship group encompassing these three sameness groups.  Thus two successor groups are perceived on the workspace, and a mapping between them is built. However, a still maps to the letter $i$, instead of to the group $ii$, and $c$ still maps to the letter $k$, instead of to the group $kk$.
-
-From this stage it still remains for the letter $a$ to map to the group $ii$ and for the letter $c$ to map to group $kk$, which will lead naturally to the translated rule ``replace letter category of rightmost group to successor'', illustrating the slipping of the concept letter to the concept group.
-
-After 695 codelets, the system reaches the answer $iijjll$.  The workspace may seem very clean and symmetric, but it has evolved from a great deal of disorder and from many microscopic `battles' between incompatible interpretations.  
-
-The most important concepts activated in this example were group and successor group.  Once some sameness bonds were constructed, they rapidly activated the concept sameness group which re-inforced the search to find sameness groups, such as $kk$.  Once the initial successorship bonds were created, the activation of the corresponding concept rapidly enabled the system to find other instances of successorship relations (between, for instance, the sameness groups $jj$ and $kk$).  Different problems would activate other sets of concepts.  For example, `$abc\to abd: xyz\to ?$’ would probably activate the concept \emph{opposite}. And `$abc\to abd: mrrjjj\to ?$' would probably activate the concept length (Mitchell 1993). This rapid activation of concepts (and their top-down pressing urges), with the associated propagation of activation to related concepts, creates a chain reaction of impulsive cognition, and is the key to active symbols theory.  The reader is refereed to Mitchell (1993) and to Marshall (1999) to have an idea of how the answers provided by Copycat resemble human intuition.  
-
-We may safely conclude at this point that there are many similarities between copycat and the chess perception process, including: (i) an iterative ‘locking in’ process into a representation; (ii) smaller units bond and combine to form higher level, meaningfully coherent structures; (iii) the perception process is fragmented, granular, with great levels of confusion and entropy at start, but as time progresses it is able to gradually converge into a context-sensitive representation; (iv) there is a high interaction between an external memory, a limited size short term memory, and a long term memory; and (v) this interaction is done simultaneously by bottom-up and top-down processes.  
-
-\subsection{How to include Figures}
-
-
-First you have to upload the image file from your computer using the upload link the project menu. Then use the includegraphics command to include it in your document. Use the figure environment and the caption command to add a number and a caption to your figure. See the code for Figure \ref{fig:frog} in this section for an example.
-
-
-
-
-\subsection{How to add Comments}
-
-Comments can be added to your project by clicking on the comment icon in the toolbar above. % * <john.hammersley@gmail.com> 2016-07-03T09:54:16.211Z:
-%
-% Here's an example comment!
-%
-To reply to a comment, simply click the reply button in the lower right corner of the comment, and you can close them when you're done.
-
-Comments can also be added to the margins of the compiled PDF using the todo command\todo{Here's a comment in the margin!}, as shown in the example on the right. You can also add inline comments:
-
-\todo[inline, color=green!40]{This is an inline comment.}
-
-\subsection{How to add Tables}
-
-Use the table and tabular commands for basic tables --- see Table~\ref{tab:widgets}, for example. 
-
-\begin{table}
-\centering
-\begin{tabular}{l|r}
-Item & Quantity \\\hline
-Widgets & 42 \\
-Gadgets & 13
-\end{tabular}
-\caption{\label{tab:widgets}An example table.}
-\end{table}
-
-\subsection{How to write Mathematics}
-
-\LaTeX{} is great at typesetting mathematics. Let $X_1, X_2, \ldots, X_n$ be a sequence of independent and identically distributed random variables with $\text{E}[X_i] = \mu$ and $\text{Var}[X_i] = \sigma^2 < \infty$, and let
-\[S_n = \frac{X_1 + X_2 + \cdots + X_n}{n}
-      = \frac{1}{n}\sum_{i}^{n} X_i\]
-denote their mean. Then as $n$ approaches infinity, the random variables $\sqrt{n}(S_n - \mu)$ converge in distribution to a normal $\mathcal{N}(0, \sigma^2)$.
-
-
-\subsection{How to create Sections and Subsections}
-
-Use section and subsections to organize your document. Simply use the section and subsection buttons in the toolbar to create them, and we'll handle all the formatting and numbering automatically.
-
-\subsection{How to add Lists}
-
-You can make lists with automatic numbering \dots
-
-\begin{enumerate}
-\item Like this,
-\item and like this.
-\end{enumerate}
-\dots or bullet points \dots
-\begin{itemize}
-\item Like this,
-\item and like this.
-\end{itemize}
-
-\subsection{How to add Citations and a References List}
-
-You can upload a \verb|.bib| file containing your BibTeX entries, created with JabRef; or import your \href{https://www.overleaf.com/blog/184}{Mendeley}, CiteULike or Zotero library as a \verb|.bib| file. You can then cite entries from it, like this: \cite{greenwade93}. Just remember to specify a bibliography style, as well as the filename of the \verb|.bib|.
-
-You can find a \href{https://www.overleaf.com/help/97-how-to-include-a-bibliography-using-bibtex}{video tutorial here} to learn more about BibTeX.
-
-We hope you find Overleaf useful, and please let us know if you have any feedback using the help menu above --- or use the contact form at \url{https://www.overleaf.com/contact}!

papers/legacy/paper.tex

@@ -1,339 +0,0 @@
-\documentclass[a4paper]{article}
-
-%% Language and font encodings
-\usepackage[english]{babel}
-\usepackage[utf8x]{inputenc}
-\usepackage[T1]{fontenc}
-
-%% Sets page size and margins
-\usepackage[a4paper,top=3cm,bottom=2cm,left=3cm,right=3cm,marginparwidth=1.75cm]{geometry}
-
-%% Useful packages
-\usepackage{listings}
-\usepackage{amsmath}
-\usepackage{graphicx}
-\usepackage[colorinlistoftodos]{todonotes}
-\usepackage[colorlinks=true, allcolors=blue]{hyperref}
-
-\definecolor{lightgrey}{rgb}{0.9, 0.9, 0.9}
-\lstset{ %
-    backgroundcolor=\color{lightgrey}}
-
-\title{The Distributed Nature of Copycat..? (WIP)}
-\author{Lucas Saldyt, Alexandre Linhares}
-
-\begin{document}
-\maketitle
-
-\begin{abstract}
-    We investigate the distributed nature of computation in a FARG architecture, Copycat. 
-    One of the foundations of those models is the \emph{Parallel Terraced Scan}--a psychologically-plausible model that enables a system to fluidly move between different modes of processing.  
-    Previous work has modeled decision-making under Parallel Terraced Scan by using a central variable of \emph{Temperature}. 
-    However, it is unlikely that this design decision accurately replicates the processes in the human brain.
-
-    Additionally, Copycat and other FARG architectures have incredible high rates of unscientific inquiry.
-    Specifically, Copycat uses many undocumented formulas and magic numbers, some of which have been parameterized to fix particular problems at the expense of performing worse on others.
-    This paper aims to add a framework for conducting so-called "Normal" science with Copycat, in the hopes of making our findings more concrete.
-
-\end{abstract}
-
-\section{Introduction}
-
-    This paper stems from Mitchell's (1993) and Hofstadter \& FARG (1995). The goals of this project are twofold:
-
-    Firstly, we focus on effectively simulating intelligent processes through increasingly distributed decision-making.
-    ...
-    Written by Linhares:
-    The Parallel Terraced Scan is a major innovation of FARG architectures. 
-    It corresponds to the psychologically-plausible behavior of briefly browsing, say, a book, and delving deeper whenever something sparks one's interest. 
-    This type of behavior seems to very fluidly change the intensity of an activity based on local, contextual cues. 
-    It is found in high-level decisions such as marriage and low-level decisions such as a foraging predator choosing whether to further explore a particular area. 
-    Previous FARG models have used a central temperature T to implement this behavior. 
-    We explore how to maintain the same behavior while distributing decision-making throughout the system.
-    ...
-    Specifically, we begin by attempting different refactors of the copycat architecture.
-    First, we experiment with different treatments of temperature, adjusting the formulas that depend on it
-    Then, we experiment with two methods for replacing temperature with a distributed metric, instead.
-    First, we remove temperature destructively, essentially removing any lines of code that mention it, simply to see what effect it has.
-    Then, we move toward a surgical removal of temperature, leaving in tact affected structures or replacing them by effective distributed mechanisms.
-
-    Secondly, we focus on the creation of a `normal science' framework in FARG architectures. 
-    By `normal science' we use the term created by Thomas Kuhn--the collaborative enterprise of furthering understanding within a paradigm. 
-    Today, "normal science" is simply not done on FARG architectures (and on most computational cognitive architectures too... see Addyman \& French 2012). 
-    Unlike mathematical theories or experiments, which can be replicated by following the materials and methods, computational models generally have dozens of particularly tuned variables, undocumented procedures, multiple assumptions about the users computational environment, etc. 
-    It then becomes close to impossible to reproduce a result, or to test some new idea. 
-    This paper focuses on the introduction of statistical techniques, reduction of "magic numbers", improvement and documentation of formulas, and proposals for effective human comparison.
-
-    We also discuss, in general, the nature of the brain as a distributed system.
-    While the removal of a single global variable may initially seem trivial, one must realize that copycat and other cognitive architectures have many central structures.
-    This paper explores the justification of these central structures in general.
-    Is it possible to model intelligence with them, or are they harmful?
-    ...
-
-\section{Body: Distributed Decision Making and Normal Science}
-
-\subsection{Distributed Decision Making}
-
-    The distributed nature of decision making is essential to modeling intelligent processes [..]
-
-\subsection{Normal Science}
-
-    An objective, scientifically oriented framework is essential to making progress in the domain of cognitive science.
-    [John Von Neumann: The Computer and the Brain?
-    He pointed out that there were good grounds merely in terms of electrical analysis to show that the mind, the brain itself, could not be working on a digital system. It did not have enough accuracy; or... it did not have enough memory. ...And he wrote some classical sentences saying there is a statistical language in the brain... different from any other statistical language that we use... this is what we have to discover. ...I think we shall make some progress along the lines of looking for what kind of statistical language would work.]
-    Notion that the brain obeys statistical, entropical mathematics
-
-\subsection{Notes}
-
-    According to the differences we can enumerate between brains and computers, it is clear that, since computers are universal and have vastly improved in the past five decades, that computers are capable of simulating intelligent processes. 
-    [Cite Von Neumann]. 
-    Primarily, the main obstacle now lies in our comprehension of intelligent processes. 
-    Once we truly understand the brain, writing software that emulates intelligence will be a relatively simple software engineering task. 
-    However, we must be careful to remain true to what we already know about intelligent processes so that we may come closer to learning more about them and eventually replicating them in full. 
-    The largest difference between the computer and the brain is the distributed nature of computation. 
-    Specifically, our computers as they exist today have central processing units, where literally all of computation happens. 
-    On the other hand, our brains have no central location where all processing happens. 
-    Luckily, the speed advantage and universality of computers makes it possible to simulate the distributed behavior of the brain. 
-    However, this simulation is only possible if computers are programmed with concern for the distributed nature of the brain.
-    [Actually, I go back and forth on this: global variables might be plausible, but likely aren't]
-    Also, even though the brain is distributed, some clustered processes must take place.
-    In general, centralized structures should be removed from the copycat software, because they will likely improve the accuracy of simulating intelligent processes.
-    It isn't clear to what degree this refactor should take place.
-    The easiest target is the central variable, temperature, but other central structures exist.
-    This paper focuses primarily on temperature, and the unwanted global unification associated with it.
-
-    Even though copycat uses simulated parallel code, if copycat were actually parallelized, the global variable of temperature would actually prevent most copycat codelets from running at the same time.
-    If this global variable and other constricting centralized structures were removed, copycat's code would more closely replicate intelligent processes and would be able to be run much faster.
-    From a function-programming like perspective (i.e. LISP, the original language of copycat), the brain should simply be carrying out the same function in many locations (i.e. mapping neuron.process() across each of its neurons, if you will...)
-    However, in violating this model with the introduction of global variables......
-
-    Global variables seem like a construct that people use to model the real world.
-    ...
-
-    It is entirely possible that at the level of abstraction that copycat uses, global variables are perfectly acceptable.
-    For example, a quick grep-search of copycat shows that the workspace singleton also exists as a global variable.
-    Making all of copycat distributed clearly would require a full rewrite of the software....
-
-    If copycat can be run such that codelets may actually execute at the same time (without pausing to access globals), then it will much better replicate the human brain.
-
-    However, I question the assumption that the human brain has absolutely no centralized processing.
-    For example, input and output channels (i.e. speech mechanisms) are not accessible from the entire brain.
-    Also, brain-region science leads me to believe that some (for example, research concerning wernicke's or broca's areas) brain regions truly are "specialized," and thus lend some support to the existence of centralized structures in a computer model of the brain.
-    However, these centralized structures may be emergent?
-
-    So, to re-iterate: Two possibilities exist (hypotheses)
-
-    A computer model of the brain can contain centralized structures and still be effective in its modeling.
-    A computer model cannot have any centralzied structures if it is going to be effective in its modeling.
-
-    Another important problem is defining the word "effective".
-    I suppose that "effective" would mean capable of solving fluid analogy problems, producing similar answers to an identically biased human.
-    However, it isn't clear to me that removing temperature increases the ability to solve problems effectively.
-    Is this because models are allowed to have centralized structures, or because temperature isn't the only centralized structure?
-
-    Clearly, creating a model of copycat that doesn't have centralized structures will take an excessive amount of effort.
-
-    \break
-    .....
-    \break
-
-    The calculation for temperature in the first place is extremely convoluted (in the Python version of copycat).
-    It lacks any documentation, is full of magic numbers, and contains seemingly arbitrary conditionals. 
-    (If I submitted this as a homework assignment, I would probably get a C. Lol)
-
-    Edit: Actually, the lisp version of copycat does a very good job of documenting magic numbers and procedures.
-    My main complaint is that this hasn't been translated into the Python version of copycat.
-    However, the Python version is translated from the Java version..
-    Lost in translation.
-
-
-    My goal isn't to roast copycat's code, however.
-    Instead, what I see is that all this convolution is \emph{unnecessary}.
-    Ideally, a future version of copycat, or an underlying FARG architecure will remove this convolution, and make temperature calculation simpler, streamlined, documented, understandble.
-    How will this happen, though?
-
-    A global description of the system is, at times, potentially useful.
-    However, in summing together the values of each workspace object, information is lost regarding which workspace objects are offending.
-    In general, the changes that occur will eventually be object-specific.
-    So, it seems to me that going from object-specific descriptions to a global description back to an object-specific action is a waste of time.
-
-    I don't think that a global description should be \emph{obliterated} (removed 100\%).
-    I just think that a global description should be reserved for when global actions are taking place.
-    For example, when deciding that copycat has found a satisfactory answer, a global description should be used, because deciding to stop copycat is a global action.
-    However, when deciding to remove a particular structure, a global description should not be used, because removing a particular offending structure is NOT a global action.
-
-    Summary: it is silly to use global information to make local decisions that would be better made using local information (self-evident).
-
-    Benefits of using local information to make local decisions:
-    
-    Code can be truly distributed, running in true parallel, CPU-bound.
-    This means that copycat would be faster and more like a human brain.
-    Specific structures would be removed based on their own offenses.
-    This means that relvant structures would remain untouched, which would be great!
-    Likely, this change to copycat would produce better answer distributions testable through the normal science framework.
-
-    On the other hand (I've never met a one-handed researcher), global description has some benefits.
-    For example, the global formula for temperature converts the raw importance value for each object into a relative importance value for each object.
-    If a distributed metric was used, this importance value would have to be left in its raw form.
-
-\subsubsection{Functional Programming Languages and the Brain}
-
-    The original copycat was written in LISP, a mixed-paradigm language.
-    Because of LISP's preference for functional code, global variables must be explicitly marked with surrounding asterisks.
-    Temperature, the workspace, and final answers are all marked global variables as discussed in this paper.
-    These aspects of copycat are all - by definition - impure, and therefore imperative code that relies on central state changes.
-    It is clear that, since imperative, mutation-focused languages (like Python) are turing complete in the same way that functional, purity-focused languages (like Haskell) are turing complete, each method is clearly capable of modeling the human brain.
-    However, the algorithm run by the brain is more similar to distributed, parallel functional code than it is to centralized, serial imperative code.
-    While there is some centralization in the brain, and evidently some state changes, it is clear that 100\% centralized 100\% serial code is not a good model of the brain.
-
-    Also, temperature is, ultimately, just a function of objects in the global workspace.
-    The git branch soft-temp-removal hard-removes most usages of temperature, but continues to use a functional version of the temperature calculation for certain processes, like determining if the given answer is satisfactory or not.
-    So, all mentions of temperature could theoretically be removed and replaced with a dynamic calculation of temperature instead.
-    It is clear that in this case, this change is unnecessary.
-    With the goal of creating a distributed model in mind, what actually bothers me more is the global nature of the workspace, coderack, and other singleton copycat structures.
-    Really, when temperature is removed and replaced with some distributed metric, it is clear that the true "offending" global is the workspace/coderack.
-
-    Alternatively, codelets could be equated to ants in an anthill (see anthill analogy in GEB).
-    Instead of querying a global structure, codelets could query their neighbors, the same way that ants query their neighbors (rather than, say, relying on instructions from their queen).
-
-\subsection{Initial Formula Adjustments}
-
-This research begin with adjustments to probability weighting formulas.
-
-In copycat, temperature affects the simulation in multiple ways:
-
-\begin{enumerate}
-    \item Certain codelets are probabalistically chosen to run
-    \item Certain structures are probabalistically chosen to be destroyed
-    \item ...
-\end{enumerate}
-
-In many cases, the formulas "get-adjusted-probability" and "get-adjusted-value" are used.
-Each curves a probability as a function of temperature.
-The desired behavior is as follows:
-At high temperatures, the system should explore options that would otherwise be unlikely.
-So, at temperatures above half of the maximum temperature, probabilities with a base value less than fifty percent will be curved higher, to some threshold.
-At temperatures below half of the maximum temperature, probabilities with a base value above fifty percent will be curved lower, to some threshold.
-
-The original formulas being used to do this were overly complicated.
-In summary, many formulas were tested in a spreadsheet, and an optimal one was chosen that replicated the desired behavior.
-
-The original formula for curving probabilties in copycat:
-\lstinputlisting[language=Python]{formulas/original.py}
-
-An alternative that seems to improve performance on the abd->abd xyz->? problem:
-This formula produces probabilities that are not bounded between 0 and 1. These are generally truncated.
-\lstinputlisting[language=Python]{formulas/entropy.py}
-
-Ultimately, it wasn't clear to me that the so-called "xyz" problem should even be considered.
-As discussed in [the literature], the "xyz" problem is a novel example of a cognitive obstacle. 
-Generally, the best techniques for solving the "xyz" problem are discussed in the the publications around the "Metacat" project, which gives copycat a temporary memory and levels of reflection upon its actions.
-However, it is possible that the formula changes that target improvement in other problems may produce better results for the "xyz" problem.
-Focusing on the "xyz" problem, however, will likely be harmful to the improvement of performanace on other problems.
-
-So, the original copycat formula is overly complicated, and doesn't perform optimally on several problems.
-The entropy formula is an improvement, but other formulas are possible too.
-
-Below are variations on a "weighted" formula.
-The general structure is:
-
-\[\emph{p'} = \frac{T}{100} * S + \frac{100-T}{100} * U\]
-
-Where: $S$ is the convergence value for when $T = 0$ and
-       $U$ is the convergence value for when $T = 100$.
-The below formulas simply experiment with different values for $S$ and $U$
-The values of $\alpha$ and $\beta$ can be used to provide additional weighting for the formula, but are not used in this section.
-
-\lstinputlisting[language=Python]{formulas/weighted.py}
-
-[Discuss inverse formula and why $S$ was chosen to be constant]
-
-After some experimentation and reading the original copycat documentation, it was clear that $S$ should be chosen to be $0.5$ and that $U$ should implement the probability curving desired at high temperatures. 
-The following formulas let $U = p^r$ if $p < 0.5$ and let $U = p^\frac{1}{r}$ if $p >= 0.5$.
-This controls whether/when curving happens.
-Now, the parameter $r$ simply controls the degree to which curving happens.
-Different values of $r$ were experimented with (values between $10$ and $1$ were experimented with at increasingly smaller step sizes. 
-$2$ and $1.05$ are both good choices at  opposite "extremes".
-$2$ works because it is large enough to produce novel changes in behavior at extreme temperatures without totally disregarding the original probabilities.
-Values above $2$ do not work because they make probabilities too uniform.
-Values below $2$ (and above $1.05$) are feasible, but produce less curving and therefore less unique behavior.
-$1.05$ works because it very closely replicates the original copycat formulas, providing a very smooth curving.
-Values beneath $1.05$ essentially leave probabilities unaffected, producing no significant unique behavior dependent on temperature.
-
-\lstinputlisting[language=Python]{formulas/best.py}
-
-Random thought:
-It would be interesting to not hardcode the value of $r$, but to instead leave it as a variable between $0$ and $2$ that changes depending on frustration.
-However, this would be much like temperature in the first place....?
-$r$ could itself be a function of temperature. That would be.... meta.... lol.
-
-\break
-...
-\break
-
-And ten minutes later, it was done.
-The "meta" formula performs as well as the "best" formula on the "ijjkkk" problem, which I consider the most novel.
-Interestingly, I noticed that the paramterized formulas aren't as good on this problem. What did I parameterize them for? Was it well justified?
-(Probably not)
-
-At this point, I plan on using the git branch "feature-normal-science-framework" to implement a system that takes in a problem set and provides several answer distributions as output.
-Then, I'll do a massive cross-formula answer distribution comparison with $\chi^2$ tests. This will give me an idea about which formula and which changes are best.
-I'll also be able to compare all of these answer distributions to the frequencies obtained in temperature removal branches of the repository.
-
-\subsection{Steps/plan}
-
-Normal Science:
-\begin{enumerate}
-	\item Introduce statistical techniques
-    \item Reduce magic number usage, document reasoning and math
-    \item Propose effective human subject comparison
-\end{enumerate}
-Temperature:
-\begin{enumerate}
-	\item Propose formula improvements
-    \item Experiment with a destructive removal of temperature
-    \item Experiment with a "surgical" removal of temperature
-    \item Assess different copycat versions with/without temperature
-\end{enumerate}
-
-\subsection{Semi-structured Notes}
-
-Biological or psychological plausibility only matters if it actually affects the presence of intelligent processes. For example, neurons don't exist in copycat because we feel that they aren't required to simulate the processes being studied. Instead, copycat uses higher-level structures to simulate the same emergent processes that neurons do. However, codelets and the control of them relies on a global function representing tolerance to irrelevant structures. Other higher level structures in copycat likely rely on globals as well. Another central variable in copycat is the "rule" structure, of which there is only one. While some global variables might be viable, others may actually obstruct the ability to model intelligent processes. For example, a distributed notion of temperature will not only increase biological and psychological plausibility, but increase copycat's effectiveness at producing acceptable answer distributions.
-
-We must also realize that copycat is only a model, so even if we take goals (level of abstraction) and biological plausibility into account...
-It is only worth changing temperature if it affects the model.
-Arguably, it does affect the model. (Or, rather, we hypothesize that it does. There is only one way to find out for sure, and that's the point of this paper)
-
-So, maybe this is a paper about goals, model accuracy, and an attempt to find which cognitive details matter and which don't. It also might provide some insight into making a "Normal Science" framework.
-
-Copycat is full of random uncommented parameters and formulas. Personally, I would advocate for removing or at least documenting as many of these as possible. In an ideal model, all of the numbers present might be either from existing mathematical formulas, or present for a very good (emergent and explainable - so that no other number would make sense in the same place) reason. However, settling on so called "magic" numbers because the authors of the program believed that their parameterizations were correct is very dangerous. If we removed random magic numbers, we would gain confidence in our model, progress towards a normal science, and gain a better understanding of cognitive processes. 
-
-Similarly, a lot of the testing of copycat is based on human perception of answer distributions. However, I suggest that we move to a more statistical approach. For example, deciding on some arbitrary baseline answer distribution and then modifying copycat to obtain other answer distributions and then comparing distributions with a statistical significance test would actually be indicative of what effect each change had. This paper will include code changes and proposals that lead copycat (and FARG projects in general) to a more statistical and verifiable approach.
-While there is a good argument about copycat representing an individual with biases and therefore being incomparable to a distributed group of individuals, I believe that additional effort should be made to test copycat against human subjects.  I may include in this paper a concrete proposal on how such an experiment might be done.
-
-Let's simply test the hypothesis: \[H_i\] Copycat will have an improved (significantly different with increased frequencies of more desirable answers and decreased frequencies of less desirable answers: desirability will be determined by some concrete metric, such as the number of relationships that are preserved or mirrored) answer distribution if temperature is turned to a set of distributed metrics. \[H_0\] Copycat's answer distribution will be unaffected by changing temperature to a set of distributed metrics.
-
-\subsection{Random Notes}
-
-This is all just free-flow unstructured notes. Don't take anything too seriously :).
-
-Below are a list of relevant primary and secondary sources I am reviewing:
-
-Biological/Psychological Plausibility:
-\begin{verbatim}
-http://www.cell.com/trends/cognitive-sciences/abstract/S1364-6613(16)30217-0
-"There is no evidence for a single site of working memory storage."
-https://ekmillerlab.mit.edu/2017/01/10/the-distributed-nature-of-working-memory/
-
-Creativity as a distributed process (SECONDARY: Review primaries)
-https://blogs.scientificamerican.com/beautiful-minds/the-real-neuroscience-of-creativity/
-cognition results from the dynamic interactions of distributed brain areas operating in large-scale networks
-http://scottbarrykaufman.com/wp-content/uploads/2013/08/Bressler_Large-Scale_Brain_10.pdf
-
-\end{verbatim}
-
-
-\bibliographystyle{alpha}
-\bibliography{sample}
-
-\end{document}

papers/resources/adj.l

@@ -1,28 +0,0 @@
-(defun get-temperature-adjusted-probability (prob &aux low-prob-factor
-						       result)
-; This function is a filter:  it inputs a value (from 0 to 100) and returns
-; a probability (from 0 - 1) based on that value and the temperature.  When
-; the temperature is 0, the result is (/ value 100), but at higher 
-; temperatures, values below 50 get raised and values above 50 get lowered
-; as a function of temperature.
-; I think this whole formula could probably be simplified.
-
-  (setq result
-	(cond ((= prob 0) 0)
-	      ((<= prob .5)
-               (setq low-prob-factor (max 1 (truncate (abs (log prob 10)))))
-               (min (+ prob 
-		       (* (/ (- 10 (sqrt (fake-reciprocal *temperature*))) 
-			     100) 
-			  (- (expt 10 (- (1- low-prob-factor))) prob)))
-		    .5))
-		     
-   	      ((= prob .5) .5)
-	      ((> prob .5)
-               (max (- 1
-		        (+ (- 1 prob) 
-		           (* (/ (- 10 (sqrt (fake-reciprocal *temperature*))) 
-			         100)
-			      (- 1 (- 1 prob)))))
-	            .5))))
-  result)

papers/resources/best.py

@@ -1,21 +0,0 @@
-def _working_best(temp, prob):
-    s = .5   # convergence
-    r = 1.05 # power
-    u = prob ** r if prob < .5 else prob ** (1/r)
-    return _weighted(temp, prob, s, u)
-
-def _soft_best(temp, prob):
-    s = .5   # convergence
-    r = 1.05 # power
-    u = prob ** r if prob < .5 else prob ** (1/r)
-    return _weighted(temp, prob, s, u)
-
-def _parameterized_best(temp, prob):
-    alpha = 5
-    beta  = 1
-    s     = .5
-    s     = (alpha * prob + beta * s) / (alpha + beta)
-    r     = 1.05
-    u = prob ** r if prob < .5 else prob ** (1/r)
-    return _weighted(temp, prob, s, u)
-

papers/resources/entropy.py

@@ -1,12 +0,0 @@
-import math
-
-def _entropy(temp, prob):
-    if prob == 0 or prob == 0.5 or temp == 0:
-        return prob
-    if prob < 0.5:
-        return 1.0 - _original(temp, 1.0 - prob)
-    coldness = 100.0 - temp
-    a = math.sqrt(coldness)
-    c = (10 - a) / 100
-    f = (c + 1) * prob
-    return -f * math.log2(f)

papers/resources/original.py

@@ -1,12 +0,0 @@
-import math
-
-def _original(temp, prob):
-    if prob == 0 or prob == 0.5 or temp == 0:
-        return prob
-    if prob < 0.5:
-        return 1.0 - _original(temp, 1.0 - prob)
-    coldness = 100.0 - temp
-    a = math.sqrt(coldness)
-    c = (10 - a) / 100
-    f = (c + 1) * prob
-    return max(f, 0.5)

papers/resources/weighted.py

@@ -1,28 +0,0 @@
-def _weighted(temp, prob, s, u):
-    weighted = (temp / 100) * s + ((100 - temp) / 100) * u
-    return weighted
-
-def _weighted_inverse(temp, prob):
-    iprob = 1 - prob
-    return _weighted(temp, prob, iprob, prob)
-
-# Uses .5 instead of 1-prob
-def _fifty_converge(temp, prob):
-    return _weighted(temp, prob, .5, prob)
-
-# Curves to the average of the (1-p) and .5
-def _soft_curve(temp, prob):
-    return min(1, _weighted(temp, prob, (1.5-prob)/2, prob))
-
-# Curves to the weighted average of the (1-p) and .5
-def _weighted_soft_curve(temp, prob):
-    weight = 100
-    gamma  = .5  # convergance value
-    alpha  = 1   # gamma weight
-    beta   = 3   # iprob weight
-    curved = min(1,
-                 (temp / weight) *
-                     ((alpha * gamma + beta * (1 - prob)) /
-                         (alpha + beta)) +
-                 ((weight - temp) / weight) * prob)
-    return curved

papers/sources.bib

@@ -1,55 +0,0 @@
-
-@article{linhares,
-    author = "Alexandre Linhares",
-    title  = "The emergence of choice: Decision-making and strategic thinking through analogies",
-    journal = "Information Sciences",
-    volume  = "259",
-    pages   = "36-56",
-    year    = "2014"
-}
-
-@article{compmodeling,
-    author = "Casper Addyman , Robert M. French",
-    title = "Computational modeling in cognitive science: a manifesto for change.",
-    journal = "Topics in Cognitive Science",
-    year="2012"
-}
-
-@book{analogyasperception,
-    title  = {Analogy Making as Perception},
-    author = {Melanie Mitchell},
-    isbn   = {0-262-13289-3},
-    year   = {1993},
-    publisher = {Massachusetts Institute of Technology}
-}
- 
-@book{fluidconcepts,
-    title={Fluid Concepts and Creative Analogies},
-    author={Douglas Hofstadter, FARG},
-    isbn={0-465-02475-0},
-    year={1995},
-    publisher={Basic Books}
-}
-
-@book{computerandthebrain,
-    title={The Computer \& The Brain},
-    author={John Von Neumann},
-    isbn={978-0-300-18111-1},
-    year={1958},
-    publisher={Yale University Press}
-}
-
-@book{geb,
-    title={Gödel, Escher, Bach: an Eternal Golden Braid},
-    author={Douglas Hofstadter},
-    isbn={0-456-02656-7},
-    year={1979},
-    publisher={Basic Books}
-}
- 
-@online{knuthwebsite,
-    author    = "Donald Knuth",
-    title     = "Knuth: Computers and Typesetting",
-    url       = "http://www-cs-faculty.stanford.edu/~uno/abcde.html",
-    keywords  = "latex,knuth"
-}

slipnet_analysis/centrality_results.json

@@ -0,0 +1,86 @@
+{
+  "analysis_type": "centrality_correlation",
+  "n_nodes": 33,
+  "metrics": [
+    {
+      "name": "Eccentricity",
+      "key": "eccentricity",
+      "pearson_r": -0.3796,
+      "pearson_p": 0.029349,
+      "spearman_r": -0.2988,
+      "spearman_p": 0.091181,
+      "r_squared": 0.1441,
+      "significant": true
+    },
+    {
+      "name": "Closeness Centrality",
+      "key": "closeness",
+      "pearson_r": -0.2699,
+      "pearson_p": 0.128801,
+      "spearman_r": -0.1804,
+      "spearman_p": 0.315126,
+      "r_squared": 0.0728,
+      "significant": false
+    },
+    {
+      "name": "Degree Centrality",
+      "key": "degree",
+      "pearson_r": -0.2643,
+      "pearson_p": 0.137147,
+      "spearman_r": -0.2362,
+      "spearman_p": 0.18565,
+      "r_squared": 0.0699,
+      "significant": false
+    },
+    {
+      "name": "PageRank",
+      "key": "pagerank",
+      "pearson_r": -0.257,
+      "pearson_p": 0.148771,
+      "spearman_r": -0.1908,
+      "spearman_p": 0.287516,
+      "r_squared": 0.0661,
+      "significant": false
+    },
+    {
+      "name": "Clustering Coefficient",
+      "key": "clustering",
+      "pearson_r": -0.2191,
+      "pearson_p": 0.2205,
+      "spearman_r": -0.2761,
+      "spearman_p": 0.119934,
+      "r_squared": 0.048,
+      "significant": false
+    },
+    {
+      "name": "Betweenness Centrality",
+      "key": "betweenness",
+      "pearson_r": -0.1716,
+      "pearson_p": 0.339655,
+      "spearman_r": -0.0801,
+      "spearman_p": 0.657858,
+      "r_squared": 0.0294,
+      "significant": false
+    },
+    {
+      "name": "Eigenvector Centrality",
+      "key": "eigenvector",
+      "pearson_r": -0.1482,
+      "pearson_p": 0.410425,
+      "spearman_r": -0.2367,
+      "spearman_p": 0.184728,
+      "r_squared": 0.022,
+      "significant": false
+    },
+    {
+      "name": "Avg Neighbor Degree",
+      "key": "avg_neighbor_degree",
+      "pearson_r": 0.0517,
+      "pearson_p": 0.775231,
+      "spearman_r": -0.3006,
+      "spearman_p": 0.089172,
+      "r_squared": 0.0027,
+      "significant": false
+    }
+  ]
+}

slipnet_analysis/compute_centrality.py

@@ -0,0 +1,283 @@
+"""
+Compute various centrality and graph metrics for slipnet nodes.
+Compare correlations with conceptual depth.
+"""
+
+import json
+import numpy as np
+import networkx as nx
+from scipy import stats
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+
+def load_slipnet(filepath):
+    with open(filepath, 'r') as f:
+        return json.load(f)
+
+def build_graph(data):
+    """Build an undirected graph from slipnet JSON."""
+    G = nx.Graph()
+    for node in data['nodes']:
+        G.add_node(node['name'], depth=node['conceptualDepth'])
+    for link in data['links']:
+        G.add_edge(link['source'], link['destination'])
+    return G
+
+def get_letter_nodes():
+    return set(chr(i) for i in range(ord('a'), ord('z') + 1))
+
+def compute_all_metrics(G):
+    """Compute all centrality and graph metrics."""
+    metrics = {}
+
+    # Degree centrality
+    metrics['degree'] = nx.degree_centrality(G)
+
+    # Betweenness centrality
+    metrics['betweenness'] = nx.betweenness_centrality(G)
+
+    # Closeness centrality
+    metrics['closeness'] = nx.closeness_centrality(G)
+
+    # Eigenvector centrality (may fail on disconnected graphs)
+    try:
+        metrics['eigenvector'] = nx.eigenvector_centrality(G, max_iter=1000)
+    except nx.PowerIterationFailedConvergence:
+        # For disconnected graphs, compute on largest component
+        largest_cc = max(nx.connected_components(G), key=len)
+        subG = G.subgraph(largest_cc)
+        eig = nx.eigenvector_centrality(subG, max_iter=1000)
+        # Assign 0 to disconnected nodes
+        metrics['eigenvector'] = {n: eig.get(n, 0.0) for n in G.nodes()}
+
+    # PageRank
+    metrics['pagerank'] = nx.pagerank(G)
+
+    # Clustering coefficient
+    metrics['clustering'] = nx.clustering(G)
+
+    # Average neighbor degree
+    metrics['avg_neighbor_degree'] = nx.average_neighbor_degree(G)
+
+    # Eccentricity (only for connected components)
+    metrics['eccentricity'] = {}
+    for component in nx.connected_components(G):
+        subG = G.subgraph(component)
+        ecc = nx.eccentricity(subG)
+        metrics['eccentricity'].update(ecc)
+    # Disconnected nodes get max eccentricity + 1
+    max_ecc = max(metrics['eccentricity'].values()) if metrics['eccentricity'] else 0
+    for n in G.nodes():
+        if n not in metrics['eccentricity']:
+            metrics['eccentricity'][n] = max_ecc + 1
+
+    return metrics
+
+def main():
+    filepath = r'C:\Users\alexa\copycat\slipnet_analysis\slipnet.json'
+    data = load_slipnet(filepath)
+
+    print(f"Loaded slipnet with {data['nodeCount']} nodes and {data['linkCount']} links")
+
+    # Build graph
+    G = build_graph(data)
+    print(f"Built graph with {G.number_of_nodes()} nodes and {G.number_of_edges()} edges")
+
+    # Get letter nodes
+    letter_nodes = get_letter_nodes()
+
+    # Compute all metrics
+    print("\nComputing centrality metrics...")
+    metrics = compute_all_metrics(G)
+
+    # Extract non-letter nodes with their depths
+    names = []
+    depths = []
+    for node in data['nodes']:
+        if node['name'] not in letter_nodes:
+            names.append(node['name'])
+            depths.append(node['conceptualDepth'])
+
+    depths = np.array(depths)
+
+    # Compute correlations for each metric
+    print("\n" + "=" * 80)
+    print("CORRELATION ANALYSIS: Conceptual Depth vs Graph Metrics")
+    print("=" * 80)
+
+    results = []
+
+    metric_names = {
+        'degree': 'Degree Centrality',
+        'betweenness': 'Betweenness Centrality',
+        'closeness': 'Closeness Centrality',
+        'eigenvector': 'Eigenvector Centrality',
+        'pagerank': 'PageRank',
+        'clustering': 'Clustering Coefficient',
+        'avg_neighbor_degree': 'Avg Neighbor Degree',
+        'eccentricity': 'Eccentricity'
+    }
+
+    for metric_key, metric_label in metric_names.items():
+        metric_values = np.array([metrics[metric_key][n] for n in names])
+
+        # Skip if all values are the same (no variance)
+        if np.std(metric_values) == 0:
+            print(f"\n{metric_label}: No variance, skipping")
+            continue
+
+        # Compute correlations
+        pearson_r, pearson_p = stats.pearsonr(depths, metric_values)
+        spearman_r, spearman_p = stats.spearmanr(depths, metric_values)
+
+        # R-squared
+        z = np.polyfit(depths, metric_values, 1)
+        y_pred = np.polyval(z, depths)
+        ss_res = np.sum((metric_values - y_pred) ** 2)
+        ss_tot = np.sum((metric_values - np.mean(metric_values)) ** 2)
+        r_squared = 1 - (ss_res / ss_tot) if ss_tot > 0 else 0
+
+        results.append({
+            'metric': metric_label,
+            'key': metric_key,
+            'pearson_r': pearson_r,
+            'pearson_p': pearson_p,
+            'spearman_r': spearman_r,
+            'spearman_p': spearman_p,
+            'r_squared': r_squared,
+            'slope': z[0],
+            'intercept': z[1],
+            'values': metric_values
+        })
+
+        print(f"\n{metric_label}:")
+        print(f"  Pearson r = {pearson_r:.4f} (p = {pearson_p:.6f})")
+        print(f"  Spearman rho = {spearman_r:.4f} (p = {spearman_p:.6f})")
+        print(f"  R-squared = {r_squared:.4f}")
+
+    # Sort by absolute Pearson correlation
+    results.sort(key=lambda x: abs(x['pearson_r']), reverse=True)
+
+    print("\n" + "=" * 80)
+    print("SUMMARY: Metrics ranked by |Pearson r|")
+    print("=" * 80)
+    print(f"{'Metric':<25} {'Pearson r':>12} {'p-value':>12} {'Spearman':>12} {'R-squared':>12}")
+    print("-" * 75)
+    for r in results:
+        sig = "*" if r['pearson_p'] < 0.05 else " "
+        print(f"{r['metric']:<25} {r['pearson_r']:>11.4f}{sig} {r['pearson_p']:>12.6f} {r['spearman_r']:>12.4f} {r['r_squared']:>12.4f}")
+
+    print("\n* = statistically significant at p < 0.05")
+
+    # Create comparison plot (2x4 grid)
+    fig, axes = plt.subplots(2, 4, figsize=(16, 8))
+    axes = axes.flatten()
+
+    for idx, r in enumerate(results):
+        if idx >= 8:
+            break
+        ax = axes[idx]
+
+        # Add jitter for visibility
+        jitter = np.random.normal(0, 0.02 * np.std(r['values']), len(r['values']))
+
+        ax.scatter(depths, r['values'] + jitter, alpha=0.7, s=60, c='steelblue', edgecolors='navy')
+
+        # Trend line
+        x_line = np.linspace(min(depths), max(depths), 100)
+        y_line = r['slope'] * x_line + r['intercept']
+        ax.plot(x_line, y_line, 'r--', alpha=0.8)
+
+        ax.set_xlabel('Conceptual Depth', fontsize=10)
+        ax.set_ylabel(r['metric'], fontsize=10)
+
+        sig_marker = "*" if r['pearson_p'] < 0.05 else ""
+        ax.set_title(f"r = {r['pearson_r']:.3f}{sig_marker}, R² = {r['r_squared']:.3f}", fontsize=10)
+        ax.grid(True, alpha=0.3)
+
+    # Hide unused subplots
+    for idx in range(len(results), 8):
+        axes[idx].set_visible(False)
+
+    plt.suptitle('Conceptual Depth vs Graph Metrics (n=33 non-letter nodes)', fontsize=12, y=1.02)
+    plt.tight_layout()
+    plt.savefig(r'C:\Users\alexa\copycat\slipnet_analysis\centrality_comparison.png', dpi=150, bbox_inches='tight')
+    print(f"\nComparison plot saved to: centrality_comparison.png")
+
+    # Create individual detailed plots for top 4 metrics
+    fig2, axes2 = plt.subplots(2, 2, figsize=(12, 10))
+    axes2 = axes2.flatten()
+
+    for idx, r in enumerate(results[:4]):
+        ax = axes2[idx]
+
+        jitter = np.random.normal(0, 0.02 * np.std(r['values']), len(r['values']))
+
+        ax.scatter(depths, r['values'] + jitter, alpha=0.7, s=80, c='steelblue', edgecolors='navy')
+
+        # Add labels
+        for i, name in enumerate(names):
+            ax.annotate(name, (depths[i], r['values'][i] + jitter[i]),
+                       fontsize=7, alpha=0.7, xytext=(3, 3), textcoords='offset points')
+
+        # Trend line
+        x_line = np.linspace(min(depths), max(depths), 100)
+        y_line = r['slope'] * x_line + r['intercept']
+        ax.plot(x_line, y_line, 'r--', alpha=0.8,
+               label=f'y = {r["slope"]:.4f}x + {r["intercept"]:.4f}')
+
+        ax.set_xlabel('Conceptual Depth', fontsize=11)
+        ax.set_ylabel(r['metric'], fontsize=11)
+
+        sig_text = " (significant)" if r['pearson_p'] < 0.05 else " (not significant)"
+        ax.set_title(f"{r['metric']}\nPearson r = {r['pearson_r']:.3f} (p = {r['pearson_p']:.4f}){sig_text}",
+                    fontsize=11)
+        ax.legend(loc='best', fontsize=9)
+        ax.grid(True, alpha=0.3)
+
+    plt.suptitle('Top 4 Metrics: Conceptual Depth Correlations', fontsize=13)
+    plt.tight_layout()
+    plt.savefig(r'C:\Users\alexa\copycat\slipnet_analysis\top_metrics_detailed.png', dpi=150, bbox_inches='tight')
+    print(f"Detailed plot saved to: top_metrics_detailed.png")
+
+    # Save results to JSON for paper
+    output_data = {
+        'analysis_type': 'centrality_correlation',
+        'n_nodes': len(names),
+        'metrics': []
+    }
+    for r in results:
+        output_data['metrics'].append({
+            'name': r['metric'],
+            'key': r['key'],
+            'pearson_r': round(r['pearson_r'], 4),
+            'pearson_p': round(r['pearson_p'], 6),
+            'spearman_r': round(r['spearman_r'], 4),
+            'spearman_p': round(r['spearman_p'], 6),
+            'r_squared': round(r['r_squared'], 4),
+            'significant': bool(r['pearson_p'] < 0.05)
+        })
+
+    with open(r'C:\Users\alexa\copycat\slipnet_analysis\centrality_results.json', 'w') as f:
+        json.dump(output_data, f, indent=2)
+    print(f"Results saved to: centrality_results.json")
+
+    # Print data table for paper
+    print("\n" + "=" * 80)
+    print("DATA TABLE FOR PAPER")
+    print("=" * 80)
+    print(f"{'Node':<25} {'Depth':>6} {'Degree':>8} {'Between':>8} {'Close':>8} {'Eigen':>8} {'PageRank':>8}")
+    print("-" * 80)
+
+    sorted_nodes = sorted(zip(names, depths), key=lambda x: x[1])
+    for name, depth in sorted_nodes:
+        deg = metrics['degree'][name]
+        bet = metrics['betweenness'][name]
+        clo = metrics['closeness'][name]
+        eig = metrics['eigenvector'][name]
+        pr = metrics['pagerank'][name]
+        print(f"{name:<25} {depth:>6.0f} {deg:>8.4f} {bet:>8.4f} {clo:>8.4f} {eig:>8.4f} {pr:>8.4f}")
+
+if __name__ == '__main__':
+    main()

slipnet_analysis/compute_letter_paths.py

@@ -0,0 +1,157 @@
+"""
+Compute minimum hops from each node to the nearest letter node (a-z) in the slipnet.
+Like Erdos number, but starting from letter nodes.
+Adds 'minPathToLetter' field to each node in the JSON.
+"""
+
+import json
+import networkx as nx
+
+def load_slipnet(filepath):
+    with open(filepath, 'r') as f:
+        return json.load(f)
+
+def save_slipnet(data, filepath):
+    with open(filepath, 'w') as f:
+        json.dump(data, f, indent=2)
+
+def build_graph(data):
+    """Build an undirected unweighted NetworkX graph from slipnet JSON."""
+    G = nx.Graph()  # Undirected graph - edges work both ways
+
+    # Add all nodes
+    for node in data['nodes']:
+        G.add_node(node['name'])
+
+    # Add edges (unweighted - each edge counts as 1 hop)
+    for link in data['links']:
+        G.add_edge(link['source'], link['destination'])
+
+    return G
+
+def get_letter_nodes():
+    """Return set of letter nodes (a-z)."""
+    return set(chr(i) for i in range(ord('a'), ord('z') + 1))
+
+def compute_min_hops_to_letters(G, letter_nodes):
+    """
+    Compute minimum hops from each node to the nearest letter node.
+    Like Erdos number but for letters.
+    Returns dict: node_name -> {hops, path, nearest_letter}
+    """
+    results = {}
+
+    # For each node, find shortest path (by hop count) to any letter
+    for node in G.nodes():
+        if node in letter_nodes:
+            # Letters have 0 hops to themselves
+            results[node] = {
+                'hops': 0,
+                'path': [node],
+                'nearestLetter': node
+            }
+        else:
+            min_hops = float('inf')
+            min_path = None
+            nearest_letter = None
+
+            for letter in letter_nodes:
+                try:
+                    # Find shortest path by hop count (no weight parameter)
+                    path = nx.shortest_path(G, source=node, target=letter)
+                    hops = len(path) - 1  # Number of edges = nodes - 1
+                    if hops < min_hops:
+                        min_hops = hops
+                        min_path = path
+                        nearest_letter = letter
+                except nx.NetworkXNoPath:
+                    continue
+
+            if min_path is not None:
+                results[node] = {
+                    'hops': min_hops,
+                    'path': min_path,
+                    'nearestLetter': nearest_letter
+                }
+            else:
+                results[node] = {
+                    'hops': None,
+                    'path': None,
+                    'nearestLetter': None
+                }
+
+    return results
+
+def main():
+    filepath = r'C:\Users\alexa\copycat\slipnet_analysis\slipnet.json'
+
+    # Load the slipnet
+    data = load_slipnet(filepath)
+    print(f"Loaded slipnet with {data['nodeCount']} nodes and {data['linkCount']} links")
+
+    # Build the graph
+    G = build_graph(data)
+    print(f"Built graph with {G.number_of_nodes()} nodes and {G.number_of_edges()} edges")
+
+    # Get letter nodes
+    letter_nodes = get_letter_nodes()
+    print(f"Letter nodes: {sorted(letter_nodes)}")
+
+    # Compute minimum hops to letters
+    path_results = compute_min_hops_to_letters(G, letter_nodes)
+
+    # Find max hops among reachable nodes
+    max_hops = max(r['hops'] for r in path_results.values() if r['hops'] is not None)
+    unreachable_hops = 2 * max_hops
+    print(f"Max hops among reachable nodes: {max_hops}")
+    print(f"Assigning unreachable nodes hops = 2 * {max_hops} = {unreachable_hops}")
+
+    # Assign unreachable nodes hops = 2 * max_hops
+    for node_name, result in path_results.items():
+        if result['hops'] is None:
+            result['hops'] = unreachable_hops
+            result['path'] = None  # No path exists
+            result['nearestLetter'] = None
+
+    # Add results to each node in the JSON
+    for node in data['nodes']:
+        node_name = node['name']
+        if node_name in path_results:
+            result = path_results[node_name]
+            node['minPathToLetter'] = {
+                'hops': result['hops'],
+                'path': result['path'],
+                'nearestLetter': result['nearestLetter']
+            }
+
+    # Save the updated JSON
+    save_slipnet(data, filepath)
+    print(f"\nUpdated slipnet saved to {filepath}")
+
+    # Print summary sorted by hops
+    print("\n=== Summary of minimum hops to letter nodes (Erdos-style) ===")
+    reachable_nodes = [(n['name'], n['minPathToLetter']) for n in data['nodes']
+                       if 'minPathToLetter' in n and n['minPathToLetter']['path'] is not None
+                       and n['minPathToLetter']['hops'] > 0]
+    unreachable_nodes = [(n['name'], n['minPathToLetter']) for n in data['nodes']
+                         if 'minPathToLetter' in n and n['minPathToLetter']['path'] is None
+                         and n['minPathToLetter']['hops'] > 0]
+
+    # Sort by hops, then by name
+    reachable_nodes.sort(key=lambda x: (x[1]['hops'], x[0]))
+    unreachable_nodes.sort(key=lambda x: x[0])
+
+    print(f"\n{'Node':<30} {'Hops':<6} {'Nearest':<8} {'Path'}")
+    print("-" * 80)
+
+    for name, info in reachable_nodes:
+        path_str = ' -> '.join(info['path'])
+        print(f"{name:<30} {info['hops']:<6} {info['nearestLetter']:<8} {path_str}")
+
+    if unreachable_nodes:
+        print(f"\nUnreachable nodes (assigned hops = {unreachable_hops}):")
+        for name, info in unreachable_nodes:
+            print(f"  {name:<30} (depth: {[n['conceptualDepth'] for n in data['nodes'] if n['name'] == name][0]})")
+
+if __name__ == '__main__':
+    main()

slipnet_analysis/compute_stats.py

@@ -0,0 +1,85 @@
+"""Compute correlation statistics for the paper (hop-based)."""
+
+import json
+import numpy as np
+from scipy import stats
+
+def main():
+    with open(r'C:\Users\alexa\copycat\slipnet_analysis\slipnet.json', 'r') as f:
+        data = json.load(f)
+
+    # Extract data points (excluding letter nodes themselves)
+    names = []
+    depths = []
+    hops = []
+    is_unreachable = []
+
+    for node in data['nodes']:
+        name = node['name']
+        depth = node['conceptualDepth']
+        path_info = node.get('minPathToLetter', {})
+        hop_count = path_info.get('hops')
+        nearest = path_info.get('nearestLetter')
+
+        # Skip letter nodes (hops 0)
+        if hop_count is not None and hop_count > 0:
+            names.append(name)
+            depths.append(depth)
+            hops.append(hop_count)
+            is_unreachable.append(nearest is None)
+
+    # Convert to numpy arrays
+    depths = np.array(depths)
+    hops = np.array(hops)
+
+    # Compute correlation
+    correlation, p_value = stats.pearsonr(depths, hops)
+    spearman_corr, spearman_p = stats.spearmanr(depths, hops)
+
+    # Linear regression
+    z = np.polyfit(depths, hops, 1)
+
+    # R-squared
+    y_pred = np.polyval(z, depths)
+    ss_res = np.sum((hops - y_pred) ** 2)
+    ss_tot = np.sum((hops - np.mean(hops)) ** 2)
+    r_squared = 1 - (ss_res / ss_tot)
+
+    num_unreachable = sum(is_unreachable)
+    print(f"Number of nodes analyzed: {len(names)}")
+    print(f"Total nodes: {data['nodeCount']}")
+    print(f"Letter nodes (excluded): 26")
+    print(f"Unreachable nodes (hops = 2*max): {num_unreachable}")
+    print()
+    print(f"Pearson correlation: r = {correlation:.4f}")
+    print(f"Pearson p-value: p = {p_value:.6f}")
+    print(f"Spearman correlation: rho = {spearman_corr:.4f}")
+    print(f"Spearman p-value: p = {spearman_p:.6f}")
+    print(f"R-squared: {r_squared:.4f}")
+    print(f"Linear regression: hops = {z[0]:.4f} * depth + {z[1]:.4f}")
+    print()
+    print(f"Depth range: {min(depths):.1f} - {max(depths):.1f}")
+    print(f"Hops range: {min(hops)} - {max(hops)}")
+    print(f"Mean depth: {np.mean(depths):.2f}")
+    print(f"Mean hops: {np.mean(hops):.2f}")
+    print(f"Std depth: {np.std(depths):.2f}")
+    print(f"Std hops: {np.std(hops):.2f}")
+    print()
+
+    # Distribution of hops
+    print("Distribution of hops:")
+    for h in sorted(set(hops)):
+        count = sum(1 for x in hops if x == h)
+        nodes_at_h = [n for n, hp in zip(names, hops) if hp == h]
+        print(f"  {h} hops: {count} nodes")
+
+    print()
+    print("Data points (sorted by hops, then depth):")
+    print(f"{'Node':<30} {'Depth':<10} {'Hops':<10} {'Reachable':<10}")
+    print("-" * 60)
+    for name, depth, hop, unreachable in sorted(zip(names, depths, hops, is_unreachable), key=lambda x: (x[2], x[1])):
+        status = "No" if unreachable else "Yes"
+        print(f"{name:<30} {depth:<10.1f} {hop:<10} {status:<10}")
+
+if __name__ == '__main__':
+    main()

slipnet_analysis/edge_types.md

@@ -0,0 +1,162 @@
+# Slipnet Edge Types
+
+This document describes all relationship types between nodes in the Copycat slipnet.
+
+## Overview
+
+The slipnet contains **202 links** connecting **59 nodes**. Links are categorized by:
+1. **Link Type** - The structural role of the link
+2. **Label** - An optional semantic annotation (itself a slipnode)
+
+---
+
+## Link Types (5 types)
+
+### 1. `nonSlip` (83 links)
+Lateral connections that do NOT allow conceptual slippage during analogy-making.
+
+**Purpose**: Connect related concepts that should remain distinct during mapping.
+
+**Examples**:
+- `a` → `b` (labeled `successor`) - sequential letter relationship
+- `b` → `a` (labeled `predecessor`) - reverse sequential relationship
+- `left` → `leftmost` - direction to position association
+- `sameness` → `samenessGroup` (labeled `groupCategory`) - bond type to group type
+- `predecessorGroup` → `length` - groups have length property
+
+### 2. `instance` (50 links)
+Connect a category to its instances (downward in the hierarchy).
+
+**Purpose**: Define membership relationships.
+
+**Examples**:
+- `letterCategory` → `a` (and all letters a-z)
+- `length` → `1`, `2`, `3`, `4`, `5`
+- `stringPositionCategory` → `leftmost`, `rightmost`, `middle`, `single`, `whole`
+- `directionCategory` → `left`, `right`
+- `bondCategory` → `predecessor`, `successor`, `sameness`
+- `objectCategory` → `letter`, `group`
+
+### 3. `category` (51 links)
+Connect an instance back to its category (upward in the hierarchy).
+
+**Purpose**: Allow instances to reference their parent category.
+
+**Examples**:
+- `a` → `letterCategory` (and all letters)
+- `1` → `length` (and all numbers)
+- `leftmost` → `stringPositionCategory`
+- `predecessor` → `bondCategory`
+- `samenessGroup` → `letterCategory`
+
+### 4. `slip` (16 links)
+Lateral connections that ALLOW conceptual slippage during analogy-making.
+
+**Purpose**: Enable flexible mappings between related but distinct concepts.
+
+**Examples**:
+- `first` ↔ `last` (labeled `opposite`) - opposites can slip to each other
+- `left` ↔ `right` (labeled `opposite`)
+- `successor` ↔ `predecessor` (labeled `opposite`)
+- `letterCategory` ↔ `length` - facets can slip
+- `letter` ↔ `group` - object types can slip
+- `single` ↔ `whole` - string positions can slip
+
+### 5. `property` (2 links)
+Connect objects to their intrinsic properties.
+
+**Purpose**: Define inherent attributes of specific nodes.
+
+**Examples**:
+- `a` → `first` (letter 'a' has property of being first)
+- `z` → `last` (letter 'z' has property of being last)
+
+---
+
+## Link Labels (5 labels)
+
+Labels are themselves slipnodes that annotate links with semantic meaning.
+
+### 1. `successor` (29 links)
+Marks sequential forward relationships.
+
+**Used on**: nonSlip links between consecutive letters (a→b, b→c, ..., y→z) and numbers (1→2, ..., 4→5)
+
+### 2. `predecessor` (29 links)
+Marks sequential backward relationships.
+
+**Used on**: nonSlip links in reverse direction (b→a, c→b, ..., z→y) and numbers (2→1, ..., 5→4)
+
+### 3. `opposite` (10 links)
+Marks oppositional relationships.
+
+**Used on**: slip links between conceptual opposites:
+- `first` ↔ `last`
+- `leftmost` ↔ `rightmost`
+- `left` ↔ `right`
+- `successor` ↔ `predecessor`
+- `successorGroup` ↔ `predecessorGroup`
+
+### 4. `groupCategory` (3 links)
+Links bond types to their corresponding group types.
+
+**Used on**: nonSlip links:
+- `sameness` → `samenessGroup`
+- `successor` → `successorGroup`
+- `predecessor` → `predecessorGroup`
+
+### 5. `bondCategory` (3 links)
+Links group types back to their corresponding bond types.
+
+**Used on**: nonSlip links:
+- `samenessGroup` → `sameness`
+- `successorGroup` → `successor`
+- `predecessorGroup` → `predecessor`
+
+---
+
+## Special Cases: Label-Only Nodes
+
+Two nodes exist in the slipnet but have **no edges as endpoints**:
+
+### `opposite`
+- Has 0 incoming and 0 outgoing edges as a graph node
+- Used only as a label on 10 slip links
+- Exists as a node so its activation can be tracked during reasoning
+
+### `identity`
+- Has 0 incoming and 0 outgoing edges as a graph node
+- Not used as a label on any links in the current implementation
+- Reserved for potential identity mappings in analogies
+
+---
+
+## Disconnected Cluster
+
+Three nodes form a separate cluster disconnected from the letter nodes:
+
+- `objectCategory` → `letter` (instance link)
+- `objectCategory` → `group` (instance link)
+- `letter` ↔ `group` (slip links)
+
+These nodes are reachable from each other but not from any letter (a-z).
+
+---
+
+## Summary Table
+
+| Type       | Count | Direction    | Allows Slippage | Purpose                          |
+|------------|-------|--------------|-----------------|----------------------------------|
+| nonSlip    | 83    | Directional  | No              | Lateral associations             |
+| instance   | 50    | Category→Instance | N/A         | Membership (downward)            |
+| category   | 51    | Instance→Category | N/A         | Classification (upward)          |
+| slip       | 16    | Directional  | Yes             | Flexible analogy mappings        |
+| property   | 2     | Object→Property | N/A           | Intrinsic attributes             |
+
+| Label        | Count | Semantic Meaning                    |
+|--------------|-------|-------------------------------------|
+| successor    | 29    | Forward sequential relationship     |
+| predecessor  | 29    | Backward sequential relationship    |
+| opposite     | 10    | Oppositional relationship           |
+| groupCategory| 3     | Bond-to-group association           |
+| bondCategory | 3     | Group-to-bond association           |

slipnet_analysis/export_slipnet.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""Export the Slipnet structure to a JSON file.
+
+This script is self-contained to avoid Python version compatibility issues
+with the main copycat package.
+"""
+
+import json
+
+
+class Slipnode:
+    """Minimal Slipnode for export purposes."""
+
+    def __init__(self, slipnet, name, depth, length=0.0):
+        self.slipnet = slipnet
+        self.name = name
+        self.conceptualDepth = depth
+        self.intrinsicLinkLength = length
+        self.shrunkLinkLength = length * 0.4
+        self.codelets = []
+        self.categoryLinks = []
+        self.instanceLinks = []
+        self.propertyLinks = []
+        self.lateralSlipLinks = []
+        self.lateralNonSlipLinks = []
+        self.incomingLinks = []
+        self.outgoingLinks = []
+
+
+class Sliplink:
+    """Minimal Sliplink for export purposes."""
+
+    def __init__(self, source, destination, label=None, length=0.0):
+        self.source = source
+        self.destination = destination
+        self.label = label
+        self.fixedLength = length
+        source.outgoingLinks.append(self)
+        destination.incomingLinks.append(self)
+
+
+class SlipnetExporter:
+    """Recreates the Slipnet structure for export."""
+
+    def __init__(self):
+        self.slipnodes = []
+        self.sliplinks = []
+        self._addInitialNodes()
+        self._addInitialLinks()
+
+    def _addNode(self, name, depth, length=0):
+        slipnode = Slipnode(self, name, depth, length)
+        self.slipnodes.append(slipnode)
+        return slipnode
+
+    def _addLink(self, source, destination, label=None, length=0.0):
+        link = Sliplink(source, destination, label=label, length=length)
+        self.sliplinks.append(link)
+        return link
+
+    def _addSlipLink(self, source, destination, label=None, length=0.0):
+        link = self._addLink(source, destination, label, length)
+        source.lateralSlipLinks.append(link)
+
+    def _addNonSlipLink(self, source, destination, label=None, length=0.0):
+        link = self._addLink(source, destination, label, length)
+        source.lateralNonSlipLinks.append(link)
+
+    def _addBidirectionalLink(self, source, destination, length):
+        self._addNonSlipLink(source, destination, length=length)
+        self._addNonSlipLink(destination, source, length=length)
+
+    def _addCategoryLink(self, source, destination, length):
+        link = self._addLink(source, destination, None, length)
+        source.categoryLinks.append(link)
+
+    def _addInstanceLink(self, source, destination, length=100.0):
+        categoryLength = source.conceptualDepth - destination.conceptualDepth
+        self._addCategoryLink(destination, source, categoryLength)
+        link = self._addLink(source, destination, None, length)
+        source.instanceLinks.append(link)
+
+    def _addPropertyLink(self, source, destination, length):
+        link = self._addLink(source, destination, None, length)
+        source.propertyLinks.append(link)
+
+    def _addOppositeLink(self, source, destination):
+        self._addSlipLink(source, destination, label=self.opposite)
+        self._addSlipLink(destination, source, label=self.opposite)
+
+    def _link_items_to_their_neighbors(self, items):
+        previous = items[0]
+        for item in items[1:]:
+            self._addNonSlipLink(previous, item, label=self.successor)
+            self._addNonSlipLink(item, previous, label=self.predecessor)
+            previous = item
+
+    def _addInitialNodes(self):
+        self.letters = []
+        for c in 'abcdefghijklmnopqrstuvwxyz':
+            slipnode = self._addNode(c, 10.0)
+            self.letters.append(slipnode)
+
+        self.numbers = []
+        for c in '12345':
+            slipnode = self._addNode(c, 30.0)
+            self.numbers.append(slipnode)
+
+        # string positions
+        self.leftmost = self._addNode('leftmost', 40.0)
+        self.rightmost = self._addNode('rightmost', 40.0)
+        self.middle = self._addNode('middle', 40.0)
+        self.single = self._addNode('single', 40.0)
+        self.whole = self._addNode('whole', 40.0)
+
+        # alphabetic positions
+        self.first = self._addNode('first', 60.0)
+        self.last = self._addNode('last', 60.0)
+
+        # directions
+        self.left = self._addNode('left', 40.0)
+        self.left.codelets += ['top-down-bond-scout--direction']
+        self.left.codelets += ['top-down-group-scout--direction']
+        self.right = self._addNode('right', 40.0)
+        self.right.codelets += ['top-down-bond-scout--direction']
+        self.right.codelets += ['top-down-group-scout--direction']
+
+        # bond types
+        self.predecessor = self._addNode('predecessor', 50.0, 60.0)
+        self.predecessor.codelets += ['top-down-bond-scout--category']
+        self.successor = self._addNode('successor', 50.0, 60.0)
+        self.successor.codelets += ['top-down-bond-scout--category']
+        self.sameness = self._addNode('sameness', 80.0)
+        self.sameness.codelets += ['top-down-bond-scout--category']
+
+        # group types
+        self.predecessorGroup = self._addNode('predecessorGroup', 50.0)
+        self.predecessorGroup.codelets += ['top-down-group-scout--category']
+        self.successorGroup = self._addNode('successorGroup', 50.0)
+        self.successorGroup.codelets += ['top-down-group-scout--category']
+        self.samenessGroup = self._addNode('samenessGroup', 80.0)
+        self.samenessGroup.codelets += ['top-down-group-scout--category']
+
+        # other relations
+        self.identity = self._addNode('identity', 90.0)
+        self.opposite = self._addNode('opposite', 90.0, 80.0)
+
+        # objects
+        self.letter = self._addNode('letter', 20.0)
+        self.group = self._addNode('group', 80.0)
+
+        # categories
+        self.letterCategory = self._addNode('letterCategory', 30.0)
+        self.stringPositionCategory = self._addNode('stringPositionCategory', 70.0)
+        self.stringPositionCategory.codelets += ['top-down-description-scout']
+        self.alphabeticPositionCategory = self._addNode('alphabeticPositionCategory', 80.0)
+        self.alphabeticPositionCategory.codelets += ['top-down-description-scout']
+        self.directionCategory = self._addNode('directionCategory', 70.0)
+        self.bondCategory = self._addNode('bondCategory', 80.0)
+        self.groupCategory = self._addNode('groupCategory', 80.0)
+        self.length = self._addNode('length', 60.0)
+        self.objectCategory = self._addNode('objectCategory', 90.0)
+        self.bondFacet = self._addNode('bondFacet', 90.0)
+
+        self.initiallyClampedSlipnodes = [
+            self.letterCategory,
+            self.stringPositionCategory,
+        ]
+
+    def _addInitialLinks(self):
+        self._link_items_to_their_neighbors(self.letters)
+        self._link_items_to_their_neighbors(self.numbers)
+
+        # letter categories
+        for letter in self.letters:
+            self._addInstanceLink(self.letterCategory, letter, 97.0)
+        self._addCategoryLink(self.samenessGroup, self.letterCategory, 50.0)
+
+        # lengths
+        for number in self.numbers:
+            self._addInstanceLink(self.length, number)
+
+        groups = [self.predecessorGroup, self.successorGroup, self.samenessGroup]
+        for group in groups:
+            self._addNonSlipLink(group, self.length, length=95.0)
+
+        opposites = [
+            (self.first, self.last),
+            (self.leftmost, self.rightmost),
+            (self.left, self.right),
+            (self.successor, self.predecessor),
+            (self.successorGroup, self.predecessorGroup),
+        ]
+        for a, b in opposites:
+            self._addOppositeLink(a, b)
+
+        # properties
+        self._addPropertyLink(self.letters[0], self.first, 75.0)
+        self._addPropertyLink(self.letters[-1], self.last, 75.0)
+
+        links = [
+            # object categories
+            (self.objectCategory, self.letter),
+            (self.objectCategory, self.group),
+            # string positions
+            (self.stringPositionCategory, self.leftmost),
+            (self.stringPositionCategory, self.rightmost),
+            (self.stringPositionCategory, self.middle),
+            (self.stringPositionCategory, self.single),
+            (self.stringPositionCategory, self.whole),
+            # alphabetic positions
+            (self.alphabeticPositionCategory, self.first),
+            (self.alphabeticPositionCategory, self.last),
+            # direction categories
+            (self.directionCategory, self.left),
+            (self.directionCategory, self.right),
+            # bond categories
+            (self.bondCategory, self.predecessor),
+            (self.bondCategory, self.successor),
+            (self.bondCategory, self.sameness),
+            # group categories
+            (self.groupCategory, self.predecessorGroup),
+            (self.groupCategory, self.successorGroup),
+            (self.groupCategory, self.samenessGroup),
+            # bond facets
+            (self.bondFacet, self.letterCategory),
+            (self.bondFacet, self.length),
+        ]
+        for a, b in links:
+            self._addInstanceLink(a, b)
+
+        # link bonds to their groups
+        self._addNonSlipLink(self.sameness, self.samenessGroup, label=self.groupCategory, length=30.0)
+        self._addNonSlipLink(self.successor, self.successorGroup, label=self.groupCategory, length=60.0)
+        self._addNonSlipLink(self.predecessor, self.predecessorGroup, label=self.groupCategory, length=60.0)
+
+        # link bond groups to their bonds
+        self._addNonSlipLink(self.samenessGroup, self.sameness, label=self.bondCategory, length=90.0)
+        self._addNonSlipLink(self.successorGroup, self.successor, label=self.bondCategory, length=90.0)
+        self._addNonSlipLink(self.predecessorGroup, self.predecessor, label=self.bondCategory, length=90.0)
+
+        # letter category to length
+        self._addSlipLink(self.letterCategory, self.length, length=95.0)
+        self._addSlipLink(self.length, self.letterCategory, length=95.0)
+
+        # letter to group
+        self._addSlipLink(self.letter, self.group, length=90.0)
+        self._addSlipLink(self.group, self.letter, length=90.0)
+
+        # direction-position, direction-neighbor, position-neighbor
+        self._addBidirectionalLink(self.left, self.leftmost, 90.0)
+        self._addBidirectionalLink(self.right, self.rightmost, 90.0)
+        self._addBidirectionalLink(self.right, self.leftmost, 100.0)
+        self._addBidirectionalLink(self.left, self.rightmost, 100.0)
+        self._addBidirectionalLink(self.leftmost, self.first, 100.0)
+        self._addBidirectionalLink(self.rightmost, self.first, 100.0)
+        self._addBidirectionalLink(self.leftmost, self.last, 100.0)
+        self._addBidirectionalLink(self.rightmost, self.last, 100.0)
+
+        # other
+        self._addSlipLink(self.single, self.whole, length=90.0)
+        self._addSlipLink(self.whole, self.single, length=90.0)
+
+
+def export_slipnet():
+    """Export slipnet nodes and links to a JSON structure."""
+    slipnet = SlipnetExporter()
+
+    # Build node data
+    nodes = []
+    node_to_id = {}
+
+    for node in slipnet.slipnodes:
+        node_to_id[node] = node.name
+        node_data = {
+            "name": node.name,
+            "conceptualDepth": node.conceptualDepth,
+            "intrinsicLinkLength": node.intrinsicLinkLength,
+            "shrunkLinkLength": node.shrunkLinkLength,
+        }
+        if node.codelets:
+            node_data["codelets"] = node.codelets
+        nodes.append(node_data)
+
+    # Build link data with type classification
+    links = []
+
+    for link in slipnet.sliplinks:
+        link_data = {
+            "source": node_to_id[link.source],
+            "destination": node_to_id[link.destination],
+            "fixedLength": link.fixedLength,
+        }
+        if link.label:
+            link_data["label"] = node_to_id[link.label]
+
+        # Determine link type
+        if link in link.source.lateralSlipLinks:
+            link_data["type"] = "slip"
+        elif link in link.source.lateralNonSlipLinks:
+            link_data["type"] = "nonSlip"
+        elif link in link.source.categoryLinks:
+            link_data["type"] = "category"
+        elif link in link.source.instanceLinks:
+            link_data["type"] = "instance"
+        elif link in link.source.propertyLinks:
+            link_data["type"] = "property"
+
+        links.append(link_data)
+
+    # Identify initially clamped nodes
+    initially_clamped = [node_to_id[n] for n in slipnet.initiallyClampedSlipnodes]
+
+    # Create the full structure
+    data = {
+        "description": "Copycat Slipnet - A semantic network for analogical reasoning",
+        "nodeCount": len(nodes),
+        "linkCount": len(links),
+        "initiallyClampedNodes": initially_clamped,
+        "nodes": nodes,
+        "links": links,
+    }
+
+    return data
+
+
+if __name__ == '__main__':
+    data = export_slipnet()
+
+    output_file = 'slipnet.json'
+    with open(output_file, 'w') as f:
+        json.dump(data, f, indent=2)
+
+    print(f"Exported {data['nodeCount']} nodes and {data['linkCount']} links to {output_file}")

slipnet_analysis/plot_depth_distance_correlation.py

@@ -0,0 +1,108 @@
+"""
+Plot correlation between minimum hops to letter nodes and conceptual depth.
+"""
+
+import json
+import matplotlib
+matplotlib.use('Agg')  # Non-interactive backend
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy import stats
+
+def load_slipnet(filepath):
+    with open(filepath, 'r') as f:
+        return json.load(f)
+
+def main():
+    filepath = r'C:\Users\alexa\copycat\slipnet_analysis\slipnet.json'
+    data = load_slipnet(filepath)
+
+    # Extract data points (excluding letter nodes themselves)
+    names = []
+    depths = []
+    hops = []
+    is_unreachable = []  # Track which nodes are unreachable
+
+    for node in data['nodes']:
+        name = node['name']
+        depth = node['conceptualDepth']
+        path_info = node.get('minPathToLetter', {})
+        hop_count = path_info.get('hops')
+        nearest = path_info.get('nearestLetter')
+
+        # Skip letter nodes (hops 0)
+        if hop_count is not None and hop_count > 0:
+            names.append(name)
+            depths.append(depth)
+            hops.append(hop_count)
+            # Unreachable nodes have no nearestLetter
+            is_unreachable.append(nearest is None)
+
+    # Convert to numpy arrays
+    depths = np.array(depths)
+    hops = np.array(hops)
+    is_unreachable = np.array(is_unreachable)
+
+    # Compute correlation
+    correlation, p_value = stats.pearsonr(depths, hops)
+    spearman_corr, spearman_p = stats.spearmanr(depths, hops)
+
+    # Create the plot
+    fig, ax = plt.subplots(figsize=(10, 8))
+
+    # Scatter plot with jitter for overlapping points
+    jitter = np.random.normal(0, 0.08, len(hops))
+
+    # Plot reachable nodes in blue
+    reachable_mask = ~is_unreachable
+    ax.scatter(depths[reachable_mask], hops[reachable_mask] + jitter[reachable_mask],
+               alpha=0.7, s=100, c='steelblue', edgecolors='navy', label='Reachable')
+
+    # Plot unreachable nodes in red
+    if np.any(is_unreachable):
+        ax.scatter(depths[is_unreachable], hops[is_unreachable] + jitter[is_unreachable],
+                   alpha=0.7, s=100, c='crimson', edgecolors='darkred', label='Unreachable (2×max)')
+
+    # Add labels to each point
+    for i, name in enumerate(names):
+        ax.annotate(name, (depths[i], hops[i] + jitter[i]), fontsize=8, alpha=0.8,
+                    xytext=(5, 5), textcoords='offset points')
+
+    # Add trend line
+    z = np.polyfit(depths, hops, 1)
+    p = np.poly1d(z)
+    x_line = np.linspace(min(depths), max(depths), 100)
+    ax.plot(x_line, p(x_line), "r--", alpha=0.8, label=f'Linear fit (y = {z[0]:.3f}x + {z[1]:.2f})')
+
+    # Labels and title
+    ax.set_xlabel('Conceptual Depth', fontsize=12)
+    ax.set_ylabel('Minimum Hops to Letter Node (Erdos-style)', fontsize=12)
+    ax.set_title('Correlation: Conceptual Depth vs Hops to Nearest Letter\n'
+                 f'Pearson r = {correlation:.3f} (p = {p_value:.4f}), '
+                 f'Spearman rho = {spearman_corr:.3f} (p = {spearman_p:.4f})',
+                 fontsize=11)
+
+    ax.legend(loc='upper left')
+    ax.grid(True, alpha=0.3)
+    max_hops = int(max(hops))
+    ax.set_yticks(range(1, max_hops + 1))
+    ax.set_ylim(0.5, max_hops + 0.5)
+
+    # Print statistics
+    print(f"Number of nodes with paths (excluding letters): {len(names)}")
+    print(f"\nPearson correlation: r = {correlation:.4f}, p-value = {p_value:.6f}")
+    print(f"Spearman correlation: rho = {spearman_corr:.4f}, p-value = {spearman_p:.6f}")
+    print(f"\nLinear regression: hops = {z[0]:.4f} * depth + {z[1]:.4f}")
+
+    print("\nData points:")
+    print(f"{'Node':<30} {'Depth':<10} {'Hops':<10}")
+    print("-" * 50)
+    for name, depth, hop in sorted(zip(names, depths, hops), key=lambda x: (x[2], x[1])):
+        print(f"{name:<30} {depth:<10.1f} {hop:<10}")
+
+    plt.tight_layout()
+    plt.savefig(r'C:\Users\alexa\copycat\slipnet_analysis\depth_hops_correlation.png', dpi=150)
+    print(f"\nPlot saved to: C:\\Users\\alexa\\copycat\\slipnet_analysis\\depth_hops_correlation.png")
+
+if __name__ == '__main__':
+    main()

slipnet_analysis/slipnet_depth_analysis.aux

@@ -0,0 +1,41 @@
+\relax 
+\providecommand\hyper@newdestlabel[2]{}
+\providecommand\HyField@AuxAddToFields[1]{}
+\providecommand\HyField@AuxAddToCoFields[2]{}
+\citation{mitchell1993,hofstadter1995}
+\@writefile{toc}{\contentsline {section}{\numberline {1}Introduction}{1}{section.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {1.1}The Slipnet}{1}{subsection.1.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {1.2}Research Questions}{1}{subsection.1.2}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {2}Methods}{1}{section.2}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Graph Construction}{1}{subsection.2.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}Metrics Computed}{1}{subsection.2.2}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Statistical Analysis}{2}{subsection.2.3}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {3}Results}{2}{section.3}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.1}Correlation Summary}{2}{subsection.3.1}\protected@file@percent }
+\@writefile{lot}{\contentsline {table}{\numberline {1}{\ignorespaces Correlations with conceptual depth (n=33)}}{2}{table.caption.2}\protected@file@percent }
+\providecommand*\caption@xref[2]{\@setref\relax\@undefined{#1}}
+\newlabel{tab:correlations}{{1}{2}{Correlations with conceptual depth (n=33)}{table.caption.2}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.2}Visualization}{2}{subsection.3.2}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {1}{\ignorespaces Conceptual depth vs eight graph metrics. Only eccentricity (*) shows significant correlation.}}{2}{figure.caption.3}\protected@file@percent }
+\newlabel{fig:comparison}{{1}{2}{Conceptual depth vs eight graph metrics. Only eccentricity (*) shows significant correlation}{figure.caption.3}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.3}Hop Distance Analysis}{2}{subsection.3.3}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.4}Eccentricity: The Significant Finding}{2}{subsection.3.4}\protected@file@percent }
+\@writefile{lot}{\contentsline {table}{\numberline {2}{\ignorespaces Eccentricity examples}}{2}{table.caption.4}\protected@file@percent }
+\newlabel{tab:eccentricity}{{2}{2}{Eccentricity examples}{table.caption.4}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {3.5}Non-Significant Centralities}{3}{subsection.3.5}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {4}Discussion}{3}{section.4}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1}Eccentricity as Global Position}{3}{subsection.4.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2}Local vs Global Structure}{3}{subsection.4.2}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.3}Design Implications}{3}{subsection.4.3}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.4}Limitations}{3}{subsection.4.4}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {5}Conclusion}{3}{section.5}\protected@file@percent }
+\bibcite{mitchell1993}{{1}{}{{}}{{}}}
+\bibcite{hofstadter1995}{{2}{}{{}}{{}}}
+\providecommand\NAT@force@numbers{}\NAT@force@numbers
+\@writefile{toc}{\contentsline {section}{\numberline {A}Complete Correlation Data}{4}{appendix.A}\protected@file@percent }
+\@writefile{lot}{\contentsline {table}{\numberline {3}{\ignorespaces Full correlation statistics}}{4}{table.caption.6}\protected@file@percent }
+\newlabel{tab:full}{{3}{4}{Full correlation statistics}{table.caption.6}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {B}Node Data Sample}{4}{appendix.B}\protected@file@percent }
+\@writefile{lot}{\contentsline {table}{\numberline {4}{\ignorespaces Selected nodes with metrics}}{4}{table.caption.7}\protected@file@percent }
+\newlabel{tab:nodes}{{4}{4}{Selected nodes with metrics}{table.caption.7}{}}
+\gdef \@abspage@last{4}

slipnet_analysis/slipnet_depth_analysis.log

@@ -0,0 +1,556 @@
+This is pdfTeX, Version 3.141592653-2.6-1.40.28 (MiKTeX 25.12) (preloaded format=pdflatex 2026.1.28)  1 FEB 2026 21:16
+entering extended mode
+ restricted \write18 enabled.
+ %&-line parsing enabled.
+**./slipnet_depth_analysis.tex
+(slipnet_depth_analysis.tex
+LaTeX2e <2025-11-01>
+L3 programming layer <2025-12-29>
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/base\article.cls
+Document Class: article 2025/01/22 v1.4n Standard LaTeX document class
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/base\size11.clo
+File: size11.clo 2025/01/22 v1.4n Standard LaTeX file (size option)
+)
+\c@part=\count275
+\c@section=\count276
+\c@subsection=\count277
+\c@subsubsection=\count278
+\c@paragraph=\count279
+\c@subparagraph=\count280
+\c@figure=\count281
+\c@table=\count282
+\abovecaptionskip=\skip49
+\belowcaptionskip=\skip50
+\bibindent=\dimen148
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/base\inputenc.sty
+Package: inputenc 2024/02/08 v1.3d Input encoding file
+\inpenc@prehook=\toks17
+\inpenc@posthook=\toks18
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/base\fontenc.sty
+Package: fontenc 2025/07/18 v2.1d Standard LaTeX package
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsmath.sty
+Package: amsmath 2025/07/09 v2.17z AMS math features
+\@mathmargin=\skip51
+
+For additional information on amsmath, use the `?' option.
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amstext.sty
+Package: amstext 2024/11/17 v2.01 AMS text
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsgen.sty
+File: amsgen.sty 1999/11/30 v2.0 generic functions
+\@emptytoks=\toks19
+\ex@=\dimen149
+))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsbsy.sty
+Package: amsbsy 1999/11/29 v1.2d Bold Symbols
+\pmbraise@=\dimen150
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsmath\amsopn.sty
+Package: amsopn 2022/04/08 v2.04 operator names
+)
+\inf@bad=\count283
+LaTeX Info: Redefining \frac on input line 233.
+\uproot@=\count284
+\leftroot@=\count285
+LaTeX Info: Redefining \overline on input line 398.
+LaTeX Info: Redefining \colon on input line 409.
+\classnum@=\count286
+\DOTSCASE@=\count287
+LaTeX Info: Redefining \ldots on input line 495.
+LaTeX Info: Redefining \dots on input line 498.
+LaTeX Info: Redefining \cdots on input line 619.
+\Mathstrutbox@=\box53
+\strutbox@=\box54
+LaTeX Info: Redefining \big on input line 721.
+LaTeX Info: Redefining \Big on input line 722.
+LaTeX Info: Redefining \bigg on input line 723.
+LaTeX Info: Redefining \Bigg on input line 724.
+\big@size=\dimen151
+LaTeX Font Info:    Redeclaring font encoding OML on input line 742.
+LaTeX Font Info:    Redeclaring font encoding OMS on input line 743.
+\macc@depth=\count288
+LaTeX Info: Redefining \bmod on input line 904.
+LaTeX Info: Redefining \pmod on input line 909.
+LaTeX Info: Redefining \smash on input line 939.
+LaTeX Info: Redefining \relbar on input line 969.
+LaTeX Info: Redefining \Relbar on input line 970.
+\c@MaxMatrixCols=\count289
+\dotsspace@=\muskip17
+\c@parentequation=\count290
+\dspbrk@lvl=\count291
+\tag@help=\toks20
+\row@=\count292
+\column@=\count293
+\maxfields@=\count294
+\andhelp@=\toks21
+\eqnshift@=\dimen152
+\alignsep@=\dimen153
+\tagshift@=\dimen154
+\tagwidth@=\dimen155
+\totwidth@=\dimen156
+\lineht@=\dimen157
+\@envbody=\toks22
+\multlinegap=\skip52
+\multlinetaggap=\skip53
+\mathdisplay@stack=\toks23
+LaTeX Info: Redefining \[ on input line 2950.
+LaTeX Info: Redefining \] on input line 2951.
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\amssymb.sty
+Package: amssymb 2013/01/14 v3.01 AMS font symbols
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\amsfonts.sty
+Package: amsfonts 2013/01/14 v3.01 Basic AMSFonts support
+\symAMSa=\mathgroup4
+\symAMSb=\mathgroup5
+LaTeX Font Info:    Redeclaring math symbol \hbar on input line 98.
+LaTeX Font Info:    Overwriting math alphabet `\mathfrak' in version `bold'
+(Font)                  U/euf/m/n --> U/euf/b/n on input line 106.
+)) (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\graphicx.st
+y
+Package: graphicx 2024/12/31 v1.2e Enhanced LaTeX Graphics (DPC,SPQR)
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\keyval.sty
+Package: keyval 2022/05/29 v1.15 key=value parser (DPC)
+\KV@toks@=\toks24
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\graphics.sty
+Package: graphics 2024/08/06 v1.4g Standard LaTeX Graphics (DPC,SPQR)
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics\trig.sty
+Package: trig 2023/12/02 v1.11 sin cos tan (DPC)
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics-cfg\graphics.c
+fg
+File: graphics.cfg 2016/06/04 v1.11 sample graphics configuration
+)
+Package graphics Info: Driver file: pdftex.def on input line 106.
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/graphics-def\pdftex.def
+File: pdftex.def 2025/09/29 v1.2d Graphics/color driver for pdftex
+))
+\Gin@req@height=\dimen158
+\Gin@req@width=\dimen159
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/booktabs\booktabs.sty
+Package: booktabs 2020/01/12 v1.61803398 Publication quality tables
+\heavyrulewidth=\dimen160
+\lightrulewidth=\dimen161
+\cmidrulewidth=\dimen162
+\belowrulesep=\dimen163
+\belowbottomsep=\dimen164
+\aboverulesep=\dimen165
+\abovetopsep=\dimen166
+\cmidrulesep=\dimen167
+\cmidrulekern=\dimen168
+\defaultaddspace=\dimen169
+\@cmidla=\count295
+\@cmidlb=\count296
+\@aboverulesep=\dimen170
+\@belowrulesep=\dimen171
+\@thisruleclass=\count297
+\@lastruleclass=\count298
+\@thisrulewidth=\dimen172
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\hyperref.sty
+Package: hyperref 2025-07-12 v7.01o Hypertext links for LaTeX
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/iftex\iftex.sty
+Package: iftex 2024/12/12 v1.0g TeX engine tests
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/kvsetkeys\kvsetkeys.sty
+Package: kvsetkeys 2022-10-05 v1.19 Key value parser (HO)
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/kvdefinekeys\kvdefine
+keys.sty
+Package: kvdefinekeys 2019-12-19 v1.6 Define keys (HO)
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pdfescape\pdfescape.s
+ty
+Package: pdfescape 2019/12/09 v1.15 Implements pdfTeX's escape features (HO)
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/ltxcmds\ltxcmds.sty
+Package: ltxcmds 2023-12-04 v1.26 LaTeX kernel commands for general use (HO)
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/pdftexcmds\pdftexcmds
+.sty
+Package: pdftexcmds 2020-06-27 v0.33 Utility functions of pdfTeX for LuaTeX (HO
+)
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/infwarerr\infwarerr.s
+ty
+Package: infwarerr 2019/12/03 v1.5 Providing info/warning/error messages (HO)
+)
+Package pdftexcmds Info: \pdf@primitive is available.
+Package pdftexcmds Info: \pdf@ifprimitive is available.
+Package pdftexcmds Info: \pdfdraftmode found.
+))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hycolor\hycolor.sty
+Package: hycolor 2020-01-27 v1.10 Color options for hyperref/bookmark (HO)
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\nameref.sty
+Package: nameref 2025-06-21 v2.57 Cross-referencing by name of section
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/refcount\refcount.sty
+Package: refcount 2019/12/15 v3.6 Data extraction from label references (HO)
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/gettitlestring\gettit
+lestring.sty
+Package: gettitlestring 2019/12/15 v1.6 Cleanup title references (HO)
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/kvoptions\kvoptions.sty
+Package: kvoptions 2022-06-15 v3.15 Key value format for package options (HO)
+))
+\c@section@level=\count299
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/etoolbox\etoolbox.sty
+Package: etoolbox 2025/10/02 v2.5m e-TeX tools for LaTeX (JAW)
+\etb@tempcnta=\count300
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/stringenc\stringenc.s
+ty
+Package: stringenc 2019/11/29 v1.12 Convert strings between diff. encodings (HO
+)
+)
+\@linkdim=\dimen173
+\Hy@linkcounter=\count301
+\Hy@pagecounter=\count302
+ (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\pd1enc.def
+File: pd1enc.def 2025-07-12 v7.01o Hyperref: PDFDocEncoding definition (HO)
+Now handling font encoding PD1 ...
+... no UTF-8 mapping file for font encoding PD1
+) (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/intcalc\intcalc.sty
+Package: intcalc 2019/12/15 v1.3 Expandable calculations with integers (HO)
+)
+\Hy@SavedSpaceFactor=\count303
+ (C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\puenc.def
+File: puenc.def 2025-07-12 v7.01o Hyperref: PDF Unicode definition (HO)
+Now handling font encoding PU ...
+... no UTF-8 mapping file for font encoding PU
+)
+Package hyperref Info: Hyper figures OFF on input line 4195.
+Package hyperref Info: Link nesting OFF on input line 4200.
+Package hyperref Info: Hyper index ON on input line 4203.
+Package hyperref Info: Plain pages OFF on input line 4210.
+Package hyperref Info: Backreferencing OFF on input line 4215.
+Package hyperref Info: Implicit mode ON; LaTeX internals redefined.
+Package hyperref Info: Bookmarks ON on input line 4462.
+\c@Hy@tempcnt=\count304
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/url\url.sty
+\Urlmuskip=\muskip18
+Package: url 2013/09/16  ver 3.4  Verb mode for urls, etc.
+)
+LaTeX Info: Redefining \url on input line 4801.
+\XeTeXLinkMargin=\dimen174
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/bitset\bitset.sty
+Package: bitset 2019/12/09 v1.3 Handle bit-vector datatype (HO)
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/bigintcalc\bigintcalc
+.sty
+Package: bigintcalc 2019/12/15 v1.5 Expandable calculations on big integers (HO
+)
+))
+\Fld@menulength=\count305
+\Field@Width=\dimen175
+\Fld@charsize=\dimen176
+Package hyperref Info: Hyper figures OFF on input line 6078.
+Package hyperref Info: Link nesting OFF on input line 6083.
+Package hyperref Info: Hyper index ON on input line 6086.
+Package hyperref Info: backreferencing OFF on input line 6093.
+Package hyperref Info: Link coloring OFF on input line 6098.
+Package hyperref Info: Link coloring with OCG OFF on input line 6103.
+Package hyperref Info: PDF/A mode OFF on input line 6108.
+\Hy@abspage=\count306
+\c@Item=\count307
+\c@Hfootnote=\count308
+)
+Package hyperref Info: Driver (autodetected): hpdftex.
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/hyperref\hpdftex.def
+File: hpdftex.def 2025-07-12 v7.01o Hyperref driver for pdfTeX
+\Fld@listcount=\count309
+\c@bookmark@seq@number=\count310
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/rerunfilecheck\rerunfil
+echeck.sty
+Package: rerunfilecheck 2025-06-21 v1.11 Rerun checks for auxiliary files (HO)
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/uniquecounter\uniquec
+ounter.sty
+Package: uniquecounter 2019/12/15 v1.4 Provide unlimited unique counter (HO)
+)
+Package uniquecounter Info: New unique counter `rerunfilecheck' on input line 2
+84.
+)
+\Hy@SectionHShift=\skip54
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/geometry\geometry.sty
+Package: geometry 2020/01/02 v5.9 Page Geometry
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/generic/iftex\ifvtex.sty
+Package: ifvtex 2019/10/25 v1.7 ifvtex legacy package. Use iftex instead.
+)
+\Gm@cnth=\count311
+\Gm@cntv=\count312
+\c@Gm@tempcnt=\count313
+\Gm@bindingoffset=\dimen177
+\Gm@wd@mp=\dimen178
+\Gm@odd@mp=\dimen179
+\Gm@even@mp=\dimen180
+\Gm@layoutwidth=\dimen181
+\Gm@layoutheight=\dimen182
+\Gm@layouthoffset=\dimen183
+\Gm@layoutvoffset=\dimen184
+\Gm@dimlist=\toks25
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/geometry\geometry.cfg))
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/natbib\natbib.sty
+Package: natbib 2010/09/13 8.31b (PWD, AO)
+\bibhang=\skip55
+\bibsep=\skip56
+LaTeX Info: Redefining \cite on input line 694.
+\c@NAT@ctr=\count314
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/float\float.sty
+Package: float 2001/11/08 v1.3d Float enhancements (AL)
+\c@float@type=\count315
+\float@exts=\toks26
+\float@box=\box55
+\@float@everytoks=\toks27
+\@floatcapt=\box56
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/caption\caption.sty
+Package: caption 2023/08/05 v3.6o Customizing captions (AR)
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/caption\caption3.sty
+Package: caption3 2023/07/31 v2.4d caption3 kernel (AR)
+\caption@tempdima=\dimen185
+\captionmargin=\dimen186
+\caption@leftmargin=\dimen187
+\caption@rightmargin=\dimen188
+\caption@width=\dimen189
+\caption@indent=\dimen190
+\caption@parindent=\dimen191
+\caption@hangindent=\dimen192
+Package caption Info: Standard document class detected.
+)
+\c@caption@flags=\count316
+\c@continuedfloat=\count317
+Package caption Info: float package is loaded.
+Package caption Info: hyperref package is loaded.
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/caption\subcaption.sty
+Package: subcaption 2023/07/28 v1.6b Sub-captions (AR)
+Package caption Info: New subtype `subfigure' on input line 238.
+\c@subfigure=\count318
+Package caption Info: New subtype `subtable' on input line 238.
+\c@subtable=\count319
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/l3backend\l3backend-pdf
+tex.def
+File: l3backend-pdftex.def 2025-10-09 L3 backend support: PDF output (pdfTeX)
+\l__color_backend_stack_int=\count320
+) (slipnet_depth_analysis.aux
+
+! Package natbib Error: Bibliography not compatible with author-year citations.
+
+(natbib)                Press <return> to continue in numerical citation style.
+
+
+See the natbib package documentation for explanation.
+Type  H <return>  for immediate help.
+ ...                                              
+                                                  
+l.34 ...mand\NAT@force@numbers{}\NAT@force@numbers
+                                                  
+Check the bibliography entries for non-compliant syntax,
+or select author-year BibTeX style, e.g. plainnat
+
+)
+\openout1 = `slipnet_depth_analysis.aux'.
+
+LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 24.
+LaTeX Font Info:    ... okay on input line 24.
+LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 24.
+LaTeX Font Info:    ... okay on input line 24.
+LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 24.
+LaTeX Font Info:    ... okay on input line 24.
+LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 24.
+LaTeX Font Info:    ... okay on input line 24.
+LaTeX Font Info:    Checking defaults for TS1/cmr/m/n on input line 24.
+LaTeX Font Info:    ... okay on input line 24.
+LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 24.
+LaTeX Font Info:    ... okay on input line 24.
+LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 24.
+LaTeX Font Info:    ... okay on input line 24.
+LaTeX Font Info:    Checking defaults for PD1/pdf/m/n on input line 24.
+LaTeX Font Info:    ... okay on input line 24.
+LaTeX Font Info:    Checking defaults for PU/pdf/m/n on input line 24.
+LaTeX Font Info:    ... okay on input line 24.
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/context/base/mkii\supp-pdf.mk
+ii
+[Loading MPS to PDF converter (version 2006.09.02).]
+\scratchcounter=\count321
+\scratchdimen=\dimen193
+\scratchbox=\box57
+\nofMPsegments=\count322
+\nofMParguments=\count323
+\everyMPshowfont=\toks28
+\MPscratchCnt=\count324
+\MPscratchDim=\dimen194
+\MPnumerator=\count325
+\makeMPintoPDFobject=\count326
+\everyMPtoPDFconversion=\toks29
+)
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/epstopdf-pkg\epstopdf-b
+ase.sty
+Package: epstopdf-base 2020-01-24 v2.11 Base part for package epstopdf
+Package epstopdf-base Info: Redefining graphics rule for `.eps' on input line 4
+85.
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/00miktex\epstopdf-sys.c
+fg
+File: epstopdf-sys.cfg 2021/03/18 v2.0 Configuration of epstopdf for MiKTeX
+))
+Package hyperref Info: Link coloring OFF on input line 24.
+ (slipnet_depth_analysis.out) (slipnet_depth_analysis.out)
+\@outlinefile=\write3
+\openout3 = `slipnet_depth_analysis.out'.
+
+
+*geometry* driver: auto-detecting
+*geometry* detected driver: pdftex
+*geometry* verbose mode - [ preamble ] result:
+* driver: pdftex
+* paper: <default>
+* layout: <same size as paper>
+* layoutoffset:(h,v)=(0.0pt,0.0pt)
+* modes: 
+* h-part:(L,W,R)=(65.04256pt, 484.20988pt, 65.04256pt)
+* v-part:(T,H,B)=(65.04256pt, 664.88487pt, 65.04256pt)
+* \paperwidth=614.295pt
+* \paperheight=794.96999pt
+* \textwidth=484.20988pt
+* \textheight=664.88487pt
+* \oddsidemargin=-7.22743pt
+* \evensidemargin=-7.22743pt
+* \topmargin=-44.22743pt
+* \headheight=12.0pt
+* \headsep=25.0pt
+* \topskip=11.0pt
+* \footskip=30.0pt
+* \marginparwidth=4.0pt
+* \marginparsep=10.0pt
+* \columnsep=10.0pt
+* \skip\footins=10.0pt plus 4.0pt minus 2.0pt
+* \hoffset=0.0pt
+* \voffset=0.0pt
+* \mag=1000
+* \@twocolumntrue
+* \@twosidefalse
+* \@mparswitchfalse
+* \@reversemarginfalse
+* (1in=72.27pt=25.4mm, 1cm=28.453pt)
+
+Package caption Info: Begin \AtBeginDocument code.
+Package caption Info: End \AtBeginDocument code.
+LaTeX Font Info:    Trying to load font information for U+msa on input line 27.
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\umsa.fd
+File: umsa.fd 2013/01/14 v3.01 AMS symbols A
+)
+LaTeX Font Info:    Trying to load font information for U+msb on input line 27.
+
+
+(C:\Users\alexa\AppData\Local\Programs\MiKTeX\tex/latex/amsfonts\umsb.fd
+File: umsb.fd 2013/01/14 v3.01 AMS symbols B
+)
+Underfull \vbox (badness 6284) has occurred while \output is active []
+
+
+Underfull \hbox (badness 2662) in paragraph at lines 46--47
+[]\T1/cmr/m/n/10.95 Global cen-tral-ity (be-tween-ness, close-ness,
+ []
+
+[1{C:/Users/alexa/AppData/Local/MiKTeX/fonts/map/pdftex/pdftex.map}
+
+
+]
+Underfull \hbox (badness 1303) in paragraph at lines 83--83
+[]\T1/cmr/m/n/10.95 Table 1: |Cor-re-la-tions with con-cep-tual depth
+ []
+
+<centrality_comparison.png, id=116, 1148.1294pt x 592.1322pt>
+File: centrality_comparison.png Graphic file (type png)
+<use centrality_comparison.png>
+Package pdftex.def Info: centrality_comparison.png  used on input line 114.
+(pdftex.def)             Requested size: 237.10493pt x 122.28236pt.
+
+Underfull \hbox (badness 10000) in paragraph at lines 123--124
+[]\T1/cmr/m/n/10.95 Counterexamples abound: \T1/cmtt/m/n/10.95 bondFacet
+ []
+
+[2 <./centrality_comparison.png>]
+Underfull \hbox (badness 1117) in paragraph at lines 215--216
+[]\T1/cmtt/m/n/10.95 centrality_results.json\T1/cmr/m/n/10.95 : Nu-mer-i-cal re
+-
+ []
+
+[3]
+Underfull \hbox (badness 1502) in paragraph at lines 216--217
+[]\T1/cmtt/m/n/10.95 centrality_comparison.png\T1/cmr/m/n/10.95 : Com-par-i-son
+
+ []
+
+[4
+
+] (slipnet_depth_analysis.aux)
+ ***********
+LaTeX2e <2025-11-01>
+L3 programming layer <2025-12-29>
+ ***********
+Package rerunfilecheck Info: File `slipnet_depth_analysis.out' has not changed.
+
+(rerunfilecheck)             Checksum: E004728272BA2383E766BFD309DA0B11;3052.
+ ) 
+Here is how much of TeX's memory you used:
+ 12358 strings out of 467871
+ 192776 string characters out of 5418376
+ 613190 words of memory out of 5000000
+ 41046 multiletter control sequences out of 15000+600000
+ 647276 words of font info for 93 fonts, out of 8000000 for 9000
+ 1141 hyphenation exceptions out of 8191
+ 75i,9n,79p,1060b,515s stack positions out of 10000i,1000n,20000p,200000b,200000s
+ <C:\Users\alexa\AppData\Local\MiKTeX\fonts/pk/ljfour/jknappen/ec/dpi600\ecrm
+0900.pk> <C:\Users\alexa\AppData\Local\MiKTeX\fonts/pk/ljfour/jknappen/ec/dpi60
+0\ecrm1000.pk> <C:\Users\alexa\AppData\Local\MiKTeX\fonts/pk/ljfour/jknappen/ec
+/dpi600\tcrm1095.pk> <C:\Users\alexa\AppData\Local\MiKTeX\fonts/pk/ljfour/jknap
+pen/ec/dpi600\ectt1095.pk> <C:\Users\alexa\AppData\Local\MiKTeX\fonts/pk/ljfour
+/jknappen/ec/dpi600\ecbx1200.pk> <C:\Users\alexa\AppData\Local\MiKTeX\fonts/pk/
+ljfour/jknappen/ec/dpi600\ecti1095.pk> <C:\Users\alexa\AppData\Local\MiKTeX\fon
+ts/pk/ljfour/jknappen/ec/dpi600\ecbx1095.pk> <C:\Users\alexa\AppData\Local\MiKT
+eX\fonts/pk/ljfour/jknappen/ec/dpi600\ecrm1095.pk> <C:\Users\alexa\AppData\Loca
+l\MiKTeX\fonts/pk/ljfour/jknappen/ec/dpi600\ecbx1440.pk> <C:\Users\alexa\AppDat
+a\Local\MiKTeX\fonts/pk/ljfour/jknappen/ec/dpi600\ectt1200.pk> <C:\Users\alexa\
+AppData\Local\MiKTeX\fonts/pk/ljfour/jknappen/ec/dpi600\ecrm1200.pk> <C:\Users\
+alexa\AppData\Local\MiKTeX\fonts/pk/ljfour/jknappen/ec/dpi600\ecrm1728.pk><C:/U
+sers/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/cm/cmmi10.
+pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/amsfonts/c
+m/cmmi9.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/public/am
+sfonts/cm/cmr10.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/type1/p
+ublic/amsfonts/cm/cmr7.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX/fonts/
+type1/public/amsfonts/cm/cmr8.pfb><C:/Users/alexa/AppData/Local/Programs/MiKTeX
+/fonts/type1/public/amsfonts/cm/cmr9.pfb><C:/Users/alexa/AppData/Local/Programs
+/MiKTeX/fonts/type1/public/amsfonts/cm/cmsy10.pfb>
+Output written on slipnet_depth_analysis.pdf (4 pages, 432492 bytes).
+PDF statistics:
+ 589 PDF objects out of 1000 (max. 8388607)
+ 43 named destinations out of 1000 (max. 500000)
+ 174 words of extra memory for PDF output out of 10000 (max. 10000000)
+

slipnet_analysis/slipnet_depth_analysis.out

@@ -0,0 +1,21 @@
+\BOOKMARK [1][-]{section.1}{\376\377\000I\000n\000t\000r\000o\000d\000u\000c\000t\000i\000o\000n}{}% 1
+\BOOKMARK [2][-]{subsection.1.1}{\376\377\000T\000h\000e\000\040\000S\000l\000i\000p\000n\000e\000t}{section.1}% 2
+\BOOKMARK [2][-]{subsection.1.2}{\376\377\000R\000e\000s\000e\000a\000r\000c\000h\000\040\000Q\000u\000e\000s\000t\000i\000o\000n\000s}{section.1}% 3
+\BOOKMARK [1][-]{section.2}{\376\377\000M\000e\000t\000h\000o\000d\000s}{}% 4
+\BOOKMARK [2][-]{subsection.2.1}{\376\377\000G\000r\000a\000p\000h\000\040\000C\000o\000n\000s\000t\000r\000u\000c\000t\000i\000o\000n}{section.2}% 5
+\BOOKMARK [2][-]{subsection.2.2}{\376\377\000M\000e\000t\000r\000i\000c\000s\000\040\000C\000o\000m\000p\000u\000t\000e\000d}{section.2}% 6
+\BOOKMARK [2][-]{subsection.2.3}{\376\377\000S\000t\000a\000t\000i\000s\000t\000i\000c\000a\000l\000\040\000A\000n\000a\000l\000y\000s\000i\000s}{section.2}% 7
+\BOOKMARK [1][-]{section.3}{\376\377\000R\000e\000s\000u\000l\000t\000s}{}% 8
+\BOOKMARK [2][-]{subsection.3.1}{\376\377\000C\000o\000r\000r\000e\000l\000a\000t\000i\000o\000n\000\040\000S\000u\000m\000m\000a\000r\000y}{section.3}% 9
+\BOOKMARK [2][-]{subsection.3.2}{\376\377\000V\000i\000s\000u\000a\000l\000i\000z\000a\000t\000i\000o\000n}{section.3}% 10
+\BOOKMARK [2][-]{subsection.3.3}{\376\377\000H\000o\000p\000\040\000D\000i\000s\000t\000a\000n\000c\000e\000\040\000A\000n\000a\000l\000y\000s\000i\000s}{section.3}% 11
+\BOOKMARK [2][-]{subsection.3.4}{\376\377\000E\000c\000c\000e\000n\000t\000r\000i\000c\000i\000t\000y\000:\000\040\000T\000h\000e\000\040\000S\000i\000g\000n\000i\000f\000i\000c\000a\000n\000t\000\040\000F\000i\000n\000d\000i\000n\000g}{section.3}% 12
+\BOOKMARK [2][-]{subsection.3.5}{\376\377\000N\000o\000n\000-\000S\000i\000g\000n\000i\000f\000i\000c\000a\000n\000t\000\040\000C\000e\000n\000t\000r\000a\000l\000i\000t\000i\000e\000s}{section.3}% 13
+\BOOKMARK [1][-]{section.4}{\376\377\000D\000i\000s\000c\000u\000s\000s\000i\000o\000n}{}% 14
+\BOOKMARK [2][-]{subsection.4.1}{\376\377\000E\000c\000c\000e\000n\000t\000r\000i\000c\000i\000t\000y\000\040\000a\000s\000\040\000G\000l\000o\000b\000a\000l\000\040\000P\000o\000s\000i\000t\000i\000o\000n}{section.4}% 15
+\BOOKMARK [2][-]{subsection.4.2}{\376\377\000L\000o\000c\000a\000l\000\040\000v\000s\000\040\000G\000l\000o\000b\000a\000l\000\040\000S\000t\000r\000u\000c\000t\000u\000r\000e}{section.4}% 16
+\BOOKMARK [2][-]{subsection.4.3}{\376\377\000D\000e\000s\000i\000g\000n\000\040\000I\000m\000p\000l\000i\000c\000a\000t\000i\000o\000n\000s}{section.4}% 17
+\BOOKMARK [2][-]{subsection.4.4}{\376\377\000L\000i\000m\000i\000t\000a\000t\000i\000o\000n\000s}{section.4}% 18
+\BOOKMARK [1][-]{section.5}{\376\377\000C\000o\000n\000c\000l\000u\000s\000i\000o\000n}{}% 19
+\BOOKMARK [1][-]{appendix.A}{\376\377\000C\000o\000m\000p\000l\000e\000t\000e\000\040\000C\000o\000r\000r\000e\000l\000a\000t\000i\000o\000n\000\040\000D\000a\000t\000a}{}% 20
+\BOOKMARK [1][-]{appendix.B}{\376\377\000N\000o\000d\000e\000\040\000D\000a\000t\000a\000\040\000S\000a\000m\000p\000l\000e}{}% 21

slipnet_analysis/slipnet_depth_analysis.tex

@@ -0,0 +1,276 @@
+\documentclass[11pt,twocolumn]{article}
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{amsmath,amssymb}
+\usepackage{graphicx}
+\usepackage{booktabs}
+\usepackage{hyperref}
+\usepackage[margin=0.9in]{geometry}
+\usepackage{natbib}
+\usepackage{float}
+\usepackage{caption}
+\usepackage{subcaption}
+
+\title{Conceptual Depth and Graph Topology in the Copycat Slipnet: A Correlation Analysis}
+
+\author{
+Slipnet Analysis Project\\
+\texttt{slipnet\_analysis/}
+}
+
+\date{\today}
+
+\begin{document}
+
+\maketitle
+
+\begin{abstract}
+The Copycat system employs a semantic network (slipnet) where each node has a ``conceptual depth'' parameter representing abstraction level. We investigate whether conceptual depth correlates with various graph-theoretic metrics including hop distance to letter nodes, centrality measures, and eccentricity. Analyzing 33 non-letter nodes, we find that \textbf{eccentricity is the only metric significantly correlated with conceptual depth} (Pearson $r = -0.380$, $p = 0.029$), explaining 14.4\% of variance. Hop distance to letters shows no significant correlation ($r = 0.281$, $p = 0.113$), nor do standard centrality measures (degree, betweenness, closeness, eigenvector, PageRank). The negative eccentricity correlation indicates that deeper concepts tend to be more globally central---closer to all other nodes in the network. These findings suggest that while conceptual depth is largely independent of local connectivity patterns, it partially reflects global network position.
+\end{abstract}
+
+\section{Introduction}
+
+The Copycat project, developed by Douglas Hofstadter and Melanie Mitchell \citep{mitchell1993,hofstadter1995}, models analogical reasoning using a semantic network called the \emph{slipnet}. Each node has a \emph{conceptual depth} parameter (10--90) intended to capture abstraction level. We systematically test whether any graph-theoretic metric correlates with this hand-assigned depth value.
+
+\subsection{The Slipnet}
+
+The slipnet contains 59 nodes: 26 letters (a--z), 5 numbers (1--5), and 28 concept nodes (categories, positions, relations). These are connected by 202 directed links (104 undirected edges). Five nodes form a disconnected cluster (\texttt{identity}, \texttt{opposite}, \texttt{letter}, \texttt{group}, \texttt{objectCategory}).
+
+\subsection{Research Questions}
+
+We ask: Does conceptual depth correlate with...
+\begin{enumerate}
+    \item Hop distance to concrete letter nodes?
+    \item Local centrality (degree, clustering)?
+    \item Global centrality (betweenness, closeness, eigenvector)?
+    \item Network position (eccentricity)?
+\end{enumerate}
+
+\section{Methods}
+
+\subsection{Graph Construction}
+
+We constructed an undirected graph $G = (V, E)$ from the slipnet using NetworkX, with $|V| = 59$ vertices and $|E| = 104$ edges.
+
+\subsection{Metrics Computed}
+
+For each non-letter node, we computed:
+
+\begin{itemize}
+    \item \textbf{Hop distance}: Minimum edges to any letter (a--z). Unreachable nodes assigned $2 \times \max(\text{hops}) = 8$.
+    \item \textbf{Degree centrality}: Fraction of nodes connected to.
+    \item \textbf{Betweenness centrality}: Fraction of shortest paths passing through node.
+    \item \textbf{Closeness centrality}: Reciprocal of average distance to all nodes.
+    \item \textbf{Eigenvector centrality}: Importance based on connections to important nodes.
+    \item \textbf{PageRank}: Random walk stationary distribution.
+    \item \textbf{Clustering coefficient}: Fraction of neighbor pairs that are connected.
+    \item \textbf{Eccentricity}: Maximum distance to any other node.
+\end{itemize}
+
+\subsection{Statistical Analysis}
+
+For each metric, we computed Pearson's $r$, Spearman's $\rho$, and $R^2$ against conceptual depth. Significance assessed at $\alpha = 0.05$.
+
+\section{Results}
+
+\subsection{Correlation Summary}
+
+Table~\ref{tab:correlations} presents all correlations, ranked by $|r|$.
+
+\begin{table}[H]
+\centering
+\caption{Correlations with conceptual depth (n=33)}
+\label{tab:correlations}
+\small
+\begin{tabular}{lccc}
+\toprule
+Metric & Pearson $r$ & $p$-value & $R^2$ \\
+\midrule
+Eccentricity & $-0.380$* & 0.029 & 0.144 \\
+Hop distance & $+0.281$ & 0.113 & 0.079 \\
+Closeness & $-0.270$ & 0.129 & 0.073 \\
+Degree & $-0.264$ & 0.137 & 0.070 \\
+PageRank & $-0.257$ & 0.149 & 0.066 \\
+Clustering & $-0.219$ & 0.221 & 0.048 \\
+Betweenness & $-0.172$ & 0.340 & 0.029 \\
+Eigenvector & $-0.148$ & 0.410 & 0.022 \\
+Avg neighbor deg & $+0.052$ & 0.775 & 0.003 \\
+\bottomrule
+\end{tabular}
+
+\vspace{0.5em}
+\footnotesize{* = significant at $p < 0.05$}
+\end{table}
+
+\textbf{Key finding}: Only eccentricity achieves statistical significance. The negative correlation ($r = -0.380$) indicates that higher-depth concepts have \emph{lower} eccentricity---they are more globally central, with shorter maximum distances to other nodes.
+
+\subsection{Visualization}
+
+Figure~\ref{fig:comparison} shows scatter plots for all metrics. The eccentricity plot shows the clearest negative trend.
+
+\begin{figure}[H]
+\centering
+\includegraphics[width=\columnwidth]{centrality_comparison.png}
+\caption{Conceptual depth vs eight graph metrics. Only eccentricity (*) shows significant correlation.}
+\label{fig:comparison}
+\end{figure}
+
+\subsection{Hop Distance Analysis}
+
+The hop distance analysis ($r = 0.281$, $p = 0.113$) found no significant relationship between conceptual depth and distance to letter nodes. This weak positive trend fails significance, with $R^2 = 0.079$ explaining less than 8\% of variance.
+
+Counterexamples abound: \texttt{bondFacet} (depth=90) is only 2 hops from letters, while \texttt{middle} (depth=40) requires 4 hops.
+
+\subsection{Eccentricity: The Significant Finding}
+
+Eccentricity measures the maximum distance from a node to any other node. The significant negative correlation ($r = -0.380$, $p = 0.029$) suggests:
+
+\begin{quote}
+\emph{Deeper concepts tend to be positioned more centrally in terms of worst-case distance to any node.}
+\end{quote}
+
+Table~\ref{tab:eccentricity} shows examples:
+
+\begin{table}[H]
+\centering
+\caption{Eccentricity examples}
+\label{tab:eccentricity}
+\small
+\begin{tabular}{lcc}
+\toprule
+Node & Depth & Eccentricity \\
+\midrule
+letterCategory & 30 & 4 \\
+length & 60 & 5 \\
+bondFacet & 90 & 5 \\
+\midrule
+middle & 40 & 7 \\
+identity & 90 & 3 (isolated) \\
+\bottomrule
+\end{tabular}
+\end{table}
+
+The hub node \texttt{letterCategory} (connected to all 26 letters) has low eccentricity (4), enabling short paths to the entire network.
+
+\subsection{Non-Significant Centralities}
+
+Standard centrality measures show weak negative correlations but none reach significance:
+
+\begin{itemize}
+    \item \textbf{Degree} ($r = -0.264$): Deeper nodes don't have more connections.
+    \item \textbf{Betweenness} ($r = -0.172$): Deeper nodes aren't more often on shortest paths.
+    \item \textbf{Closeness} ($r = -0.270$): Weak trend toward central positioning.
+    \item \textbf{PageRank} ($r = -0.257$): Random walk importance unrelated to depth.
+\end{itemize}
+
+\section{Discussion}
+
+\subsection{Eccentricity as Global Position}
+
+The eccentricity finding reveals that conceptual depth partially reflects \emph{global} network position. Nodes with high depth tend to have lower eccentricity, meaning they are never ``too far'' from any other node. This differs from local centrality (degree, clustering), which shows no relationship.
+
+Intuitively, abstract concepts like \texttt{bondFacet} or \texttt{samenessGroup} may have been positioned to be accessible from many parts of the conceptual space, even if they don't have many direct connections.
+
+\subsection{Local vs Global Structure}
+
+The contrast between local and global metrics is striking:
+
+\begin{itemize}
+    \item \textbf{Local metrics} (degree, clustering, betweenness): No significant correlation
+    \item \textbf{Global metric} (eccentricity): Significant correlation
+\end{itemize}
+
+This suggests depth was assigned based on semantic considerations (abstraction level) that happen to align with global positioning but not with local connectivity patterns.
+
+\subsection{Design Implications}
+
+The partial correlation with eccentricity ($R^2 = 0.144$) means:
+\begin{itemize}
+    \item 14.4\% of depth variance is explained by global position
+    \item 85.6\% reflects other factors (semantic intuition, domain knowledge)
+\end{itemize}
+
+For extending the slipnet, this suggests that new abstract concepts should be positioned with moderate connectivity to multiple network regions, not necessarily with high local degree.
+
+\subsection{Limitations}
+
+\begin{enumerate}
+    \item \textbf{Sample size}: 33 nodes limits power; the eccentricity finding should be interpreted cautiously.
+    \item \textbf{Multiple comparisons}: Testing 9 metrics inflates Type I error. A Bonferroni-corrected threshold of $p < 0.0056$ would render eccentricity non-significant.
+    \item \textbf{Disconnected nodes}: Five nodes are unreachable, affecting eccentricity calculations.
+\end{enumerate}
+
+\section{Conclusion}
+
+Among nine graph metrics tested, only \textbf{eccentricity} significantly correlates with conceptual depth ($r = -0.380$, $p = 0.029$). Deeper concepts tend to occupy more globally central positions. However, this explains only 14.4\% of variance, confirming that conceptual depth primarily reflects semantic judgments rather than topological properties.
+
+Notably, hop distance to letter nodes shows no significant correlation ($r = 0.281$, $p = 0.113$), contradicting the intuition that abstract concepts should be topologically distant from concrete letters. The slipnet's design keeps depth and local connectivity largely orthogonal while partially aligning depth with global network position.
+
+\section*{Data Availability}
+
+Scripts and data: \texttt{slipnet\_analysis/}
+\begin{itemize}
+    \item \texttt{compute\_centrality.py}: Full analysis
+    \item \texttt{centrality\_results.json}: Numerical results
+    \item \texttt{centrality\_comparison.png}: Comparison plot
+\end{itemize}
+
+\appendix
+
+\section{Complete Correlation Data}
+
+\begin{table}[H]
+\centering
+\caption{Full correlation statistics}
+\label{tab:full}
+\small
+\begin{tabular}{lcccc}
+\toprule
+Metric & $r$ & $p$ & $\rho$ & $\rho$-$p$ \\
+\midrule
+Eccentricity & $-0.380$ & 0.029 & $-0.299$ & 0.091 \\
+Hop distance & $+0.281$ & 0.113 & $+0.141$ & 0.433 \\
+Closeness & $-0.270$ & 0.129 & $-0.180$ & 0.315 \\
+Degree & $-0.264$ & 0.137 & $-0.236$ & 0.186 \\
+PageRank & $-0.257$ & 0.149 & $-0.191$ & 0.288 \\
+Clustering & $-0.219$ & 0.221 & $-0.276$ & 0.120 \\
+Betweenness & $-0.172$ & 0.340 & $-0.080$ & 0.658 \\
+Eigenvector & $-0.148$ & 0.410 & $-0.237$ & 0.185 \\
+Avg neighbor & $+0.052$ & 0.775 & $-0.301$ & 0.089 \\
+\bottomrule
+\end{tabular}
+\end{table}
+
+\section{Node Data Sample}
+
+\begin{table}[H]
+\centering
+\caption{Selected nodes with metrics}
+\label{tab:nodes}
+\small
+\begin{tabular}{lccccc}
+\toprule
+Node & Depth & Deg & Btw & Ecc \\
+\midrule
+letterCategory & 30 & 0.50 & 0.68 & 4 \\
+length & 60 & 0.17 & 0.25 & 5 \\
+bondFacet & 90 & 0.03 & 0.00 & 5 \\
+middle & 40 & 0.02 & 0.00 & 7 \\
+identity & 90 & 0.00 & 0.00 & 3 \\
+opposite & 90 & 0.00 & 0.00 & 3 \\
+\bottomrule
+\end{tabular}
+\end{table}
+
+\begin{thebibliography}{9}
+
+\bibitem{mitchell1993}
+Mitchell, M. (1993). \textit{Analogy-Making as Perception}. MIT Press.
+
+\bibitem{hofstadter1995}
+Hofstadter, D. R., \& FARG. (1995). \textit{Fluid Concepts and Creative Analogies}. Basic Books.
+
+\end{thebibliography}
+
+\end{document}