diff --git a/xls/ir/node_util.cc b/xls/ir/node_util.cc
index cd4cc02558..289885ddde 100644
--- a/xls/ir/node_util.cc
+++ b/xls/ir/node_util.cc
@@ -1587,4 +1587,28 @@ absl::StatusOr<Node*> GenericSelect::MakePredicateForDefault() const {
           absl::StrFormat("%s is not a select like operation.", n->ToString()));
   }
 }
+
+absl::StatusOr<Node*> GenericSelect::MakeSelectLikeWithNewArms(
+    absl::Span<Node* const> new_cases, std::optional<Node*> new_default_value,
+    const SourceInfo& loc) const {
+  XLS_RET_CHECK(valid());
+  XLS_RET_CHECK_EQ(new_cases.size(), cases().size());
+  FunctionBase* fb = AsNode()->function_base();
+  return std::visit(
+      Visitor{[&](Select* /*unused*/) -> absl::StatusOr<Node*> {
+                return fb->MakeNode<Select>(loc, selector(), new_cases,
+                                            new_default_value);
+              },
+              [&](PrioritySelect* /*unused*/) -> absl::StatusOr<Node*> {
+                XLS_RET_CHECK(new_default_value.has_value());
+                return fb->MakeNode<PrioritySelect>(loc, selector(), new_cases,
+                                                    *new_default_value);
+              },
+              [&](OneHotSelect* /*unused*/) -> absl::StatusOr<Node*> {
+                XLS_RET_CHECK(!new_default_value.has_value());
+                return fb->MakeNode<OneHotSelect>(loc, selector(), new_cases);
+              }},
+      sel_);
+}
+
 }  // namespace xls
