"""Passive response contracts. Classical Schur/Dirichlet tools, used explicitly.

Numerical certificates are floating point checks, not interval arithmetic proofs.
All matrices describe real, reciprocal, passive DC networks. A ground is fixed
before generalized eigenvalue calculations; no singular inverse is hidden.
"""
import numpy as np
from scipy.linalg import eigh
from scipy.sparse import coo_matrix
from scipy.sparse.linalg import spsolve


def laplacian(n, edges, conductances):
    edges = np.asarray(edges, dtype=int)
    g = np.asarray(conductances, dtype=float)
    if np.any(g < 0):
        raise ValueError("Passive conductances must be nonnegative")
    u, v = edges.T
    return coo_matrix((np.r_[g, g, -g, -g],
                       (np.r_[u, v, u, v], np.r_[u, v, v, u])),
                      shape=(n, n)).tocsr()


def kron(L, ports):
    L = L.toarray() if hasattr(L, 'toarray') else np.asarray(L)
    p = np.asarray(ports, dtype=int)
    interior = np.setdiff1d(np.arange(len(L)), p)
    D = L[np.ix_(p, p)].copy()
    if len(interior):
        cross = L[np.ix_(p, interior)]
        D -= cross @ np.linalg.solve(L[np.ix_(interior, interior)], cross.T)
    return (D + D.T) / 2


def relative_spectrum(D, target):
    """Ground the last port; target must be connected on its port space."""
    return eigh(D[:-1, :-1], target[:-1, :-1], eigvals_only=True)


def conductance(n, edges, g, left, right):
    L = laplacian(n, edges, g)
    fixed = np.r_[left, right].astype(int)
    free = np.setdiff1d(np.arange(n), fixed)
    V = np.zeros(n); V[left] = 1.
    if len(free):
        V[free] = spsolve(L[free][:, free], -L[free][:, fixed] @ V[fixed])
    drop = V[np.asarray(edges)[:, 0]] - V[np.asarray(edges)[:, 1]]
    return float(np.dot(g, drop * drop))


def scalar_gate(measured_ratio, measurement_radius, eta, seal_bound):
    """A pre-seal certificate covering all multiplicative seal changes ±bound."""
    return ((measured_ratio - measurement_radius) * (1-seal_bound) >= 1-eta) & \
           ((measured_ratio + measurement_radius) * (1+seal_bound) <= 1+eta)


def gaussian_radius(sigma, sample_count, modules, inspections, delta):
    """Union bound over a FIXED finite maximum number of adaptive inspections.

    Fresh conditionally zero-mean sigma-sub-Gaussian measurement errors are
    required at each inspection. Systematic calibration bias is not covered.
    """
    return float(sigma * np.sqrt(2*np.log(2*modules*inspections/delta)/sample_count))


def completion_rounds(modules, per_round_success, delta):
    if not 0 < per_round_success < 1:
        raise ValueError("Require success probability strictly between zero and one")
    return int(np.ceil(np.log(modules/delta)/-np.log1p(-per_round_success)))


def assemble_responses(local, port_maps, global_nodes, external):
    L = np.zeros((global_nodes, global_nodes))
    for D, p in zip(local, port_maps):
        L[np.ix_(p, p)] += D
    return kron(L, external)


def energy_weights(n, edges, target, left, right):
    """Target power participation weights for one terminal experiment."""
    L=laplacian(n,edges,target)
    fixed=np.r_[left,right].astype(int); free=np.setdiff1d(np.arange(n),fixed)
    V=np.zeros(n); V[left]=1.
    V[free]=spsolve(L[free][:,free],-L[free][:,fixed]@V[fixed])
    d=V[np.asarray(edges)[:,0]]-V[np.asarray(edges)[:,1]]
    e=target*d*d
    return e/e.sum()


def weighted_response_bounds(weights, conductance_ratio):
    ratio=np.asarray(conductance_ratio)
    if np.any(ratio<=0):
        raise ValueError('Positive surviving conductance required for finite flow bound')
    return float(1/np.sum(weights/ratio)), float(np.dot(weights,ratio))