app.py

"""
app.py — HuggingFace Gradio Space
Sri Yantra — Quantum Field Visualizer (Full Version)
vedic-logic.blogspot.com | Branch 2: Simulation Theory
"""

import matplotlib
matplotlib.use('Agg')

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import LinearSegmentedColormap
import gradio as gr
import io
from PIL import Image


# ─── Vedic color palette ────────────────────────────────────────────
VEDIC_CMAP = LinearSegmentedColormap.from_list('vedic', [
    '#0a0010','#1a0030','#4b0082','#8b0000',
    '#cc4400','#ff8c00','#ffd700','#ffffff'], N=256)


# ─── Geometry ───────────────────────────────────────────────────────

def triangle_verts(cx, cy, r, pointing='up'):
    offset = np.pi if pointing == 'down' else 0
    angles = [np.pi/2 + offset + i*2*np.pi/3 for i in range(3)]
    return np.array([(cx + r*np.cos(a), cy + r*np.sin(a)) for a in angles])

SHIVA_PARAMS  = [(0.00,0.95,1),(0.10,0.60,3),(-0.05,0.38,5),(0.08,0.22,7)]
SHAKTI_PARAMS = [(-0.08,0.85,2),(0.00,0.65,4),(-0.10,0.48,6),(0.05,0.32,8),(-0.02,0.18,9)]

def get_triangles():
    tris = []
    for cy,r,layer in SHIVA_PARAMS:
        tris.append({'v': triangle_verts(0,cy,r,'up'),   'type':'shiva',  'layer':layer})
    for cy,r,layer in SHAKTI_PARAMS:
        tris.append({'v': triangle_verts(0,cy,r,'down'), 'type':'shakti', 'layer':layer})
    return sorted(tris, key=lambda t: t['layer'])

def lotus(n, r_in, r_out):
    petals = []
    for i in range(n):
        a = 2*np.pi*i/n
        t = np.linspace(0, 2*np.pi, 60)
        px = 0.15*np.cos(t)
        py = (r_out-r_in)/2*np.sin(t) + (r_in+r_out)/2
        R = np.array([[np.cos(a),-np.sin(a)],[np.sin(a),np.cos(a)]])
        c = R @ np.array([px, py])
        petals.append((c[0], c[1]))
    return petals

def outer_square(s=1.45, g=0.18):
    lines = []
    for si in [s, s-0.08]:
        sq = np.array([[-si,-si],[si,-si],[si,si],[-si,si],[-si,-si]])
        lines.append((sq[:,0], sq[:,1]))
    for a in [0, np.pi/2, np.pi, 3*np.pi/2]:
        R = np.array([[np.cos(a),-np.sin(a)],[np.sin(a),np.cos(a)]])
        st = R @ np.array([[0,0],[s,s+g]]).T
        cr = R @ np.array([[-g,g],[s+g,s+g]]).T
        lines.append((st[0],st[1]))
        lines.append((cr[0],cr[1]))
    return lines

def seg_intersect(p1,p2,p3,p4):
    d1,d2 = p2-p1, p4-p3
    cross = d1[0]*d2[1]-d1[1]*d2[0]
    if abs(cross)<1e-10: return None
    t = ((p3[0]-p1[0])*d2[1]-(p3[1]-p1[1])*d2[0])/cross
    u = ((p3[0]-p1[0])*d1[1]-(p3[1]-p1[1])*d1[0])/cross
    if 0<=t<=1 and 0<=u<=1: return p1+t*d1
    return None

def intersections(tris):
    edges = []
    for tri in tris:
        v = tri['v']
        for i in range(3): edges.append((v[i], v[(i+1)%3]))
    pts = []
    for i in range(len(edges)):
        for j in range(i+1, len(edges)):
            pt = seg_intersect(np.array(edges[i][0]),np.array(edges[i][1]),
                               np.array(edges[j][0]),np.array(edges[j][1]))
            if pt is not None: pts.append(pt)
    return np.array(pts) if pts else np.empty((0,2))


# ─── Quantum ────────────────────────────────────────────────────────

