#!/usr/bin/env python3 """ Dark Counterpart Analysis: Find TSE False Negatives This script finds cases where TSE says "different" but they're actually similar: 1. Cases where TSE says dissimilar (<60%) but alternative analysis shows relationship 2. Temperaments with different comma patterns but similar musical character 3. Well-temperaments that TSE misclassifies 4. Cases where musical relationship exists but TSE misses it Supports parameterized weighting schemes via --weighting-scheme or custom weights. Output: JSON results and text report with timestamp and weighting scheme identifier """ import json import sys import urllib.request import math import argparse from typing import List, Dict, Optional from collections import defaultdict from datetime import datetime # Import weighting config loader try: from weighting_config_loader import ( load_weighting_config, parse_weighting_args, add_weighting_args ) # Import component similarity functions from disprove script import sys import os sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from disprove_tse_similarity import ( calculate_fifth_similarity, calculate_third_similarity, calculate_comma_similarity, calculate_weighted_similarity, compute_thirds ) except ImportError: print("Warning: Could not import weighting_config_loader or similarity functions.") def load_weighting_config(): return {'weighting_schemes': {}, 'default_scheme': 'tse_standard'} def parse_weighting_args(args, config=None): return {'id': 'tse_standard', 'name': 'TSE Standard', 'fifths': 0.50, 'thirds': 0.25, 'commas': 0.25}, 'tse_standard' def add_weighting_args(parser): pass # Fallback similarity functions def calculate_fifth_similarity(f1, f2): return 0.5 def calculate_third_similarity(t1, t2): return 0.5 def calculate_comma_similarity(result): return 0.5 def calculate_weighted_similarity(f1, f2, t1, t2, result, scheme): return 0.5, 0.5, 0.5, 0.5 def compute_thirds(dev): return [400.0] * 12 BASE_URL = "http://localhost:8000" API_BASE = f"{BASE_URL}/api_temperament_similarity.php" PURE_FIFTH = 701.955000865387 def fetch_temperaments(source: str) -> List[Dict]: """Fetch all temperaments from a specific source.""" url = f"{BASE_URL}/api_temperaments_table.php?source={source}°=12&limit=10000" try: with urllib.request.urlopen(url, timeout=30) as response: data = json.loads(response.read().decode('utf-8')) if data.get('ok') and 'items' in data: return data['items'] except Exception as e: print(f"Error fetching {source}: {e}") return [] def get_temperament_deviations(temperament_id: int) -> Optional[List[float]]: """Get deviations for a temperament.""" url = f"{API_BASE}?temperament_id={temperament_id}&pattern=1" try: with urllib.request.urlopen(url, timeout=10) as response: data = json.loads(response.read().decode('utf-8')) if data.get('ok') and 'deviations' in data: return data['deviations'] except: pass return None def compute_fifths(deviations: List[float]) -> List[float]: """Compute all 12 fifths from deviations.""" base_cents = [0.0, 100.0, 200.0, 300.0, 400.0, 500.0, 600.0, 700.0, 800.0, 900.0, 1000.0, 1100.0] offsets = [base_cents[i] + deviations[i] for i in range(12)] fifths = [] for i in range(12): j = (i + 7) % 12 diff = offsets[j] - offsets[i] if diff < 0: diff += 1200.0 fifths.append(diff) return fifths def is_well_temperament(fifths: List[float]) -> bool: """Check if temperament is well-temperament (circulating, no wolf).""" # Well-temperament: all fifths are reasonable (not extremely narrow/wide) # No wolf fifth (one extremely different) min_fifth = min(fifths) max_fifth = max(fifths) range_fifth = max_fifth - min_fifth # Well-temperament typically has range < 20 cents # And no single fifth is extremely different avg_fifth = sum(fifths) / 12.0 deviations = [abs(f - avg_fifth) for f in fifths] max_dev = max(deviations) return range_fifth < 20.0 and max_dev < 15.0 def is_meantone(fifths: List[float]) -> bool: """Check if temperament is meantone-like.""" avg_fifth = sum(fifths) / 12.0 avg_deviation = avg_fifth - PURE_FIFTH # Meantone: negative average deviation, low variance if avg_deviation >= 0: return False variance = sum((f - avg_fifth) ** 2 for f in fifths) / 12.0 std_dev = math.sqrt(variance) return std_dev < 2.5 def structural_similarity(fifths1: List[float], fifths2: List[float]) -> float: """Measure structural similarity (pattern, not magnitude).""" # Normalize by subtracting mean mean1 = sum(fifths1) / 12.0 mean2 = sum(fifths2) / 12.0 norm1 = [f - mean1 for f in fifths1] norm2 = [f - mean2 for f in fifths2] # Cosine similarity of normalized vectors dot_product = sum(a * b for a, b in zip(norm1, norm2)) magnitude1 = math.sqrt(sum(a * a for a in norm1)) magnitude2 = math.sqrt(sum(a * a for a in norm2)) if magnitude1 == 0 or magnitude2 == 0: return 0.0 return dot_product / (magnitude1 * magnitude2) def compare_temperaments_tse(id1: int, id2: int) -> Optional[Dict]: """Get TSE comparison result.""" url = f"{API_BASE}?temperament_id1={id1}&temperament_id2={id2}" try: with urllib.request.urlopen(url, timeout=10) as response: data = json.loads(response.read().decode('utf-8')) if data.get('ok'): return data except: pass return None def find_false_negatives(temperaments: List[Dict], weighting_scheme: Dict) -> Dict: """Find cases where TSE says different but they're actually similar.""" print("\n" + "="*70) print("FINDING TSE FALSE NEGATIVES") print("="*70) results = { 'tse_dissimilar_but_related': [], 'different_patterns_same_family': [], 'well_temperament_misclassifications': [], 'structural_similarity_missed': [] } sample = temperaments print(f"\nAnalyzing {len(sample)} temperaments...") for i, temp1 in enumerate(sample): if i % 5 == 0: print(f" Progress: {i}/{len(sample)}") dev1 = get_temperament_deviations(temp1['id']) if not dev1 or len(dev1) != 12: continue fifths1 = compute_fifths(dev1) is_wt1 = is_well_temperament(fifths1) is_mt1 = is_meantone(fifths1) for temp2 in sample[i+1:]: dev2 = get_temperament_deviations(temp2['id']) if not dev2 or len(dev2) != 12: continue fifths2 = compute_fifths(dev2) is_wt2 = is_well_temperament(fifths2) is_mt2 = is_meantone(fifths2) # Get TSE comparison tse_result = compare_temperaments_tse(temp1['id'], temp2['id']) if not tse_result: continue # Calculate weighted similarity using specified weighting scheme thirds1 = compute_thirds(dev1) thirds2 = compute_thirds(dev2) tse_similarity, _, _, _ = calculate_weighted_similarity( fifths1, fifths2, thirds1, thirds2, tse_result, weighting_scheme ) # Case 1: TSE says dissimilar but they're both well-temperaments if tse_similarity < 0.60 and is_wt1 and is_wt2: # Check structural similarity struct_sim = structural_similarity(fifths1, fifths2) if struct_sim > 0.70: results['tse_dissimilar_but_related'].append({ 'temp1_name': temp1['name'], 'temp2_name': temp2['name'], 'tse_similarity': tse_similarity, 'structural_similarity': struct_sim, 'both_well_temperaments': True, 'description': 'TSE says dissimilar but both are well-temperaments with high structural similarity' }) # Case 2: Different comma patterns but same family (meantone) if tse_similarity < 0.60 and is_mt1 and is_mt2: # Both meantone but TSE says different avg1 = sum(fifths1) / 12.0 avg2 = sum(fifths2) / 12.0 # If both are meantone-like, they're related if abs(avg1 - avg2) < 2.0: # Similar average results['different_patterns_same_family'].append({ 'temp1_name': temp1['name'], 'temp2_name': temp2['name'], 'tse_similarity': tse_similarity, 'avg_fifth1': avg1, 'avg_fifth2': avg2, 'description': 'Both meantone but TSE classifies as different' }) # Case 3: Structural similarity but TSE misses it struct_sim = structural_similarity(fifths1, fifths2) if struct_sim > 0.75 and tse_similarity < 0.65: results['structural_similarity_missed'].append({ 'temp1_name': temp1['name'], 'temp2_name': temp2['name'], 'tse_similarity': tse_similarity, 'structural_similarity': struct_sim, 'description': 'High structural similarity but TSE says dissimilar' }) return results def generate_report(results: Dict, weighting_scheme: Dict) -> str: """Generate human-readable report.""" report = [] report.append("="*70) report.append("DARK COUNTERPART: FINDING TSE FALSE NEGATIVES") report.append("="*70) report.append("") report.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") report.append("") # TSE Dissimilar But Related report.append("CASE 1: TSE SAYS DISSIMILAR BUT THEY'RE RELATED") report.append("-"*70) cases = results.get('tse_dissimilar_but_related', []) report.append(f"Found {len(cases)} cases where TSE says dissimilar (<60%)") report.append("but both temperaments are well-temperaments with high structural similarity.") report.append("") if cases: for i, case in enumerate(cases[:10], 1): report.append(f"{i}. {case['temp1_name']} ↔ {case['temp2_name']}") report.append(f" TSE Similarity: {case['tse_similarity']:.1%}") report.append(f" Structural Similarity: {case['structural_similarity']:.1%}") report.append("") # Different Patterns Same Family report.append("CASE 2: DIFFERENT PATTERNS BUT SAME FAMILY") report.append("-"*70) family_cases = results.get('different_patterns_same_family', []) report.append(f"Found {len(family_cases)} cases where both are meantone") report.append("but TSE classifies as different due to different comma fractions.") report.append("") if family_cases: for i, case in enumerate(family_cases[:10], 1): report.append(f"{i}. {case['temp1_name']} ↔ {case['temp2_name']}") report.append(f" TSE Similarity: {case['tse_similarity']:.1%}") report.append(f" Avg Fifth 1: {case['avg_fifth1']:.2f} cents") report.append(f" Avg Fifth 2: {case['avg_fifth2']:.2f} cents") report.append("") # Structural Similarity Missed report.append("CASE 3: STRUCTURAL SIMILARITY MISSED BY TSE") report.append("-"*70) struct_cases = results.get('structural_similarity_missed', []) report.append(f"Found {len(struct_cases)} cases with high structural similarity") report.append("but TSE says dissimilar.") report.append("") if struct_cases: for i, case in enumerate(struct_cases[:10], 1): report.append(f"{i}. {case['temp1_name']} ↔ {case['temp2_name']}") report.append(f" TSE Similarity: {case['tse_similarity']:.1%}") report.append(f" Structural Similarity: {case['structural_similarity']:.1%}") report.append("") # Summary report.append("="*70) report.append("SUMMARY") report.append("="*70) report.append("") report.append("The TSE misses relationships that are musically meaningful:") report.append("1. Well-temperament family relationships") report.append("2. Meantone family relationships (different fractions)") report.append("3. Structural similarities (pattern, not magnitude)") report.append("") report.append("CONCLUSION: TSE's focus on exact comma fractions and weighted") report.append("similarity causes it to miss broader temperament family relationships.") return "\n".join(report) def main(): global BASE_URL, API_BASE # Parse command-line arguments parser = argparse.ArgumentParser( description='Dark Counterpart Analysis: Find TSE False Negatives' ) add_weighting_args(parser) parser.add_argument('--base-url', type=str, default=BASE_URL, help=f'Base URL for API (default: {BASE_URL})') args = parser.parse_args() # Update BASE_URL if specified if args.base_url: BASE_URL = args.base_url API_BASE = f"{BASE_URL}/api_temperament_similarity.php" # Load weighting scheme try: config = load_weighting_config() weighting_scheme, scheme_id = parse_weighting_args(args, config) except Exception as e: print(f"Warning: Could not load weighting config: {e}") print("Using default TSE standard weighting.") weighting_scheme = {'id': 'tse_standard', 'name': 'TSE Standard', 'fifths': 0.50, 'thirds': 0.25, 'commas': 0.25} scheme_id = 'tse_standard' print("="*70) print("DARK COUNTERPART: FINDING TSE FALSE NEGATIVES") print("="*70) print(f"Weighting Scheme: {weighting_scheme['name']} ({int(weighting_scheme['fifths']*100)}/{int(weighting_scheme['thirds']*100)}/{int(weighting_scheme['commas']*100)})") if BASE_URL == "http://localhost": print("\n⚠ WARNING: BASE_URL is set to localhost") response = input("\nContinue anyway? (y/n): ") if response.lower() != 'y': sys.exit(1) # Fetch datasets print("\n" + "="*70) print("FETCHING DATASETS") print("="*70) fred_temps = fetch_temperaments('Fred') chip2_temps = fetch_temperaments('Chip2') all_temps = fred_temps + chip2_temps if not all_temps: print("\n❌ Error: Could not fetch datasets.") sys.exit(1) # Find false negatives results = find_false_negatives(all_temps, weighting_scheme) # Generate report report = generate_report(results, weighting_scheme) print("\n" + report) # Save results timestamp = datetime.now().strftime('%Y%m%d_%H%M%S') json_output = { 'timestamp': timestamp, 'weighting_scheme': { 'id': weighting_scheme.get('id', scheme_id), 'name': weighting_scheme['name'], 'fifths': weighting_scheme['fifths'], 'thirds': weighting_scheme['thirds'], 'commas': weighting_scheme['commas'] }, 'false_negatives': results } # Include scheme in filename json_file = f"scripts/find_tse_false_negatives_{timestamp}_{scheme_id}.json" with open(json_file, 'w') as f: json.dump(json_output, f, indent=2) print(f"\n✓ JSON results saved to: {json_file}") report_file = f"scripts/find_tse_false_negatives_{timestamp}_{scheme_id}.txt" with open(report_file, 'w') as f: f.write(report) print(f"✓ Text report saved to: {report_file}") print("\n" + "="*70) if __name__ == "__main__": main()

!/usr/bin/env python3

⚠️ Experimental Content