Ignoring arithmetic progressions of 0. The even progression lengths behave regularly, and the odds... don't.
The even ones seem to converge up to
n+1 where
n is the progression length.
The odd numbers.... don't.
I've wrote a program to generate arithmetic progressions the same way that you described. (Proving it generates the densest set is a different matter, of course.) And I let it run over night.
For progression length 2, it's converged very quickly on 3.
For progression length 3, it is converging very very slowly on a number at least 4.2623
23741011 241957 125 4.262390641893804677
23741094 241958 83 4.2623906840148624298
23741153 241959 59 4.2623907261358162657
23741480 241960 327 4.2623907682561892329
23741530 241961 50 4.2623908103764733823
23741690 241962 160 4.2623908524964742028
23741798 241963 108 4.2623908946162831768
23741883 241964 85 4.2623909367359411604
23741980 241965 97 4.2623909788554277256
23742158 241966 178 4.2623910209745980993
I just tailed the results and that's what I get, the columns are current member of the series, current series length, difference between the current member and the last member, and the sum total.
I haven't a clue when it's going to stabilize out.
If anyone cares to run it on a faster computer, here's the code I wrote, it's a little hackish, but well optimized.
#include <iostream>
#include <iomanip>
int main() {
int series[1000000]; //we can change this later if we need more computingness.
series[0] = 1;
int series_length = 1;
int length_arith_prog = 3;
double sum = 1.0;
int n = 2;
std::cout << std::setprecision(20);
for (;;n++) {
int found = 0;
for (int i=0; i < series_length && found == 0; i++) {
int members_arith_prog = 0;
int debug = (n - series[i])%length_arith_prog;
if (!((n - series[i])%length_arith_prog)) { //if between these two numbers it is possible to have an arithmetic progression of the specified length
int common_diff = (n - series[i])/length_arith_prog;
for (int j=1; j < length_arith_prog; j++) {
/* for (int k=i+1; k < series_length; k++) { //we only want to test numbers larger than the one we're currently examining.
if (series[k] == series[i] + j*common_diff) {
members_arith_prog++;
}
}*/
int mid=((i+1)+(series_length-1))/2; //the +1 and -1 cancel, they're just there to remind me.
int high = series_length;
int low = i+1;
int value = series[i] + j*common_diff;
while (low < high) {
mid = low + ((high - low) / 2); // Note: not (low + high) / 2 !!
if (series[mid] < value) {
low = mid + 1;
} else {
high = mid;
}
}
if ((low < series_length) && (series[low] == value)) {
members_arith_prog++;
}
}
}
if (members_arith_prog+1 == length_arith_prog) { //found a arithmetic progression!
found = 1;
}
}
if (found == 0) {
series[series_length] = n;
int deriv = series[series_length] - series[series_length-1];
series_length++;
sum += (1.0/n);
std::cout << n << " " << series_length << " " << std::setw(5) << deriv << " " << sum << std::endl;
}
}
}