§ The arg function, continuity, orientation

Let us think of the function arg:CRarg: \mathbb C \rightarrow \mathbb R as a multi valued function, which maps each complex number to the set of possible valid angles that generate it:
arg(z){tR:zei(π/2)t=z} arg(z) \equiv \{ t \in \mathbb R : |z|e^{i (\pi/2)t} = z \}
We plot the function here:
  • Note that for every value zCz \in C, we get a set of values associatedto it.

§ Recovering single valued-ness

Now, the question is, can we somehow automatically recover single valued-ness? kind of, by stipulating that for any given curve c:[0,1]Cc: [0, 1] \rightarrow \mathbb C, the function argc:[0,1]Rarg \circ c: [0, 1] \rightarrow \mathbb R is continuous. Let's try to investigate what happens if we move from right towards bot, arbitrarily stipulating ("picking a branch") that arg(right) = 0 as a sort of basepoint.
  • Note that we were forced to pick the value arg(bot) = -1 from ourconsiderations of continuity. No other value extends continuous from theright to the bottom.
  • Also note that we got a smaller value: we move from 0 -> -1: we decreaseour value as we move clockwise.
This prompts the natural question:
what happens if we move in the opposite direction?

§ Counter-clockwise movement

  • Let's move counter-clockwise from right, arbitrarily picking the brancharg(right) = 0 as before. This gives us:
  • Note that once again, we were forced to pick arg(top) = 1 by continuityconsiderations.
  • Also note that this time, we got a larger value: we move from 0 -> 1: weincrease our value as we move counter-clockwise

§ Multiple winding

the true power of this multi-valued approach comes from being able to handle multiple windings. Here the real meaning of being a multi-valued function shows through. If we decide to go through the the loop twice, as:
bot -> right -> top -> left -> bot -> right -> top -> left
-1  -> 0     -> 1   -> 2    -> 3   -> 4     -> 5   -> 6
That is, we end up with the value 6, which can only b

§ Orientation from continuity

There's something really elegant about being able to recover a notion of "orientation" by simply:
  1. Allowing multi-valued functions.
  2. Forcing continuity constraints.
  3. Interpreting increase/decrease in the value of the function.

§ Discretizing, gaining more insight

I was personally dis-satisfied with the above explanation, because it seemed weird that we would need to depend on the history to define this function. We can formalize this notion of history. Let's first discretize the situation, giving us:
  • We are on the space of the spokes, given by a, b, c, d, e, f, g, h.
  • We have a function f: Spoke -> Val whose values are given on the spokes.
  • We are interested in the path p: Time -> Spoke, p = [a, b, c, d, e, f, g, h, a].
  • If we evaluate the function f on the path p, we get out: Time -> Val, out = [0, 1, 2, 3, 4, 5, 6, 7, 0].
  • We have a "jump" from 7 to 0 in out as we cross from h to a. This is adiscontinuity in out at time 7.
  • We want to fix this, so we make the function f multi-valued.
  • We assign both values 8 and 0 to the spoke a. We wish to definethe evaluation of f: Spoke -> 2^N relative to path p. At time t, pointp[t], we pick any value in f(p[t]) that makes out[t] continuous.
  • So in this case, when we start, we have two choices for out[0] = f(p[0]) = f(a): 0 and 8.But we know that out[1] = f(p[1]) = f(b) = 1. Hence, for out[0] to be continuous, we mustpick out[0] = 0.
  • Similarly, at out[8] we have two choices: 0 and 8. But we have thatout[7] = 7, hence we pick out[8] = 8.
  • Note that we say 'we pick the value' that makes out continuous. This isnot really rigorous. We can fix this by re-defining f in such a waythat f is not Spoke -> Val, but rather it knows the full path:f': (Time -> Spoke) -> Val.

§ Making the theory path-dependent

We originally had:
path: Time -> Spoke
f: Spoke -> 2^Val -- multi-valued

-- | morally, not mathematically.
out: Time -> Val
out t = choose_best_value (f(path[t]))
But there was a vagueness in this 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)
  • The function f' that defines the value of the path has fullaccess to the path itself!
  • At time tcur, it attempts to pick the value in f(path[tcur]) whichmakes the discontinuity as small as possible. It picks a value v from thepossible values of f(path[tcur]). This v minimises 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]).
  • This provides a rigorous definition of what it means to "pick a value in the branch".This can clearly be extended to the continuous domain.