"""Polynomial-jet evaluation and local diagnostics for the v2 inverse bounds.

The generic projection theorem concerns almost every exact real matrix.
A sampled/rounded matrix returned here is NOT a global injectivity certificate.
Global certified rational selection is specified by the manuscript's CAD search;
that external quantifier-elimination procedure is not implemented here.
"""
from __future__ import annotations
import math
import numpy as np


def jets_from_layers(speeds_squared, durations, layer_bound: int | None = None) -> np.ndarray:
    """Return [M11^(2)(0),M12^(2)(0),M11^(4)(0),...] by polynomial convolution.

    q_j=c_j^2 and tau_j>0. Complex perturbations are permitted for derivative
    checks. This floating-point implementation limits the layer bound to five;
    the theorem itself does not have that restriction.
    """
    q=np.asarray(speeds_squared);t=np.asarray(durations)
    if q.ndim!=1 or t.ndim!=1 or len(q)!=len(t) or not len(q):
        raise ValueError('Provide equally sized nonempty one-dimensional layer arrays.')
    if not np.all(np.isfinite(q)) or not np.all(np.isfinite(t)):
        raise ValueError('All layer parameters must be finite.')
    if np.any(np.real(q)<=0) or np.any(np.real(t)<=0):
        raise ValueError('Layer speeds squared and durations must have positive real parts.')
    r=len(q) if layer_bound is None else int(layer_bound)
    if not len(q)<=r<=5:
        raise ValueError('This float evaluator requires actual_layers <= layer_bound <= 5.')
    hmax=2**r-1
    dtype=np.result_type(q.dtype,t.dtype,np.float64)
    product=np.zeros((hmax+1,2,2),dtype=dtype);product[0]=np.eye(2)
    for speed2,tau in zip(q,t):
        layer=np.zeros_like(product)
        for h in range(hmax+1):
            co=(-speed2)**h*tau**(2*h)/float(math.factorial(2*h))
            up=(-speed2)**h*tau**(2*h+1)/float(math.factorial(2*h+1))
            layer[h,0,0]=co;layer[h,1,1]=co;layer[h,0,1]=up
            if h:layer[h,1,0]=-speed2*layer[h-1,0,1]
        new=np.zeros_like(product)
        for h in range(hmax+1):
            for k in range(h+1):new[h]+=layer[k]@product[h-k]
        product=new
    out=[]
    for h in range(1,hmax+1):
        fac=float(math.factorial(2*h))
        out.extend([fac*product[h,0,0],fac*product[h,0,1]])
    return np.asarray(out,dtype=dtype)


def draw_projection(layer_bound:int, *, known_resource:bool=False, seed:int=260925)->np.ndarray:
    """Draw a finite-precision test matrix, without claiming global certification."""
    if not 1<=layer_bound<=5:raise ValueError('Demo layer bound must lie in 1..5.')
    K=2**(layer_bound+1)-2
    if layer_bound==1:
        return np.empty((0,K)) if known_resource else np.array([[1.,0.]])
    m=min(K,4*layer_bound-(3 if known_resource else 1))
    if m==K:return np.eye(K)
    rng=np.random.default_rng(seed)
    P=rng.normal(size=(m,K));P/=np.linalg.norm(P,axis=1,keepdims=True)
    return P


def complex_step_jacobian(function, parameters, step:float=1e-25)->np.ndarray:
    """Derivative diagnostic for real polynomial/rational maps with no branching."""
    x=np.asarray(parameters,dtype=float)
    if x.ndim!=1 or step<=0:raise ValueError('Vector parameters and positive step required.')
    columns=[]
    for j in range(len(x)):
        z=x.astype(complex);z[j]+=1j*step
        columns.append(np.imag(np.asarray(function(z)))/step)
    return np.column_stack(columns)