diff --git a/sycl/doc/extensions/experimental/sycl_ext_oneapi_properties.asciidoc b/sycl/doc/extensions/experimental/sycl_ext_oneapi_properties.asciidoc
index 82c6d6fb454c6..9555e92dcc359 100644
--- a/sycl/doc/extensions/experimental/sycl_ext_oneapi_properties.asciidoc
+++ b/sycl/doc/extensions/experimental/sycl_ext_oneapi_properties.asciidoc
@@ -200,11 +200,10 @@ inline constexpr boo_key::value_t<Ts...> boo;
 === Property traits
 
 All runtime and compile-time-constant properties must have a specialization of 
-`is_property_key` and `is_property_value` that inherits from
-`std::true_type`, and they must have a specialization of `is_property_key_of`
-and `is_property_value_of`
-that inherits from `std::true_type` for each SYCL runtime class that the
-property can be applied to. All have a base case which inherits from `std::false_type`.
+`is_property_key` that inherits from `std::true_type`, and they must have a
+specialization of `is_property_key_of` that inherits from `std::true_type` for
+each SYCL runtime class that the property can be applied to. All have a base
+case which inherits from `std::false_type`.
 
 ```c++
 namespace sycl::ext::oneapi::experimental {
@@ -221,18 +220,6 @@ struct is_property_key_of<foo_key, SyclObjectT> : std::true_type {};
 template<typename SyclObjectT>
 struct is_property_key_of<bar_key, SyclObjectT> : std::true_type {};
 
-// is_property_value and is_property_value_of based on is_property_key(_of)
-template<typename V, typename=void> struct is_property_value;
-template<typename V, typename O, typename=void> struct is_property_value_of;
-// Specialization for runtime properties
-template<typename V> struct is_property_value<V, std::enable_if_t<(sizeof(V)>0)>> : is_property_key<V> {};
-template<typename V, typename O> struct is_property_value_of<V, O, std::enable_if_t<(sizeof(V)>0)>> : is_property_key_of<V,O> {};
-// Specialization for compile-time-constant properties
-template<typename V> struct is_property_value<V, std::void_t<typename V::key_t>> :
-  is_property_key<typename V::key_t> {};
-template<typename V, typename O> struct is_property_value_of<V, O, std::void_t<typename V::key_t>> :
-  is_property_key_of<typename V::key_t, O> {};
-
 } // namespace experimental::oneapi::ext::sycl
 ```
 
diff --git a/sycl/include/sycl/ext/oneapi/experimental/cluster_group_prop.hpp b/sycl/include/sycl/ext/oneapi/experimental/cluster_group_prop.hpp
index 31487beffd810..22ded7b960777 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/cluster_group_prop.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/cluster_group_prop.hpp
@@ -47,28 +47,6 @@ struct is_property_key_of<cuda::cluster_size_key<2>, T> : std::true_type {};
 template <typename T>
 struct is_property_key_of<cuda::cluster_size_key<3>, T> : std::true_type {};
 
