What is the maximal size of a subset of consecutive integers such that they are all coprime? Suppose that $a$,$b$, and $n$ are positive integers such that $a = b - n$. In terms of $n$, what is the largest number of integers $z_1,z_2,z_3,\cdots, z_m$ all between $a$ and $b$ such that all $z$ are coprime to each other?
I feel like this is something I should be able to find online somewhere, but I couldn't find it. I'm not looking for a proof so much as just looking for the current proven metric. I know it cannot be more than roughly $\frac n2$.
 A: This problem is closely related to the seminal work of Hensley and Richards on admissible $k$-tuples.  Let $r(n)$ be the maximum cardinality indicated in the question.  Clearly we have the lower bound $r(n) \ge \pi(n)$ by taking $a=1, b=n+1$ and choosing all primes up to $n$.  We could also include $1$ itself and $n+1$ if it happens to be prime, but this only contributes a bounded amount to the maximum.  Consequently the research on this question has been directed towards understanding the nature of $r(n) - \pi(n)$.
This was first considered by Erdős and Selfridge in their 1971 paper "Complete prime subsets of consecutive integers", where they showed (PDF link) that for infinitely many values of $n$, $$r(n) - \pi(n) > (\log 2 - \tfrac12 - o(1)) \frac{n}{(\log n)^2}.$$
As observed by fleablood in the comments, a valid set is allowed to contain one even number, one multiple of $3$, one multiple of $5$, etc.  At the time of the previous paper, it appears that Erdős may have believed that these contributions are essential to the above lower bound.
However, this was disproven by Hensley and Richards in their famous 1974 paper "Primes in intervals" (PDF link).  There, they considered the maximum cardinality of a subset of integers in $[a,a+n]$ which contains no even numbers, no multiples of $3$, and so on up to $n$.  Calling this $\rho(n)$, they showed that:
$$\rho(n) - \pi(n) > (\log 2 - o(1)) \frac{n}{(\log n)^2}.$$
Since clearly $\rho(n) \le r(n)$, this also improves the bound of Erdős and Selfridge.  This surely attracted Erdős's attention and soon afterwards he co-authored "Density Functions for Prime and Relatively Prime Numbers" with Hensley (PDF link).  There they showed that in fact
$$r(n) - \rho(n) = o(\frac{n}{(\log n)^2}),$$
so that the difference between "at most one multiple of $p$" and "no multiples of $p$" is surprisingly small compared to $\rho(n) - \pi(n)$ itself.
As of 1985, the question of whether $r(n)-\pi(n)$ is truly $\Theta(n/(\log n)^2)$ or something even larger was still open, as Erdős listed it as one of his favorite open problems in http://www.math-inst.hu/~p_erdos/1985-17.pdf.
Some computational data: OEIS A062575 contains a table of the values of $r(n)$ for the first $76$ values of $n$.
A: Your question isn't quite clear. My understanding is that you are asking: Given an integer n, which is the maximum number of co-prime numbers in an interval [a, b] with b - a = n? 
Among your numbers, at most one may be divisible by 2. At most one may be divisible by 3, by 5 and so on. Assume you found m numbers of which no two have a common prime factor up to p, and q is the next prime number after p. Let P = product of all primes up to p. If m ≤ 2q - 1 then there is a remainder r such that at most one number is equal to r (modulo q). By adding the right multiple of P, you can find numbers such that no two are divisible by the same prime p, and no two are divisible by q. We can repeat this, getting bigger numbers but with the same property. Eventually q > n, and then no two numbers can be divisible by q or any bigger prime, and at that point we have found m co-prime numbers. 
So you can try to find $m_2$ integers of which no two are even, then $m_3$ integers of which no two are divisible by 3 and so on. Once $m_p ≤ 2q - 1$ you know the answer is m. With n = 20 you can find 10 numbers: 11, 13, 16, 17, 19, 23, 25, 27, 29, 31. For large n, say n = 1000, if you took any interval [a, b] of 1001 numbers, you would remove almost half the numbers because they are even, almost one third of the remainder because they are divisible by 3, almost one fifth because they are divisible by 5, then almost one seventh, so more than 3/4s of the numbers would be gone. Finding a maximum set will be very, very hard once n gets a bit larger. 
A: The title of your post says consecutive integers. If that is the case, $n=2$, for a total of 3 elements of the set. 
Proof: 
Let $a=11$. Then count until we find a number that is not coprime to any others. We have to stop at $b=14$, because $12$ and $14$ are both divisible by 2. So our set has 3 members, namely $\{11, 12, 13\}$. 
Even if we start with super small positive integers, for example $a=3$, we can't have more than $\{3, 4, 5\}$ because the next integer, $6$, is divisible by the first integer, $3$.
A: This isn't entirely an answer, but I wrote some Haskell code meant to be the largest subset between a particular $a$ and $b$. It seems to give much larger values than I was expecting. If anyone has any suggestions please feel free to let me know. Once again, this is just as a tool to help in this problem. It seems very very hard to prove in general.
The following is Haskell source code. DO NOT apply math jax. It will mess it up.

    subsets []  = [[]]
    subsets (x:xs) = subsets xs ++ map (x:) (subsets xs)

    divides a b = (mod a b == 0)

    coprime a b = ((gcd a b) == 1)

    mutually_coprime []  = True
    mutually_coprime (x:xs) | (coprime_list x xs) = mutually_coprime xs
                            | otherwise = False

    coprime_list _ [] = True
    coprime_list a (x:xs) | (coprime a x) = coprime_list a xs
                          | otherwise = False

    coprime_subsets a b = coprime_subsets_helper (subsets [a..b])

    coprime_subsets_helper [] = []
    coprime_subsets_helper (x:xs) | ((mutually_coprime x) && ((list_length x) > 2)) = [x] ++ (coprime_subsets_helper xs)
                                  | otherwise = coprime_subsets_helper xs

    coprime_subset_length a b = max_element (map list_length (coprime_subsets a b))

    list_length [] = 0
    list_length (x:xs) = 1 + list_length xs

    max_element a = max_element_helper a 0

    max_element_helper [] a = a
    max_element_helper (x:xs) a | (x > a) = max_element_helper xs x
                                | otherwise = max_element_helper xs a

