Datasets:

PureOne
/

elysian-noctilucent-algebra

#!/usr/bin/env python3
"""Standalone certified return-compression experiments for ELYSIAEN.
NumPy/SciPy/Matplotlib only. No earlier project module is imported. The full
return matrix is retained by the independent oracle, never by CompressedReturn.
Arithmetic work models are counts, not CPU/GPU or photonic benchmarks.
"""
from __future__ import annotations
import os
os.environ.setdefault('OPENBLAS_NUM_THREADS', '1')
os.environ.setdefault('OMP_NUM_THREADS', '1')
from dataclasses import dataclass
from pathlib import Path
import argparse
import json
import platform
import numpy as np
import scipy
from scipy.linalg import solve


@dataclass(frozen=True)
class CompressedReturn:
    U: np.ndarray
    V: np.ndarray
    weight: np.ndarray
    return_on_weight: np.ndarray
    delta: float


def weighted_inf(x, weight):
    return float(np.max(np.abs(x)/weight, initial=0.0))


def compile_return(C, U, V, weight):
    """Oracle/offline compilation; measured deployment needs valid envelopes."""
    a=np.asarray(weight, dtype=float)
    if np.any(a<=0) or np.min(C, initial=0)<0:
        raise ValueError('Expected positive weights and nonnegative true return')
    E=np.abs(C-U@V)
    delta=weighted_inf(E@a,a)
    arrays=[np.array(z,copy=True) for z in (U,V,a,C@a)]
    for z in arrays: z.setflags(write=False)
    return CompressedReturn(*arrays,delta)


def evaluate_diagonal(capsule, bdiag, ldiag, rdiag, f):
    """Only compressed arrays; no true/dense return or full-state callback.
    This optimized path assumes diagonal B,L,R. The true A is admitted by a
    positive witness derived from a and C a. Any error certificate is ordinary
    floating-point evaluation of an exact inequality, not outward rounding.
    """
    U,V,a,c,delta=(capsule.U,capsule.V,capsule.weight,
                   capsule.return_on_weight,capsule.delta)
    b,l,r=map(np.asarray,(bdiag,ldiag,rdiag))
    if any(np.min(z,initial=0)<0 for z in (b,l,r)) or np.any(b>=1):
        raise ValueError('Nonnegative diagonal maps and I-B invertible required')
    tR=weighted_inf(r*a,a)
    slack=a-b*a-tR*l*c
    if np.min(slack)<=0:
        raise ValueError('The retained true-class stability witness fails')
    P=(l/(1-b))[:,None]*U
    T=V*r[None,:]
    q=f/(1-b)
    K=np.eye(V.shape[0])-T@P
    z=solve(K,T@q,assume_a='gen',check_finite=True)
    u=q+P@z
    residual=(1-b)*u-l*(U@(V@(r*u)))-f
    forcing=np.abs(residual)+delta*weighted_inf(r*u,a)*l*a
    beta=float(np.max(forcing/slack, initial=0.0))
    return u,beta,{'small_rank':V.shape[0], 'true_weighted_slack_min':float(np.min(slack/a)),
                   'small_condition_2':float(np.linalg.cond(K)),
                   'retained_array_bytes':sum(z.nbytes for z in (U,V,a,c))}


def positive_world(k,rng):
    q=10
    u=rng.uniform(.2,1.2,(k,q))
    v=rng.uniform(.2,1.2,(q,k))
    u/=u.sum(axis=0,keepdims=True)
    v/=v.sum(axis=1,keepdims=True)
    decay=.55**np.arange(q)
    u*=decay[None,:]
    # The positive diagonal tail makes the return full rank. Compressibility
    # is a stipulated generated property, not inferred for arbitrary scenes.
    U0=np.column_stack((u,.001*np.eye(k)))
    V0=np.vstack((v,np.eye(k)))
    C0=U0@V0
    scale=.60/np.max(C0.sum(axis=1))
    U0*=scale
    a=np.exp(rng.uniform(-1.5,1.5,k))
    U=a[:,None]*U0
    V=V0/a[None,:]
    return U@V,U,V,a


