OpenAI AI Solves the 80-Year Erdős Conjecture — From Tool to Research Partner

"""
Module 1: Combinatorial Geometry Problem Generation & Verification
=============================================================
Implements unit distance graph generation and counting for verification.
"""

import numpy as np
from typing import List, Tuple, Set, Dict
from dataclasses import dataclass, field
from collections import defaultdict
import itertools
from fractions import Fraction


@dataclass
class Point:
    """Represents a point in n-dimensional Euclidean space."""
    coordinates: Tuple[float, ...]
    
    def distance_to(self, other: 'Point') -> float:
        """Calculate Euclidean distance to another point."""
        return np.linalg.norm(
            np.array(self.coordinates) - np.array(other.coordinates)
        )
    
    def is_unit_distance(self, other: 'Point', tolerance: float = 1e-9) -> bool:
        """Check if distance to another point is approximately 1."""
        return abs(self.distance_to(other) - 1.0) < tolerance


@dataclass
class UnitDistanceGraph:
    """Graph where edges represent unit distances between points."""
    points: List[Point]
    edges: Set[Tuple[int, int]] = field(default_factory=set)
    
    def add_point(self, point: Point) -> int:
        """Add a point and return its index."""
        idx = len(self.points)
        self.points.append(point)
        return idx
    
    def compute_unit_distances(self, tolerance: float = 1e-9) -> None:
        """Compute all unit distance pairs in the point set."""
        n = len(self.points)
        for i in range(n):
            for j in range(i + 1, n):
                if self.points[i].is_unit_distance(self.points[j], tolerance):
                    self.edges.add((i, j))
    
    def count_unit_distances(self) -> int:
        """Return the total number of unit distances."""
        return len(self.edges)
    
    def get_degree(self, vertex: int) -> int:
        """Get the degree of a vertex."""
        return sum(1 for e in self.edges if vertex in e)


class GridLatticeGenerator:
    """Generates unit distance graphs from various lattice structures."""
    
    @staticmethod
    def generate_integer_lattice(dimensions: int, size: int) -> UnitDistanceGraph:
        """Generate points on a scaled integer lattice."""
        points = []
        for coords in itertools.product(range(size), repeat=dimensions):
            points.append(Point(tuple(float(c) for c in coords)))
        
        graph = UnitDistanceGraph(points)
        graph.compute_unit_distances(tolerance=1e-6)
        return graph
    
    @staticmethod
    def generate_diamond_lattice(size: int) -> UnitDistanceGraph:
        """Generate points on a diamond (checkerboard) lattice."""
        points = []
        for x in range(size):
            for y in range(size):
                # Diamond constraint: |x - size/2| + |y - size/2| <= size/2
                if abs(x - size/2) + abs(y - size/2) <= size/2:
                    points.append(Point((float(x), float(y))))
        
        graph = UnitDistanceGraph(points)
        graph.compute_unit_distances()
        return graph
    
    @staticmethod
    def generate_hexagonal_lattice(size: int) -> UnitDistanceGraph:
        """Generate points on a hexagonal lattice."""
        points = []
        sqrt3 = np.sqrt(3)
        
        for i in range(size):
            for j in range(size):
                x = i * 1.5
                y = sqrt3 * (j + 0.5 * (i % 2))
                points.append(Point((x, y)))
        
        graph = UnitDistanceGraph(points)
        graph.compute_unit_distances(tolerance=1e-6)
        return graph


class ErdősConjectureVerifier:
    """Verifies properties related to Erdős's Unit Distance Conjecture."""
    
    def __init__(self):
        self.results: Dict[str, List[float]] = defaultdict(list)
    
    def compute_g_n_empirical(self, n: int, trials: int = 100) -> float:
        """
        Approximate g(n) empirically through random sampling.
        g(n) = maximum number of unit distances with n points.
        """
        max_unit_distances = 0
        
        for _ in range(trials):
            # Generate n random points in unit square
            points = [
                Point(tuple(np.random.uniform(0, 1) for _ in range(2)))
                for _ in range(n)
            ]
            
            graph = UnitDistanceGraph(points)
            graph.compute_unit_distances()
            max_unit_distances = max(max_unit_distances, graph.count_unit_distances())
        
        return max_unit_distances
    
    def verify_asymptotic_bound(self, max_n: int = 50) -> Dict[str, float]:
        """
        Verify that empirical results satisfy theoretical bounds.
        Upper bound: O(n^{3/2})
        Conjecture: O(n^{1 + c/log log n})
        """
        results = {}
        
        for n in range(5, max_n + 1, 5):
            g_n = self.compute_g_n_empirical(n, trials=20)
            results[n] = g_n
            
            # Compute ratios against bounds
            n_32 = n ** 1.5
            n_log_log = n ** (1 + 1 / np.log(np.log(n) + 1))
            
            print(f"n={n}: g(n)={g_n:.1f}, "
                  f"n^1.5 ratio={g_n/n_32:.3f}, "
                  f"n^(1+1/log log n) ratio={g_n/n_log_log:.3f}")
        
        return results
    
    def analyze_graph_structure(self, graph: UnitDistanceGraph) -> Dict:
        """Analyze structural properties of a unit distance graph."""
        n = len(graph.points)
        if n == 0:
            return {}
        
        degrees = [graph.get_degree(i) for i in range(n)]
        
        return {
            'num_points': n,
            'num_edges': graph.count_unit_distances(),
            'density': graph.count_unit_distances() / (n * (n - 1) / 2) if n > 1 else 0,
            'max_degree': max(degrees) if degrees else 0,
            'min_degree': min(degrees) if degrees else 0,
            'avg_degree': np.mean(degrees) if degrees else 0
        }


