bot, arbitrarily stipulating ("picking a branch") that
arg(right) = 0as a sort of basepoint.
arg(bot) = -1from our considerations of continuity. No other value extends continuous from the right to the bottom.
0 -> -1: we decrease our value as we move clockwise.
what happens if we move in the opposite direction?
right, arbitrarily picking the branch
arg(right) = 0as before. This gives us:
arg(top) = 1by continuity considerations.
0 -> 1: we increase our value as we move counter-clockwise
That is, we end up with the value
bot -> right -> top -> left -> bot -> right -> top -> left -1 -> 0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6
6, which can only b
a, b, c, d, e, f, g, h.
f: Spoke -> Valwhose values are given on the spokes.
p: Time -> Spoke,
p = [a, b, c, d, e, f, g, h, a].
fon the path
p, we get
out: Time -> Val,
out = [0, 1, 2, 3, 4, 5, 6, 7, 0].
outas we cross from
a. This is a discontinuity in
0to the spoke
a. We wish to define the evaluation of
f: Spoke -> 2^Nrelative to path
p. At time
p[t], we pick any value in
out = f(p) = f(a):
8. But we know that
out = f(p) = f(b) = 1. Hence, for
outto be continuous, we must pick
out = 0.
outwe have two choices:
8. But we have that
out = 7, hence we pick
out = 8.
outcontinuous. This is not really rigorous. We can fix this by re-defining
fin such a way that
Spoke -> Val, but rather it knows the full path:
f': (Time -> Spoke) -> Val.
But there was a vagueness in this
path: Time -> Spoke f: Spoke -> 2^Val -- multi-valued -- | morally, not mathematically. out: Time -> Val out t = choose_best_value (f(path[t]))
choose_best_value. So we redefine it:
path: Time -> Spoke f': (Time -> Spoke) -> Time -> Val f'(path, tcur) = argmax (\v -> |v - path[tcur-1]| + |v - path[tcur+1|) f(path[tcur]) out: Time -> Val out = f'(path)
f'that defines the value of the path has full access to the path itself!
tcur, it attempts to pick the value in
f(path[tcur])which makes the discontinuity as small as possible. It picks a value
vfrom the possible values of
vminimises the of the distances from the previous time point (
|v - path[tcur-1]), and the distance from the next time point (
|v - path[tcur + 1]).