Circle calibration and path offsets

The full executable fixture. The host applies the selected reader and binds its calculated surface into the traversal request.

gojo 1;

// First construct a native circle: point, common offset, radius and actual seam.
let $origin = point(carrier(), 0);
let $outward = orthogonal($origin);
let $contour = crystal($outward);
let $ray = crystal(orthogonal($origin -> $origin));
let $start = point($contour, 0);
let $end = point($contour, 1);
// Bind actual radius endpoints, rather than separately equal tick values.
let $radius_start = point($ray, 0);
let $radius_end = point($ray, 1);
let $reach = $radius_start -> $radius_end;
let $attachment = group($origin -> $radius_start, $reach, $radius_end -> $start);
let $whole = $start -> $end;
let $circle = group($outward -> ($reach -> $contour), $attachment, $whole, $end -> $start);
let $fine = carrier(subdivision(unit_of($contour), 360));
let $partition = group($circle, span($fine, 0, 360) -> $whole);

// A selected local chart and metric, with a common linear measurement unit.
// This is supplied calibration evidence. The intrinsic circle already exists.
let $space = carrier();
let $x = carrier();
let $y = carrier(unit_of($x));
let $length = carrier(unit_of($x));
let $squared = carrier(product_units(unit_of($x), unit_of($x)));
let $ux = span($x, 0, 1);
let $uy = span($y, 0, 1);
let $basis = group_on($space, $ux, $uy);
let $metric = group($basis, frame(($ux -> $ux) -> at($squared, 1),
    ($ux -> $uy) -> at($squared, 0), ($uy -> $uy) -> at($squared, 1)));
let $centre = group_on($space, at($x, 10), at($y, 20));
let $direction = group_on($space, at($x, 16), at($y, 28));
let $side = group_on($space, at($x, 10), at($y, 21));
let $calibration = $reach -> span($length, 0, 5);

// The selected read calculates four rim points. None is authored here.
// Positive native traversal follows the side relative to the reference ray.
root group($partition, $metric, $origin -> $centre, $calibration,
    $centre -> $direction, $centre -> $side);

let $p = group_on($space, at($x, 12), at($y, 20));
root group_on($space, $p, group_on($space, at($x, 12), at($y, 21)), $p);
root group(?constructed_surface, ?actual_start_marker, span(carrier(), 0, 1));
root group(?traversal_witness, ?exposed_points);

The same two offset requests feed the joined construction. The parameter supports express the selected corner policy.

gojo 1;

// Inputs in a selected local chart. No world-up direction is implied.
let $space = carrier();
let $x = carrier();
let $y = carrier(unit_of($x));
let $length = carrier(unit_of($x));
let $squared = carrier(product_units(unit_of($x), unit_of($x)));
let $ux = span($x, 0, 1);
let $uy = span($y, 0, 1);
let $metric = group(group_on($space, $ux, $uy), frame(
    ($ux -> $ux) -> at($squared, 1), ($ux -> $uy) -> at($squared, 0),
    ($uy -> $uy) -> at($squared, 1)));
let $a = group_on($space, at($x, 0), at($y, 0));
let $b = group_on($space, at($x, 6), at($y, 0));
let $c = group_on($space, at($x, 6), at($y, 6));
let $first = $a -> $b;
let $second = $b -> $c;
let $reach = span(carrier(), 0, 1);
let $calibration = $reach -> span($length, 0, 2);
let $first_side = $a -> group_on($space, at($x, 0), at($y, 1));
let $second_side = $b -> group_on($space, at($x, 5), at($y, 0));
let $offset_a = group($first, $metric, orthogonal($first) -> $calibration, $first_side);
let $offset_b = group($second, $metric, orthogonal($second) -> $calibration, $second_side);
root $offset_a;
root $offset_b;

// A miter is the intersection of the two calculated straight supports.
// Each source whole has an explicit parameter frame and allowed support.
// This policy allows trimming inside these segments, but no extrapolation.
let $t = carrier();
let $u = carrier();
let $first_whole = span($t, 0, 1);
let $second_whole = span($u, 0, 1);
let $supports = group($first_whole -> $first_whole, $second_whole -> $second_whole);
root group($offset_a, $offset_b, $supports);

// A distinct policy permits limited extension. It is not an unbounded miter.
root group($offset_a, $offset_b, group($first_whole -> span($t, -1, 2),
    $second_whole -> span($u, -1, 2)));

The kernel calculates these results using exact rational arithmetic. Tests check the displayed traces, metric lengths, perpendicularity, native marker connections, shared corner identity, bounded failures and numeric restoration. This page displays those checked traces; it is not a second geometry engine.

The chart and metric are supplied calibration evidence. The circle bridge currently constructs four quarters. Exact irrational coordinate representation, arbitrary circle fractions, curved offsets, caps and other corner policies remain open. The measured-offset follow-up retains the unfinished square equation and supplies bounds at an explicit resolution. That representation limit is distinct from measurement uncertainty.