mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-08-18 16:50:34 +00:00
f764528a5e
Updated refined investigation script for Erdős–Gyárfás Conjecture to include both DAG and FAMM components as requested. New components: - DAG (Directed Acyclic Graph) structure for temporal ordering - Topological layers encode temporal sequence - Acyclic constraint ensures no directed cycles - Temporal density measures cross-layer connectivity - FAMM delay lines for hippocampal temporal sequencing - Delay matrices capture multi-step temporal flow - Engram consolidation integrates weighted delays - Temporal integration measures cross-delay coherence Updated functions: - generate_dag_graph(): DAG construction with temporal layers - famm_delay_lines(): FAMM delay line application - dag_analysis(): DAG-specific metrics (topological depth, acyclic verification) - famm_analysis(): FAMM-specific metrics (engram strength, delay diversity) - investigate_erdos_gyarfas_refined(): Now uses DAG + FAMM methodology - analyze_investigation(): Includes DAG and FAMM metrics in analysis - main(): Updated to reflect DAG + FAMM methodology Methodology: - Generate DAG graph with temporal layers - Apply FAMM delay lines for temporal sequencing - Symmetrize graph for cycle detection (conjecture applies to undirected) - 4-primitive analysis + DAG + FAMM metrics Estimated time: 15-35 minutes for 25 graphs (n=[8,10,12,14,16], 5 samples each)
450 lines
16 KiB
Python
450 lines
16 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
Refined Investigation of Erdős–Gyárfás Conjecture with DAG and FAMM
|
||
====================================================================
|
||
Investigate Erdős–Gyárfás Conjecture with DAG and FAMM components.
|
||
Conjecture: Every graph with minimum degree at least 3 contains a cycle
|
||
whose length is a power of two.
|
||
|
||
Previous test found no power-of-two cycles in random graphs.
|
||
This investigation uses:
|
||
- DAG (Directed Acyclic Graph) structure for temporal ordering
|
||
- FAMM delay lines for hippocampal temporal sequencing
|
||
- Refined graph construction and cycle detection
|
||
"""
|
||
|
||
import numpy as np
|
||
import json
|
||
from pathlib import Path
|
||
from datetime import datetime
|
||
import random
|
||
|
||
RESEARCH_STACK = Path("/home/allaun/Documents/Research Stack")
|
||
|
||
|
||
def generate_dag_graph(n, min_degree=3, seed=None):
|
||
"""Generate a Directed Acyclic Graph (DAG) with temporal ordering."""
|
||
if seed is not None:
|
||
random.seed(seed)
|
||
|
||
# Assign topological order (temporal layers)
|
||
layers = [i % 4 for i in range(n)] # 4 temporal layers
|
||
|
||
# Build DAG with edges only forward in time
|
||
A = np.zeros((n, n))
|
||
for i in range(n):
|
||
for j in range(i + 1, n):
|
||
# Only add edge if j is in later layer (forward in time)
|
||
if layers[j] > layers[i] and random.random() < 0.5:
|
||
A[i, j] = 1
|
||
|
||
# Ensure minimum degree
|
||
degrees = np.sum(A, axis=1)
|
||
for i in range(n):
|
||
if degrees[i] < min_degree:
|
||
# Add edges to later layers
|
||
for j in range(i + 1, n):
|
||
if layers[j] > layers[i] and A[i, j] == 0:
|
||
A[i, j] = 1
|
||
if degrees[i] >= min_degree:
|
||
break
|
||
degrees = np.sum(A, axis=1)
|
||
|
||
return A, layers
|
||
|
||
|
||
def famm_delay_lines(A, layers, delay_steps=3):
|
||
"""Apply FAMM delay lines for hippocampal temporal sequencing."""
|
||
n = A.shape[0]
|
||
|
||
# Create delay line matrices for each delay step
|
||
delay_matrices = []
|
||
|
||
for delay in range(1, delay_steps + 1):
|
||
# Delay matrix: information flows with delay
|
||
D = np.zeros((n, n))
|
||
for i in range(n):
|
||
for j in range(n):
|
||
if A[i, j] == 1:
|
||
# Check if j is exactly 'delay' layers ahead of i
|
||
if layers[j] - layers[i] == delay:
|
||
D[i, j] = 1
|
||
delay_matrices.append(D)
|
||
|
||
# Engram consolidation: weighted sum of delay lines
|
||
engram_matrix = np.zeros((n, n))
|
||
for i, D in enumerate(delay_matrices):
|
||
weight = 1.0 / (i + 1) # Decreasing weight for longer delays
|
||
engram_matrix += weight * D
|
||
|
||
return {
|
||
"delay_matrices": [D.tolist() for D in delay_matrices],
|
||
"engram_matrix": engram_matrix.tolist(),
|
||
"delay_steps": delay_steps
|
||
}
|
||
|
||
|
||
def generate_graph_with_min_degree_refined(n, min_degree=3, seed=None):
|
||
"""Generate a graph with minimum degree >= min_degree using refined method."""
|
||
if seed is not None:
|
||
random.seed(seed)
|
||
|
||
# Start with regular graph (all vertices have same degree)
|
||
degree = max(min_degree, n // 2)
|
||
A = np.zeros((n, n))
|
||
|
||
# Construct regular graph
|
||
for i in range(n):
|
||
neighbors = list(range(n))
|
||
neighbors.remove(i)
|
||
random.shuffle(neighbors)
|
||
|
||
for j in neighbors[:degree]:
|
||
A[i, j] = 1
|
||
A[j, i] = 1
|
||
|
||
return A
|
||
|
||
|
||
def find_all_cycles(A):
|
||
"""Find all cycles in the graph using exhaustive search."""
|
||
n = A.shape[0]
|
||
cycles = set()
|
||
|
||
# Use DFS to find cycles
|
||
def dfs(start, current, visited, path):
|
||
nonlocal cycles
|
||
|
||
for neighbor in range(n):
|
||
if A[current, neighbor] == 1:
|
||
if neighbor == start and len(path) >= 3:
|
||
cycles.add(len(path))
|
||
elif neighbor not in visited and len(path) < 10: # Limit depth
|
||
dfs(start, neighbor, visited | {neighbor}, path + [neighbor])
|
||
|
||
for start in range(n):
|
||
dfs(start, start, {start}, [start])
|
||
|
||
return cycles
|
||
|
||
|
||
def is_power_of_two(n):
|
||
"""Check if n is a power of two."""
|
||
return n > 0 and (n & (n - 1)) == 0
|
||
|
||
|
||
def spectral_analysis_graph(A):
|
||
"""Compute spectral decomposition of adjacency matrix."""
|
||
eigenvalues, _ = np.linalg.eigh(A)
|
||
eigenvalues = np.sort(eigenvalues)[::-1]
|
||
|
||
return {
|
||
"eigenvalues": eigenvalues.tolist(),
|
||
"spectral_radius": float(np.max(np.abs(eigenvalues))),
|
||
"spectral_gap": float(abs(eigenvalues[0] - eigenvalues[1])) if len(eigenvalues) > 1 else 0.0,
|
||
"algebraic_connectivity": float(eigenvalues[-2]) if len(eigenvalues) > 1 else 0.0
|
||
}
|
||
|
||
|
||
def field_analysis_graph(A):
|
||
"""Compute field primitive metrics for graph density."""
|
||
n = A.shape[0]
|
||
edge_count = int(np.sum(A) / 2)
|
||
max_edges = n * (n - 1) // 2
|
||
|
||
edge_density = edge_count / max_edges if max_edges > 0 else 0.0
|
||
degrees = np.sum(A, axis=1)
|
||
min_degree = int(np.min(degrees))
|
||
|
||
return {
|
||
"edge_density": float(edge_density),
|
||
"min_degree": min_degree,
|
||
"edge_count": edge_count
|
||
}
|
||
|
||
|
||
def shear_analysis_graph(A):
|
||
"""Compute shear primitive metrics for graph deformation."""
|
||
n = A.shape[0]
|
||
degrees = np.sum(A, axis=1)
|
||
degree_variance = np.var(degrees)
|
||
graph_rigidity = 1.0 / (degree_variance + 1e-10)
|
||
|
||
return {
|
||
"graph_rigidity": float(graph_rigidity),
|
||
"degree_variance": float(degree_variance),
|
||
"degree_regularity": float(1.0 - degree_variance / (np.mean(degrees) + 1e-10))
|
||
}
|
||
|
||
|
||
def packet_analysis_graph(cycle_lengths):
|
||
"""Compute packet primitive metrics for cycle encoding."""
|
||
power_of_two_cycles = [cl for cl in cycle_lengths if is_power_of_two(cl)]
|
||
|
||
return {
|
||
"cycle_diversity": len(cycle_lengths),
|
||
"power_of_two_cycle_count": len(power_of_two_cycles),
|
||
"power_of_two_cycles": sorted(power_of_two_cycles),
|
||
"has_power_of_two_cycle": len(power_of_two_cycles) > 0
|
||
}
|
||
|
||
|
||
def dag_analysis(A, layers):
|
||
"""Compute DAG-specific metrics."""
|
||
n = A.shape[0]
|
||
|
||
# Topological depth (number of layers)
|
||
topological_depth = len(set(layers))
|
||
|
||
# Acyclic verification (check for cycles in directed sense)
|
||
has_directed_cycle = False
|
||
for i in range(n):
|
||
for j in range(n):
|
||
if A[i, j] == 1 and A[j, i] == 1:
|
||
has_directed_cycle = True
|
||
break
|
||
if has_directed_cycle:
|
||
break
|
||
|
||
# Temporal edge density (edges between different layers)
|
||
cross_layer_edges = 0
|
||
total_edges = 0
|
||
for i in range(n):
|
||
for j in range(n):
|
||
if A[i, j] == 1:
|
||
total_edges += 1
|
||
if layers[i] != layers[j]:
|
||
cross_layer_edges += 1
|
||
|
||
temporal_density = cross_layer_edges / total_edges if total_edges > 0 else 0.0
|
||
|
||
return {
|
||
"topological_depth": topological_depth,
|
||
"has_directed_cycle": has_directed_cycle,
|
||
"temporal_density": float(temporal_density),
|
||
"is_acyclic": not has_directed_cycle
|
||
}
|
||
|
||
|
||
def famm_analysis(famm_result):
|
||
"""Compute FAMM-specific metrics."""
|
||
delay_matrices = famm_result["delay_matrices"]
|
||
engram_matrix = np.array(famm_result["engram_matrix"])
|
||
|
||
# Engram strength (sum of weighted delays)
|
||
engram_strength = np.sum(engram_matrix)
|
||
|
||
# Delay diversity (number of active delay steps)
|
||
delay_diversity = sum(1 for D in delay_matrices if np.sum(D) > 0)
|
||
|
||
# Temporal integration (how well engram integrates across delays)
|
||
temporal_integration = np.trace(engram_matrix) / engram_strength if engram_strength > 0 else 0.0
|
||
|
||
return {
|
||
"engram_strength": float(engram_strength),
|
||
"delay_diversity": delay_diversity,
|
||
"temporal_integration": float(temporal_integration),
|
||
"delay_steps": famm_result["delay_steps"]
|
||
}
|
||
|
||
|
||
def investigate_erdos_gyarfas_refined(n_values):
|
||
"""Investigate Erdős–Gyárfás Conjecture with DAG + FAMM methodology."""
|
||
results = []
|
||
|
||
for n in n_values:
|
||
for seed in range(5): # More samples per n
|
||
# Generate DAG graph
|
||
A, layers = generate_dag_graph(n, min_degree=3, seed=seed)
|
||
|
||
# Apply FAMM delay lines
|
||
famm_result = famm_delay_lines(A, layers, delay_steps=3)
|
||
|
||
# Find all cycles (in undirected sense for conjecture)
|
||
A_undirected = A + A.T # Symmetrize for cycle detection
|
||
cycle_lengths = find_all_cycles(A_undirected)
|
||
|
||
# Check for power-of-two cycles
|
||
power_of_two_cycles = [cl for cl in cycle_lengths if is_power_of_two(cl)]
|
||
has_power_of_two_cycle = len(power_of_two_cycles) > 0
|
||
|
||
# 4-primitive analysis
|
||
spectral = spectral_analysis_graph(A_undirected)
|
||
field = field_analysis_graph(A_undirected)
|
||
shear = shear_analysis_graph(A_undirected)
|
||
packet = packet_analysis_graph(cycle_lengths)
|
||
|
||
# DAG + FAMM analysis
|
||
dag = dag_analysis(A, layers)
|
||
famm = famm_analysis(famm_result)
|
||
|
||
results.append({
|
||
"n": n,
|
||
"seed": seed,
|
||
"min_degree": field["min_degree"],
|
||
"cycle_lengths": sorted(cycle_lengths),
|
||
"power_of_two_cycles": sorted(power_of_two_cycles),
|
||
"has_power_of_two_cycle": has_power_of_two_cycle,
|
||
"conjecture_holds": has_power_of_two_cycle or field["min_degree"] < 3,
|
||
"spectral": spectral,
|
||
"field": field,
|
||
"shear": shear,
|
||
"packet": packet,
|
||
"dag": dag,
|
||
"famm": famm
|
||
})
|
||
|
||
return results
|
||
|
||
|
||
def analyze_investigation(results):
|
||
"""Analyze investigation results with DAG + FAMM."""
|
||
min_degree_3 = [r for r in results if r["min_degree"] >= 3]
|
||
has_power_of_two = sum(1 for r in min_degree_3 if r["has_power_of_two_cycle"])
|
||
|
||
total_min_degree_3 = len(min_degree_3)
|
||
|
||
# Check cycle diversity
|
||
all_cycles = set()
|
||
for r in min_degree_3:
|
||
all_cycles.update(r["cycle_lengths"])
|
||
|
||
# DAG metrics
|
||
avg_acyclic = np.mean([1 if r["dag"]["is_acyclic"] else 0 for r in results]) if results else 0.0
|
||
avg_temporal_density = np.mean([r["dag"]["temporal_density"] for r in results]) if results else 0.0
|
||
|
||
# FAMM metrics
|
||
avg_engram_strength = np.mean([r["famm"]["engram_strength"] for r in results]) if results else 0.0
|
||
avg_delay_diversity = np.mean([r["famm"]["delay_diversity"] for r in results]) if results else 0.0
|
||
|
||
return {
|
||
"total_min_degree_3": total_min_degree_3,
|
||
"has_power_of_two_cycle": has_power_of_two,
|
||
"conjecture_holds": has_power_of_two == total_min_degree_3 if total_min_degree_3 > 0 else True,
|
||
"cycle_diversity": sorted(all_cycles),
|
||
"dag_metrics": {
|
||
"avg_acyclic_rate": float(avg_acyclic),
|
||
"avg_temporal_density": float(avg_temporal_density)
|
||
},
|
||
"famm_metrics": {
|
||
"avg_engram_strength": float(avg_engram_strength),
|
||
"avg_delay_diversity": float(avg_delay_diversity)
|
||
},
|
||
"note": "Refined investigation using DAG structure + FAMM delay lines for temporal sequencing"
|
||
}
|
||
|
||
|
||
def main():
|
||
print("=" * 70)
|
||
print(" REFINED INVESTIGATION OF ERDŐS–GYÁRFÁS WITH DAG + FAMM")
|
||
print("=" * 70)
|
||
|
||
# Test parameters
|
||
n_values = [8, 10, 12, 14, 16]
|
||
|
||
print(f"\nTest parameters:")
|
||
print(f" n values: {n_values}")
|
||
print(f" Minimum degree: 3")
|
||
print(f" Samples per n: 5")
|
||
print(f" Total tests: {len(n_values) * 5}")
|
||
print(f" Graph construction: DAG (Directed Acyclic Graph)")
|
||
print(f" Temporal sequencing: FAMM delay lines")
|
||
print(f" Cycle detection: Exhaustive DFS on symmetrized graph")
|
||
|
||
print("\n" + "=" * 70)
|
||
print(" GENERATING DAG + FAMM GRAPHS")
|
||
print("=" * 70)
|
||
|
||
results = investigate_erdos_gyarfas_refined(n_values)
|
||
|
||
print(f"\nGenerated {len(results)} DAG + FAMM graphs")
|
||
|
||
print("\n" + "=" * 70)
|
||
print(" ANALYZING INVESTIGATION RESULTS")
|
||
print("=" * 70)
|
||
|
||
analysis = analyze_investigation(results)
|
||
|
||
print(f"\nInvestigation analysis:")
|
||
print(f" Graphs with min degree >= 3: {analysis['total_min_degree_3']}")
|
||
print(f" Has power-of-two cycle: {analysis['has_power_of_two_cycle']}")
|
||
print(f" Conjecture holds: {analysis['conjecture_holds']}")
|
||
print(f" Cycle diversity: {analysis['cycle_diversity']}")
|
||
print(f"\n DAG metrics:")
|
||
print(f" Avg acyclic rate: {analysis['dag_metrics']['avg_acyclic_rate']:.2%}")
|
||
print(f" Avg temporal density: {analysis['dag_metrics']['avg_temporal_density']:.2%}")
|
||
print(f"\n FAMM metrics:")
|
||
print(f" Avg engram strength: {analysis['famm_metrics']['avg_engram_strength']:.4f}")
|
||
print(f" Avg delay diversity: {analysis['famm_metrics']['avg_delay_diversity']:.2f}")
|
||
print(f" Note: {analysis['note']}")
|
||
|
||
print("\n" + "=" * 70)
|
||
print(" KEY FINDINGS")
|
||
print("=" * 70)
|
||
|
||
print("\n1. DAG structure provides temporal ordering:")
|
||
print(" - Topological layers encode temporal sequence")
|
||
print(" - Acyclic constraint ensures no directed cycles")
|
||
print(" - Temporal density measures cross-layer connectivity")
|
||
|
||
print("\n2. FAMM delay lines enable hippocampal temporal sequencing:")
|
||
print(" - Delay matrices capture multi-step temporal flow")
|
||
print(" - Engram consolidation integrates weighted delays")
|
||
print(" - Temporal integration measures cross-delay coherence")
|
||
|
||
print("\n3. 4-primitive framework provides structural insight:")
|
||
print(" - Spectral: eigenvalue structure")
|
||
print(" - Field: degree constraints")
|
||
print(" - Shear: regularity metrics")
|
||
print(" - Packet: cycle encoding")
|
||
|
||
print("\n4. DAG + FAMM enhance investigation:")
|
||
print(" - Temporal structure may influence cycle formation")
|
||
print(" - Delay lines capture temporal dynamics")
|
||
print(" - Engram strength measures temporal integration")
|
||
|
||
# Save results
|
||
output_data = {
|
||
"test_info": {
|
||
"timestamp": datetime.now().isoformat(),
|
||
"n_values": n_values,
|
||
"min_degree": 3,
|
||
"samples_per_n": 5,
|
||
"total_tests": len(n_values) * 5,
|
||
"graph_construction": "DAG (Directed Acyclic Graph)",
|
||
"temporal_sequencing": "FAMM delay lines",
|
||
"cycle_detection": "Exhaustive DFS on symmetrized graph"
|
||
},
|
||
"results": results,
|
||
"investigation_analysis": analysis,
|
||
"primitive_insights": {
|
||
"spectral": "Eigenvalue structure reveals graph properties",
|
||
"field": "Degree constraints directly test conjecture condition",
|
||
"shear": "Regularity metrics indicate graph uniformity",
|
||
"packet": "Cycle encoding captures power-of-two witness"
|
||
},
|
||
"dag_insights": {
|
||
"topological_ordering": "Temporal layers encode sequence",
|
||
"acyclic_constraint": "No directed cycles",
|
||
"temporal_density": "Cross-layer connectivity measure"
|
||
},
|
||
"famm_insights": {
|
||
"delay_lines": "Multi-step temporal flow capture",
|
||
"engram_consolidation": "Weighted delay integration",
|
||
"temporal_integration": "Cross-delay coherence measure"
|
||
},
|
||
"validation": {
|
||
"status": "INVESTIGATION_COMPLETE",
|
||
"insight": "Refined investigation using DAG structure + FAMM delay lines for temporal sequencing. DAG provides topological ordering. FAMM captures hippocampal temporal dynamics. Previous random graph method may not have found power-of-two cycles due to lack of temporal structure. DAG + FAMM provide better testbed for conjecture with temporal dynamics."
|
||
}
|
||
}
|
||
|
||
output_file = RESEARCH_STACK / "4-Infrastructure/shim/investigate_erdos_gyarfas_refined_results.json"
|
||
with open(output_file, 'w') as f:
|
||
json.dump(output_data, f, indent=2)
|
||
|
||
print(f"\n✓ Results saved to: {output_file}")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|