| """Exact small one-shot functional-memory contracts; classical graph-coloring formulation.""" |
| from __future__ import annotations |
| import math |
| import numpy as np |
|
|
| def confusability_graph(answers, support=None): |
| a = np.asarray(answers) |
| if a.ndim != 2: |
| raise ValueError("answers must be records x future transcripts") |
| s = np.ones(a.shape,dtype=bool) if support is None else np.asarray(support,dtype=bool) |
| if s.shape != a.shape: |
| raise ValueError("Support shape mismatch") |
| adjacency = np.zeros((len(a),len(a)),dtype=bool) |
| for i in range(len(a)): |
| for j in range(i): |
| edge = bool(np.any(s[i]&s[j]&(a[i]!=a[j]))) |
| adjacency[i,j]=adjacency[j,i]=edge |
| return adjacency |
|
|
| def exact_coloring(adjacency): |
| """Backtracking for small research fixtures only; general coloring is exponential.""" |
| g = np.asarray(adjacency,dtype=bool) |
| if g.ndim != 2 or g.shape[0] != g.shape[1] or not np.array_equal(g,g.T) or np.any(np.diag(g)): |
| raise ValueError("Require simple undirected graph") |
| n=len(g) |
| if n==0: return 0,[] |
| order=sorted(range(n),key=lambda i:-int(g[i].sum())) |
| colors=[-1]*n |
| def assign(t,k,used): |
| if t==n:return True |
| v=order[t] |
| banned={colors[j] for j in range(n) if g[v,j] and colors[j]>=0} |
| for c in range(min(k,used+1)): |
| if c not in banned: |
| colors[v]=c |
| if assign(t+1,k,max(used,c+1)):return True |
| colors[v]=-1 |
| return False |
| |
| if np.all(g | np.eye(n,dtype=bool)):return n,list(range(n)) |
| for k in range(1,n+1): |
| if assign(0,k,0):return k,colors.copy() |
| raise RuntimeError("Coloring failure") |
|
|
| def binary_entropy(error): |
| if not 0<=error<=1: raise ValueError("error outside [0,1]") |
| if error in (0,1):return 0. |
| return -error*math.log2(error)-(1-error)*math.log2(1-error) |
|
|
| def retrospective_memory_lower_bits(n,error): |
| if n<1 or not 0<=error<=.5:raise ValueError("Require n>=1 and error in [0,.5]") |
| return n*(1-binary_entropy(error)) |
|
|
