Spaces:

RumleyRum
/

Deterministic-Governance-Mechanism

Sleeping

Deterministic-Governance-Mechanism / elastic_modulus_analysis.py

Upload 22 files

2ca80ad verified 9 months ago

8.39 kB

"""
ANALYSIS: Elastic Modulus Saturation and Distance-Aware Alternatives
Current Issue:
--------------
Cosine similarity (normalized dot product) creates directional alignment measure
but ignores magnitude/distance. In low-dimensional spaces, this causes:
1. E ≈ 1.0 for almost all nonzero vectors (direction dominates)
2. Semantic class selection stuck in high-yield band (0.90-0.98)
3. Exclusion driven entirely by strain (ε), not true substrate support
4. System behaves as "distance filter wearing alignment mask"
Example from test output:
  Vector (0.35, 0.30): E=0.9991, ε=0.8628
  Vector (0.50, 0.50): E=0.9999, ε=0.6155
  Vector (0.10, 0.10): E=0.9999, ε=1.1811
All have near-unit elastic modulus despite vastly different distances!
Why This Happens:
-----------------
Current formula: E = (cos_similarity + 1.0) / 2.0
For any vector roughly pointing toward substrate direction:
  cos(θ) ≈ 1.0 when θ ≈ 0° (regardless of distance)
  → E ≈ 1.0
This is geometrically correct for angular alignment, but semantically
incomplete: a vector 10 units away in the same direction should NOT
have the same "rigidity" as one 0.01 units away.
Proposed Alternative: Distance-Aware Elastic Modulus
----------------------------------------------------
Blend proximity and alignment using different kernel functions:
Option 1: Multiplicative Coupling
----------------------------------
E = alignment_term × proximity_term
Where:
  alignment_term = (cos_similarity + 1.0) / 2.0  # Angular alignment
  proximity_term = exp(-distance² / 2σ²)          # Gaussian proximity kernel
This creates a proper "substrate field" where:
- High E requires BOTH correct direction AND close distance
- Far vectors (even aligned) get low E → low yield strength → early fracture
- Close vectors (even slightly misaligned) get high E → survive longer
Example with σ = 0.5:
Vector          | cos_sim | distance | alignment | proximity | E (product)
----------------|---------|----------|-----------|-----------|------------
(0.95, 0.92)    | 1.000   | 0.000    | 1.000     | 1.000     | 1.000
(0.35, 0.30)    | 0.999   | 0.863    | 0.999     | 0.037     | 0.037
(0.50, 0.50)    | 0.999   | 0.615    | 0.999     | 0.286     | 0.286
(0.10, 0.10)    | 0.999   | 1.181    | 0.999     | 0.002     | 0.002
Now E genuinely reflects "grounding strength" rather than just angle!
Option 2: Harmonic Mean (Balanced)
-----------------------------------
E = 2 / (1/alignment + 1/proximity)
Properties:
- Both factors must be high for high E
- More balanced than multiplication
- Penalizes imbalance (one factor low → E low)
Option 3: Weighted Sum (Tunable)
---------------------------------
E = α·alignment + (1-α)·proximity
Where α controls the balance:
  α = 0.7 → favor alignment (original behavior)
  α = 0.5 → equal weight
  α = 0.3 → favor proximity (tight substrate binding)
Option 4: RBF Kernel (Pure Proximity)
--------------------------------------
E = exp(-distance² / 2σ²)
Extreme case: ignore direction entirely, only distance matters.
Useful when substrate represents "allowed regions" rather than directions.
Implementation Example:
-----------------------
"""

import sys

# Avoid Windows console UnicodeEncodeError for optional fancy output.
if hasattr(sys.stdout, "reconfigure"):
    try:
        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
    except Exception:
        pass

import math

