# JUNTO Practice: Probability, Circle Arcs

Discussed on June 30, 2020.

From "Twenty problems in probability":

Choose, at random, three points on the circle

x^{2}+y^{2}= 1. Interpret them as cuts that divide the circle into three arcs. Compute the expected length of the arc that contains the point (1, 0).

Please provide an answer and a justification.

## Solutions

Click to see:

### Oscar Martinez

```
import numpy as np
def random_theta():
return 360 * np.random.sample()
def get_x_y(theta, r=1):
return r * np.cos(theta), r * np.sin(theta), theta
def get_arc_lengths():
points = [get_x_y(random_theta()) for _ in range(3)]
lengths = sorted([p[2] for p in points])
length_w_point = lengths[0] + (360 - lengths[-1])
return length_w_point
np.mean([get_arc_lengths() for _ in range(1000000)])
```

Initially I naively assumed that (1,0) was just a random point, and so I assumed the expected value f the arc containing it was just the expected value of the length of any arc (120 degrees or 2pi/3).

I realized after reviewing John's solution and the answer in the document that this was an oversimplification. I instead simulated, the last and first point around the 360 degrees of the circle and calculated the mean. The mean was 180 degrees, or roughly pi in radians.

### John Lekberg

I believe that the expected length of the arc that contains (1, 0) is π.

I wrote a Python function to sample the random variable "the length of the arc that contains (1, 0)":

`import math, random, statistics def n_random_arc_length(*, n): """Sample the random variable 'length of the arc containing (1, 0)' `n` times. """ rand = random.random tau = math.tau arcs = [None] * n for i in range(n): points = [rand() * tau, rand() * tau, rand() * tau] points.sort() arcs[i] = points[0] + (tau - points[-1]) return arcs statistics.mean(n_random_arc_length(n=10_000_000))`

```
3.1416595239407696
```

This seems suspiciously close to π, and given that this problem takes place on a circle, this makes me believe that the expected value is π.

### Daniel Bassett

The answer is approximately 'pi' as per the five simulation findings below:

`from random import random import math from statistics import mean def simulate(n): # create empty list for desire arc lengths l = [0 for i in range(n)] i = 0 s = len(l) while i < s: # create three random points along the circle theta = random() * (2 * math.pi) alpha = random() * (2 * math.pi) gamma = random() * (2 * math.pi) cartesian = [theta, alpha, gamma] # order the values in a copied list from smallest to # largest so that we may 'measure' the arc length # around our desired coordinate which is in between # the smallest and largest cartesian coordinate pair # (1, 0) ordered = sorted(cartesian) largest_coordinate = ordered[2] middle_coordinate = ordered[1] smallest_coordinate = ordered[0] # populate the arc length list with values passing # through desired point l[i] = ( smallest_coordinate + middle_coordinat + largest_coordinate ) - (2 * math.pi) i += 1 return l # print the mean of the total simulated values from # arclength list print(mean(simulate(1000000)))`

```
3.14038739
```