def signed_svd_control(rng):
    # Search a fixed seeded family for the well-known fact that truncating an
    # asymmetric nonnormal stable positive operator need not preserve stability.
    for attempt in range(1500):
        k=5
        C0=rng.uniform(0,1,(k,k))
        C0*=.85/max(abs(np.linalg.eigvals(C0)))
        w=np.exp(rng.uniform(-7,7,k))
        C=w[:,None]*C0/w[None,:]
        uu,ss,vv=np.linalg.svd(C,full_matrices=False)
        for rank in (2,3):
            Cr=(uu[:,:rank]*ss[:rank])@vv[:rank]
            rho=float(max(abs(np.linalg.eigvals(Cr))))
            if rho>1.02 and np.min(Cr)<-1e-7:
                return {'found':True,'attempt':attempt,'rank':rank,
                        'true_spectral_radius':float(max(abs(np.linalg.eigvals(C)))),
                        'truncated_spectral_radius':rho,'minimum_truncated_entry':float(Cr.min()),
                        'C':C.tolist(),'C_rank':Cr.tolist(),
                        'meaning':'SVD rank truncation can destroy positivity and stability; certificate uses true class.'}
    return {'found':False,'meaning':'No such counterexample found in this finite search; no preservation claim follows.'}


def main():
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--quick',action='store_true')
    parser.add_argument('--output-prefix',default='v5_compression')
    args=parser.parse_args()
    rng=np.random.default_rng(2026102551)
    count=12 if args.quick else 60
    records=[]; max_reconstruction=0.; max_ratio=0.; violations=0
    monotone_checks=0; monotone_violations=0; signed_checks=0
    frontier=[]
    for case in range(count):
        k=(16,32,64)[case%3]
        C,U,V,a=positive_world(k,rng)
        b=rng.uniform(0,.14,k); l=rng.uniform(.25,1,k); r=rng.uniform(.25,1,k)
        f=a*rng.uniform(.1,1,k)
        O=rng.uniform(0,1,(3,k))/a[None,:]/k
        A=np.diag(b)+l[:,None]*C*r[None,:]
        exact=solve(np.eye(k)-A,f)
        ranks=(1,2,4,8,10,k+10)
        previous=None
        for rank in ranks:
            cap=compile_return(C,U[:,:rank],V[:rank],a)
            approx,beta,info=evaluate_diagonal(cap,b,l,r,f)
            approx_direct=solve(np.eye(k)-np.diag(b)-l[:,None]*(cap.U@cap.V)*r[None,:],f)
            max_reconstruction=max(max_reconstruction,weighted_inf(approx-approx_direct,a))
            err=weighted_inf(exact-approx,a)
            out_err=np.abs(O@(exact-approx)); out_bound=(np.abs(O)@a)*beta
            if err>beta+2e-10 or np.any(out_err>out_bound+2e-10): violations+=1
            if beta>1e-13: max_ratio=max(max_ratio,err/beta)
            if previous is not None:
                monotone_checks+=1
                if np.min(approx-previous)<-2e-10: monotone_violations+=1
            previous=approx
            rec={'case':case,'k':k,'factor_count':rank,'error':err,'certificate':beta,
                 'relative_return_envelope':cap.delta,**info}
            records.append(rec)
            if case==1: frontier.append(rec)
        # Signed SVD factors use the very same true-class compression barrier.
        uu,ss,vv=np.linalg.svd(C,full_matrices=False)
        for rank in (2,5,min(10,k)):
            cap=compile_return(C,uu[:,:rank]*ss[:rank],vv[:rank],a)
            approx,beta,_=evaluate_diagonal(cap,b,l,r,f)
            if weighted_inf(exact-approx,a)>beta+2e-10: violations+=1
            signed_checks+=1
    assert violations==0 and monotone_violations==0
    near=[]
    for eps in np.logspace(-1,-6,20):
        delta=1e-4
        exact=1/eps; approx=1/(eps+delta)
        actual=abs(exact-approx)
        certificate=delta*approx/eps
        assert actual<=certificate+1e-5*max(1,actual)
        near.append({'epsilon':float(eps),'return_error':delta,'actual_state_error':actual,
                     'certificate':certificate})
    work=[]
    for k in (32,64,128,256):
        dense=2*k**3/3+2*k*k
        for rank in (1,2,4,8,12):
            # One dense r-core factorization per local configuration and one RHS.
            low=2*k*rank**2+2*rank**3/3+8*k*rank+2*rank**2+12*k
            work.append({'k':k,'rank':rank,'dense_digital_model_flops':dense,
                         'compressed_digital_model_flops':low,'modeled_ratio':dense/low})
    signed_control=signed_svd_control(rng)
    assert signed_control['found'], 'Seeded signed-SVD negative control was not reproduced'
    # Simple exact impossibility control: any deficient-rank Cr has a kernel.
    gamma=.6; k=8
    Cr=np.zeros((k,k));Cr[:3,:3]=gamma*np.eye(3)
    z=np.zeros(k);z[-1]=1
    lower_bound_error=float(np.linalg.norm(z/(1-gamma)-solve(np.eye(k)-Cr,z)))
    assert abs(lower_bound_error-gamma/(1-gamma))<1e-12
    result={'project':'ELYSIAEN certified return compression','date':'2026-10-25',
            'seed':2026102551,'software':{'Python':platform.python_version(),'NumPy':np.__version__,'SciPy':scipy.__version__},
            'random_capsules':count,'positive_prefix_candidate_checks':len(records),
            'signed_svd_candidate_checks':signed_checks,'certificate_violations':violations,
            'monotone_prefix_checks':monotone_checks,'monotone_prefix_violations':monotone_violations,
            'maximum_small_solve_reconstruction_error':max_reconstruction,
            'maximum_actual_error_to_certificate_ratio':max_ratio,
            'retained_contract':'U,V,a,Ca,delta only; no dense true return in evaluate_diagonal',
            'signed_svd_negative_control':signed_control,
            'full_rank_negative_control':{'gamma':gamma,'k':k,'rank':3,'observed_error':lower_bound_error,'lower_bound':gamma/(1-gamma)},
            'rank_frontier':frontier,'near_critical':near,'digital_work_model':work,'records':records,
            'scope':'Finite arithmetic identities, stated diagonal local maps, generated compressibility and oracle-derived offline envelopes. Flop models are not measured timing/energy or photonic speedups. Ordinary double precision, not outward-rounded certificates.'}
    path=Path(args.output_prefix);path.parent.mkdir(parents=True,exist_ok=True)
    path.with_name(path.name+'_results.json').write_text(json.dumps(result,indent=2)+'\n')
    import matplotlib
    matplotlib.use('Agg')
    import matplotlib.pyplot as plt
    plt.rcParams.update({'font.size':11,'axes.spines.top':False,'axes.spines.right':False})
    fig,axes=plt.subplots(1,2,figsize=(9,4.2),constrained_layout=True)
    # Plot practical nonexact prefixes. Exact reconstruction reaches ordinary
    # floating-point noise, not an outward-rounded certificate floor.
    shown=[x for x in frontier if x['factor_count']<=10]
    ranks=[x['factor_count'] for x in shown]
    axes[0].semilogy(ranks,[x['error'] for x in shown],'o-',label='Actual state error')
    axes[0].semilogy(ranks,[x['certificate'] for x in shown],'s--',label='Certified barrier')
    axes[0].set(xlabel='Retained positive factors',ylabel='Weighted infinity error',title='Compression versus accuracy');axes[0].legend()
    axes[1].loglog([x['epsilon'] for x in near],[x['actual_state_error'] for x in near],'o-',label='Actual = barrier')
    axes[1].invert_xaxis();axes[1].set(xlabel='True feedback slack',ylabel='State error for return error 10⁻⁴',title='Near-unit return remains sensitive')
    for ax in axes: ax.grid(alpha=.2)
    fig.suptitle('Finite generated transport; no hardware measurements',fontsize=12)
    fig.savefig(path.with_suffix('.png'),dpi=170);plt.close(fig)
    fig,ax=plt.subplots(figsize=(8,3.4),constrained_layout=True)
    for rank in (2,4,8,12):
        rr=[x for x in work if x['rank']==rank]
        ax.plot([x['k'] for x in rr],[x['modeled_ratio'] for x in rr],'o-',label=f'r={rank}')
    ax.axhline(1,color='gray',lw=.7);ax.set(xlabel='Capsule dimension k',ylabel='Dense / compressed work model',title='Same algorithm, digital baseline');ax.legend();ax.grid(alpha=.2)
    fig.savefig(path.with_name(path.name+'_work').with_suffix('.png'),dpi=170);plt.close(fig)
    print(json.dumps({k:result[k] for k in ['random_capsules','positive_prefix_candidate_checks','signed_svd_candidate_checks','certificate_violations','monotone_prefix_checks','maximum_small_solve_reconstruction_error','maximum_actual_error_to_certificate_ratio']},indent=2))