def main():
    """Demonstration of combinatorial geometry tools."""
    print("=" * 60)
    print("Erdős Unit Distance Conjecture - Verification Suite")
    print("=" * 60)
    
    # Test lattice generators
    print("\n[1] Lattice Generation Tests")
    print("-" * 40)
    
    # Integer lattice
    int_lattice = GridLatticeGenerator.generate_integer_lattice(2, 5)
    print(f"Integer Lattice (5x5): {int_lattice.count_unit_distances()} unit distances")
    
    # Diamond lattice
    diamond = GridLatticeGenerator.generate_diamond_lattice(5)
    print(f"Diamond Lattice (size 5): {diamond.count_unit_distances()} unit distances")
    
    # Hexagonal lattice
    hex_lattice = GridLatticeGenerator.generate_hexagonal_lattice(5)
    print(f"Hexagonal Lattice (5x5): {hex_lattice.count_unit_distances()} unit distances")
    
    # Verify conjecture bounds
    print("\n[2] Asymptotic Bound Verification")
    print("-" * 40)
    
    verifier = ErdősConjectureVerifier()
    results = verifier.verify_asymptotic_bound(max_n=30)
    
    print("\n[3] Graph Structure Analysis")
    print("-" * 40)
    analysis = verifier.analyze_graph_structure(hex_lattice)
    for key, value in analysis.items():
        print(f"{key}: {value:.4f}" if isinstance(value, float) else f"{key}: {value}")
    
    return results


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

/*
Module 2: Graph Coloring Algorithm Implementation
=================================================
Implements graph coloring algorithms for unit distance graph analysis.
Particularly useful for proving bounds on the chromatic number of the plane.
*/

package main

import (
	"fmt"
	"math"
	"math/rand"
	"time"
)

// Point represents a 2D point
type Point struct {
	X, Y float64
}

// UnitDistanceGraph represents a graph where edges connect unit-distance points
type UnitDistanceGraph struct {
	Vertices []Point
	Edges    map[int]map[int]bool
	N        int
}

// NewUnitDistanceGraph creates a new empty graph
func NewUnitDistanceGraph() *UnitDistanceGraph {
	return &UnitDistanceGraph{
		Vertices: make([]Point, 0),
		Edges:    make(map[int]map[int]bool),
	}
}

// AddVertex adds a point to the graph and returns its index
func (g *UnitDistanceGraph) AddVertex(x, y float64) int {
	idx := g.N
	g.Vertices = append(g.Vertices, Point{X: x, Y: y})
	g.Edges[idx] = make(map[int]bool)
	g.N++
	return idx
}

// AddEdge adds an undirected edge between two vertices
func (g *UnitDistanceGraph) AddEdge(i, j int) {
	if i == j {
		return
	}
	if g.Edges[i] == nil {
		g.Edges[i] = make(map[int]bool)
	}
	if g.Edges[j] == nil {
		g.Edges[j] = make(map[int]bool)
	}
	g.Edges[i][j] = true
	g.Edges[j][i] = true
}

// Distance calculates Euclidean distance between two points
func Distance(p1, p2 Point) float64 {
	dx := p1.X - p2.X
	dy := p1.Y - p2.Y
	return math.Sqrt(dx*dx + dy*dy)
}

// IsUnitDistance checks if two points are at unit distance
func IsUnitDistance(p1, p2 Point) bool {
	const tolerance = 1e-9
	return math.Abs(Distance(p1, p2)-1.0) < tolerance
}

// GenerateLattice creates a grid of points with unit spacing
func (g *UnitDistanceGraph) GenerateLattice(width, height int) {
	for i := 0; i < width; i++ {
		for j := 0; j < height; j++ {
			g.AddVertex(float64(i), float64(j))
		}
	}
}

// GenerateHexagonalLattice creates a hexagonal grid
func (g *UnitDistanceGraph) GenerateHexagonalLattice(width, height int) {
	for i := 0; i < width; i++ {
		for j := 0; j < height; j++ {
			x := float64(i) * 1.5
			y := math.Sqrt(3) * (float64(j) + 0.5*float64(i%2))
			g.AddVertex(x, y)
		}
	}
}

// BuildUnitDistanceEdges creates edges for all unit-distance pairs
func (g *UnitDistanceGraph) BuildUnitDistanceEdges() {
	for i := 0; i < g.N; i++ {
		for j := i + 1; j < g.N; j++ {
			if IsUnitDistance(g.Vertices[i], g.Vertices[j]) {
				g.AddEdge(i, j)
			}
		}
	}
}

// Degree returns the degree of a vertex
func (g *UnitDistanceGraph) Degree(v int) int {
	return len(g.Edges[v])
}

// Coloring represents a vertex coloring
type Coloring struct {
	Colors map[int]int
	K      int // Number of colors used
}

// NewColoring creates an empty coloring
func NewColoring() *Coloring {
	return &Coloring{
		Colors: make(map[int]int),
		K:      0,
	}
}

// SetColor assigns a color to a vertex
func (c *Coloring) SetColor(v, color int) {
	if color+1 > c.K {
		c.K = color + 1
	}
	c.Colors[v] = color
}

// GetColor returns the color of a vertex (-1 if uncolored)
func (c *Coloring) GetColor(v int) int {
	if color, ok := c.Colors[v]; ok {
		return color
	}
	return -1
}

// IsValid checks if the coloring is valid (no adjacent vertices share color)
func (c *Coloring) IsValid(g *UnitDistanceGraph) bool {
	for u := 0; u < g.N; u++ {
		for v := range g.Edges[u] {
			if c.Colors[u] == c.Colors[v] {
				return false
			}
		}
	}
	return true
}

// GreedyColoring colors vertices greedily
func (g *UnitDistanceGraph) GreedyColoring() *Coloring {
	coloring := NewColoring()
	available := make([]bool, g.N) // available[c] = true if color c is available

	for v := 0; v < g.N; v++ {
		// Mark colors used by neighbors as unavailable
		for neighbor := range g.Edges[v] {
			if color := coloring.GetColor(neighbor); color >= 0 {
				available[color] = true
			}
		}

		// Find the first available color
		color := 0
		for color < g.N && available[color] {
			color++
		}
		coloring.SetColor(v, color)

		// Reset available colors
		for neighbor := range g.Edges[v] {
			if color := coloring.GetColor(neighbor); color >= 0 {
				available[color] = false
			}
		}
	}

	return coloring
}