-template <>
-struct is_property_value<cuda::cluster_size_key<1>>
-    : is_property_key<cuda::cluster_size_key<1>> {};
-template <>
-struct is_property_value<cuda::cluster_size_key<2>>
-    : is_property_key<cuda::cluster_size_key<2>> {};
-template <>
-struct is_property_value<cuda::cluster_size_key<3>>
-    : is_property_key<cuda::cluster_size_key<3>> {};
-
-template <typename O>
-struct is_property_value_of<cuda::cluster_size_key<1>, O>
-    : is_property_key_of<cuda::cluster_size_key<1>, O> {};
-
-template <typename O>
-struct is_property_value_of<cuda::cluster_size_key<2>, O>
-    : is_property_key_of<cuda::cluster_size_key<2>, O> {};
-
-template <typename O>
-struct is_property_value_of<cuda::cluster_size_key<3>, O>
-    : is_property_key_of<cuda::cluster_size_key<3>, O> {};
-
 namespace detail {
 template <typename PropertiesT> constexpr std::size_t getClusterDim() {
   if constexpr (PropertiesT::template has_property<
diff --git a/sycl/include/sycl/ext/oneapi/properties/property_value.hpp b/sycl/include/sycl/ext/oneapi/properties/property_value.hpp
index e208f59d85830..bd57cc7d1debf 100644
--- a/sycl/include/sycl/ext/oneapi/properties/property_value.hpp
+++ b/sycl/include/sycl/ext/oneapi/properties/property_value.hpp
@@ -57,22 +57,6 @@ operator!=(const property_value<PropertyT, A...> &,
   return (!std::is_same<A, B>::value || ...);
 }
 
-template <typename V, typename = void> struct is_property_value {
-  static constexpr bool value =
-      detail::IsRuntimeProperty<V>::value && is_property_key<V>::value;
-};
-template <typename V, typename O, typename = void> struct is_property_value_of {
-  static constexpr bool value =
-      detail::IsRuntimeProperty<V>::value && is_property_key_of<V, O>::value;
-};
-// Specialization for compile-time-constant properties
-template <typename V>
-struct is_property_value<V, std::void_t<typename V::key_t>>
-    : is_property_key<typename V::key_t> {};
-template <typename V, typename O>
-struct is_property_value_of<V, O, std::void_t<typename V::key_t>>
-    : is_property_key_of<typename V::key_t, O> {};
-
 namespace detail {
 
 // Specialization of PropertyID for propagating IDs through property_value.
diff --git a/sycl/include/syclcompat/traits.hpp b/sycl/include/syclcompat/traits.hpp
index 7ed4d765251bc..2d7aa9eeb48e4 100644
--- a/sycl/include/syclcompat/traits.hpp
+++ b/sycl/include/syclcompat/traits.hpp
@@ -249,8 +249,9 @@ inline constexpr bool is_launch_policy_v = is_launch_policy<T>::value;
 
 // Trait to detect if all args are sycl_exp property types
 template <typename... Args>
-using are_all_props = std::conjunction<
-    sycl::ext::oneapi::experimental::is_property_value<Args>...>;
+using are_all_props =
+    sycl::ext::oneapi::experimental::detail::AllPropertyValues<
+        std::tuple<Args...>>;
 
 } // namespace experimental::detail
 
diff --git a/sycl/test/extensions/annotated_arg/annotated_arg_properties.cpp b/sycl/test/extensions/annotated_arg/annotated_arg_properties.cpp
index 9fd5b926f023a..01ba48c4cd8a5 100644
--- a/sycl/test/extensions/annotated_arg/annotated_arg_properties.cpp
+++ b/sycl/test/extensions/annotated_arg/annotated_arg_properties.cpp
@@ -18,7 +18,7 @@ static annotated_arg<int *, decltype(properties(buffer_location<1>,
 
 struct A {};
 
-// Checks is_property_key_of and is_property_value_of for T.
+// Checks is_property_key_of for T.
 template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<register_map_key, T>::value);
   static_assert(is_property_key_of<conduit_key, T>::value);
@@ -31,19 +31,6 @@ template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<read_write_mode_key, T>::value);
   static_assert(is_property_key_of<maxburst_key, T>::value);
   static_assert(is_property_key_of<wait_request_key, T>::value);
-
-  static_assert(is_property_value_of<decltype(register_map), T>::value);
-  static_assert(is_property_value_of<decltype(conduit), T>::value);
-  static_assert(is_property_value_of<decltype(stable), T>::value);
-
-  static_assert(is_property_value_of<decltype(buffer_location<1>), T>::value);
-  static_assert(is_property_value_of<decltype(awidth<2>), T>::value);
-  static_assert(is_property_value_of<decltype(dwidth<8>), T>::value);
-  static_assert(is_property_value_of<decltype(latency<0>), T>::value);
-  static_assert(is_property_value_of<decltype(read_write_mode_read), T>::value);
-  static_assert(is_property_value_of<decltype(maxburst<1>), T>::value);
-  static_assert(
-      is_property_value_of<decltype(wait_request_requested), T>::value);
 }
 
 int main() {
diff --git a/sycl/test/extensions/annotated_ptr/annotated_ptr_properties.cpp b/sycl/test/extensions/annotated_ptr/annotated_ptr_properties.cpp
index 19f42b3764429..b84f0d503639f 100644
--- a/sycl/test/extensions/annotated_ptr/annotated_ptr_properties.cpp
+++ b/sycl/test/extensions/annotated_ptr/annotated_ptr_properties.cpp
@@ -16,7 +16,7 @@ static annotated_ptr<int, decltype(properties(buffer_location<1>,
 
 struct A {};
 
-// Checks is_property_key_of and is_property_value_of for T.
+// Checks is_property_key_of for T.
 template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<register_map_key, T>::value);
   static_assert(is_property_key_of<conduit_key, T>::value);
@@ -29,23 +29,9 @@ template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<read_write_mode_key, T>::value);
   static_assert(is_property_key_of<maxburst_key, T>::value);
   static_assert(is_property_key_of<wait_request_key, T>::value);
-
-  static_assert(is_property_value_of<decltype(register_map), T>::value);
-  static_assert(is_property_value_of<decltype(conduit), T>::value);
-  static_assert(is_property_value_of<decltype(stable), T>::value);
-
-  static_assert(is_property_value_of<decltype(buffer_location<1>), T>::value);
-  static_assert(is_property_value_of<decltype(awidth<2>), T>::value);
-  static_assert(is_property_value_of<decltype(dwidth<8>), T>::value);
-  static_assert(is_property_value_of<decltype(latency<0>), T>::value);
-  static_assert(is_property_value_of<decltype(read_write_mode_read), T>::value);
-  static_assert(is_property_value_of<decltype(maxburst<1>), T>::value);
-  static_assert(
-      is_property_value_of<decltype(wait_request_requested), T>::value);
 }
 
-// Checks is_property_key_of and is_property_value_of are false for non-pointer
-// type T.
+// Checks is_property_key_of is false for non-pointer type T.
 template <typename T> void checkIsValidPropertyOfNonPtr() {
   static_assert(
       is_valid_property<T, decltype(wait_request_not_requested)>::value ==
diff --git a/sycl/test/extensions/device_global/device_global_properties.cpp b/sycl/test/extensions/device_global/device_global_properties.cpp
index 8a995ce8dd708..56afcb04b57fa 100644
--- a/sycl/test/extensions/device_global/device_global_properties.cpp
+++ b/sycl/test/extensions/device_global/device_global_properties.cpp
@@ -25,23 +25,12 @@ static device_global<int, decltype(properties(
                               device_image_scope, init_mode_reprogram))>
     DeviceGlobal5;
 
-// Checks is_property_key_of and is_property_value_of for T.
+// Checks is_property_key_of for T.
 template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<device_image_scope_key, T>::value);
   static_assert(is_property_key_of<host_access_key, T>::value);
   static_assert(is_property_key_of<init_mode_key, T>::value);
   static_assert(is_property_key_of<implement_in_csr_key, T>::value);
-
-  static_assert(is_property_value_of<decltype(device_image_scope), T>::value);
-  static_assert(is_property_value_of<decltype(host_access_read), T>::value);
-  static_assert(is_property_value_of<decltype(host_access_write), T>::value);
-  static_assert(
-      is_property_value_of<decltype(host_access_read_write), T>::value);
-  static_assert(is_property_value_of<decltype(host_access_none), T>::value);
-  static_assert(is_property_value_of<decltype(init_mode_reset), T>::value);
-  static_assert(is_property_value_of<decltype(init_mode_reprogram), T>::value);
-  static_assert(is_property_value_of<decltype(implement_in_csr_on), T>::value);
-  static_assert(is_property_value_of<decltype(implement_in_csr_off), T>::value);
 }
 
 int main() {
@@ -50,16 +39,6 @@ int main() {
   static_assert(is_property_key<init_mode_key>::value);
   static_assert(is_property_key<implement_in_csr_key>::value);
 
-  static_assert(is_property_value<decltype(device_image_scope)>::value);
-  static_assert(is_property_value<decltype(host_access_read)>::value);
-  static_assert(is_property_value<decltype(host_access_write)>::value);
-  static_assert(is_property_value<decltype(host_access_read_write)>::value);
-  static_assert(is_property_value<decltype(host_access_none)>::value);
-  static_assert(is_property_value<decltype(init_mode_reset)>::value);
-  static_assert(is_property_value<decltype(init_mode_reprogram)>::value);
-  static_assert(is_property_value<decltype(implement_in_csr_on)>::value);
-  static_assert(is_property_value<decltype(implement_in_csr_off)>::value);
-
   checkIsPropertyOf<decltype(DeviceGlobal1)>();
   static_assert(DeviceGlobal1.has_property<device_image_scope_key>());
   static_assert(!DeviceGlobal1.has_property<host_access_key>());
diff --git a/sycl/test/extensions/fpga_mem/fpga_mem_properties.cpp b/sycl/test/extensions/fpga_mem/fpga_mem_properties.cpp
index 88bbaddcd9fb4..7609d95c4998b 100644
--- a/sycl/test/extensions/fpga_mem/fpga_mem_properties.cpp
+++ b/sycl/test/extensions/fpga_mem/fpga_mem_properties.cpp
@@ -22,7 +22,7 @@ static intel::fpga_mem<int, decltype(oneapi::properties(
                                 intel::bi_directional_ports_true))>
     mem_multi;
 
-// Checks is_property_key_of and oneapi::is_property_value_of for T.
+// Checks is_property_key_of for T.
 template <typename T> void checkIsPropertyOf() {
   static_assert(oneapi::is_property_key_of<intel::resource_key, T>::value);
   static_assert(oneapi::is_property_key_of<intel::num_banks_key, T>::value);
@@ -51,34 +51,6 @@ int main() {
   static_assert(oneapi::is_property_key<intel::max_private_copies_key>::value);
   static_assert(oneapi::is_property_key<intel::num_replicates_key>::value);
 
-  // Are all common values usable
-  static_assert(
-      oneapi::is_property_value<decltype(intel::resource_mlab)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::resource_block_ram)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::num_banks<8>)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::stride_size<8>)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::word_size<32>)>::value);
-  static_assert(oneapi::is_property_value<
-                decltype(intel::bi_directional_ports_false)>::value);
-  static_assert(oneapi::is_property_value<
-                decltype(intel::bi_directional_ports_true)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::clock_2x_false)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::clock_2x_true)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::ram_stitching_min_ram)>::value);
-  static_assert(oneapi::is_property_value<
-                decltype(intel::ram_stitching_max_fmax)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::max_private_copies<8>)>::value);
-  static_assert(
-      oneapi::is_property_value<decltype(intel::num_replicates<8>)>::value);
-
   // Check that only the property that are expected are associated with obj
   checkIsPropertyOf<decltype(mem_num)>();
   static_assert(mem_num.has_property<intel::num_banks_key>());