if __name__=='__main__': main()

	#!/usr/bin/env python3
	"""Standalone certified return-compression experiments for ELYSIAEN.

	NumPy/SciPy/Matplotlib only. No earlier project module is imported. The full
	return matrix is retained by the independent oracle, never by CompressedReturn.
	Arithmetic work models are counts, not CPU/GPU or photonic benchmarks.
	"""
	from __future__ import annotations
	import os
	os.environ.setdefault('OPENBLAS_NUM_THREADS', '1')
	os.environ.setdefault('OMP_NUM_THREADS', '1')
	from dataclasses import dataclass
	from pathlib import Path
	import argparse
	import json
	import platform
	import numpy as np
	import scipy
	from scipy.linalg import solve


	@dataclass(frozen=True)
	class CompressedReturn:
	U: np.ndarray
	V: np.ndarray
	weight: np.ndarray
	return_on_weight: np.ndarray
	delta: float


	def weighted_inf(x, weight):
	return float(np.max(np.abs(x)/weight, initial=0.0))


	def compile_return(C, U, V, weight):
	"""Oracle/offline compilation; measured deployment needs valid envelopes."""
	a=np.asarray(weight, dtype=float)
	if np.any(a<=0) or np.min(C, initial=0)<0:
	raise ValueError('Expected positive weights and nonnegative true return')
	E=np.abs(C-U@V)
	delta=weighted_inf(E@a,a)
	arrays=[np.array(z,copy=True) for z in (U,V,a,C@a)]
	for z in arrays: z.setflags(write=False)
	return CompressedReturn(*arrays,delta)


	def evaluate_diagonal(capsule, bdiag, ldiag, rdiag, f):
	"""Only compressed arrays; no true/dense return or full-state callback.

	This optimized path assumes diagonal B,L,R. The true A is admitted by a
	positive witness derived from a and C a. Any error certificate is ordinary
	floating-point evaluation of an exact inequality, not outward rounding.
	"""
	U,V,a,c,delta=(capsule.U,capsule.V,capsule.weight,
	capsule.return_on_weight,capsule.delta)
	b,l,r=map(np.asarray,(bdiag,ldiag,rdiag))
	if any(np.min(z,initial=0)<0 for z in (b,l,r)) or np.any(b>=1):
	raise ValueError('Nonnegative diagonal maps and I-B invertible required')
	tR=weighted_inf(r*a,a)
	slack=a-ba-tRl*c
	if np.min(slack)<=0:
	raise ValueError('The retained true-class stability witness fails')
	P=(l/(1-b))[:,None]*U
	T=V*r[None,:]
	q=f/(1-b)
	K=np.eye(V.shape[0])-T@P
	z=solve(K,T@q,assume_a='gen',check_finite=True)
	u=q+P@z
	residual=(1-b)u-l(U@(V@(r*u)))-f
	forcing=np.abs(residual)+deltaweighted_inf(ru,a)la
	beta=float(np.max(forcing/slack, initial=0.0))
	return u,beta,{'small_rank':V.shape[0], 'true_weighted_slack_min':float(np.min(slack/a)),
	'small_condition_2':float(np.linalg.cond(K)),
	'retained_array_bytes':sum(z.nbytes for z in (U,V,a,c))}


	def positive_world(k,rng):
	q=10
	u=rng.uniform(.2,1.2,(k,q))
	v=rng.uniform(.2,1.2,(q,k))
	u/=u.sum(axis=0,keepdims=True)
	v/=v.sum(axis=1,keepdims=True)
	decay=.55**np.arange(q)
	u*=decay[None,:]
	# The positive diagonal tail makes the return full rank. Compressibility
	# is a stipulated generated property, not inferred for arbitrary scenes.
	U0=np.column_stack((u,.001*np.eye(k)))
	V0=np.vstack((v,np.eye(k)))
	C0=U0@V0
	scale=.60/np.max(C0.sum(axis=1))
	U0*=scale
	a=np.exp(rng.uniform(-1.5,1.5,k))
	U=a[:,None]*U0
	V=V0/a[None,:]
	return U@V,U,V,a


	def signed_svd_control(rng):
	# Search a fixed seeded family for the well-known fact that truncating an
	# asymmetric nonnormal stable positive operator need not preserve stability.
	for attempt in range(1500):
	k=5
	C0=rng.uniform(0,1,(k,k))
	C0*=.85/max(abs(np.linalg.eigvals(C0)))
	w=np.exp(rng.uniform(-7,7,k))
	C=w[:,None]*C0/w[None,:]
	uu,ss,vv=np.linalg.svd(C,full_matrices=False)
	for rank in (2,3):
	Cr=(uu[:,:rank]*ss[:rank])@vv[:rank]
	rho=float(max(abs(np.linalg.eigvals(Cr))))
	if rho>1.02 and np.min(Cr)<-1e-7:
	return {'found':True,'attempt':attempt,'rank':rank,
	'true_spectral_radius':float(max(abs(np.linalg.eigvals(C)))),
	'truncated_spectral_radius':rho,'minimum_truncated_entry':float(Cr.min()),
	'C':C.tolist(),'C_rank':Cr.tolist(),
	'meaning':'SVD rank truncation can destroy positivity and stability; certificate uses true class.'}
	return {'found':False,'meaning':'No such counterexample found in this finite search; no preservation claim follows.'}


	def main():
	parser=argparse.ArgumentParser(description=__doc__)
	parser.add_argument('--quick',action='store_true')
	parser.add_argument('--output-prefix',default='v5_compression')
	args=parser.parse_args()
	rng=np.random.default_rng(2026102551)
	count=12 if args.quick else 60
	records=[]; max_reconstruction=0.; max_ratio=0.; violations=0
	monotone_checks=0; monotone_violations=0; signed_checks=0
	frontier=[]
	for case in range(count):
	k=(16,32,64)[case%3]
	C,U,V,a=positive_world(k,rng)
	b=rng.uniform(0,.14,k); l=rng.uniform(.25,1,k); r=rng.uniform(.25,1,k)
	f=a*rng.uniform(.1,1,k)
	O=rng.uniform(0,1,(3,k))/a[None,:]/k
	A=np.diag(b)+l[:,None]Cr[None,:]
	exact=solve(np.eye(k)-A,f)
	ranks=(1,2,4,8,10,k+10)
	previous=None
	for rank in ranks:
	cap=compile_return(C,U[:,:rank],V[:rank],a)
	approx,beta,info=evaluate_diagonal(cap,b,l,r,f)
	approx_direct=solve(np.eye(k)-np.diag(b)-l[:,None](cap.U@cap.V)r[None,:],f)
	max_reconstruction=max(max_reconstruction,weighted_inf(approx-approx_direct,a))
	err=weighted_inf(exact-approx,a)
	out_err=np.abs(O@(exact-approx)); out_bound=(np.abs(O)@a)*beta
	if err>beta+2e-10 or np.any(out_err>out_bound+2e-10): violations+=1
	if beta>1e-13: max_ratio=max(max_ratio,err/beta)
	if previous is not None:
	monotone_checks+=1
	if np.min(approx-previous)<-2e-10: monotone_violations+=1
	previous=approx
	rec={'case':case,'k':k,'factor_count':rank,'error':err,'certificate':beta,
	'relative_return_envelope':cap.delta,**info}
	records.append(rec)
	if case==1: frontier.append(rec)
	# Signed SVD factors use the very same true-class compression barrier.
	uu,ss,vv=np.linalg.svd(C,full_matrices=False)
	for rank in (2,5,min(10,k)):
	cap=compile_return(C,uu[:,:rank]*ss[:rank],vv[:rank],a)
	approx,beta,_=evaluate_diagonal(cap,b,l,r,f)
	if weighted_inf(exact-approx,a)>beta+2e-10: violations+=1
	signed_checks+=1
	assert violations==0 and monotone_violations==0
	near=[]
	for eps in np.logspace(-1,-6,20):
	delta=1e-4
	exact=1/eps; approx=1/(eps+delta)
	actual=abs(exact-approx)
	certificate=delta*approx/eps
	assert actual<=certificate+1e-5*max(1,actual)
	near.append({'epsilon':float(eps),'return_error':delta,'actual_state_error':actual,
	'certificate':certificate})
	work=[]
	for k in (32,64,128,256):
	dense=2k3/3+2k*k
	for rank in (1,2,4,8,12):
	# One dense r-core factorization per local configuration and one RHS.
	low=2krank*2+2rank*3/3+8krank+2rank*2+12k
	work.append({'k':k,'rank':rank,'dense_digital_model_flops':dense,
	'compressed_digital_model_flops':low,'modeled_ratio':dense/low})
	signed_control=signed_svd_control(rng)
	assert signed_control['found'], 'Seeded signed-SVD negative control was not reproduced'
	# Simple exact impossibility control: any deficient-rank Cr has a kernel.
	gamma=.6; k=8
	Cr=np.zeros((k,k));Cr[:3,:3]=gamma*np.eye(3)
	z=np.zeros(k);z[-1]=1
	lower_bound_error=float(np.linalg.norm(z/(1-gamma)-solve(np.eye(k)-Cr,z)))
	assert abs(lower_bound_error-gamma/(1-gamma))<1e-12
	result={'project':'ELYSIAEN certified return compression','date':'2026-10-25',
	'seed':2026102551,'software':{'Python':platform.python_version(),'NumPy':np.__version__,'SciPy':scipy.__version__},
	'random_capsules':count,'positive_prefix_candidate_checks':len(records),
	'signed_svd_candidate_checks':signed_checks,'certificate_violations':violations,
	'monotone_prefix_checks':monotone_checks,'monotone_prefix_violations':monotone_violations,
	'maximum_small_solve_reconstruction_error':max_reconstruction,
	'maximum_actual_error_to_certificate_ratio':max_ratio,
	'retained_contract':'U,V,a,Ca,delta only; no dense true return in evaluate_diagonal',
	'signed_svd_negative_control':signed_control,
	'full_rank_negative_control':{'gamma':gamma,'k':k,'rank':3,'observed_error':lower_bound_error,'lower_bound':gamma/(1-gamma)},
	'rank_frontier':frontier,'near_critical':near,'digital_work_model':work,'records':records,
	'scope':'Finite arithmetic identities, stated diagonal local maps, generated compressibility and oracle-derived offline envelopes. Flop models are not measured timing/energy or photonic speedups. Ordinary double precision, not outward-rounded certificates.'}
	path=Path(args.output_prefix);path.parent.mkdir(parents=True,exist_ok=True)
	path.with_name(path.name+'_results.json').write_text(json.dumps(result,indent=2)+'\n')
	import matplotlib
	matplotlib.use('Agg')
	import matplotlib.pyplot as plt
	plt.rcParams.update({'font.size':11,'axes.spines.top':False,'axes.spines.right':False})
	fig,axes=plt.subplots(1,2,figsize=(9,4.2),constrained_layout=True)
	# Plot practical nonexact prefixes. Exact reconstruction reaches ordinary
	# floating-point noise, not an outward-rounded certificate floor.
	shown=[x for x in frontier if x['factor_count']<=10]
	ranks=[x['factor_count'] for x in shown]
	axes[0].semilogy(ranks,[x['error'] for x in shown],'o-',label='Actual state error')
	axes[0].semilogy(ranks,[x['certificate'] for x in shown],'s--',label='Certified barrier')
	axes[0].set(xlabel='Retained positive factors',ylabel='Weighted infinity error',title='Compression versus accuracy');axes[0].legend()
	axes[1].loglog([x['epsilon'] for x in near],[x['actual_state_error'] for x in near],'o-',label='Actual = barrier')
	axes[1].invert_xaxis();axes[1].set(xlabel='True feedback slack',ylabel='State error for return error 10⁻⁴',title='Near-unit return remains sensitive')
	for ax in axes: ax.grid(alpha=.2)
	fig.suptitle('Finite generated transport; no hardware measurements',fontsize=12)
	fig.savefig(path.with_suffix('.png'),dpi=170);plt.close(fig)
	fig,ax=plt.subplots(figsize=(8,3.4),constrained_layout=True)
	for rank in (2,4,8,12):
	rr=[x for x in work if x['rank']==rank]
	ax.plot([x['k'] for x in rr],[x['modeled_ratio'] for x in rr],'o-',label=f'r={rank}')
	ax.axhline(1,color='gray',lw=.7);ax.set(xlabel='Capsule dimension k',ylabel='Dense / compressed work model',title='Same algorithm, digital baseline');ax.legend();ax.grid(alpha=.2)
	fig.savefig(path.with_name(path.name+'_work').with_suffix('.png'),dpi=170);plt.close(fig)
	print(json.dumps({k:result[k] for k in ['random_capsules','positive_prefix_candidate_checks','signed_svd_candidate_checks','certificate_violations','monotone_prefix_checks','maximum_small_solve_reconstruction_error','maximum_actual_error_to_certificate_ratio']},indent=2))


	if __name__=='__main__': main()