// WelshPowellColoring colors vertices in decreasing degree order
func (g *UnitDistanceGraph) WelshPowellColoring() *Coloring {
	// Sort vertices by degree (descending)
	vertices := make([]int, g.N)
	for i := 0; i < g.N; i++ {
		vertices[i] = i
	}

	// Sort by degree
	for i := 0; i < g.N-1; i++ {
		for j := i + 1; j < g.N; j++ {
			if g.Degree(vertices[i]) < g.Degree(vertices[j]) {
				vertices[i], vertices[j] = vertices[j], vertices[i]
			}
		}
	}

	coloring := NewColoring()
	available := make([]bool, g.N)

	for _, v := range vertices {
		// Mark colors used by neighbors as unavailable
		for neighbor := range g.Edges[v] {
			if color := coloring.GetColor(neighbor); color >= 0 {
				available[color] = true
			}
		}

		// Find the first available color
		color := 0
		for color < g.N && available[color] {
			color++
		}
		coloring.SetColor(v, color)

		// Reset available colors
		for neighbor := range g.Edges[v] {
			if color := coloring.GetColor(neighbor); color >= 0 {
				available[color] = false
			}
		}
	}

	return coloring
}

// BacktrackingColoring finds an optimal coloring using backtracking
func (g *UnitDistanceGraph) BacktrackingColoring(maxColors int) *Coloring {
	coloring := NewColoring()
	usedColors := make([]bool, maxColors)
	
	var backtrack func(v int) bool
	backtrack = func(v int) bool {
		if v == g.N {
			return true
		}

		// Get colors used by neighbors
		for neighbor := range g.Edges[v] {
			if color := coloring.GetColor(neighbor); color >= 0 {
				usedColors[color] = true
			}
		}

		// Try each color
		for color := 0; color < maxColors; color++ {
			if !usedColors[color] {
				coloring.SetColor(v, color)
				if backtrack(v + 1) {
					return true
				}
				delete(coloring.Colors, v)
			}
		}

		// Reset used colors
		for neighbor := range g.Edges[v] {
			if color := coloring.GetColor(neighbor); color >= 0 {
				usedColors[color] = false
			}
		}

		return false
	}

	if backtrack(0) {
		return coloring
	}
	return nil
}

// BacktrackingColoringAll finds ALL valid colorings with minimum colors
func (g *UnitDistanceGraph) BacktrackingColoringAll(minColors int, limit int) []*Coloring {
	coloring := NewColoring()
	usedColors := make([]bool, minColors)
	solutions := make([]*Coloring, 0)
	
	var backtrack func(v int)
	backtrack = func(v int) {
		if len(solutions) >= limit {
			return
		}
		
		if v == g.N {
			// Found a valid coloring
			sol := NewColoring()
			for k, v := range coloring.Colors {
				sol.Colors[k] = v
			}
			sol.K = minColors
			solutions = append(solutions, sol)
			return
		}

		for neighbor := range g.Edges[v] {
			if color := coloring.GetColor(neighbor); color >= 0 {
				usedColors[color] = true
			}
		}

		for color := 0; color < minColors; color++ {
			if !usedColors[color] {
				coloring.SetColor(v, color)
				backtrack(v + 1)
				delete(coloring.Colors, v)
			}
		}

		for neighbor := range g.Edges[v] {
			if color := coloring.GetColor(neighbor); color >= 0 {
				usedColors[color] = false
			}
		}
	}

	backtrack(0)
	return solutions
}

// Statistics holds coloring statistics
type Statistics struct {
	Vertices         int
	Edges            int
	GreedyColors     int
	WelchPowellColors int
	MaxDegree        int
	AvgDegree        float64
}

func (g *UnitDistanceGraph) Statistics() Statistics {
	stats := Statistics{
		Vertices: g.N,
		Edges:    0,
	}

	for i := 0; i < g.N; i++ {
		stats.Edges += len(g.Edges[i])
	}
	stats.Edges /= 2

	maxDeg := 0
	for i := 0; i < g.N; i++ {
		if len(g.Edges[i]) > maxDeg {
			maxDeg = len(g.Edges[i])
		}
	}
	stats.MaxDegree = maxDeg
	stats.AvgDegree = float64(stats.Edges*2) / float64(g.N)

	return stats
}

func main() {
	rand.Seed(time.Now().UnixNano())
	fmt.Println("=" + strings.Repeat("=", 59))
	fmt.Println("Unit Distance Graph Coloring - Erdős Conjecture Analysis")
	fmt.Println("=" + strings.Repeat("=", 59))

	// Create hexagonal lattice (known to have interesting coloring properties)
	graph := NewUnitDistanceGraph()
	graph.GenerateHexagonalLattice(5, 5)
	graph.BuildUnitDistanceEdges()

	fmt.Println("\n[1] Graph Statistics")
	fmt.Println(strings.Repeat("-", 40))
	stats := graph.Statistics()
	fmt.Printf("Vertices: %d\n", stats.Vertices)
	fmt.Printf("Edges: %d\n", stats.Edges)
	fmt.Printf("Max Degree: %d\n", stats.MaxDegree)
	fmt.Printf("Avg Degree: %.2f\n", stats.AvgDegree)

	fmt.Println("\n[2] Greedy Coloring")
	fmt.Println(strings.Repeat("-", 40))
	greedy := graph.GreedyColoring()
	fmt.Printf("Colors used: %d\n", greedy.K)
	fmt.Printf("Valid: %v\n", greedy.IsValid(graph))

	fmt.Println("\n[3] Welsh-Powell Coloring")
	fmt.Println(strings.Repeat("-", 40))
	wp := graph.WelshPowellColoring()
	fmt.Printf("Colors used: %d\n", wp.K)
	fmt.Printf("Valid: %v\n", wp.IsValid(graph))

	fmt.Println("\n[4] Optimal Coloring Search")
	fmt.Println(strings.Repeat("-", 40))
	// Try different numbers of colors
	for colors := 2; colors <= 4; colors++ {
		result := graph.BacktrackingColoring(colors)
		if result != nil {
			fmt.Printf("Found %d-coloring\n", colors)
		} else {
			fmt.Printf("No %d-coloring exists\n", colors)
		}
	}

	fmt.Println("\n[5] Chromatic Number Analysis")
	fmt.Println(strings.Repeat("-", 40))
	// The Hadwiger-Nelson problem relates to unit distance graph coloring
	fmt.Println("The chromatic number of the plane (Hadwiger-Nelson problem)")
	fmt.Println("remains unsolved, with known bounds: 4 ≤ χ ≤ 7")
}