def qubit(tri_type, layer, phase=0.0):
    ln = layer/9.0
    if tri_type == 'shiva':
        a = np.cos(ln*np.pi/2)*np.exp(1j*phase)
        b = np.sin(ln*np.pi/2)*np.exp(1j*(phase+np.pi/4))
    else:
        a = np.sin(ln*np.pi/2)*np.exp(1j*phase)
        b = np.cos(ln*np.pi/2)*np.exp(1j*(phase+np.pi/4))
    n = np.sqrt(abs(a)**2+abs(b)**2)
    return a/n, b/n

def get_states(phase=0.0):
    return [{'layer':t['layer'],'type':t['type'],
             **dict(zip(['alpha','beta'], qubit(t['type'],t['layer'],phase))),
             'prob_0':abs(qubit(t['type'],t['layer'],phase)[0])**2,
             'prob_1':abs(qubit(t['type'],t['layer'],phase)[1])**2}
            for t in get_triangles()]

def interference(res=120, phase=0.0):
    x = np.linspace(-1.2,1.2,res)
    y = np.linspace(-1.2,1.2,res)
    X,Y = np.meshgrid(x,y)
    Z = np.zeros_like(X, dtype=complex)
    tris = get_triangles()
    states = get_states(phase)
    for tri,state in zip(tris,states):
        cx,cy = tri['v'].mean(axis=0)
        r = np.sqrt((X-cx)**2+(Y-cy)**2)+1e-6
        amp = state['alpha']-state['beta']
        k = 2*np.pi*(tri['layer']/3.0)
        Z += amp*np.exp(1j*k*r)/r
    return X,Y,np.abs(Z)**2

def bindu_state(phase=0.0):
    states = get_states(phase)
    ta = sum(s['alpha'] for s in states)
    tb = sum(s['beta']  for s in states)
    n = np.sqrt(abs(ta)**2+abs(tb)**2)
    return ta/n, tb/n


# ─── Renderer ───────────────────────────────────────────────────────

def render(phase_shift, show_quantum, show_entangle, show_labels):
    fig, ax = plt.subplots(figsize=(8,8), facecolor='#0d0010')
    ax.set_facecolor('#0d0010')
    ax.set_aspect('equal')
    ax.axis('off')
    ax.set_xlim(-1.8,1.8)
    ax.set_ylim(-1.8,1.8)

    # Quantum heatmap
    if show_quantum:
        try:
            X,Y,Z = interference(res=120, phase=phase_shift)
            ax.contourf(X,Y,Z, levels=20, cmap=VEDIC_CMAP, alpha=0.5, zorder=1)
        except Exception:
            pass

    # Bhupura
    for lx,ly in outer_square():
        ax.plot(lx,ly, color='#DAA520', linewidth=1.1, zorder=3)

    # Circles
    t = np.linspace(0,2*np.pi,200)
    for r,a in [(1.18,0.9),(1.10,0.7),(1.02,0.5)]:
        ax.plot(r*np.cos(t),r*np.sin(t), color='#DAA520', linewidth=0.8, alpha=a, zorder=3)

    # Lotus
    for xp,yp in lotus(16,0.92,1.08):
        ax.fill(xp,yp, color='#cc4400', alpha=0.12, zorder=2)
        ax.plot(xp,yp, color='#ff6a00', linewidth=0.5, alpha=0.5, zorder=3)
    for xp,yp in lotus(8,0.75,0.92):
        ax.fill(xp,yp, color='#8b0000', alpha=0.15, zorder=2)
        ax.plot(xp,yp, color='#cc2200', linewidth=0.6, alpha=0.6, zorder=3)

    # Triangles
    tris   = get_triangles()
    states = get_states(phase_shift)
    for tri,state in zip(tris,states):
        color = '#FF6B35' if tri['type']=='shiva' else '#C2185B'
        ax.add_patch(plt.Polygon(tri['v'], closed=True, fill=True,
                                 facecolor=color, alpha=0.20+0.07*state['prob_0'],
                                 edgecolor=color, linewidth=1.4, zorder=4))

    # Entanglement nodes
    if show_entangle:
        pts = intersections(tris)
        if len(pts)>0:
            ax.scatter(pts[:,0],pts[:,1], s=6, c='#FFD700', alpha=0.7, zorder=6, linewidths=0)

    # Bindu
    ax.add_patch(plt.Circle((0,0),0.10, color='#FFD700', alpha=0.3, zorder=7))
    ax.add_patch(plt.Circle((0,0),0.04, color='#FFFFFF', zorder=8))

    # Labels
    if show_labels:
        ls = dict(color='#FFD700', fontsize=7, ha='center', va='center',
                  fontfamily='monospace', zorder=10,
                  bbox=dict(boxstyle='round,pad=0.2', fc='#0d0010', ec='#FFD700', alpha=0.7, lw=0.6))
        ax.text(0,0.06,'BINDU', fontsize=6, color='white', ha='center', va='center', zorder=11)
        ax.text(0,-1.55,'BHUPURA  <->  Boundary Conditions', **ls)
        ax.text(-1.6,0,'SHIVA\n|0>', **ls)
        ax.text( 1.6,0,'SHAKTI\n|1>', **ls)

    fig.text(0.5,0.97,'SRI YANTRA  <->  QUANTUM FIELD',
             ha='center', color='#FFD700', fontsize=12, fontweight='bold', fontfamily='monospace')
    fig.text(0.5,0.02,f'Phase: {phase_shift:.2f} rad  |  vedic-logic.blogspot.com',
             ha='center', color='#888888', fontsize=8, fontfamily='monospace')

    plt.tight_layout(pad=0)
    buf = io.BytesIO()
    fig.savefig(buf, format='png', dpi=120, bbox_inches='tight', facecolor='#0d0010')
    buf.seek(0)
    plt.close(fig)
    return Image.open(buf)


