Preface
I've seen a whole bunch of different numbers thrown around in different threads regarding how effective talent points placed in Eradication are. I tried running the numbers myself and came up with numbers that I hadn't seen in those posts. I rechecked my math and wrote an Eradication proc simulation that I think shows my numbers are right.
TL;DR Version
1 point in Eradication gives an uptime percentage of 11.76%, or about 2.35% effective spell haste
2 points in Eradication gives an uptime percentage of 17.18%, or about 3.44% effective spell haste
3 points in Eradication gives an uptime percentage of 21.05%, or about 4.21% effective spell haste
The Math
Call the probability that an eligible Corruption tic results in an Eradication proc
p.
Call
q the probability that an eligible Corruption tic does not result in an Eradication proc, i.e., q = 1 - p.
Assume 100% uptime of Corruption. Assume cows are spherical.
Take the first Corruption tic after an Eradication proc that is eligible to proc another Eradication, i.e., 30 or more seconds since the previeous proc. There is probability p that 12 of the next 30 seconds will be hasted, after which the next Corruption tic will be eligible to proc another Eradication. There is probabiiity p * q that 12 of the next 33 seconds will be hasted, following which, again, the next Corruption tic will be eligible. The expected duration until the next time a Corruption tic will be eligible following an Eradication proc is the infinite sum:
30 * p + 33 * p * q + 36 * p * q^2 + ... + (30 + 3 * k) * p * q^k + ...
Which can be separated into two infinite sums:
30 * p + 30 * p * q + 30 * p * q^2 + ... + 0 * p + 3 * p * q + 6 * p * q^2 + ...
The first infinite sum is a simple geometric series multiplied by a constant:
30 * p * Sum(q^k, k = 0, 1, 2, ...)
Which is therefore equal to 30 * p * 1/(1 - q). But since, from above, we've said that 1 - p = q, then 1 - q = p, so that gives us 30 * p / p = 30 for p not equal to 0.
The second infinite sum is trickier. To solve it we rely on some calculus. Since Sum(q^k, k = 0, 1, 2, ...) = 1/(1 - q), take the derivative of both sides:
d/dq Sum(q^k, k = 0, 1, 2, ...) = Sum( d/dq q^k, k = 0, 1, 2, ...) = Sum(k * q^(k-1), k = 0, 1, 2)
d/dq 1/(1-q) = d/dq (1-q)^-1 = -1 * (1 - q)^-2 * d/dq (1 - q) = -1 * (1 - q)^-2 * -1 = (1 - q)^-2
The second infinite series, expressed in summation form is
3 * p * Sum(k * q^k, k = 0, 1, 2, ...) = 3 * p * q * Sum(k * q^(k-1), k = 0, 1, 2, ... )
Which, from the calculus equations makes it equal to 3 * p * q / (1 - q)^2, which is simplifies to 3 * p * (1 - p) / p^2, which further simplifies to 3 * (1 - p) / p.
Which gives the total duration equal to:
30 + 3 * (1 - p) / p
Therefore, for p = 0.04 (i.e., 1 point in the talent) the duration equals 102 seconds, for p = 0.07 the duration is sightly less than 70 seconds, and for p = 0.1 the duration equals 57 seconds. Therefore, for one talent point the uptime ratio is 12 / 102, for two points it's about 12 / 70, and for three points it's 12 / 57. These fractions are approximately
0.1176,
0.1718, and
0.2105, respectively.
The Simulation
Written in Perl because I'm lazy, impatient and overconfident. It models the latency between corruption completion and recast as an exponential distribution. As the time that a single simulation is performed over is increased, the number appear to converge to the fractions given above.

#!/usr/bin/perl -w
use strict;
# globals
# change these for different simulations
my $procProbability = 0.04;
my $simTime = 600;
my $iterations = 10000;
my $uptime = .9999;
# these shouldn't change
my $duration = 18;
my $tics = 6;
my $ticTime = $duration / $tics;
my $eradDuration = 12;
my $downtimeSecs = $duration / $uptime - $duration;
my $eradLockout = 30;
# Modeling the lag time as an exponential distribution.
sub randlag()
{
return $downtimeSecs * -log(1 - rand())
}
# Run the simulation once and return the eradication uptime in seconds
sub runSim()
{
my $lastErad = -$eradLockout; # Low enough so that any initial procs will not be suppressed
my $curTime = 0;
my $ticsLeft = 0;
my $eradTime = 0;
my $clip = 0;
my $clipTime = 0;
while ($curTime < $simTime)
{
if ($ticsLeft == 0)
{
# Model lag, and recast
$curTime += randlag() + $ticTime;
$ticsLeft = $tics;
}
$ticsLeft--;
if ($curTime - $lastErad >= $eradLockout && rand() < $procProbability)
{
$lastErad = $curTime;
$eradTime += $eradDuration;
}
if ($ticsLeft > 0)
{
$curTime += $ticTime;
}
}
# If the final eradication proc was clipped by the duration of the sim,
# chop off the unused portion
if ($simTime - $lastErad < $eradDuration)
{
$eradTime = $eradTime - $eradDuration + $simTime - $lastErad;
}
return $eradTime;
}
# Main starts here
my $sumTimes = 0;
for(my $i = 0; $i < $iterations; $i++)
{
$sumTimes += runSim();
}
my $averageRun = $sumTimes / $iterations;
my $avgPct = 100 * $averageRun / $simTime;
print "For the average run over $simTime, uptime is $averageRun ($avgPct%)\n";
exit 0;