"""
Module 3: Unit Distance Graph Modeling
=====================================
Advanced modeling of unit distance graphs with algebraic structure.
Implements connections between geometric and algebraic representations.
"""

import numpy as np
from typing import List, Tuple, Set, Dict, Optional, Generator
from dataclasses import dataclass, field
from enum import Enum
import itertools
from collections import deque
import heapq


class CoordinateSystem(Enum):
    """Coordinate systems for point generation."""
    CARTESIAN = "cartesian"
    POLAR = "polar"
    SPHERICAL = "spherical"
    COMPLEX = "complex"
    QUATERNION = "quaternion"


@dataclass
class AlgebraicPoint:
    """Represents a point with algebraic structure."""
    coordinates: np.ndarray
    field: Optional[str] = None  # e.g., "Q(i)", "Q(√2)"
    
    @property
    def dimension(self) -> int:
        return len(self.coordinates)
    
    def as_complex(self) -> complex:
        """Interpret as complex number if 2D."""
        if self.dimension == 2:
            return complex(self.coordinates[0], self.coordinates[1])
        raise ValueError("Only 2D points can be complex")
    
    @staticmethod
    def from_complex(z: complex, field: str = "Q(i)") -> 'AlgebraicPoint':
        """Create from complex number."""
        return AlgebraicPoint(
            coordinates=np.array([z.real, z.imag]),
            field=field
        )


class UnitDistanceGraphModel:
    """
    Advanced unit distance graph with algebraic structure.
    Supports multiple dimensions and coordinate systems.
    """
    
    def __init__(self, dimension: int = 2, coordinate_system: CoordinateSystem = CoordinateSystem.CARTESIAN):
        self.dimension = dimension
        self.coordinate_system = coordinate_system
        self.points: List[AlgebraicPoint] = []
        self.adjacency_list: Dict[int, Set[int]] = {}
        self.adjacency_matrix: Optional[np.ndarray] = None
        self._dirty = True
        
    def add_point(self, point: AlgebraicPoint) -> int:
        """Add a point and return its index."""
        idx = len(self.points)
        self.points.append(point)
        self.adjacency_list[idx] = set()
        self._dirty = True
        return idx
    
    def _compute_distance(self, i: int, j: int) -> float:
        """Compute Euclidean distance between points i and j."""
        return np.linalg.norm(
            self.points[i].coordinates - self.points[j].coordinates
        )
    
    def _is_unit_distance(self, distance: float, tolerance: float = 1e-9) -> bool:
        """Check if distance equals 1 (within tolerance)."""
        return abs(distance - 1.0) < tolerance
    
    def build_edges(self, tolerance: float = 1e-9, max_neighbors: Optional[int] = None) -> None:
        """
        Build adjacency list for unit distance edges.
        Optionally limit to max_neighbors per vertex for large graphs.
        """
        n = len(self.points)
        
        if max_neighbors is None or max_neighbors >= n:
            # Full computation
            for i in range(n):
                for j in range(i + 1, n):
                    if self._is_unit_distance(self._compute_distance(i, j), tolerance):
                        self.adjacency_list[i].add(j)
                        self.adjacency_list[j].add(i)
        else:
            # Approximate computation for large graphs
            for i in range(n):
                distances = []
                for j in range(n):
                    if i != j:
                        d = self._compute_distance(i, j)
                        distances.append((d, j))
                
                # Keep only closest neighbors
                distances.sort(key=lambda x: x[0])
                for d, j in distances[:max_neighbors]:
                    if self._is_unit_distance(d, tolerance):
                        self.adjacency_list[i].add(j)
        
        self._dirty = False
    
    def _ensure_matrix(self) -> None:
        """Ensure adjacency matrix is up-to-date."""
        if self._dirty or self.adjacency_matrix is None:
            n = len(self.points)
            self.adjacency_matrix = np.zeros((n, n), dtype=np.int8)
            for i, neighbors in self.adjacency_list.items():
                for j in neighbors:
                    self.adjacency_matrix[i, j] = 1
                    self.adjacency_matrix[j, i] = 1
    
    def num_edges(self) -> int:
        """Count total number of edges."""
        return sum(len(neighbors) for neighbors in self.adjacency_list.values()) // 2
    
    def num_vertices(self) -> int:
        """Number of vertices."""
        return len(self.points)
    
    def degree(self, vertex: int) -> int:
        """Degree of a vertex."""
        return len(self.adjacency_list.get(vertex, set()))
    
    def adjacency_spectrum(self) -> np.ndarray:
        """Compute eigenvalues of adjacency matrix."""
        self._ensure_matrix()
        eigenvalues = np.linalg.eigvalsh(self.adjacency_matrix)
        return np.sort(eigenvalues)[::-1]
    
    def is_regular(self) -> Tuple[bool, Optional[int]]:
        """Check if graph is regular and return common degree."""
        if not self.adjacency_list:
            return True, 0
        
        degrees = [len(neighbors) for neighbors in self.adjacency_list.values()]
        is_reg = len(set(degrees)) == 1
        return is_reg, degrees[0] if is_reg else None
    
    def connected_components(self) -> List[Set[int]]:
        """Find connected components using BFS."""
        n = self.num_vertices()
        visited = [False] * n
        components = []
        
        for start in range(n):
            if visited[start]:
                continue
            
            component = set()
            queue = deque([start])
            
            while queue:
                v = queue.popleft()
                if visited[v]:
                    continue
                
                visited[v] = True
                component.add(v)
                
                for neighbor in self.adjacency_list.get(v, []):
                    if not visited[neighbor]:
                        queue.append(neighbor)
            
            components.append(component)
        
        return components
    
    def diameter(self) -> int:
        """Compute graph diameter using BFS from all nodes."""
        n = self.num_vertices()
        max_distance = 0
        
        for start in range(n):
            distances = [-1] * n
            distances[start] = 0
            queue = deque([start])
            
            while queue:
                v = queue.popleft()
                for neighbor in self.adjacency_list.get(v, []):
                    if distances[neighbor] == -1:
                        distances[neighbor] = distances[v] + 1
                        max_distance = max(max_distance, distances[neighbor])
                        queue.append(neighbor)
        
        return max_distance


