Probability that one of a set of four points lies within the triangle formed by the other three Given four points, each randomly chosen with a uniform probability distribution in the interior of a (WLOG unit) circle, what is the probability that (any) one of the points lies within the triangle formed by the other three. This is (meant to be) equivalent to asking what is the probability, given these four random points, that one can form two "layers" of triangles, with for example ABC covered by (though sharing a side with) ABD because C lies in the interior of ABD.
Ideally, the method of solution would be generalizable to numbers of points greater than four; in other words, given (3+n) points (for n>1), each randomly chosen with a uniform probability within the interior of a circle, what is the probability that one can form n+1 layers. (I'm having trouble stating the generalized problem precisely; I hope it's clear.)
Edit to add: In case anyone is curious about whence the problem comes: it was inspired by Ingress, an enhanced reality game run by Google wherein players go to and link predesignated geographic points to form "fields", which are simply completed triangles but which are limited by the rule that links can never cross each other. In the game it is often advantageous to form layers of fields, the simplest case of which, for four points, is what I describe in the first paragraph and the most efficient general case (n-2 overlapping fields out of n points) I allude to in the second. I've seen and heard many comments by players about how often such overlapping fields can be formed, but I've never seen anything approaching a definitive answer to it.
Note that this means the question I really wanted to ask is the same one but for points on the surface of a sphere, not a portion of a flat plane, but almost all fields in the game are quite small relative to the Earth (though not all; on rare occasions, fields with edge lengths of thousands of kilometers are formed; the great majority are tens or hundreds of meters) so the answer to the question I posed will be a very good approximation.
 A: I'm posting this code to numerically compute the answer as community wiki as a response to @Dijkgraaf's post. It gives values
average area =  0.23156136586256632
probability of hitting =  0.0737082720122766
rejected =  81491 3.1455525818433463

Here is the code (Google Go language):
package main

import (
    "fmt"
    "math/rand"
    "math"
)

var rejected int = 0
var calls int = 0

type point struct {
    x float64
    y float64
}

func rpoint() point {
    var p point
tryagain:
    calls++
    p.x = 2.0*rand.Float64()-1.0;
    p.y = 2.0*rand.Float64()-1.0;
    len := p.x*p.x + p.y*p.y
    if len > 1.0 {
        rejected++
        goto tryagain;
    }
    return p
}

func lensq(p1 point, p2 point) float64 {
    x := p1.x - p2.x
    y := p1.y - p2.y
    l := math.Sqrt(x*x + y*y)
    return l
}

func area(p1 point, p2 point, p3 point) float64 {
    a := lensq(p1, p2)
    b := lensq(p3, p2)
    c := lensq(p3, p1)
    s := (a + b + c)/2.0
    hero := math.Sqrt(s*(s-a)*(s-b)*(s-c))
    return hero
}

func main() {
    max := 100000
    total := 0.0
    for test := 0; test < max; test++ {
        p1 := rpoint()
        p2 := rpoint()
        p3 := rpoint()
        a := area(p1, p2, p3)
        total += a
    }
    fmt.Println("average area = ",total/(float64(max)))
    fmt.Println("probability of hitting = ",total/(float64(max)*math.Pi))
    // As a check, see if we get a value close to PI here.
    fmt.Println("rejected = ", rejected, 4.0*float64(calls-rejected)/float64(calls))
}