diff --git a/xls/ir/node_util.h b/xls/ir/node_util.h
index af2885430e..2b8363cb03 100644
--- a/xls/ir/node_util.h
+++ b/xls/ir/node_util.h
@@ -593,6 +593,8 @@ absl::StatusOr<Node*> RemoveFromTuple(Node* tuple,
 // select nodes.
 class GenericSelect {
  public:
+  enum class Kind { kSel, kPrioritySel, kOneHotSel };
+
   // noop constructor for lists and such
   GenericSelect() : sel_(static_cast<Select*>(nullptr)) {}
   explicit GenericSelect(Select* select) : sel_(select) {}
@@ -635,6 +637,13 @@ class GenericSelect {
   }
 
   bool valid() const { return AsNode() != nullptr; }
+  Kind kind() const {
+    return std::visit(
+        Visitor{[](Select*) { return Kind::kSel; },
+                [](PrioritySelect*) { return Kind::kPrioritySel; },
+                [](OneHotSelect*) { return Kind::kOneHotSel; }},
+        sel_);
+  }
   absl::Span<Node* const> cases() const {
     return std::visit(
         Visitor{
@@ -669,6 +678,16 @@ class GenericSelect {
   // Make and return a new node which is true if the default case is selected.
   absl::StatusOr<Node*> MakePredicateForDefault() const;
 
+  // Creates a new select-like node of the same kind as this GenericSelect.
+  //
+  // `new_cases` must have the same size as `cases()`.
+  //
+  // - For `priority_sel`, `new_default_value` must be present.
+  // - For `one_hot_sel`, `new_default_value` must be empty.
+  absl::StatusOr<Node*> MakeSelectLikeWithNewArms(
+      absl::Span<Node* const> new_cases, std::optional<Node*> new_default_value,
+      const SourceInfo& loc) const;
+
   friend bool operator==(const GenericSelect& lhs, const GenericSelect& rhs) {
     return lhs.AsNode() == rhs.AsNode();
   }
diff --git a/xls/passes/select_simplification_pass.cc b/xls/passes/select_simplification_pass.cc
index a8ea38a293..a4bd64ac55 100644
--- a/xls/passes/select_simplification_pass.cc
+++ b/xls/passes/select_simplification_pass.cc
@@ -1202,9 +1202,138 @@ absl::StatusOr<bool> MaybeReorderSelect(Node* node,
   return true;
 }
 
+absl::StatusOr<bool> TryHoistPredicateThroughSelectLike(
+    Node* node, const QueryEngine& query_engine) {
+  enum class HoistKind : uint8_t { kCompare, kBitwiseReduce };
+  HoistKind kind;
+  CompareOp* cmp = nullptr;
+  Op bitwise_reduce_op;
+
+  std::optional<GenericSelect> sel;
+  Node* other = nullptr;
+  bool select_like_is_lhs = false;
+  if (node->Is<CompareOp>()) {
+    kind = HoistKind::kCompare;
+    cmp = node->As<CompareOp>();
+
+    // Look for `cmp(sel_like, literal)` or `cmp(literal, sel_like)` where
+    // `sel_like` is any select-like node wrapped by `GenericSelect`. We keep
+    // track of which side the select-like node is on so we preserve operand
+    // ordering for non-commutative compares (e.g. ULT/UGT).
+    if (auto gs = GenericSelect::From(cmp->operand(0)); gs.ok()) {
+      sel = *gs;
+      other = cmp->operand(1);
+      select_like_is_lhs = true;
+    } else if (auto gs = GenericSelect::From(cmp->operand(1)); gs.ok()) {
+      sel = *gs;
+      other = cmp->operand(0);
+      select_like_is_lhs = false;
+    } else {
+      return false;
+    }
+  } else if (node->Is<BitwiseReductionOp>()) {
+    kind = HoistKind::kBitwiseReduce;
+    bitwise_reduce_op = node->op();
+    // Treat `reduce(sel_like(...))` similarly to applying the reduction to the
+    // selected value.
+    if (auto gs = GenericSelect::From(node->operand(0)); gs.ok()) {
+      sel = *gs;
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+  XLS_RET_CHECK(sel.has_value() && sel->valid());
+  if (sel->kind() == GenericSelect::Kind::kOneHotSel &&
+      !query_engine.ExactlyOneBitTrue(sel->selector())) {
+    // For `one_hot_sel`, hoisting the compare into the arms is only semantics-
+    // preserving when the selector is exactly-one-hot. Otherwise, `one_hot_sel`
+    // has "multiple active arms" behavior which is not equivalent to selecting
+    // exactly one arm and then comparing.
+    return false;
+  }
+
+  // Guardrails:
+  //
+  // - Single use: avoids duplicating the select tree under multiple
+  //   compares/users (this rewrite clones the compare into each arm). Use
+  //   `HasSingleUse()` so we account for implicit uses.
+  // - Literal other operand: maximizes folding opportunities after hoisting the
+  //   comparison through the select(-like) into the arms.
+  //   This keeps the rewrite roughly area-preserving in the intended cases:
+  //   all-but-(at most)-one arm becomes a constant after folding.
+  if (!HasSingleUse(sel->AsNode()) ||
+      (kind == HoistKind::kCompare && !other->Is<Literal>())) {
+    return false;
+  }
+
+  auto count_non_literal_arms =
+      [&](absl::Span<Node* const> cases,
+          std::optional<Node*> default_value) -> int64_t {
+    int64_t non_literal_arm_count = 0;
+    for (Node* c : cases) {
+      if (!c->Is<Literal>()) {
+        ++non_literal_arm_count;
+      }
+    }
+    if (default_value.has_value() && !default_value.value()->Is<Literal>()) {
+      ++non_literal_arm_count;
+    }
+    return non_literal_arm_count;
+  };
+
+  // Profitability: we only rewrite when there is at most one non-literal arm
+  // (including the default). In these cases, hoisting the predicate into the
+  // arms enables aggressive folding of constant arms and can reduce critical-
+  // path delay by moving the predicate "closer" to the data.
+  if (count_non_literal_arms(sel->cases(), sel->default_value()) > 1) {
+    return false;
+  }
+
+  FunctionBase* f = node->function_base();
+  auto make_predicate = [&](Node* arm) -> absl::StatusOr<Node*> {
+    if (kind == HoistKind::kCompare) {
+      // Preserve operand order for non-commutative compares by placing `arm` on
+      // the same side where the select-like result originally appeared.
+      Node* lhs = select_like_is_lhs ? arm : other;
+      Node* rhs = select_like_is_lhs ? other : arm;
+      return f->MakeNode<CompareOp>(node->loc(), lhs, rhs, cmp->op());
+    }
+    XLS_RET_CHECK(kind == HoistKind::kBitwiseReduce);
+    return f->MakeNode<BitwiseReductionOp>(node->loc(), arm, bitwise_reduce_op);
+  };
+
+  std::vector<Node*> new_cases;
+  new_cases.reserve(sel->cases().size());
+  for (Node* c : sel->cases()) {
+    XLS_ASSIGN_OR_RETURN(Node * new_case, make_predicate(c));
+    new_cases.push_back(new_case);
+  }
+  std::optional<Node*> new_default = std::nullopt;
+  if (sel->default_value().has_value()) {
+    XLS_ASSIGN_OR_RETURN(new_default, make_predicate(*sel->default_value()));
+  }
+
+  XLS_ASSIGN_OR_RETURN(
+      Node * replacement,
+      sel->MakeSelectLikeWithNewArms(new_cases, new_default, node->loc()));
+  VLOG(2) << "Hoisting "
+          << (kind == HoistKind::kCompare ? "compare" : OpToString(node->op()))
+          << " through " << sel->AsNode()->op() << ": " << node->ToString();
+  XLS_RETURN_IF_ERROR(node->ReplaceUsesWith(replacement));
+  return true;
+}
+
 absl::StatusOr<bool> SimplifyNode(Node* node, const QueryEngine& query_engine,
                                   BitProvenanceAnalysis& provenance,
                                   int64_t opt_level, bool range_analysis) {
+  XLS_ASSIGN_OR_RETURN(bool hoisted_cmp,
+                       TryHoistPredicateThroughSelectLike(node, query_engine));
+  if (hoisted_cmp) {
+    return true;
+  }
+
   // Select with a constant selector can be replaced with the respective
   // case.
   if (node->Is<Select>() &&
diff --git a/xls/passes/select_simplification_pass_test.cc b/xls/passes/select_simplification_pass_test.cc
index cb6f24329b..048ef66fa5 100644
--- a/xls/passes/select_simplification_pass_test.cc
+++ b/xls/passes/select_simplification_pass_test.cc
@@ -58,13 +58,14 @@ enum class AnalysisType {
   kTernary,
   kRange,
 };
-std::ostream& operator<<(std::ostream& os, AnalysisType a) {
+[[maybe_unused]] std::ostream& operator<<(std::ostream& os, AnalysisType a) {
   switch (a) {
     case AnalysisType::kTernary:
       return os << "Ternary";
     case AnalysisType::kRange:
       return os << "Range";
   }
+  return os;
 }
 class SelectSimplificationPassTest
     : public IrTestBase,
@@ -163,6 +164,261 @@ TEST_P(SelectSimplificationPassTest, BinaryTuplePrioritySelect) {
                    /*default_value=*/m::TupleIndex(m::Tuple(), 1))));
 }
 
+TEST_P(SelectSimplificationPassTest,
+       HoistCompareThroughSelectLikeWithMostlyLiteralArms) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue s = fb.Param("s", p->GetBitsType(2));
+  BValue x = fb.Param("x", p->GetBitsType(8));
+  BValue param_p = fb.Param("p", p->GetBitsType(1));
+
+  BValue lit0 = fb.Literal(Value(UBits(0, 8)));
+  BValue lit1 = fb.Literal(Value(UBits(1, 8)));
+  BValue lit2 = fb.Literal(Value(UBits(2, 8)));
+
+  BValue pr = fb.PrioritySelect(s, /*cases=*/{lit1, x}, /*default_value=*/lit2);
+  BValue eq_pr = fb.Eq(pr, lit0);
+
+  BValue se = fb.Select(s, /*cases=*/{lit1, x}, /*default_value=*/lit2);
+  BValue eq_se = fb.Eq(se, lit0);
+
+  // Selector is provably exactly-one-hot: concat(not(p), p).
+  BValue not_p = fb.Not(param_p);
+  BValue oh = fb.Concat({not_p, param_p});
+  BValue ohs = fb.OneHotSelect(oh, /*cases=*/{lit1, x});
+  BValue eq_ohs = fb.Eq(ohs, lit0);
+
+  XLS_ASSERT_OK_AND_ASSIGN(
+      Function * f, fb.BuildWithReturnValue(fb.Tuple({eq_pr, eq_se, eq_ohs})));
+  EXPECT_TRUE(f->return_value()->Is<Tuple>());
+
+  solvers::z3::ScopedVerifyEquivalence stays_equivalent{f};
+  EXPECT_THAT(Run(f), IsOkAndHolds(true));
+  EXPECT_THAT(
+      f->return_value(),
+      m::Tuple(m::PrioritySelect(m::Param("s"),
+                                 {m::Eq(m::Literal(1), m::Literal(0)),
+                                  m::Eq(m::Param("x"), m::Literal(0))},
+                                 m::Eq(m::Literal(2), m::Literal(0))),
+               m::Select(m::Param("s"),
+                         {m::Eq(m::Literal(1), m::Literal(0)),
+                          m::Eq(m::Param("x"), m::Literal(0))},
+                         m::Eq(m::Literal(2), m::Literal(0))),
+               m::OneHotSelect(m::Concat(m::Not(m::Param("p")), m::Param("p")),
+                               {m::Eq(m::Literal(1), m::Literal(0)),
+                                m::Eq(m::Param("x"), m::Literal(0))})));
+}
+
+TEST_P(SelectSimplificationPassTest,
+       HoistOrReduceThroughSelectLikeWithMostlyLiteralArms) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue s = fb.Param("s", p->GetBitsType(2));
+  BValue x = fb.Param("x", p->GetBitsType(8));
+  BValue param_p = fb.Param("p", p->GetBitsType(1));
+
+  BValue lit1 = fb.Literal(Value(UBits(1, 8)));
+  BValue lit2 = fb.Literal(Value(UBits(2, 8)));
+
+  BValue pr = fb.PrioritySelect(s, /*cases=*/{lit1, x}, /*default_value=*/lit2);
+  BValue or_pr = fb.OrReduce(pr);
+
+  BValue se = fb.Select(s, /*cases=*/{lit1, x}, /*default_value=*/lit2);
+  BValue or_se = fb.OrReduce(se);
+
+  // Selector is provably exactly-one-hot: concat(not(p), p).
+  BValue not_p = fb.Not(param_p);
+  BValue oh = fb.Concat({not_p, param_p});
+  BValue ohs = fb.OneHotSelect(oh, /*cases=*/{lit1, x});
+  BValue or_ohs = fb.OrReduce(ohs);
+
+  XLS_ASSERT_OK_AND_ASSIGN(
+      Function * f, fb.BuildWithReturnValue(fb.Tuple({or_pr, or_se, or_ohs})));
+  EXPECT_TRUE(f->return_value()->Is<Tuple>());
+
+  solvers::z3::ScopedVerifyEquivalence stays_equivalent{f};
+  EXPECT_THAT(Run(f), IsOkAndHolds(true));
+  EXPECT_THAT(
+      f->return_value(),
+      m::Tuple(
+          m::PrioritySelect(
+              m::Param("s"),
+              {m::OrReduce(m::Literal(1)), m::OrReduce(m::Param("x"))},
+              m::OrReduce(m::Literal(2))),
+          m::Select(m::Param("s"),
+                    {m::OrReduce(m::Literal(1)), m::OrReduce(m::Param("x"))},
+                    m::OrReduce(m::Literal(2))),
+          m::OneHotSelect(
+              m::Concat(m::Not(m::Param("p")), m::Param("p")),
+              {m::OrReduce(m::Literal(1)), m::OrReduce(m::Param("x"))})));
+}
+
+TEST_P(SelectSimplificationPassTest,
+       HoistAndXorReduceThroughSelectLikeWithMostlyLiteralArms) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue s = fb.Param("s", p->GetBitsType(2));
+  BValue x = fb.Param("x", p->GetBitsType(8));
+
+  BValue lit1 = fb.Literal(Value(UBits(1, 8)));
+  BValue lit2 = fb.Literal(Value(UBits(2, 8)));
+
+  // Keep the single-use profitability guard enabled by giving each select-like
+  // node exactly one use.
+  BValue pr_and =
+      fb.PrioritySelect(s, /*cases=*/{lit1, x}, /*default_value=*/lit2);
+  BValue and_pr = fb.AndReduce(pr_and);
+  BValue pr_xor =
+      fb.PrioritySelect(s, /*cases=*/{lit1, x}, /*default_value=*/lit2);
+  BValue xor_pr = fb.XorReduce(pr_xor);
+
+  BValue se_and = fb.Select(s, /*cases=*/{lit1, x}, /*default_value=*/lit2);
+  BValue and_se = fb.AndReduce(se_and);
+  BValue se_xor = fb.Select(s, /*cases=*/{lit1, x}, /*default_value=*/lit2);
+  BValue xor_se = fb.XorReduce(se_xor);
+
+  XLS_ASSERT_OK_AND_ASSIGN(
+      Function * f,
+      fb.BuildWithReturnValue(fb.Tuple({and_pr, xor_pr, and_se, xor_se})));
+  EXPECT_TRUE(f->return_value()->Is<Tuple>());
+
+  solvers::z3::ScopedVerifyEquivalence stays_equivalent{f};
+  EXPECT_THAT(Run(f), IsOkAndHolds(true));
+  EXPECT_THAT(
+      f->return_value(),
+      m::Tuple(
+          m::PrioritySelect(
+              m::Param("s"),
+              {m::AndReduce(m::Literal(1)), m::AndReduce(m::Param("x"))},
+              m::AndReduce(m::Literal(2))),
+          m::PrioritySelect(
+              m::Param("s"),
+              {m::XorReduce(m::Literal(1)), m::XorReduce(m::Param("x"))},
+              m::XorReduce(m::Literal(2))),
+          m::Select(m::Param("s"),
+                    {m::AndReduce(m::Literal(1)), m::AndReduce(m::Param("x"))},
+                    m::AndReduce(m::Literal(2))),
+          m::Select(m::Param("s"),
+                    {m::XorReduce(m::Literal(1)), m::XorReduce(m::Param("x"))},
+                    m::XorReduce(m::Literal(2)))));
+}
+
+TEST_P(SelectSimplificationPassTest,
+       HoistNonCommutativeCompareThroughSelectPreservesOrder) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue s = fb.Param("s", p->GetBitsType(2));
+  BValue x = fb.Param("x", p->GetBitsType(8));
+  BValue lit0 = fb.Literal(Value(UBits(0, 8)));
+  BValue lit1 = fb.Literal(Value(UBits(1, 8)));
+  BValue lit2 = fb.Literal(Value(UBits(2, 8)));
+
+  BValue se = fb.Select(s, /*cases=*/{lit1, x}, /*default_value=*/lit2);
+  XLS_ASSERT_OK_AND_ASSIGN(Function * f,
+                           fb.BuildWithReturnValue(fb.ULt(lit0, se)));
+  EXPECT_TRUE(f->return_value()->Is<CompareOp>());
+
+  solvers::z3::ScopedVerifyEquivalence stays_equivalent{f};
+  EXPECT_THAT(Run(f), IsOkAndHolds(true));
+  EXPECT_THAT(f->return_value(),
+              m::Select(m::Param("s"),
+                        {m::ULt(m::Literal(0), m::Literal(1)),
+                         m::ULt(m::Literal(0), m::Param("x"))},
+                        m::ULt(m::Literal(0), m::Literal(2))));
+}
+
+TEST_P(SelectSimplificationPassTest,
+       HoistCompareThroughSelectLikeWithAllLiteralArms) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue s = fb.Param("s", p->GetBitsType(2));
+  BValue param_p = fb.Param("p", p->GetBitsType(1));
+
+  BValue lit0 = fb.Literal(Value(UBits(0, 8)));
+  BValue lit1 = fb.Literal(Value(UBits(1, 8)));
+  BValue lit2 = fb.Literal(Value(UBits(2, 8)));
+
+  BValue pr =
+      fb.PrioritySelect(s, /*cases=*/{lit0, lit1}, /*default_value=*/lit2);
+  BValue eq_pr = fb.Eq(pr, lit0);
+
+  BValue se = fb.Select(s, /*cases=*/{lit0, lit1}, /*default_value=*/lit2);
+  BValue eq_se = fb.Eq(se, lit0);
+
+  BValue not_p = fb.Not(param_p);
+  BValue oh = fb.Concat({not_p, param_p});
+  BValue ohs = fb.OneHotSelect(oh, /*cases=*/{lit0, lit1});
+  BValue eq_ohs = fb.Eq(ohs, lit0);
+
+  XLS_ASSERT_OK_AND_ASSIGN(
+      Function * f, fb.BuildWithReturnValue(fb.Tuple({eq_pr, eq_se, eq_ohs})));
+  EXPECT_TRUE(f->return_value()->Is<Tuple>());
+
+  solvers::z3::ScopedVerifyEquivalence stays_equivalent{f};
+  EXPECT_THAT(Run(f), IsOkAndHolds(true));
+
+  // Key invariant: after hoisting, no compare should directly compare a
+  // select-like node (sel/priority_sel/one_hot_sel) against the literal.
+  for (Node* n : f->nodes()) {
+    if (!n->Is<CompareOp>()) {
+      continue;
+    }
+    if (n->operand(0)->OpIn({Op::kPrioritySel, Op::kSel, Op::kOneHotSel}) ||
+        n->operand(1)->OpIn({Op::kPrioritySel, Op::kSel, Op::kOneHotSel})) {
+      // The hoisted compares can still exist (e.g. eq(lit0, lit0)), but the
+      // compare itself should no longer be comparing the select-like result to
+      // the literal.
+      FAIL() << "Unexpected compare of select-like value: " << n->ToString();
+    }
+  }
+}
+
+TEST_P(SelectSimplificationPassTest,
+       CompareThroughSelectLikeWithTwoNonLiteralArmsDoesNotHoist) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue s = fb.Param("s", p->GetBitsType(2));
+  BValue x = fb.Param("x", p->GetBitsType(8));
+  BValue y = fb.Param("y", p->GetBitsType(8));
+  BValue lit0 = fb.Literal(Value(UBits(0, 8)));
+  BValue lit2 = fb.Literal(Value(UBits(2, 8)));
+
+  // Two non-literal arms => profitability guard should block the rewrite.
+  BValue se = fb.Select(s, /*cases=*/{x, y}, /*default_value=*/lit2);
+  XLS_ASSERT_OK_AND_ASSIGN(Function * f,
+                           fb.BuildWithReturnValue(fb.Eq(se, lit0)));
+
+  solvers::z3::ScopedVerifyEquivalence stays_equivalent{f};
+  EXPECT_THAT(Run(f), IsOkAndHolds(false));
+  EXPECT_THAT(f->return_value(),
+              m::Eq(m::Select(m::Param("s"),
+                              /*cases=*/{m::Param("x"), m::Param("y")},
+                              /*default_value=*/m::Literal(2)),
+                    m::Literal(0)));
+}
+
+TEST_P(SelectSimplificationPassTest,
+       OrReduceThroughSelectLikeWithTwoNonLiteralArmsDoesNotHoist) {
+  auto p = CreatePackage();
+  FunctionBuilder fb(TestName(), p.get());
+  BValue s = fb.Param("s", p->GetBitsType(2));
+  BValue x = fb.Param("x", p->GetBitsType(8));
+  BValue y = fb.Param("y", p->GetBitsType(8));
+  BValue lit2 = fb.Literal(Value(UBits(2, 8)));
+
+  // Two non-literal arms => profitability guard should block the rewrite.
+  BValue se = fb.Select(s, /*cases=*/{x, y}, /*default_value=*/lit2);
+  XLS_ASSERT_OK_AND_ASSIGN(Function * f,
+                           fb.BuildWithReturnValue(fb.OrReduce(se)));
+
+  solvers::z3::ScopedVerifyEquivalence stays_equivalent{f};
+  EXPECT_THAT(Run(f), IsOkAndHolds(false));
+  EXPECT_THAT(f->return_value(),
+              m::OrReduce(m::Select(m::Param("s"),
+                                    /*cases=*/{m::Param("x"), m::Param("y")},
+                                    /*default_value=*/m::Literal(2))));
+}
+
 TEST_P(SelectSimplificationPassTest, FourWayTupleSelect) {
   auto p = CreatePackage();
   XLS_ASSERT_OK_AND_ASSIGN(Function * f, ParseFunction(R"(
diff --git a/xls/passes/stateless_query_engine.cc b/xls/passes/stateless_query_engine.cc
index 2c41d40957..214185512c 100644
--- a/xls/passes/stateless_query_engine.cc
+++ b/xls/passes/stateless_query_engine.cc
@@ -262,6 +262,10 @@ bool StatelessQueryEngine::AtMostOneBitTrue(Node* node) const {
   if (node->Is<OneHot>()) {
     return true;
   }
+  // A <=1-bit value can never have more than one bit set.
+  if (node->GetType()->IsBits() && node->BitCountOrDie() <= 1) {
+    return true;
+  }
 
   return QueryEngine::AtMostOneBitTrue(node);
 }
@@ -277,6 +281,49 @@ bool StatelessQueryEngine::ExactlyOneBitTrue(Node* node) const {
     return true;
   }
 
+  // Fast pattern matches for selectors which are exactly-one-hot by
+  // construction.
+  //
+  // Note: This is intentionally local/structural reasoning; stateless query
+  // engine does not propagate facts through the graph.
+  if (node->op() == Op::kConcat && node->operand_count() == 2) {
+    Node* msb = node->operand(0);
+    Node* lsb = node->operand(1);
+    auto is_single_bit = [](Node* n) {
+      return n->GetType()->IsBits() && n->BitCountOrDie() == 1;
+    };
+    auto is_not_of = [](Node* n, Node* x) {
+      return n->op() == Op::kNot && n->operand_count() == 1 &&
+             n->operand(0) == x;
+    };
+
+    // concat(not(x), x) or concat(x, not(x)) is exactly-one-hot when x is a
+    // single-bit value.
+    if (is_single_bit(lsb) && is_not_of(msb, lsb)) {
+      return true;
+    }
+    if (is_single_bit(msb) && is_not_of(lsb, msb)) {
+      return true;
+    }
+
+    // OneHot(x) may be rewritten into concat(eq(x, 0), x) (e.g. by select
+    // simplification). This concat is exactly-one-hot when x is mutually
+    // exclusive (at most one bit set).
+    Node* maybe_eq = msb;
+    Node* x = lsb;
+    if (maybe_eq->op() == Op::kEq && maybe_eq->operand_count() == 2) {
+      Node* eq_lhs = maybe_eq->operand(0);
+      Node* eq_rhs = maybe_eq->operand(1);
+      // We only handle the literal-zero comparison in stateless mode.
+      if ((eq_lhs == x && IsAllZeros(eq_rhs)) ||
+          (eq_rhs == x && IsAllZeros(eq_lhs))) {
+        if (AtMostOneBitTrue(x)) {
+          return true;
+        }
+      }
+    }
+  }
+
   return QueryEngine::ExactlyOneBitTrue(node);
 }
 
diff --git a/xls/passes/stateless_query_engine_test.cc b/xls/passes/stateless_query_engine_test.cc
index 87259a0031..bc9e267790 100644
--- a/xls/passes/stateless_query_engine_test.cc
+++ b/xls/passes/stateless_query_engine_test.cc
@@ -117,6 +117,31 @@ TEST_F(StatelessQueryEngineTest, OneHotMsb) {
   EXPECT_TRUE(query_engine.ExactlyOneBitTrue(f->return_value()));
 }
 
+TEST_F(StatelessQueryEngineTest, ExactlyOneBitTrueConcatNotXAndX) {
+  Package p("test_package");
+  FunctionBuilder fb("f", &p);
+  BValue x = fb.Param("x", p.GetBitsType(1));
+  BValue selector = fb.Concat({fb.Not(x), x});
+  XLS_ASSERT_OK_AND_ASSIGN(Function * f, fb.BuildWithReturnValue(selector));
+  VLOG(3) << f->DumpIr();
+
+  StatelessQueryEngine query_engine;
+  EXPECT_TRUE(query_engine.ExactlyOneBitTrue(f->return_value()));
+}
+
+TEST_F(StatelessQueryEngineTest, ExactlyOneBitTrueConcatEqXZeroAndX) {
+  Package p("test_package");
+  FunctionBuilder fb("f", &p);
+  BValue x = fb.Param("x", p.GetBitsType(1));
+  BValue x_eq_zero = fb.Eq(x, fb.Literal(UBits(0, 1)));
+  BValue selector = fb.Concat({x_eq_zero, x});
+  XLS_ASSERT_OK_AND_ASSIGN(Function * f, fb.BuildWithReturnValue(selector));
+  VLOG(3) << f->DumpIr();
+
+  StatelessQueryEngine query_engine;
+  EXPECT_TRUE(query_engine.ExactlyOneBitTrue(f->return_value()));
+}
+
 TEST_F(StatelessQueryEngineTest, ZeroExtend) {
   Package p("test_package");
   FunctionBuilder fb("f", &p);
diff --git a/xls/passes/union_query_engine.cc b/xls/passes/union_query_engine.cc
index 3df0501d10..4fb9a4e273 100644
--- a/xls/passes/union_query_engine.cc
+++ b/xls/passes/union_query_engine.cc
@@ -14,6 +14,7 @@
 
 #include "xls/passes/union_query_engine.h"
 
+#include <algorithm>
 #include <cstdint>
 #include <memory>
 #include <optional>
@@ -237,6 +238,27 @@ bool UnownedUnionQueryEngine::AtLeastOneTrue(
   return false;
 }
 
+bool UnownedUnionQueryEngine::AtMostOneBitTrue(Node* node) const {
+  return std::any_of(engines_.begin(), engines_.end(),
+                     [&](const QueryEngine* engine) {
+                       return engine->AtMostOneBitTrue(node);
+                     });
+}
+
+bool UnownedUnionQueryEngine::AtLeastOneBitTrue(Node* node) const {
+  return std::any_of(engines_.begin(), engines_.end(),
+                     [&](const QueryEngine* engine) {
+                       return engine->AtLeastOneBitTrue(node);
+                     });
+}
+
+bool UnownedUnionQueryEngine::ExactlyOneBitTrue(Node* node) const {
+  return std::any_of(engines_.begin(), engines_.end(),
+                     [&](const QueryEngine* engine) {
+                       return engine->ExactlyOneBitTrue(node);
+                     });
+}
+
 bool UnownedUnionQueryEngine::KnownEquals(const TreeBitLocation& a,
                                           const TreeBitLocation& b) const {
   for (const auto& engine : engines_) {
diff --git a/xls/passes/union_query_engine.h b/xls/passes/union_query_engine.h
index d76f3704fc..104d21cf6c 100644
--- a/xls/passes/union_query_engine.h
+++ b/xls/passes/union_query_engine.h
@@ -101,6 +101,12 @@ class UnownedUnionQueryEngine : public QueryEngine {
   bool IsAllZeros(Node* n) const override;
   bool IsAllOnes(Node* n) const override;
 
+  // Returns true if at most/at least/exactly one of the bits in 'node' is true.
+  // 'node' must be bits-typed.
+  bool AtMostOneBitTrue(Node* node) const override;
+  bool AtLeastOneBitTrue(Node* node) const override;
+  bool ExactlyOneBitTrue(Node* node) const override;
+
   Bits MaxUnsignedValue(Node* node) const override;
   Bits MinUnsignedValue(Node* node) const override;
   std::optional<int64_t> KnownLeadingZeros(Node* node) const override;