class AlgebraicLatticeGenerator:
    """Generate structured point sets from algebraic number fields."""
    
    @staticmethod
    def gaussian_integer_lattice(size: int) -> UnitDistanceGraphModel:
        """
        Generate points from Gaussian integers Z[i].
        Units: ±1, ±i
        """
        graph = UnitDistanceGraphModel(dimension=2, coordinate_system=CoordinateSystem.COMPLEX)
        
        for a in range(-size, size + 1):
            for b in range(-size, size + 1):
                point = AlgebraicPoint(
                    coordinates=np.array([float(a), float(b)]),
                    field="Q(i)"
                )
                graph.add_point(point)
        
        graph.build_edges()
        return graph
    
    @staticmethod
    def eisenstein_lattice(size: int) -> UnitDistanceGraphModel:
        """
        Generate points from Eisenstein integers Z[ω].
        ω = e^(2πi/3) = -1/2 + i√3/2
        Units: ±1, ±ω, ±ω²
        """
        graph = UnitDistanceGraphModel(dimension=2, coordinate_system=CoordinateSystem.COMPLEX)
        
        for a in range(-size, size + 1):
            for b in range(-size, size + 1):
                x = a - 0.5 * b
                y = (np.sqrt(3) / 2) * b
                point = AlgebraicPoint(
                    coordinates=np.array([x, y]),
                    field="Q(ω)"
                )
                graph.add_point(point)
        
        graph.build_edges()
        return graph
    
    @staticmethod
    def quadratic_field_lattice(size: int, sqrt_d: float) -> UnitDistanceGraphModel:
        """
        Generate points from quadratic field Z[√d].
        For d = 2: √2 ≈ 1.414 (diagonal distances become unit distances)
        """
        graph = UnitDistanceGraphModel(dimension=2, coordinate_system=CoordinateSystem.CARTESIAN)
        
        for a in range(-size, size + 1):
            for b in range(-size, size + 1):
                x = float(a)
                y = sqrt_d * float(b)
                point = AlgebraicPoint(
                    coordinates=np.array([x, y]),
                    field=f"Q(√{int(sqrt_d)})"
                )
                graph.add_point(point)
        
        graph.build_edges()
        return graph


class GraphAlgorithm:
    """Graph algorithms for unit distance graph analysis."""
    
    @staticmethod
    def find_cliques(graph: UnitDistanceGraphModel, min_size: int = 3) -> List[List[int]]:
        """
        Find all cliques of size >= min_size using Bron-Kerbosch algorithm.
        A clique is a set of vertices all pairwise connected.
        """
        cliques = []
        adjacency = graph.adjacency_list
        
        def bron_kerbosch(R: Set[int], P: Set[int], X: Set[int]):
            if not P and not X:
                if len(R) >= min_size:
                    cliques.append(list(R))
                return
            
            # Pivot selection to reduce branching
            pivot = max(P | X, key=lambda v: len(adjacency.get(v, set()) & P))
            candidates = P - adjacency.get(pivot, set())
            
            for v in candidates:
                neighbors = adjacency.get(v, set())
                bron_kerbosch(R | {v}, P & neighbors, X & neighbors)
                P.remove(v)
                X.add(v)
        
        all_vertices = set(range(graph.num_vertices()))
        bron_kerbosch(set(), all_vertices, set())
        return cliques
    
    @staticmethod
    def independent_set_approx(graph: UnitDistanceGraphModel) -> List[int]:
        """
        Find a large independent set using greedy algorithm.
        An independent set has no edges between vertices.
        """
        remaining = set(range(graph.num_vertices()))
        independent = []
        
        while remaining:
            # Select vertex with minimum degree in remaining graph
            v = min(remaining, key=lambda x: len(graph.adjacency_list.get(x, set()) & remaining))
            independent.append(v)
            remaining -= graph.adjacency_list.get(v, set()) | {v}
        
        return independent
    
    @staticmethod
    def vertex_cover_approx(graph: UnitDistanceGraphModel) -> List[int]:
        """
        Approximate minimum vertex cover using 2-approximation.
        A vertex cover touches all edges.
        """
        uncovered = set()
        for i, neighbors in graph.adjacency_list.items():
            for j in neighbors:
                if i < j:
                    uncovered.add((i, j))
        
        cover = []
        while uncovered:
            # Pick an edge and add both vertices
            i, j = uncovered.pop()
            if (i, j) in uncovered:
                uncovered.remove((i, j))
            
            cover.append(i)
            cover.append(j)
            
            # Remove all edges incident to i and j
            uncovered = {
                (u, v) for u, v in uncovered
                if u != i and u != j and v != i and v != j
            }
        
        return cover


