| """Exact-formula positional line-overlap certificates, evaluated in float64. |
| |
| For two segments, Q is the measure of unoriented lines meeting both, with |
| line measure dtheta*dt for theta in [0,pi). The endpoint formula is exact |
| mathematically; its implementation and all returned numbers use floating |
| point arithmetic, not outward-rounded interval arithmetic. |
| |
| The certificates are NECESSARY conditions for an opaque barrier of the |
| unit-radius disk. Passing them does not establish opacity. Positive-length |
| collinear overlaps must be merged first, to avoid counting length twice. |
| """ |
| import math |
| import numpy as np |
|
|
|
|
| def _cross(u,v): |
| return float(u[0]*v[1]-u[1]*v[0]) |
|
|
|
|
| def _point(x): |
| p=np.asarray(x,dtype=float) |
| if p.shape!=(2,) or not np.isfinite(p).all(): |
| raise ValueError("Endpoints must be finite two-dimensional points") |
| return p |
|
|
|
|
| def _distance(p,q): |
| return math.hypot(float(p[0]-q[0]),float(p[1]-q[1])) |
|
|
|
|
| def _four_point(a,b,c,d): |
| return abs(math.fsum([_distance(a,c),_distance(b,d), |
| -_distance(a,d),-_distance(b,c)])) |
|
|
|
|
| def pair_overlap(first,second,relative_tolerance=1e-11): |
| """Evaluate Q by a finite sum of absolute four-endpoint distance terms. |
| |
| Split both segments at the intersection of their supporting lines when |
| that intersection is interior. On each resulting parameter rectangle, |
| the mixed derivative of distance has constant sign. |
| |
| Collinear positive-length overlaps are rejected. Numerically ambiguous |
| near-collinear positive overlaps within relative_tolerance are rejected |
| as well. A shared endpoint and isolated zero-length pieces are allowed. |
| """ |
| a,b=map(_point,first) |
| c,d=map(_point,second) |
| e,f=b-a,d-c |
| le,lf=_distance(a,b),_distance(c,d) |
| if le==0 or lf==0: |
| return 0.0 |
| scale=max(le,lf,_distance(a,c),_distance(a,d), |
| _distance(b,c),_distance(b,d)) |
| tol=relative_tolerance*scale |
| determinant=_cross(e,f) |
| near_parallel=abs(determinant)<=relative_tolerance*le*lf |
| near_collinear=(near_parallel and |
| abs(_cross(c-a,e))/le<=tol and |
| abs(_cross(d-a,e))/le<=tol) |
| if near_collinear: |
| unit=e/le |
| pc,pd=float(np.dot(c-a,unit)),float(np.dot(d-a,unit)) |
| overlap=min(le,max(pc,pd))-max(0.,min(pc,pd)) |
| if overlap>tol: |
| raise ValueError("Collinear or numerically near-collinear positive-length overlap: merge these pieces first") |
| return 0.0 |
| if determinant==0: |
| return _four_point(a,b,c,d) |
| t=_cross(c-a,f)/determinant |
| u=_cross(c-a,e)/determinant |
| |
| p=.5*((a+t*e)+(c+u*f)) |
| first_pieces=[(a,b)] |
| second_pieces=[(c,d)] |
| if relative_tolerance<t<1-relative_tolerance: |
| first_pieces=[(a,p),(p,b)] |
| if relative_tolerance<u<1-relative_tolerance: |
| second_pieces=[(c,p),(p,d)] |
| return math.fsum(_four_point(x,y,z,w) |
| for x,y in first_pieces for z,w in second_pieces) |
|
|
|
|
| def positional_certificate(segments,certified_max_hits=None): |
| """Return pair energy and maximum-spanning-forest necessary bounds. |
| |
| If the input is an actual opaque barrier with total length L, then |
| L >= pi + .5*maximum_spanning_forest_value. |
| If a separate proof establishes N(line)<=M for almost every line, |
| L >= pi + pair_energy/M. |
| 'certified_max_hits' records that EXTERNAL assumption. This function |
| never certifies a line-intersection maximum by sampling or otherwise. |
| The universal automatic maximum is the number of nondegenerate pieces. |
| """ |
| pieces=[tuple(map(_point,s)) for s in segments] |
| n=len(pieces) |
| if n==0: |
| raise ValueError("At least one segment is required") |
| lengths=[_distance(a,b) for a,b in pieces] |
| n_active=sum(x>0 for x in lengths) |
| pairs=[] |
| for i in range(n): |
| for j in range(i+1,n): |
| pairs.append((i,j,pair_overlap(pieces[i],pieces[j]))) |
| parent=list(range(n)) |
| def find(x): |
| while parent[x]!=x: |
| parent[x]=parent[parent[x]] |
| x=parent[x] |
| return x |
| forest=[] |
| for i,j,q in sorted(pairs,key=lambda item:item[2],reverse=True): |
| ri,rj=find(i),find(j) |
| if ri!=rj: |
| parent[ri]=rj |
| forest.append((i,j,q)) |
| energy=math.fsum(q for i,j,q in pairs) |
| forest_value=math.fsum(q for i,j,q in forest) |
| result={"segment_count":n,"nondegenerate_segment_count":n_active, |
| "total_segment_length":math.fsum(lengths), |
| "pair_overlaps":[{"i":i,"j":j,"Q":q} for i,j,q in pairs], |
| "pair_energy":energy, |
| "maximum_spanning_forest_edges":[{"i":i,"j":j,"Q":q} for i,j,q in forest], |
| "maximum_spanning_forest_value":forest_value, |
| "forest_necessary_lower_bound":math.pi+.5*forest_value, |
| "automatic_hit_bound":n_active, |
| "automatic_pair_necessary_lower_bound":math.pi+energy/n_active if n_active else None, |
| "opacity_established":False, |
| "arithmetic":"float64 evaluation of exact geometric formulas"} |
| if certified_max_hits is not None: |
| if not isinstance(certified_max_hits,int) or not 1<=certified_max_hits<=n_active: |
| raise ValueError("Externally certified M must be an integer between 1 and the number of nondegenerate pieces") |
| result.update(externally_assumed_max_hits=certified_max_hits, |
| conditional_pair_necessary_lower_bound=math.pi+energy/certified_max_hits, |
| max_hits_assumption_verified_by_this_code=False) |
| return result |
|
|