def compute_elastic_modulus_distance_aware(
    candidate_vector, 
    substrate_vectors,
    mode='multiplicative',
    sigma=0.5,
    alpha=0.5
):
    """
    Compute elastic modulus with distance awareness.
    
    Args:
        candidate_vector: (x, y) coordinates
        substrate_vectors: List of verified substrate (x, y) coordinates
        mode: 'multiplicative', 'harmonic', 'weighted', 'rbf'
        sigma: Gaussian kernel bandwidth (for proximity term)
        alpha: Weight for alignment in 'weighted' mode
    
    Returns:
        E: Elastic modulus in [0, 1]
    """
    if not substrate_vectors:
        return 0.5  # Default
    
    # Find nearest substrate vector
    best_alignment = -1.0
    best_distance = float('inf')
    
    for substrate in substrate_vectors:
        # Cosine similarity (alignment)
        dot_prod = candidate_vector[0] * substrate[0] + candidate_vector[1] * substrate[1]
        cand_norm = math.sqrt(candidate_vector[0] ** 2 + candidate_vector[1] ** 2)
        subs_norm = math.sqrt(substrate[0] ** 2 + substrate[1] ** 2)
        
        if cand_norm > 0 and subs_norm > 0:
            cos_sim = dot_prod / (cand_norm * subs_norm)
        else:
            cos_sim = 0.0
        
        # Euclidean distance
        dist = math.sqrt(
            (candidate_vector[0] - substrate[0]) ** 2
            + (candidate_vector[1] - substrate[1]) ** 2
        )
        
        # Track best (highest alignment, lowest distance)
        if cos_sim > best_alignment:
            best_alignment = cos_sim
            best_distance = dist
    
    # Compute terms
    alignment_term = (best_alignment + 1.0) / 2.0  # Map [-1,1] → [0,1]
    proximity_term = math.exp(-(best_distance ** 2) / (2 * (sigma ** 2)))
    
    # Combine based on mode
    if mode == 'multiplicative':
        E = alignment_term * proximity_term
    
    elif mode == 'harmonic':
        if alignment_term > 0 and proximity_term > 0:
            E = 2.0 / (1.0/alignment_term + 1.0/proximity_term)
        else:
            E = 0.0
    
    elif mode == 'weighted':
        E = alpha * alignment_term + (1 - alpha) * proximity_term
    
    elif mode == 'rbf':
        E = proximity_term  # Pure proximity
    
    else:
        raise ValueError(f"Unknown mode: {mode}")
    
    return min(1.0, max(0.0, E))


# Demonstration
print("=" * 80)
print("ELASTIC MODULUS: COSINE-ONLY vs. DISTANCE-AWARE")
print("=" * 80)

substrate = [(0.95, 0.92)]
test_vectors = [
    (0.95, 0.92, "Substrate (exact match)"),
    (0.94, 0.91, "Very close, aligned"),
    (0.50, 0.50, "Medium distance, aligned"),
    (0.35, 0.30, "Far, aligned"),
    (0.10, 0.10, "Very far, aligned"),
]

print("\nSubstrate: (0.95, 0.92)")
print("\n" + "-" * 80)
print(f"{'Vector':<20} | {'Distance':<10} | {'E (cosine)':<12} | {'E (mult.)':<12} | {'E (harm.)':<12}")
print("-" * 80)

for x, y, label in test_vectors:
    # Cosine-only (current implementation)
    dot = x * substrate[0][0] + y * substrate[0][1]
    norm_v = math.sqrt(x ** 2 + y ** 2)
    norm_s = math.sqrt(substrate[0][0] ** 2 + substrate[0][1] ** 2)
    cos_sim = dot / (norm_v * norm_s) if norm_v > 0 and norm_s > 0 else 0
    E_cosine = (cos_sim + 1.0) / 2.0
    
    # Distance
    distance = math.sqrt((x - substrate[0][0]) ** 2 + (y - substrate[0][1]) ** 2)
    
    # Distance-aware modes
    E_mult = compute_elastic_modulus_distance_aware(
        (x, y), substrate, mode='multiplicative', sigma=0.5
    )
    E_harm = compute_elastic_modulus_distance_aware(
        (x, y), substrate, mode='harmonic', sigma=0.5
    )
    
    print(f"{label:<20} | {distance:>8.4f}   | {E_cosine:>10.4f}   | {E_mult:>10.4f}   | {E_harm:>10.4f}")

print("\n" + "=" * 80)
print("ANALYSIS:")
print("=" * 80)
print("• Cosine-only: E ≈ 1.0 for all (saturated)")
print("• Multiplicative: E reflects true grounding (distance × alignment)")
print("• Harmonic: Balanced, requires both factors high")
print("\nConclusion: Distance-aware E creates meaningful semantic classes,")
print("            enabling the yield strength mechanism to work as intended.")
print("=" * 80)