def analyze_erdos_conjecture(max_n: int = 10) -> Dict:
    """
    Analyze unit distance graphs for Erdős conjecture verification.
    """
    results = {}
    
    generators = [
        ("Gaussian Integer", AlgebraicLatticeGenerator.gaussian_integer_lattice),
        ("Eisenstein", AlgebraicLatticeGenerator.eisenstein_lattice),
        ("Quadratic (√2)", lambda n: AlgebraicLatticeGenerator.quadratic_field_lattice(n, np.sqrt(2))),
    ]
    
    for name, generator in generators:
        print(f"\n[ {name} Lattice Analysis ]")
        print("-" * 40)
        
        graph = generator(max_n)
        print(f"Vertices: {graph.num_vertices()}")
        print(f"Edges: {graph.num_edges()}")
        
        is_reg, deg = graph.is_regular()
        print(f"Regular: {is_reg} (degree={deg})" if is_reg else f"Regular: False")
        
        components = graph.connected_components()
        print(f"Components: {len(components)}")
        
        # Find cliques
        cliques = GraphAlgorithm.find_cliques(graph, min_size=3)
        print(f"Triangles (3-cliques): {len(cliques)}")
        
        # Independent set
        indep_set = GraphAlgorithm.independent_set_approx(graph)
        print(f"Independent Set Size: {len(indep_set)}")
        
        # Spectrum
        spectrum = graph.adjacency_spectrum()
        print(f"Largest Eigenvalue: {spectrum[0]:.4f}")
        
        results[name] = {
            'vertices': graph.num_vertices(),
            'edges': graph.num_edges(),
            'regular': is_reg,
            'degree': deg,
            'components': len(components),
            'triangles': len(cliques),
            'indep_set': len(indep_set),
            'spectral_radius': spectrum[0]
        }
    
    return results


if __name__ == "__main__":
    print("=" * 60)
    print("Unit Distance Graph Modeling Suite")
    print("Algebraic Number Field Connections to Erdős Conjecture")
    print("=" * 60)
    
    results = analyze_erdos_conjecture(max_n=5)
    
    print("\n" + "=" * 60)
    print("Summary Statistics")
    print("=" * 60)
    
    for name, data in results.items():
        print(f"\n{name}:")
        for key, value in data.items():
            print(f"  {key}: {value}")

"""
Module 4: AI Reasoning Path Reconstruction
==========================================
Implements the reasoning path reconstruction for AI mathematical discovery.
This module simulates how the AI system bridges different mathematical domains.
"""

import numpy as np
from typing import List, Dict, Tuple, Set, Optional, Callable
from dataclasses import dataclass, field
from enum import Enum
from collections import defaultdict
import heapq
import random


class ReasoningStepType(Enum):
    """Types of reasoning steps in mathematical proofs."""
    PREMISE = "premise"
    DEFINITION = "definition"
    LEMMA = "lemma"
    THEOREM = "theorem"
    COROLLARY = "corollary"
    PROOF_STEP = "proof_step"
    ANALOGY = "analogy"
    TRANSFER = "transfer"
    VERIFICATION = "verification"


@dataclass
class MathematicalDomain:
    """Represents a mathematical domain/field."""
    name: str
    key_concepts: List[str]
    key_theorems: List[str]
    techniques: List[str]
    
    def similarity_to(self, other: 'MathematicalDomain') -> float:
        """Compute conceptual similarity between domains."""
        concept_overlap = len(set(self.key_concepts) & set(other.key_concepts))
        technique_overlap = len(set(self.techniques) & set(other.techniques))
        
        total = len(set(self.key_concepts + other.key_concepts)) + \
                len(set(self.techniques + other.techniques))
        
        return (concept_overlap + technique_overlap) / total if total > 0 else 0.0


@dataclass
class ReasoningStep:
    """A single step in a reasoning chain."""
    step_type: ReasoningStepType
    content: str
    domain: str
    prerequisites: List[int] = field(default_factory=list)  # Indices of prerequisite steps
    confidence: float = 1.0
    novelty_score: float = 0.0
    parent_steps: List[int] = field(default_factory=list)  # For tracking analogical reasoning
    
    def __hash__(self):
        return hash((self.step_type, self.content, self.domain))


class ReasoningPath:
    """A path through mathematical reasoning steps."""
    
    def __init__(self):
        self.steps: List[ReasoningStep] = []
        self.connections: Dict[int, Set[int]] = defaultdict(set)  # step_idx -> dependent steps
        self.path_score: float = 0.0
    
    def add_step(self, step: ReasoningStep) -> int:
        """Add a step and return its index."""
        idx = len(self.steps)
        self.steps.append(step)
        for prereq in step.prerequisites:
            self.connections[prereq].add(idx)
        return idx
    
    def compute_score(self) -> float:
        """Compute overall path quality score."""
        if not self.steps:
            return 0.0
        
        # Weight: novelty + correctness + coherence
        novelty_sum = sum(s.novelty_score for s in self.steps)
        confidence_prod = np.prod([s.confidence for s in self.steps if s.confidence > 0])
        coherence = self._compute_coherence()
        
        self.path_score = (novelty_sum / len(self.steps)) * 0.4 + \
                          confidence_prod * 0.3 + \
                          coherence * 0.3
        return self.path_score
    
    def _compute_coherence(self) -> float:
        """Measure coherence of the reasoning path."""
        if len(self.steps) <= 1:
            return 1.0
        
        domain_transitions = 0
        for i in range(len(self.steps) - 1):
            if self.steps[i].domain != self.steps[i + 1].domain:
                domain_transitions += 1
        
        return 1.0 - (domain_transitions / (len(self.steps) - 1))
    
    def get_topological_order(self) -> List[int]:
        """Return steps in topological order."""
        in_degree = [0] * len(self.steps)
        for step_idx in range(len(self.steps)):
            for prereq in self.steps[step_idx].prerequisites:
                in_degree[step_idx] += 1
        
        queue = [i for i, d in enumerate(in_degree) if d == 0]
        order = []
        
        while queue:
            step_idx = queue.pop(0)
            order.append(step_idx)
            
            for dependent in self.connections[step_idx]:
                in_degree[dependent] -= 1
                if in_degree[dependent] == 0:
                    queue.append(dependent)
        
        return order if len(order) == len(self.steps) else []


