Well, they can with some slight tricks

I currently have a special module like this that handles the subscription and acts as a special dispatcher.
This does not rely on the parent LiveView and the subscription will be cleaned up when the parent LiveView process dies as normal PubSub subscriptions

defmodule MyLiveComponent.PubSub do
  @moduledoc false

  def subscribe(%Phoenix.LiveView.Socket{assigns: %{myself: myself} = socket, pubsub, topic) do
    if Phoenix.LiveView.connected?(socket) do
      Phoenix.PubSub.subscribe(pubsub, topic, metadata: %{pid: self(), cid: myself})
      socket
    else
      socket
    end
  end

  def subscribe(%Phoenix.LiveView.Socket{} = socket, pubsub, topic) do
    Phoenix.PubSub.subscribe(pubsub, topic)
    socket
  end

  def unsubscribe(pubsub, topic) do
    Phoenix.PubSub.unsubscribe(pubsub, topic)
  end

  def broadcast(pubsub, topic, message) do
    Phoenix.PubSub.broadcast(
      pubsub,
      topic,
      message,
      __MODULE__
    )
  end

  def broadcast_from(pubsub, pid, topic, message) do
    Phoenix.PubSub.broadcast_from(
      pubsub,
      pid,
      topic,
      message,
      __MODULE__
    )
  end

  def local_broadcast(pubsub, topic, message) do
    Phoenix.PubSub.local_broadcast(
      pubsub,
      topic,
      message,
      __MODULE__
    )
  end

  def dispatch(entries, _dispatch_identificator, message) do
    entries
    |> Enum.each(fn
      {_pid, %{cid: cid, pid: pid}} ->
        Phoenix.LiveView.send_update(pid, cid, source: :pubsub, message: message)

      {pid, _} ->
        send(pid, message)
    end)

    :ok
  end
end

And a live component can be something like this:

defmodule MyComponent do
  use MyWeb, :live_component
  import MyWeb.CoreComponents

  @impl true
  def render(assigns) do
   ~H"""
     <%= @message %>
    <.button phx-event="send">Send</.button>
   """
  end

  @impl true
  def update(%{source: :pubsub, message: message}, socket) do
    socket
    |> assign(:message, message)
  end

  @impl true
  def mount(socket) do
    updated_socket = socket
    |> assign(:message, "No message")
    |> MyLiveComponent.PubSub.subscribe(MyPubSub, "topic")

    {:ok, updated_socket}
  end

  @impl true
  def handle_event("send", _params, socket) do
    MyLiveComponent.PubSub.broadcast(MyPubSub, "topic", "We got a message!")
    {noreply, socket}
  end