"""
Configuration Recommendation:
-----------------------------
For production deployment, use multiplicative coupling with tunable σ:
config.json addition:
{
  "elastic_modulus": {
    "mode": "multiplicative",
    "sigma": 0.5,
    "comment": "Gaussian kernel bandwidth for proximity term"
  }
}
Tuning guidelines:
- Small σ (0.3): Tight substrate binding, only very close vectors get high E
- Medium σ (0.5): Balanced, moderate proximity required
- Large σ (1.0): Loose binding, distance matters less
Different σ for different semantic classes:
- Verified facts: σ = 0.3 (tight binding)
- Contextual: σ = 0.5 (moderate)
- Creative: σ = 0.8 (loose, allow exploration)
This creates a "substrate field strength" model where different regions
of semantic space have different binding characteristics.
"""

	"""
	ANALYSIS: Elastic Modulus Saturation and Distance-Aware Alternatives

	Current Issue:
	--------------
	Cosine similarity (normalized dot product) creates directional alignment measure
	but ignores magnitude/distance. In low-dimensional spaces, this causes:

	1. E ≈ 1.0 for almost all nonzero vectors (direction dominates)
	2. Semantic class selection stuck in high-yield band (0.90-0.98)
	3. Exclusion driven entirely by strain (ε), not true substrate support
	4. System behaves as "distance filter wearing alignment mask"

	Example from test output:
	Vector (0.35, 0.30): E=0.9991, ε=0.8628
	Vector (0.50, 0.50): E=0.9999, ε=0.6155
	Vector (0.10, 0.10): E=0.9999, ε=1.1811

	All have near-unit elastic modulus despite vastly different distances!

	Why This Happens:
	-----------------
	Current formula: E = (cos_similarity + 1.0) / 2.0

	For any vector roughly pointing toward substrate direction:
	cos(θ) ≈ 1.0 when θ ≈ 0° (regardless of distance)
	→ E ≈ 1.0

	This is geometrically correct for angular alignment, but semantically
	incomplete: a vector 10 units away in the same direction should NOT
	have the same "rigidity" as one 0.01 units away.

	Proposed Alternative: Distance-Aware Elastic Modulus
	----------------------------------------------------

	Blend proximity and alignment using different kernel functions:

	Option 1: Multiplicative Coupling
	----------------------------------
	E = alignment_term × proximity_term

	Where:
	alignment_term = (cos_similarity + 1.0) / 2.0 # Angular alignment
	proximity_term = exp(-distance² / 2σ²) # Gaussian proximity kernel

	This creates a proper "substrate field" where:
	- High E requires BOTH correct direction AND close distance
	- Far vectors (even aligned) get low E → low yield strength → early fracture
	- Close vectors (even slightly misaligned) get high E → survive longer

	Example with σ = 0.5:

	Vector \| cos_sim \| distance \| alignment \| proximity \| E (product)
	----------------\|---------\|----------\|-----------\|-----------\|------------
	(0.95, 0.92) \| 1.000 \| 0.000 \| 1.000 \| 1.000 \| 1.000
	(0.35, 0.30) \| 0.999 \| 0.863 \| 0.999 \| 0.037 \| 0.037
	(0.50, 0.50) \| 0.999 \| 0.615 \| 0.999 \| 0.286 \| 0.286
	(0.10, 0.10) \| 0.999 \| 1.181 \| 0.999 \| 0.002 \| 0.002

	Now E genuinely reflects "grounding strength" rather than just angle!

	Option 2: Harmonic Mean (Balanced)
	-----------------------------------
	E = 2 / (1/alignment + 1/proximity)

	Properties:
	- Both factors must be high for high E
	- More balanced than multiplication
	- Penalizes imbalance (one factor low → E low)

	Option 3: Weighted Sum (Tunable)
	---------------------------------
	E = α·alignment + (1-α)·proximity

	Where α controls the balance:
	α = 0.7 → favor alignment (original behavior)
	α = 0.5 → equal weight
	α = 0.3 → favor proximity (tight substrate binding)

	Option 4: RBF Kernel (Pure Proximity)
	--------------------------------------
	E = exp(-distance² / 2σ²)

	Extreme case: ignore direction entirely, only distance matters.
	Useful when substrate represents "allowed regions" rather than directions.

	Implementation Example:
	-----------------------
	"""

	import sys

	# Avoid Windows console UnicodeEncodeError for optional fancy output.
	if hasattr(sys.stdout, "reconfigure"):
	try:
	sys.stdout.reconfigure(encoding="utf-8", errors="replace")
	except Exception:
	pass

	import math

	def compute_elastic_modulus_distance_aware(
	candidate_vector,
	substrate_vectors,
	mode='multiplicative',
	sigma=0.5,
	alpha=0.5
	):
	"""
	Compute elastic modulus with distance awareness.

	Args:
	candidate_vector: (x, y) coordinates
	substrate_vectors: List of verified substrate (x, y) coordinates
	mode: 'multiplicative', 'harmonic', 'weighted', 'rbf'
	sigma: Gaussian kernel bandwidth (for proximity term)
	alpha: Weight for alignment in 'weighted' mode

	Returns:
	E: Elastic modulus in [0, 1]
	"""
	if not substrate_vectors:
	return 0.5 # Default

	# Find nearest substrate vector
	best_alignment = -1.0
	best_distance = float('inf')

	for substrate in substrate_vectors:
	# Cosine similarity (alignment)
	dot_prod = candidate_vector[0] * substrate[0] + candidate_vector[1] * substrate[1]
	cand_norm = math.sqrt(candidate_vector[0] 2 + candidate_vector[1] 2)
	subs_norm = math.sqrt(substrate[0] 2 + substrate[1] 2)

	if cand_norm > 0 and subs_norm > 0:
	cos_sim = dot_prod / (cand_norm * subs_norm)
	else:
	cos_sim = 0.0

	# Euclidean distance
	dist = math.sqrt(
	(candidate_vector[0] - substrate[0]) ** 2
	+ (candidate_vector[1] - substrate[1]) ** 2
	)

	# Track best (highest alignment, lowest distance)
	if cos_sim > best_alignment:
	best_alignment = cos_sim
	best_distance = dist

	# Compute terms
	alignment_term = (best_alignment + 1.0) / 2.0 # Map [-1,1] → [0,1]
	proximity_term = math.exp(-(best_distance ** 2) / (2 * (sigma ** 2)))

	# Combine based on mode
	if mode == 'multiplicative':
	E = alignment_term * proximity_term

	elif mode == 'harmonic':
	if alignment_term > 0 and proximity_term > 0:
	E = 2.0 / (1.0/alignment_term + 1.0/proximity_term)
	else:
	E = 0.0

	elif mode == 'weighted':
	E = alpha * alignment_term + (1 - alpha) * proximity_term

	elif mode == 'rbf':
	E = proximity_term # Pure proximity

	else:
	raise ValueError(f"Unknown mode: {mode}")

	return min(1.0, max(0.0, E))


	# Demonstration
	print("=" * 80)
	print("ELASTIC MODULUS: COSINE-ONLY vs. DISTANCE-AWARE")
	print("=" * 80)

	substrate = [(0.95, 0.92)]
	test_vectors = [
	(0.95, 0.92, "Substrate (exact match)"),
	(0.94, 0.91, "Very close, aligned"),
	(0.50, 0.50, "Medium distance, aligned"),
	(0.35, 0.30, "Far, aligned"),
	(0.10, 0.10, "Very far, aligned"),
	]

	print("\nSubstrate: (0.95, 0.92)")
	print("\n" + "-" * 80)
	print(f"{'Vector':<20} \| {'Distance':<10} \| {'E (cosine)':<12} \| {'E (mult.)':<12} \| {'E (harm.)':<12}")
	print("-" * 80)

	for x, y, label in test_vectors:
	# Cosine-only (current implementation)
	dot = x * substrate[0][0] + y * substrate[0][1]
	norm_v = math.sqrt(x 2 + y 2)
	norm_s = math.sqrt(substrate[0][0] 2 + substrate[0][1] 2)
	cos_sim = dot / (norm_v * norm_s) if norm_v > 0 and norm_s > 0 else 0
	E_cosine = (cos_sim + 1.0) / 2.0

	# Distance
	distance = math.sqrt((x - substrate[0][0]) 2 + (y - substrate[0][1]) 2)

	# Distance-aware modes
	E_mult = compute_elastic_modulus_distance_aware(
	(x, y), substrate, mode='multiplicative', sigma=0.5
	)
	E_harm = compute_elastic_modulus_distance_aware(
	(x, y), substrate, mode='harmonic', sigma=0.5
	)

	print(f"{label:<20} \| {distance:>8.4f} \| {E_cosine:>10.4f} \| {E_mult:>10.4f} \| {E_harm:>10.4f}")

	print("\n" + "=" * 80)
	print("ANALYSIS:")
	print("=" * 80)
	print("• Cosine-only: E ≈ 1.0 for all (saturated)")
	print("• Multiplicative: E reflects true grounding (distance × alignment)")
	print("• Harmonic: Balanced, requires both factors high")
	print("\nConclusion: Distance-aware E creates meaningful semantic classes,")
	print(" enabling the yield strength mechanism to work as intended.")
	print("=" * 80)

	"""
	Configuration Recommendation:
	-----------------------------

	For production deployment, use multiplicative coupling with tunable σ:

	config.json addition:
	{
	"elastic_modulus": {
	"mode": "multiplicative",
	"sigma": 0.5,
	"comment": "Gaussian kernel bandwidth for proximity term"
	}
	}

	Tuning guidelines:
	- Small σ (0.3): Tight substrate binding, only very close vectors get high E
	- Medium σ (0.5): Balanced, moderate proximity required
	- Large σ (1.0): Loose binding, distance matters less

	Different σ for different semantic classes:
	- Verified facts: σ = 0.3 (tight binding)
	- Contextual: σ = 0.5 (moderate)
	- Creative: σ = 0.8 (loose, allow exploration)

	This creates a "substrate field strength" model where different regions
	of semantic space have different binding characteristics.
	"""