class CrossDisciplinaryBridge:
    """
    Identifies and exploits connections between mathematical domains.
    This is the key innovation that enabled the Erdős conjecture breakthrough.
    """
    
    def __init__(self):
        self.domains: Dict[str, MathematicalDomain] = {}
        self.analogies: List[Tuple[str, str, str]] = []  # (domain1, domain2, shared_structure)
        self.transfer_rules: Dict[Tuple[str, str], List[str]] = defaultdict(list)
    
    def register_domain(self, domain: MathematicalDomain) -> None:
        """Register a mathematical domain."""
        self.domains[domain.name] = domain
    
    def find_analogies(self, source_domain: str, target_domain: str, 
                      min_similarity: float = 0.1) -> List[Dict]:
        """Find structural analogies between two domains."""
        if source_domain not in self.domains or target_domain not in self.domains:
            return []
        
        source = self.domains[source_domain]
        target = self.domains[target_domain]
        
        analogies = []
        
        # Find concept analogies
        for i, concept in enumerate(source.key_concepts):
            for j, other_concept in enumerate(target.key_concepts):
                similarity = self._concept_similarity(concept, other_concept)
                if similarity > min_similarity:
                    analogies.append({
                        'type': 'concept',
                        'source': concept,
                        'target': other_concept,
                        'similarity': similarity,
                        'source_theorem': source.key_theorems[i] if i < len(source.key_theorems) else None,
                        'potential_transfer': f"Apply {source.key_theorems[i]} to {other_concept}"
                    })
        
        # Find technique analogies
        for tech in source.techniques:
            for other_tech in target.techniques:
                similarity = self._technique_similarity(tech, other_tech)
                if similarity > min_similarity:
                    analogies.append({
                        'type': 'technique',
                        'source': tech,
                        'target': other_tech,
                        'similarity': similarity
                    })
        
        return sorted(analogies, key=lambda x: -x['similarity'])
    
    def _concept_similarity(self, c1: str, c2: str) -> float:
        """Simple word-based similarity for concepts."""
        words1 = set(c1.lower().split())
        words2 = set(c2.lower().split())
        
        if not words1 or not words2:
            return 0.0
        
        intersection = words1 & words2
        union = words1 | words2
        
        # Bonus for related terms
        related_pairs = [
            ('graph', 'network'), ('tower', 'hierarchy'), 
            ('extension', 'tower'), ('galois', 'automorphism'),
            ('field', 'space'), ('group', 'structure')
        ]
        
        bonus = 0.0
        for w1, w2 in related_pairs:
            if (w1 in words1 and w2 in words2) or (w2 in words1 and w1 in words2):
                bonus += 0.2
        
        return len(intersection) / len(union) + bonus
    
    def _technique_similarity(self, t1: str, t2: str) -> float:
        """Similarity for techniques."""
        return self._concept_similarity(t1, t2)
    
    def generate_transfer_rule(self, source_domain: str, target_domain: str,
                              analogy: Dict) -> str:
        """Generate a concrete transfer rule based on an analogy."""
        if analogy['type'] == 'concept' and 'source_theorem' in analogy:
            theorem = analogy['source_theorem']
            target = analogy['target']
            return f"Transfer theorem '{theorem}' from {source_domain} to {target_domain} context '{target}'"
        return f"Adapt {source_domain} technique to {target_domain}"


class ProofSearchEngine:
    """
    Monte Carlo Tree Search for mathematical proof exploration.
    Implements the core proof search strategy.
    """
    
    def __init__(self, domains: Dict[str, MathematicalDomain]):
        self.domains = domains
        self.bridge = CrossDisciplinaryBridge()
        for domain in domains.values():
            self.bridge.register_domain(domain)
        
        self.explored_paths: List[ReasoningPath] = []
        self.best_path: Optional[ReasoningPath] = None
        
    def search(self, start_domain: str, goal_property: str, 
               max_iterations: int = 1000) -> ReasoningPath:
        """
        Search for a proof path from start_domain to goal_property.
        Uses MCTS with domain-bridging heuristics.
        """
        
        # Initialize with premise
        root_path = ReasoningPath()
        root_path.add_step(ReasoningStep(
            step_type=ReasoningStepType.PREMISE,
            content=f"Starting domain: {start_domain}",
            domain=start_domain,
            prerequisites=[],
            confidence=1.0
        ))
        
        frontier = [(root_path.compute_score(), id(root_path), root_path)]
        visited_states = set()
        
        for iteration in range(max_iterations):
            if not frontier:
                break
            
            # Select highest priority path
            _, _, current_path = heapq.heappop(frontier)
            
            # Check if goal reached
            if self._is_goal(current_path, goal_property):
                self.best_path = current_path
                return current_path
            
            # Generate next steps
            current_domain = current_path.steps[-1].domain
            next_steps = self._generate_next_steps(current_path, current_domain, goal_property)
            
            for new_path in next_steps:
                state_hash = self._path_hash(new_path)
                if state_hash not in visited_states:
                    visited_states.add(state_hash)
                    heapq.heappush(frontier, (-new_path.compute_score(), id(new_path), new_path))
        
        return self.best_path or root_path
    
    def _generate_next_steps(self, path: ReasoningPath, current_domain: str, 
                             goal: str) -> List[ReasoningPath]:
        """Generate candidate next reasoning steps."""
        candidates = []
        
        # Option 1: Within-domain reasoning
        domain = self.domains.get(current_domain)
        if domain:
            for theorem in domain.key_theorems[:2]:
                new_path = ReasoningPath()
                for step in path.steps:
                    new_path.add_step(step)
                
                new_path.add_step(ReasoningStep(
                    step_type=ReasoningStepType.THEOREM,
                    content=f"Apply theorem: {theorem}",
                    domain=current_domain,
                    prerequisites=[len(path.steps) - 1],
                    confidence=0.95
                ))
                candidates.append(new_path)
        
        # Option 2: Cross-domain bridge
        for other_domain in self.domains:
            if other_domain != current_domain:
                analogies = self.bridge.find_analogies(current_domain, other_domain, min_similarity=0.2)
                if analogies:
                    analogy = analogies[0]
                    
                    new_path = ReasoningPath()
                    for step in path.steps:
                        new_path.add_step(step)
                    
                    # Add analogy step
                    analogy_step = ReasoningStep(
                        step_type=ReasoningStepType.ANALOGY,
                        content=f"Analogy: {analogy['type']} between {analogy['source']} and {analogy['target']}",
                        domain=f"{current_domain} → {other_domain}",
                        prerequisites=[len(path.steps) - 1],
                        novelty_score=analogy['similarity']
                    )
                    analogy_idx = new_path.add_step(analogy_step)
                    
                    # Add transfer step
                    transfer_rule = self.bridge.generate_transfer_rule(
                        current_domain, other_domain, analogy
                    )
                    transfer_step = ReasoningStep(
                        step_type=ReasoningStepType.TRANSFER,
                        content=transfer_rule,
                        domain=other_domain,
                        prerequisites=[analogy_idx],
                        confidence=0.8,
                        novelty_score=0.9  # High novelty for cross-domain transfer
                    )
                    new_path.add_step(transfer_step)
                    candidates.append(new_path)
        
        return candidates[:5]  # Limit branching
    
    def _is_goal(self, path: ReasoningPath, goal_property: str) -> bool:
        """Check if path achieves the goal property."""
        content_lower = ' '.join(s.content.lower() for s in path.steps)
        return goal_property.lower() in content_lower
    
    def _path_hash(self, path: ReasoningPath) -> str:
        """Generate a hash for path state."""
        return tuple(s.domain for s in path.steps).__hash__()


