A recursive_count Function For Various Type Arbitrary Nested Iterable Implementation in C++
No need for an overload that takes no parameters
Nothing calls recursive_count() without parameters, so that overload is unnecessary.
Unnecessary requirements
You don't need to require both is_elements_iterable&lt;T&gt; and is_iterable&lt;T&gt;, the former will already cover the requirements of the latter, and if you negate them then the latter covers the former. So the overloads should be:
template&lt;class T&gt; requires !is_iterable&lt;T&gt;
size_t recursive_count(const T&amp; input)
{
    return 1;
}

template&lt;class T&gt; requires (!is_elements_iterable&lt;T&gt; &amp;&amp; is_iterable&lt;T&gt;)
size_t recursive_count(const T&amp; input)
{
    return input.size();
}

template&lt;class T&gt; requires is_elements_iterable&lt;T&gt;
size_t recursive_count(const T&amp; input)
{
    size_t output{};
    for (auto &amp;element : input)
    {
        output += recursive_count(element);
    }
    return output;
}

Naming
Indeed you already noticed that STL has a std::count that does something different. However there is a function that does what you want for non-nested containers: std::size. So consider naming your function std::recursive_size.
Consider making more use of STL algorithms
You are implementing your own algorithms but you are not making use of STL's algorithms. This can reduce the amount of code you write. For example, the last overload can be rewritten as:
template&lt;class T&gt; requires is_elements_iterable&lt;T&gt;
size_t recursive_count(const T&amp; input)
{
    return std::transform_reduce(std::begin(input), std::end(input), std::size_t{}, std::plus&lt;std::size_t&gt;(), [](auto &amp;element){
        return recursive_count(element);
    });
}

Although I'm not sure this is more readable than your version.