diff --git a/sycl/test/extensions/properties/properties_device_global.cpp b/sycl/test/extensions/properties/properties_device_global.cpp
index f859852ccb4c6..743f095036ecd 100644
--- a/sycl/test/extensions/properties/properties_device_global.cpp
+++ b/sycl/test/extensions/properties/properties_device_global.cpp
@@ -17,20 +17,6 @@ int main() {
   static_assert(is_property_key<init_mode_key>::value);
   static_assert(is_property_key<implement_in_csr_key>::value);
 
-  // Check that is_property_value is correctly specialized.
-  static_assert(is_property_value<decltype(device_image_scope)>::value);
-  static_assert(is_property_value<decltype(host_access<TestAccess>)>::value);
-  static_assert(is_property_value<decltype(host_access_read)>::value);
-  static_assert(is_property_value<decltype(host_access_write)>::value);
-  static_assert(is_property_value<decltype(host_access_read_write)>::value);
-  static_assert(is_property_value<decltype(host_access_none)>::value);
-  static_assert(is_property_value<decltype(init_mode<TestTrigger>)>::value);
-  static_assert(is_property_value<decltype(init_mode_reprogram)>::value);
-  static_assert(is_property_value<decltype(init_mode_reset)>::value);
-  static_assert(is_property_value<decltype(implement_in_csr<true>)>::value);
-  static_assert(is_property_value<decltype(implement_in_csr_on)>::value);
-  static_assert(is_property_value<decltype(implement_in_csr_off)>::value);
-
   // Checks that fully specialized properties are the same as the templated
   // variants.
   static_assert(std::is_same_v<decltype(host_access_read),
diff --git a/sycl/test/extensions/properties/properties_is_property_value.cpp b/sycl/test/extensions/properties/properties_is_property_value.cpp
deleted file mode 100644
index af07b8c24813c..0000000000000
--- a/sycl/test/extensions/properties/properties_is_property_value.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsyntax-only -Xclang -verify -Xclang -verify-ignore-unexpected=note,warning %s
-// expected-no-diagnostics
-
-#include <sycl/sycl.hpp>
-
-#include "mock_compile_time_properties.hpp"
-
-class NotAPropertyKey {};
-
-int main() {
-  // Check is_property_value for compile-time property values.
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(sycl::ext::oneapi::experimental::bar)>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(sycl::ext::oneapi::experimental::baz<42>)>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(sycl::ext::oneapi::experimental::boo<int>)>::value);
-  static_assert(
-      sycl::ext::oneapi::experimental::is_property_value<
-          decltype(sycl::ext::oneapi::experimental::boo<bool, float>)>::value);
-
-  // Check is_property_value for runtime property values.
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                sycl::ext::oneapi::experimental::foo>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                sycl::ext::oneapi::experimental::foz>::value);
-
-  // Check is_property_value for compile-time property keys.
-  static_assert(!sycl::ext::oneapi::experimental::is_property_value<
-                sycl::ext::oneapi::experimental::bar_key>::value);
-  static_assert(!sycl::ext::oneapi::experimental::is_property_value<
-                sycl::ext::oneapi::experimental::baz_key>::value);
-  static_assert(!sycl::ext::oneapi::experimental::is_property_value<
-                sycl::ext::oneapi::experimental::boo_key>::value);
-
-  // Check is_property_value for runtime property keys.
-  // NOTE: For runtime properties the key is an alias of the value.
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                sycl::ext::oneapi::experimental::foo_key>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                sycl::ext::oneapi::experimental::foz_key>::value);
-
-  // Check is_property_value for non-property-key types.
-  static_assert(
-      !sycl::ext::oneapi::experimental::is_property_value<int>::value);
-  static_assert(!sycl::ext::oneapi::experimental::is_property_value<
-                NotAPropertyKey>::value);
-
-  // Check is_property_value_of for compile-time property values.
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(sycl::ext::oneapi::experimental::bar)>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value_of<
-                decltype(sycl::ext::oneapi::experimental::baz<42>),
-                sycl::queue>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value_of<
-                decltype(sycl::ext::oneapi::experimental::boo<int>),
-                sycl::queue>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value_of<
-                decltype(sycl::ext::oneapi::experimental::boo<bool, float>),
-                sycl::queue>::value);
-
-  // Check is_property_value_of for runtime property keys.
-  static_assert(sycl::ext::oneapi::experimental::is_property_value_of<
-                sycl::ext::oneapi::experimental::foo, sycl::queue>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value_of<
-                sycl::ext::oneapi::experimental::foz, sycl::queue>::value);
-
-  // Check is_property_value_of for compile-time property keys.
-  static_assert(!sycl::ext::oneapi::experimental::is_property_value_of<
-                sycl::ext::oneapi::experimental::bar_key, sycl::queue>::value);
-  static_assert(!sycl::ext::oneapi::experimental::is_property_value_of<
-                sycl::ext::oneapi::experimental::baz_key, sycl::queue>::value);
-  static_assert(!sycl::ext::oneapi::experimental::is_property_value_of<
-                sycl::ext::oneapi::experimental::boo_key, sycl::queue>::value);
-
-  // Check is_property_value_of for runtime property keys.
-  // NOTE: For runtime properties the key is an alias of the value.
-  static_assert(sycl::ext::oneapi::experimental::is_property_value_of<
-                sycl::ext::oneapi::experimental::foo_key, sycl::queue>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value_of<
-                sycl::ext::oneapi::experimental::foz_key, sycl::queue>::value);
-
-  // Check is_property_value_of for non-property-key types.
-  static_assert(!sycl::ext::oneapi::experimental::is_property_value_of<
-                int, sycl::queue>::value);
-  static_assert(!sycl::ext::oneapi::experimental::is_property_value_of<
-                NotAPropertyKey, sycl::queue>::value);
-
-  return 0;
-}
diff --git a/sycl/test/extensions/properties/properties_kernel.cpp b/sycl/test/extensions/properties/properties_kernel.cpp
index 0024cd4cb221c..b5ffd88887289 100644
--- a/sycl/test/extensions/properties/properties_kernel.cpp
+++ b/sycl/test/extensions/properties/properties_kernel.cpp
@@ -29,7 +29,6 @@ using device_has_all =
              aspect::ext_intel_memory_bus_width>);
 
 template <aspect Aspect> inline void singleAspectDeviceHasChecks() {
-  static_assert(is_property_value<decltype(device_has<Aspect>)>::value);
   static_assert(std::is_same_v<device_has_key,
                                typename decltype(device_has<Aspect>)::key_t>);
   static_assert(decltype(device_has<Aspect>)::value.size() == 1);
@@ -51,21 +50,6 @@ int main() {
   static_assert(sycl::ext::oneapi::experimental::detail::HasCompileTimeEffect<
                 device_has_key::value_t<aspect::fp64>>::value);
 
-  static_assert(is_property_value<decltype(work_group_size<1>)>::value);
-  static_assert(is_property_value<decltype(work_group_size<2, 2>)>::value);
-  static_assert(is_property_value<decltype(work_group_size<3, 3, 3>)>::value);
-  static_assert(is_property_value<decltype(work_group_size_hint<4>)>::value);
-  static_assert(is_property_value<decltype(work_group_size_hint<5, 5>)>::value);
-  static_assert(
-      is_property_value<decltype(work_group_size_hint<6, 6, 6>)>::value);
-  static_assert(is_property_value<decltype(sub_group_size<7>)>::value);
-  static_assert(is_property_value<decltype(max_work_group_size<8>)>::value);
-  static_assert(is_property_value<decltype(max_work_group_size<8, 8>)>::value);
-  static_assert(
-      is_property_value<decltype(max_work_group_size<8, 8, 8>)>::value);
-  static_assert(
-      is_property_value<decltype(max_linear_work_group_size<8>)>::value);
-
   static_assert(
       std::is_same_v<work_group_size_key, decltype(work_group_size<8>)::key_t>);
   static_assert(std::is_same_v<work_group_size_key,
@@ -152,11 +136,9 @@ int main() {
   singleAspectDeviceHasChecks<aspect::ext_intel_memory_clock_rate>();
   singleAspectDeviceHasChecks<aspect::ext_intel_memory_bus_width>();
 
-  static_assert(is_property_value<decltype(device_has<>)>::value);
   static_assert(std::is_same_v<device_has_key, decltype(device_has<>)::key_t>);
   static_assert(decltype(device_has<>)::value.size() == 0);
 
-  static_assert(is_property_value<device_has_all>::value);
   static_assert(std::is_same_v<device_has_key, device_has_all::key_t>);
   static_assert(device_has_all::value.size() == 35);
   static_assert(device_has_all::value[0] == aspect::cpu);
diff --git a/sycl/test/extensions/properties/properties_kernel_cache_config.cpp b/sycl/test/extensions/properties/properties_kernel_cache_config.cpp
index 910a41b49cfb9..e1d43ad43e84f 100644
--- a/sycl/test/extensions/properties/properties_kernel_cache_config.cpp
+++ b/sycl/test/extensions/properties/properties_kernel_cache_config.cpp
@@ -9,12 +9,6 @@ int main() {
   static_assert(sycl::ext::oneapi::experimental::is_property_key<
                 cache_config_key>::value);
 
-  // Check that oneapi::experimental::is_property_value is correctly specialized
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(cache_config{large_slm})>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(cache_config{large_data})>::value);
-
   // Check that property lists will accept the new properties
   sycl::ext::oneapi::experimental::properties Props1(
       cache_config{large_slm});
diff --git a/sycl/test/extensions/properties/properties_kernel_fpga.cpp b/sycl/test/extensions/properties/properties_kernel_fpga.cpp
index 5b50752908d2a..ae910d890b056 100644
--- a/sycl/test/extensions/properties/properties_kernel_fpga.cpp
+++ b/sycl/test/extensions/properties/properties_kernel_fpga.cpp
@@ -29,40 +29,6 @@ int main() {
                     intel::experimental::streaming_interface_options_enum::
                         accept_downstream_stall>>::value);
 
-  // Check that oneapi::experimental::is_property_value is correctly specialized
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::streaming_interface<
-                         intel::experimental::streaming_interface_options_enum::
-                             accept_downstream_stall>)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::streaming_interface<
-                         intel::experimental::streaming_interface_options_enum::
-                             remove_downstream_stall>)>::value);
-  static_assert(
-      oneapi::experimental::is_property_value<
-          decltype(intel::experimental::register_map_interface<
-                   intel::experimental::register_map_interface_options_enum::
-                       wait_for_done_write>)>::value);
-  static_assert(
-      oneapi::experimental::is_property_value<
-          decltype(intel::experimental::register_map_interface<
-                   intel::experimental::register_map_interface_options_enum::
-                       do_not_wait_for_done_write>)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::pipelined<-1>)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::pipelined<0>)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::pipelined<4>)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::fpga_cluster<
-                         intel::experimental::fpga_cluster_options_enum::
-                             stall_enable>)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::fpga_cluster<
-                         intel::experimental::fpga_cluster_options_enum::
-                             stall_free>)>::value);
-
   // Checks that fully specialized properties are the same as the templated
   // variants.
   static_assert(std::is_same_v<
diff --git a/sycl/test/extensions/properties/properties_latency_control.cpp b/sycl/test/extensions/properties/properties_latency_control.cpp
index b00e74ad6d93d..7d05845c2c963 100644
--- a/sycl/test/extensions/properties/properties_latency_control.cpp
+++ b/sycl/test/extensions/properties/properties_latency_control.cpp
@@ -14,14 +14,6 @@ int main() {
   static_assert(oneapi::experimental::is_property_key<
                 intel::experimental::latency_constraint_key>::value);
 
-  // Check that oneapi::experimental::is_property_value is correctly specialized
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::latency_anchor_id<-1>)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::latency_constraint<
-                         0, intel::experimental::latency_control_type::none,
-                         0>)>::value);
-
   // Check that property lists will accept the new properties
   using P = decltype(oneapi::experimental::properties(
       intel::experimental::latency_anchor_id<-1>,
diff --git a/sycl/test/extensions/properties/properties_pipe.cpp b/sycl/test/extensions/properties/properties_pipe.cpp
index 892a311cab13d..cc0041fed9987 100644
--- a/sycl/test/extensions/properties/properties_pipe.cpp
+++ b/sycl/test/extensions/properties/properties_pipe.cpp
@@ -25,52 +25,6 @@ int main() {
   static_assert(sycl::ext::oneapi::experimental::is_property_key<
                 sycl::ext::intel::experimental::protocol_key>::value);
 
-  // Check that is_property_value is correctly specialized.
-  static_assert(
-      sycl::ext::oneapi::experimental::is_property_value<
-          decltype(sycl::ext::intel::experimental::ready_latency<3>)>::value);
-  static_assert(
-      sycl::ext::oneapi::experimental::is_property_value<
-          decltype(sycl::ext::intel::experimental::bits_per_symbol<3>)>::value);
-
-  static_assert(
-      sycl::ext::oneapi::experimental::is_property_value<
-          decltype(sycl::ext::intel::experimental::uses_valid<true>)>::value);
-  static_assert(
-      sycl::ext::oneapi::experimental::is_property_value<
-          decltype(sycl::ext::intel::experimental::uses_valid_on)>::value);
-  static_assert(
-      sycl::ext::oneapi::experimental::is_property_value<
-          decltype(sycl::ext::intel::experimental::uses_valid_off)>::value);
-
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(sycl::ext::intel::experimental::
-                             first_symbol_in_high_order_bits<true>)>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(sycl::ext::intel::experimental::
-                             first_symbol_in_high_order_bits_on)>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(sycl::ext::intel::experimental::
-                             first_symbol_in_high_order_bits_off)>::value);
-
-  static_assert(
-      sycl::ext::oneapi::experimental::is_property_value<
-          decltype(sycl::ext::intel::experimental::protocol<TestProtocol>)>::
-          value);
-  static_assert(
-      sycl::ext::oneapi::experimental::is_property_value<
-          decltype(sycl::ext::intel::experimental::protocol_avalon_streaming)>::
-          value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(sycl::ext::intel::experimental::
-                             protocol_avalon_streaming_uses_ready)>::value);
-  static_assert(
-      sycl::ext::oneapi::experimental::is_property_value<
-          decltype(sycl::ext::intel::experimental::protocol_avalon_mm)>::value);
-  static_assert(sycl::ext::oneapi::experimental::is_property_value<
-                decltype(sycl::ext::intel::experimental::
-                             protocol_avalon_mm_uses_ready)>::value);
-
   // Checks that fully specialized properties are the same as the templated
   // variants.
   static_assert(std::is_same_v<
diff --git a/sycl/test/extensions/properties/properties_task_sequence.cpp b/sycl/test/extensions/properties/properties_task_sequence.cpp
index cab6fa36b9d2b..299a934b59cf7 100644
--- a/sycl/test/extensions/properties/properties_task_sequence.cpp
+++ b/sycl/test/extensions/properties/properties_task_sequence.cpp
@@ -18,20 +18,6 @@ int main() {
   static_assert(oneapi::experimental::is_property_key<
                 intel::experimental::invocation_capacity_key>::value);
 
-  // Check that is_property_value is correctly specialized
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::balanced)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::response_capacity<0>)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::response_capacity<
-                         TestResponseCapacity>)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::invocation_capacity<0>)>::value);
-  static_assert(oneapi::experimental::is_property_value<
-                decltype(intel::experimental::invocation_capacity<
-                         TestInvocationCapacity>)>::value);
-
   // Check that property lists will accept the new properties.
   using P = decltype(oneapi::experimental::properties(
       intel::experimental::balanced,
diff --git a/sycl/test/extensions/task_sequence/task_sequence_properties.cpp b/sycl/test/extensions/task_sequence/task_sequence_properties.cpp
index d5ca162bc4080..8de8ac28cf5b2 100644
--- a/sycl/test/extensions/task_sequence/task_sequence_properties.cpp
+++ b/sycl/test/extensions/task_sequence/task_sequence_properties.cpp
@@ -21,22 +21,13 @@ static task_sequence<
 static task_sequence<dummyTask, decltype(properties(pipelined<0>))>
     TaskSequence3;
 
-// Checks is_property_key_of and is_property_value_of for T.
+// Checks is_property_key_of for T.
 template <typename T> void checkIsPropertyOf() {
   static_assert(is_property_key_of<balanced_key, T>::value);
   static_assert(is_property_key_of<response_capacity_key, T>::value);
   static_assert(is_property_key_of<invocation_capacity_key, T>::value);
   static_assert(is_property_key_of<pipelined_key, T>::value);
   static_assert(is_property_key_of<fpga_cluster_key, T>::value);
-
-  static_assert(is_property_value_of<decltype(balanced), T>::value);
-  static_assert(is_property_value_of<decltype(response_capacity<1>), T>::value);
-  static_assert(
-      is_property_value_of<decltype(invocation_capacity<1>), T>::value);
-  static_assert(is_property_value_of<decltype(pipelined<1>), T>::value);
-  static_assert(is_property_value_of<
-                decltype(fpga_cluster<fpga_cluster_options_enum::stall_enable>),
-                T>::value);
 }
 
 int main() {
@@ -46,15 +37,6 @@ int main() {
   static_assert(is_property_key<pipelined_key>::value);
   static_assert(is_property_key<fpga_cluster_key>::value);
 
-  static_assert(is_property_value<decltype(balanced)>::value);
-  static_assert(is_property_value<decltype(response_capacity<1>)>::value);
-  static_assert(is_property_value<decltype(invocation_capacity<1>)>::value);
-  static_assert(is_property_value<decltype(pipelined<-1>)>::value);
-  static_assert(is_property_value<decltype(pipelined<0>)>::value);
-  static_assert(is_property_value<decltype(pipelined<1>)>::value);
-  static_assert(is_property_value<decltype(stall_enable_clusters)>::value);
-  static_assert(is_property_value<decltype(stall_free_clusters)>::value);
-
   checkIsPropertyOf<decltype(TaskSequence1)>();
   static_assert(TaskSequence1.has_property<balanced_key>());
   static_assert(TaskSequence1.has_property<response_capacity_key>());