def setup_erdos_conjecture_domains() -> Dict[str, MathematicalDomain]:
    """Set up the mathematical domains involved in the Erdős breakthrough."""
    return {
        'Combinatorial Geometry': MathematicalDomain(
            name='Combinatorial Geometry',
            key_concepts=[
                'unit distance graph', 'point configuration', 'distance bound',
                'lattice construction', 'graph density', 'chromatic number'
            ],
            key_theorems=[
                'Erdős Unit Distance Bound', 'Szemerédi-Trotter Theorem',
                'Crossing Number Lemma', 'Density Hales-Jewett'
            ],
            techniques=['double counting', 'probabilistic method', 'discrete geometry', 'packing arguments']
        ),
        'Algebraic Number Theory': MathematicalDomain(
            name='Algebraic Number Theory',
            key_concepts=[
                'number field', 'class field', 'galois group', 'ideal class group',
                'infinite extension', 'hilbert class field', 'ramification'
            ],
            key_theorems=[
                'Class Field Theory', 'Hilbert Theorem 94', 'Neukirch-Uchida',
                'Golod-Shafarevich Theorem'
            ],
            techniques=['galois theory', 'idele theory', 'local-global principle', 'tower construction']
        ),
        'Graph Theory': MathematicalDomain(
            name='Graph Theory',
            key_concepts=[
                'graph automorphism', 'graph spectrum', 'regular graph',
                'expander graph', 'random graph', 'graph coloring'
            ],
            key_theorems=[
                'Spectral Theorem', 'Turán Theorem', 'Erdős–Gallai',
                'Brook\'s Theorem'
            ],
            techniques=['spectral analysis', 'probabilistic combinatorics', 'extremal arguments']
        ),
        'Analytic Number Theory': MathematicalDomain(
            name='Analytic Number Theory',
            key_concepts=[
                'zeta function', 'l-function', 'density estimate', 
                'tauberian theorem', 'dirichlet series', 'average order'
            ],
            key_theorems=[
                'Prime Number Theorem', 'Delange-Iwaniec', 'Landau Ramanujan',
                'Tauberian Theorems'
            ],
            techniques=['contour integration', 'mean value estimates', 'complex analysis']
        )
    }


def main():
    """Demonstrate the reasoning path reconstruction."""
    print("=" * 60)
    print("AI Reasoning Path Reconstruction")
    print("Simulating Cross-Disciplinary Mathematical Discovery")
    print("=" * 60)
    
    # Set up domains
    domains = setup_erdos_conjecture_domains()
    engine = ProofSearchEngine(domains)
    
    print("\n[1] Registered Mathematical Domains")
    print("-" * 40)
    for name, domain in domains.items():
        print(f"\n{name}:")
        print(f"  Concepts: {', '.join(domain.key_concepts[:3])}...")
        print(f"  Techniques: {', '.join(domain.techniques)}")
    
    print("\n[2] Cross-Domain Analogies (Geometry ↔ Number Theory)")
    print("-" * 40)
    
    bridge = engine.bridge
    analogies = bridge.find_analogies('Combinatorial Geometry', 'Algebraic Number Theory')
    
    print(f"\nFound {len(analogies)} analogies:")
    for analogy in analogies[:5]:
        print(f"\n  Type: {analogy['type']}")
        print(f"  Source: {analogy['source']}")
        print(f"  Target: {analogy['target']}")
        print(f"  Similarity: {analogy['similarity']:.3f}")
        if 'potential_transfer' in analogy:
            print(f"  Transfer: {analogy['potential_transfer']}")
    
    print("\n[3] Proof Search for Erdős Conjecture Solution")
    print("-" * 40)
    
    path = engine.search(
        start_domain='Combinatorial Geometry',
        goal_property='unit distance bound',
        max_iterations=100
    )
    
    print(f"\nBest path found (score: {path.compute_score():.3f}):")
    for i, step in enumerate(path.steps):
        indent = "  " * (len(path.steps) - i - 1)
        print(f"{indent}→ {step.step_type.value}: {step.content}")
        print(f"{indent}  Domain: {step.domain}, Novelty: {step.novelty_score:.2f}")
    
    print("\n[4] Reasoning Path Statistics")
    print("-" * 40)
    print(f"Total steps: {len(path.steps)}")
    print(f"Domains visited: {len(set(s.domain for s in path.steps))}")
    print(f"Cross-domain transfers: {sum(1 for s in path.steps if s.step_type == ReasoningStepType.TRANSFER)}")
    print(f"Path coherence: {path._compute_coherence():.3f}")
    
    print("\n[5] Key Breakthrough Insight")
    print("-" * 40)
    print("The AI discovered a structural analogy between:")
    print("  • 'unit distance graph tower' (combinatorial geometry)")
    print("  • 'infinite class field tower' (algebraic number theory)")
    print("\nThis allowed transfer of Galois-theoretic techniques to bound")
    print("unit distance growth, achieving the breakthrough insight.")


if __name__ == "__main__":
    main()