def make_table(phase_shift):
    states = get_states(phase_shift)
    names  = ["Sarva Siddhi Prada","Sarva Shakti Mayi","Sarva Raksha Kara",
              "Sarva Rogahara","Sarva Siddhimaya","Sarva Anandamaya",
              "Sarva Raksha Kara II","Sarva Siddhiprada","Bindu Mandala"]
    rows = ["| Layer | Type | P(0) | P(1) | Vedic Name |",
            "|-------|------|------|------|------------|"]
    for i,s in enumerate(states):
        t = "Shiva" if s['type']=='shiva' else "Shakti"
        rows.append(f"| {s['layer']} | {t} | {s['prob_0']:.3f} | {s['prob_1']:.3f} | {names[i]} |")
    a,b = bindu_state(phase_shift)
    rows.append(f"\n**Bindu:** P(0)={abs(a)**2:.3f}  P(1)={abs(b)**2:.3f}")
    return "\n".join(rows)


# ─── Gradio UI ──────────────────────────────────────────────────────

with gr.Blocks(title="Vedic Simulation Visualizer") as demo:

    gr.Markdown("""
    # 🕉 Sri Yantra — Quantum Field Visualizer
    **vedic-logic.blogspot.com** | Branch 2: Simulation Theory

    Sri Yantra encodes a **9-qubit quantum register** in sacred geometry.
    Adjust phase shift to animate quantum interference patterns.
    """)

    with gr.Row():
        with gr.Column(scale=1):
            phase   = gr.Slider(0, 6.28, value=0.0, step=0.1,
                                label="Quantum Phase Shift (0 to 2pi)")
            show_q  = gr.Checkbox(value=True,  label="Show Interference Field")
            show_e  = gr.Checkbox(value=True,  label="Show Entanglement Nodes")
            show_l  = gr.Checkbox(value=True,  label="Show Labels")
            btn     = gr.Button("🔮 Render Yantra", variant="primary")
        with gr.Column(scale=2):
            img_out = gr.Image(label="Sri Yantra", type="pil")

    tbl_out = gr.Markdown()

    btn.click(fn=render,     inputs=[phase,show_q,show_e,show_l], outputs=img_out)
    btn.click(fn=make_table, inputs=[phase],                       outputs=tbl_out)

    gr.Markdown("""
    ---
    ### Vedic to Quantum Mapping
    | Vedic Concept | Quantum Equivalent |
    |---|---|
    | Bindu | Wave function collapse |
    | 4 Shiva triangles | Qubit 0 basis |
    | 5 Shakti triangles | Qubit 1 basis |
    | Intersection points | Entanglement nodes |
    | Phase shift | Time evolution |
    | Sri Yantra whole | Hilbert space manifold |

    vedic-logic.blogspot.com | github.com/kalpeshnitore/vedic-simulation
    """)

demo.launch()