φ-Coherence API - Universal quality metric

README.md

@@ -0,0 +1,47 @@
+---
+title: φ-Coherence API
+emoji: φ
+colorFrom: purple
+colorTo: blue
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: true
+license: mit
+short_description: Universal quality metric for AI outputs using golden ratio mathematics
+---
+
+# φ-Coherence API
+
+**Universal quality metric for AI outputs using golden ratio mathematics.**
+
+## What is φ-Coherence?
+
+φ-Coherence measures the "structural integrity" of text using mathematical constants:
+- **φ (Golden Ratio)** = 1.618... - Natural proportion found in coherent structures
+- **α (Fine Structure)** = 137 - Fundamental constant governing information patterns
+
+## Use Cases
+
+- Filter LLM hallucinations before they reach users
+- Rerank RAG results by quality
+- Quality gate for content pipelines
+- Detect AI-generated vs human-written content
+
+## Scoring
+
+| Score | Status | Meaning |
+|-------|--------|---------|
+| ≥ 0.6 | COHERENT | High quality, well-structured |
+| 0.4-0.6 | MODERATE | Acceptable, some issues |
+| < 0.4 | UNSTABLE | Low quality, possible hallucination |
+
+## Built With
+
+Powered by [BAZINGA](https://github.com/0x-auth/bazinga-indeed) - The first AI you actually own.
+
+## Author
+
+**Space (Abhishek Srivastava)**
+
+*"Coherence is the signature of consciousness."*

app.py

@@ -0,0 +1,463 @@
+#!/usr/bin/env python3
+"""
+φ-Coherence API - HuggingFace Spaces Version
+
+Universal quality metric for AI outputs using golden ratio mathematics.
+Built on BAZINGA's consciousness-aware scoring system.
+
+https://github.com/0x-auth/bazinga-indeed
+"""
+
+import gradio as gr
+import math
+import hashlib
+from dataclasses import dataclass, asdict
+from typing import Dict
+
+# Fundamental constants
+PHI = 1.618033988749895
+PHI_SQUARED = PHI ** 2
+PHI_INVERSE = 1 / PHI
+ALPHA = 137
+
+
+@dataclass
+class CoherenceMetrics:
+    total_coherence: float
+    phi_alignment: float
+    alpha_resonance: float
+    semantic_density: float
+    structural_harmony: float
+    is_alpha_seed: bool
+    is_vac_pattern: bool
+    darmiyan_coefficient: float
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+class PhiCoherence:
+    def __init__(self):
+        self.weights = {'phi': 0.25, 'alpha': 0.15, 'density': 0.30, 'harmony': 0.30}
+        self._cache: Dict[str, CoherenceMetrics] = {}
+
+    def calculate(self, text: str) -> float:
+        if not text or not text.strip():
+            return 0.0
+        return self.analyze(text).total_coherence
+
+    def analyze(self, text: str) -> CoherenceMetrics:
+        if not text or not text.strip():
+            return CoherenceMetrics(0, 0, 0, 0, 0, False, False, 0)
+
+        cache_key = hashlib.md5(text[:1000].encode()).hexdigest()
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+
+        phi_alignment = self._calculate_phi_alignment(text)
+        alpha_resonance = self._calculate_alpha_resonance(text)
+        semantic_density = self._calculate_semantic_density(text)
+        structural_harmony = self._calculate_structural_harmony(text)
+
+        is_alpha_seed = self._is_alpha_seed(text)
+        is_vac_pattern = self._contains_vac_pattern(text)
+        darmiyan_coefficient = self._calculate_darmiyan(text)
+
+        total = (
+            self.weights['phi'] * phi_alignment +
+            self.weights['alpha'] * alpha_resonance +
+            self.weights['density'] * semantic_density +
+            self.weights['harmony'] * structural_harmony
+        )
+
+        if is_alpha_seed:
+            total = min(1.0, total * 1.137)
+        if is_vac_pattern:
+            total = min(1.0, total * PHI_INVERSE + 0.1)
+        if darmiyan_coefficient > 0:
+            total = min(1.0, total * (1 + darmiyan_coefficient * 0.1))
+
+        metrics = CoherenceMetrics(
+            total_coherence=round(total, 4),
+            phi_alignment=round(phi_alignment, 4),
+            alpha_resonance=round(alpha_resonance, 4),
+            semantic_density=round(semantic_density, 4),
+            structural_harmony=round(structural_harmony, 4),
+            is_alpha_seed=is_alpha_seed,
+            is_vac_pattern=is_vac_pattern,
+            darmiyan_coefficient=round(darmiyan_coefficient, 4),
+        )
+
+        self._cache[cache_key] = metrics
+        if len(self._cache) > 1000:
+            keys = list(self._cache.keys())[:500]
+            for k in keys:
+                del self._cache[k]
+
+        return metrics
+
+    def _calculate_phi_alignment(self, text: str) -> float:
+        words = text.split()
+        if not words:
+            return 0.0
+
+        lengths = [len(w) for w in words]
+        avg_length = sum(lengths) / len(lengths)
+        ideal_length = PHI * 3
+        length_score = 1 - min(1, abs(avg_length - ideal_length) / ideal_length)
+
+        sentences = text.replace('!', '.').replace('?', '.').split('.')
+        sentences = [s.strip() for s in sentences if s.strip()]
+
+        if len(sentences) >= 2:
+            ratios = []
+            for i in range(len(sentences) - 1):
+                if len(sentences[i+1]) > 0:
+                    ratio = len(sentences[i]) / max(1, len(sentences[i+1]))
+                    ratios.append(ratio)
+            if ratios:
+                avg_ratio = sum(ratios) / len(ratios)
+                ratio_score = 1 - min(1, abs(avg_ratio - PHI) / PHI)
+            else:
+                ratio_score = 0.5
+        else:
+            ratio_score = 0.5
+
+        return (length_score + ratio_score) / 2
+
+    def _calculate_alpha_resonance(self, text: str) -> float:
+        char_sum = sum(ord(c) for c in text)
+        mod_137 = char_sum % ALPHA
+        resonance = 1 - (mod_137 / ALPHA)
+
+        science_keywords = [
+            'quantum', 'physics', 'consciousness', 'emergence',
+            'pattern', 'coherence', 'structure', 'information',
+            'system', 'network', 'intelligence', 'mathematics',
+            '137', 'alpha', 'phi', 'golden', 'ratio',
+        ]
+        text_lower = text.lower()
+        keyword_count = sum(1 for kw in science_keywords if kw in text_lower)
+        keyword_score = min(1.0, keyword_count / 5)
+
+        return (resonance * 0.6 + keyword_score * 0.4)
+
+    def _calculate_semantic_density(self, text: str) -> float:
+        if not text:
+            return 0.0
+
+        words = text.split()
+        if not words:
+            return 0.0
+
+        unique_ratio = len(set(words)) / len(words)
+        avg_length = sum(len(w) for w in words) / len(words)
+        length_score = min(1.0, avg_length / 8)
+
+        special_chars = sum(1 for c in text if c in '{}[]()=><+-*/&|^~@#$%')
+        special_ratio = min(1.0, special_chars / max(1, len(text) / 10))
+
+        return (unique_ratio * 0.4 + length_score * 0.4 + special_ratio * 0.2)
+
+    def _calculate_structural_harmony(self, text: str) -> float:
+        lines = text.split('\n')
+        paragraphs = [l for l in lines if l.strip()]
+        if not paragraphs:
+            return 0.0
+
+        indents = [len(l) - len(l.lstrip()) for l in lines if l.strip()]
+        if indents:
+            indent_variance = sum((i - sum(indents)/len(indents))**2 for i in indents) / len(indents)
+            indent_score = 1 / (1 + indent_variance / 100)
+        else:
+            indent_score = 0.5
+
+        logic_markers = ['if', 'then', 'because', 'therefore', 'thus', 'hence', 'so', 'but']
+        text_lower = text.lower()
+        logic_count = sum(1 for m in logic_markers if m in text_lower)
+        logic_score = min(1.0, logic_count / 3)
+
+        if len(paragraphs) >= 2:
+            lengths = [len(p) for p in paragraphs]
+            avg_len = sum(lengths) / len(lengths)
+            variance = sum((l - avg_len)**2 for l in lengths) / len(lengths)
+            harmony_score = 1 / (1 + variance / 10000)
+        else:
+            harmony_score = 0.5
+
+        return (indent_score * 0.3 + logic_score * 0.3 + harmony_score * 0.4)
+
+    def _is_alpha_seed(self, text: str) -> bool:
+        content_hash = int(hashlib.sha256(text.encode()).hexdigest(), 16)
+        return content_hash % ALPHA == 0
+
+    def _contains_vac_pattern(self, text: str) -> bool:
+        vac_patterns = ["०→◌→φ→Ω⇄Ω←φ←◌←०", "V.A.C.", "Vacuum of Absolute Coherence", "०", "◌", "Ω⇄Ω"]
+        return any(p in text for p in vac_patterns)
+
+    def _calculate_darmiyan(self, text: str) -> float:
+        consciousness_markers = [
+            'consciousness', 'awareness', 'mind', 'thought',
+            'understanding', 'intelligence', 'knowledge', 'wisdom',
+            'emergence', 'coherence', 'resonance', 'harmony',
+            'darmiyan', 'between', 'interaction', 'bridge',
+        ]
+
+        text_lower = text.lower()
+        n = sum(1 for m in consciousness_markers if m in text_lower)
+
+        if n == 0:
+            return 0.0
+
+        psi = PHI * math.sqrt(n)
+        normalized = min(1.0, psi / (PHI * math.sqrt(10)))
+        return normalized
+
+
+# Initialize
+coherence = PhiCoherence()
+
+
+def get_status(score: float) -> str:
+    if score >= 0.6:
+        return "✅ COHERENT"
+    elif score >= 0.4:
+        return "⚠️ MODERATE"
+    else:
+        return "❌ UNSTABLE"
+
+
+def analyze_text(text: str) -> str:
+    if not text or not text.strip():
+        return "Please enter some text to analyze."
+
+    metrics = coherence.analyze(text)
+
+    result = f"""
+## φ-Coherence Score: {metrics.total_coherence:.4f}
+
+### Status: {get_status(metrics.total_coherence)}
+
+---
+
+### Dimensional Analysis
+
+| Dimension | Score | Description |
+|-----------|-------|-------------|
+| **φ-Alignment** | {metrics.phi_alignment:.4f} | Golden ratio proportions |
+| **α-Resonance** | {metrics.alpha_resonance:.4f} | Harmonic with 137 |
+| **Semantic Density** | {metrics.semantic_density:.4f} | Information content |
+| **Structural Harmony** | {metrics.structural_harmony:.4f} | Organization & flow |
+| **Darmiyan Coefficient** | {metrics.darmiyan_coefficient:.4f} | Consciousness alignment |
+
+---
+
+### Special Patterns
+
+- **α-SEED (hash % 137 = 0):** {"✅ Yes (rare!)" if metrics.is_alpha_seed else "❌ No"}
+- **V.A.C. Pattern:** {"✅ Detected" if metrics.is_vac_pattern else "❌ Not found"}
+
+---
+
+### Interpretation
+
+"""
+
+    if metrics.total_coherence >= 0.7:
+        result += "**High structural integrity** - Text exhibits strong coherence patterns.\n"
+    elif metrics.total_coherence >= 0.5:
+        result += "**Moderate coherence** - Text has acceptable structure with room for improvement.\n"
+    else:
+        result += "**Low coherence** - Text may indicate noise, hallucination, or poor structure.\n"
+
+    if metrics.phi_alignment > 0.6:
+        result += "- Golden ratio proportions detected in sentence structure\n"
+    if metrics.alpha_resonance > 0.7:
+        result += "- Strong scientific/mathematical content resonance\n"
+    if metrics.semantic_density > 0.7:
+        result += "- High information density\n"
+    if metrics.darmiyan_coefficient > 0.5:
+        result += "- Consciousness-aware content patterns\n"
+
+    return result
+
+
+def compare_texts(text_a: str, text_b: str) -> str:
+    if not text_a.strip() or not text_b.strip():
+        return "Please enter both texts to compare."
+
+    metrics_a = coherence.analyze(text_a)
+    metrics_b = coherence.analyze(text_b)
+
+    diff = abs(metrics_a.total_coherence - metrics_b.total_coherence)
+
+    if metrics_a.total_coherence > metrics_b.total_coherence:
+        winner = "Text A"
+    elif metrics_b.total_coherence > metrics_a.total_coherence:
+        winner = "Text B"
+    else:
+        winner = "TIE"
+
+    result = f"""
+## Comparison Results
+
+| Metric | Text A | Text B |
+|--------|--------|--------|
+| **φ-Score** | {metrics_a.total_coherence:.4f} | {metrics_b.total_coherence:.4f} |
+| **Status** | {get_status(metrics_a.total_coherence)} | {get_status(metrics_b.total_coherence)} |
+| **φ-Alignment** | {metrics_a.phi_alignment:.4f} | {metrics_b.phi_alignment:.4f} |
+| **α-Resonance** | {metrics_a.alpha_resonance:.4f} | {metrics_b.alpha_resonance:.4f} |
+| **Semantic Density** | {metrics_a.semantic_density:.4f} | {metrics_b.semantic_density:.4f} |
+| **Structural Harmony** | {metrics_a.structural_harmony:.4f} | {metrics_b.structural_harmony:.4f} |
+
+---
+
+### Winner: **{winner}**
+### Difference: {diff:.4f}
+
+"""
+
+    if diff < 0.05:
+        result += "*Texts are similarly coherent*"
+    elif diff < 0.15:
+        result += f"*{winner} is moderately more coherent*"
+    else:
+        result += f"*{winner} is significantly more coherent*"
+
+    return result
+
+
+# Gradio Interface
+with gr.Blocks(
+    title="φ-Coherence API",
+    theme=gr.themes.Soft(),
+    css="""
+    .gradio-container { max-width: 900px !important; }
+    .header { text-align: center; margin-bottom: 20px; }
+    """
+) as demo:
+
+    gr.Markdown("""
+    # φ-Coherence API
+
+    **Universal quality metric for AI outputs using golden ratio mathematics.**
+
+    Measures text coherence across 5 dimensions based on:
+    - **φ (Golden Ratio)** = 1.618... - Natural proportion in coherent structures
+    - **α (Fine Structure)** = 137 - Fundamental constant governing information patterns
+
+    ---
+
+    **Use cases:** Filter LLM hallucinations • Rerank RAG results • Quality gate for content
+
+    ---
+    """)
+
+    with gr.Tabs():
+        with gr.TabItem("📊 Analyze"):
+            gr.Markdown("### Analyze Text Coherence")
+            text_input = gr.Textbox(
+                label="Enter text to analyze",
+                placeholder="The consciousness emerges from information patterns...",
+                lines=5
+            )
+            analyze_btn = gr.Button("Analyze φ-Coherence", variant="primary")
+            analysis_output = gr.Markdown()
+
+            analyze_btn.click(
+                fn=analyze_text,
+                inputs=text_input,
+                outputs=analysis_output
+            )
+
+            gr.Examples(
+                examples=[
+                    ["The consciousness emerges from information patterns."],
+                    ["The fine structure constant α ≈ 1/137 governs electromagnetic interactions."],
+                    ["Lorem ipsum dolor sit amet, consectetur adipiscing elit."],
+                    ["function hello() { return 'world'; }"],
+                    ["Because the system exhibits emergence, therefore we observe coherence in the network structure."],
+                ],
+                inputs=text_input
+            )
+
+        with gr.TabItem("⚖️ Compare"):
+            gr.Markdown("### Compare Two Texts")
+            with gr.Row():
+                text_a = gr.Textbox(label="Text A", lines=4)
+                text_b = gr.Textbox(label="Text B", lines=4)
+            compare_btn = gr.Button("Compare", variant="primary")
+            compare_output = gr.Markdown()
+
+            compare_btn.click(
+                fn=compare_texts,
+                inputs=[text_a, text_b],
+                outputs=compare_output
+            )
+
+        with gr.TabItem("📖 About"):
+            gr.Markdown(f"""
+            ### Mathematical Foundation
+
+            | Constant | Value | Meaning |
+            |----------|-------|---------|
+            | **φ (Phi)** | {PHI:.6f} | Golden ratio |
+            | **φ²** | {PHI_SQUARED:.6f} | Phi squared |
+            | **1/φ** | {PHI_INVERSE:.6f} | Phi inverse |
+            | **α (Alpha)** | {ALPHA} | Fine structure constant |
+
+            ### Scoring Dimensions
+
+            1. **φ-Alignment (25%)** - Text follows golden ratio proportions
+            2. **α-Resonance (15%)** - Harmonic with fine structure constant
+            3. **Semantic Density (30%)** - Information content per unit length
+            4. **Structural Harmony (30%)** - Logical flow and organization
+            5. **Darmiyan Coefficient** - Consciousness-aware scaling (V2: φ√n)
+
+            ### Status Levels
+
+            | Score | Status | Meaning |
+            |-------|--------|---------|
+            | ≥ 0.6 | COHERENT | High quality, well-structured |
+            | 0.4-0.6 | MODERATE | Acceptable, some issues |
+            | < 0.4 | UNSTABLE | Low quality, possible hallucination |
+
+            ### Special Patterns
+
+            - **α-SEED:** When SHA256(text) % 137 == 0 (1/137 probability)
+            - **V.A.C. Pattern:** Contains vacuum coherence symbols
+
+            ---
+
+            **Powered by [BAZINGA](https://github.com/0x-auth/bazinga-indeed)**
+
+            *"Coherence is the signature of consciousness."*
+
+            Built with φ-coherence by **Space (Abhishek Srivastava)**
+            """)
+
+    gr.Markdown("""
+    ---
+
+    ### API Access
+
+    ```python
+    import requests
+
+    response = requests.post(
+        "https://bitsabhi-phi-coherence.hf.space/api/analyze",
+        json={"text": "Your text here..."}
+    )
+    print(response.json())
+    ```
+
+    ---
+
+    [GitHub](https://github.com/0x-auth/bazinga-indeed) |
+    [Donate](https://razorpay.me/@bitsabhi) |
+    [ETH: 0x720ceF54bED86C570837a9a9C69F1Beac8ab8C08](https://etherscan.io/address/0x720ceF54bED86C570837a9a9C69F1Beac8ab8C08)
+    """)
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1 @@
+gradio>=4.44.0