Digital Hardness of Integers

Python, 76 69 68 63 62 60 57 bytes

f=lambda n,k=0:n>>k&(n&n>>k>n>>k+1)and(n&n+1>0)-~f(n,k+1)

Try it online!

How it works

This is a recursive solution that takes an input n and keeps incrementing k – starting at 0– while both LSB_k(n) (bit at index k from the right) and MSB_k(n) (bit at index k from the left) are set. Once finished, it returns k if all of n's bit are set and 2k if not.

Let's start by rewriting the lambda f as a named function F, with an auxiliary variable t.

def F(n, k = 0):
    t = n >> k
    return t & (n & t > t >> 1) and (n & (n + 1) > 0) + 1 + F(n, k + 1)

In each invocation of F, we first bit-shift n a total of k units to the right and store the result in t. This way, LSB₀(t) = LSB_k(n), so t is odd if and only if LSB_k(n) is set.

Determining whether MSB_k(n) is set is slightly trickier; this is what n & t > t >> 1 achieves. To illustrate how it works, let's consider an integer n = 1αβγδεζη₂ of bit-length 8 and analyze the function call F(n, 3), i.e., k = 3.

We're trying to determine whether MSB₃(n) = γ is set by examining the truth value of the comparison (n & t > t >> 1) = (1αβγδεζη₂ & 1αβγδ₂ > 1αβγ₂). Let's examine the involved integers.

MSB-index  012k4567

n          1αβγδεζη
t             1αβγδ

t >> 1         1αβγ

We claim that γ = 1 if and only if n & t > t >> 1.

• If γ = 1, then n & t has bit-length 5 while t >> 1 has bit-length 4, so n & t > t >> 1.

  This proves that γ = 1 implies n & t > t >> 1.

• If n & t > t >> 1, there are two options: either γ = 1 or γ = 0. In the first case, there's nothing left to prove.

  In the second case, we have that αβγδ₂ ≥ n & t > t >> 1 = 1αβγ₂.

  Since αβγδ₂ > 1αβγ₂, we must have MSB₀(αβγδ₂) ≥ MSB₀(1αβγ₂), meaning that α = 1.

  This way, 1βγδ₂ > 11βγ₂, so we must have MSB₁(1βγδ₂) ≥ MSB₁(11βγ₂), meaning that β = 1.

  In turn, this implies that 11γδ₂ > 111γ₂. Remembering that γ = 0 in the second case, we get the inequality 110δ₂ > 1110₂, which is false since MSB₂(110δ₂) = 0 < 1 = MSB₂(1110₂).

  Thus, only the first case is possible and n & t > t >> 1 implies γ = 1.

Summing up, if both LSB_k(n) and MSB_k(n) are set, t will be odd and n & t > t >> 1 will be True, so t & (n & t > t >> 1) will yield 1. However, if LSB_k(n) or MSB_k(n) is unset (or if both are), t will be even or n & t > t >> 1 will be False, so t & (n & t > t >> 1) will yield 0.

Calling F with a single argument initializes k = 0. While the condition we've discussed earlier holds, the code after and is executed, which (among other things) recursively calls F with incremented k.

Once LSB_k(n) or MSB_k(n) is unset, the condition fails and F(n, k) returns 0. Each of the preceding k function calls adds (n & (n + 1) > 0) + 1 to F(n, k) = 0, so F(n) returns ((n & (n + 1) > 0) + 1)k.

Now, if all bits of n are equal (i.e., if n is either 0 or all of its bits are set), n + 1 will not have any bits in common with n, so n & (n + 1) = 0 and F(n) returns k. However, if n has both set and unset bits, n & (n + 1) > 0 and F(n) returns 2k.

MATL, 13 12 bytes

Btv`6L&)}x@q

Try it online! Or verify all test cases.

Explanation

The code repeats each binary digit, and counts how many times it is possible to remove two outer ones.

B        % Input number (implicit). Horizontal vector of binary digits
tv       % Duplicate and concatenate vertically
`        % Do...while
  6L&)   %   Flatten the array if needed (in column-major order), and split it
         %   into two subarrays: one with the inner entries, and another
         %   with the two outer entries. The latter will be used for deciding
         %   if the loop continues or is exited
}        % Finally (execute before exiting the loop)
  x      %   Delete last subarray of inner entries
  @q     %   Push last iteration index minus 1
         % End (implicit). The next iterarion is executed if the array at the
         % top of the stack is non-empty and only contains nonzero values. 
         % Otherwise the loop is exited, executing the "finally" block first
         % Display (implicit)

Python, 82 bytes

I feel like it can still be golfed, but I spent a while trying different methods and this was the shortest.

def f(n):b=bin(n)[2:];x=min(b.find('0'),b[::-1].find('0'));print(x<0)*len(b)or x*2

Try it online

Though this works similarly to the OP's Python program, I created this before the question was posted, after viewing the question in the Sandbox, which did not contain such a program.