Простая проверка концепции

Есть ли способ выразить это как концепцию?

Вам не нужна концепция, специализация шаблона класса отлично работает в вашем случае.
Например, вы можете сделать это:

template<typename T>
class A;

template<typename U>
class A<X<U>> { /* ... */ };

Таким образом, если A не создается с типом формы X<U> (где U неизвестно), вы получите ошибку времени компиляции, поскольку первичный шаблон не определен. Другими словами, это не будет работать для всех типов, кроме X<U> (для каждого U), где последний соответствует специализации шаблона класса, которая имеет правильное определение.

Обратите внимание, что я предположил, что X является известным типом. Это неясно из вашего вопроса.
В любом случае, если это не так, и вы хотите принимать типы формы X<U> для каждого X и каждого U, вы все равно можете сделать это:

template<typename T>
class A;

template<template<typename> class X, typename U>
class A<X<U>> { /* ... */ };

В качестве минимального рабочего примера:

template<typename>
struct S {};

template<typename>
class A;

template<typename U>
class A<S<U>> {};

int main() {
    A<S<int>> aSInt;
    A<S<double>> aSDouble;
    // A<char> aChar;
}

И A<S<int>>, и A<S<double>> в порядке, и пример компилируется. Если вы переключите комментарий, он больше не будет компилироваться, поскольку A<char> вообще не определен.

В качестве примечания: если вы не хотите использовать специализацию шаблона класса и хотите имитировать концепции (помните, что они еще не являются частью стандарта и не будут, по крайней мере, до 2020 года), вы можете сделать что-то вроде это:

#include<type_traits>

template<typename>
struct X {};

template<typename>
struct is_xu: std::false_type {};

template<typename U>
struct is_xu<X<U>>: std::true_type {};

template<typename T>
struct A {
    static_assert(is_xu<T>::value, "!");
    // ...
};

int main() {
    A<X<int>> aXInt;
    A<X<double>> aXDouble;
    // A<char> aChar;
}

То есть, учитывая универсальный тип T, статические утверждения его фактического типа с помощью другой структуры (is_xu в примере), которая проверяет, имеет ли T форму X<U> (для каждого U) или нет.

Мои два цента: специализация шаблона класса легче читать и понимать с первого взгляда.

template <typename T, template <typename> class C>
concept bool Template = requires (T t) { {t} -> C<auto>; };

Теперь задан шаблон класса:

template <typename T>
struct X {};

параметр шаблона типа может быть ограничен с помощью:

template <typename T> requires Template<T, X>
class A {};

or:

template <Template<X> T>
class A {};

ДЕМО

Это будет работать и для типов, производных от X<U>.