diff --git a/geometry/grassmann.hpp b/geometry/grassmann.hpp
index 2db54de1ec..93c9a21942 100644
--- a/geometry/grassmann.hpp
+++ b/geometry/grassmann.hpp
@@ -259,43 +259,43 @@ Multivector<Scalar, Frame, rank> operator-(
     Multivector<Scalar, Frame, rank> const& right);
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> operator*(
     LScalar const& left,
     Multivector<RScalar, Frame, rank> const& right);
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> operator*(
     Multivector<LScalar, Frame, rank> const& left,
     RScalar const& right);
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Quotient<LScalar, RScalar>, Frame, rank> operator/(
     Multivector<LScalar, Frame, rank> const& left,
     RScalar const& right);
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     Multivector<LScalar, Frame, rank> const& a,
@@ -303,25 +303,25 @@ FusedNegatedMultiplySubtract(
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     LScalar const& a,
diff --git a/geometry/grassmann_body.hpp b/geometry/grassmann_body.hpp
index f2e50122a8..ce1b287cae 100644
--- a/geometry/grassmann_body.hpp
+++ b/geometry/grassmann_body.hpp
@@ -342,7 +342,7 @@ Multivector<Scalar, Frame, rank> operator-(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 operator*(LScalar const& left,
           Multivector<RScalar, Frame, rank> const& right) {
@@ -351,7 +351,7 @@ operator*(LScalar const& left,
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 operator*(Multivector<LScalar, Frame, rank> const& left,
           RScalar const& right) {
@@ -360,7 +360,7 @@ operator*(Multivector<LScalar, Frame, rank> const& left,
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Quotient<LScalar, RScalar>, Frame, rank>
 operator/(Multivector<LScalar, Frame, rank> const& left,
           RScalar const& right) {
@@ -369,7 +369,7 @@ operator/(Multivector<LScalar, Frame, rank> const& left,
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
@@ -381,7 +381,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
@@ -393,7 +393,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
@@ -405,7 +405,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     Multivector<LScalar, Frame, rank> const& a,
@@ -418,7 +418,7 @@ FusedNegatedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
@@ -430,7 +430,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
@@ -442,7 +442,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
@@ -454,7 +454,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     LScalar const& a,
diff --git a/geometry/hilbert.hpp b/geometry/hilbert.hpp
index db0709a3d0..8d1ffb7c69 100644
--- a/geometry/hilbert.hpp
+++ b/geometry/hilbert.hpp
@@ -27,7 +27,7 @@ template<typename T1, typename T2 = T1>
 struct Hilbert;
 
 template<typename T1, typename T2>
-  requires quantity<T1> && quantity<T2>
+  requires convertible_to_quantity<T1> && convertible_to_quantity<T2>
 struct Hilbert<T1, T2> : not_constructible {
   static constexpr int dimension = 1;
 
@@ -36,7 +36,7 @@ struct Hilbert<T1, T2> : not_constructible {
 };
 
 template<typename T>
-  requires quantity<T>
+  requires convertible_to_quantity<T>
 struct Hilbert<T, T> : not_constructible {
   static constexpr int dimension = 1;
 
diff --git a/geometry/hilbert_body.hpp b/geometry/hilbert_body.hpp
index 8f7ab58944..9252eb0612 100644
--- a/geometry/hilbert_body.hpp
+++ b/geometry/hilbert_body.hpp
@@ -12,26 +12,26 @@ namespace internal {
 using namespace principia::quantities::_elementary_functions;
 
 template<typename T1, typename T2>
-  requires quantity<T1> && quantity<T2>
+  requires convertible_to_quantity<T1> && convertible_to_quantity<T2>
 auto Hilbert<T1, T2>::InnerProduct(T1 const& t1, T2 const& t2)
     -> InnerProductType {
   return t1 * t2;
 }
 
 template<typename T>
-  requires quantity<T>
+  requires convertible_to_quantity<T>
 auto Hilbert<T, T>::InnerProduct(T const& t1, T const& t2) -> InnerProductType {
   return t1 * t2;
 }
 
 template<typename T>
-  requires quantity<T>
+  requires convertible_to_quantity<T>
 auto Hilbert<T, T>::Norm²(T const& t) -> Norm²Type {
   return t * t;
 }
 
 template<typename T>
-  requires quantity<T>
+  requires convertible_to_quantity<T>
 auto Hilbert<T, T>::Norm(T const& t) -> NormType {
   return Abs(t);
 }
diff --git a/geometry/point.hpp b/geometry/point.hpp
index b354da81f9..c6b76dd311 100644
--- a/geometry/point.hpp
+++ b/geometry/point.hpp
@@ -75,23 +75,23 @@ class Point final {
       L const& a, R const& b, Point<Product<L, R>> const& c);
 
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr bool operator<(Point<V> const& left, Point<V> const& right);
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr bool operator<=(Point<V> const& left, Point<V> const& right);
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr bool operator>=(Point<V> const& left, Point<V> const& right);
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr bool operator>(Point<V> const& left, Point<V> const& right);
 
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr Point<V> NextUp(Point<V> x);
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr Point<V> NextDown(Point<V> x);
 
   template<typename V>
@@ -115,28 +115,28 @@ Point<Product<L, R>> FusedNegatedMultiplyAdd(L const& a,
                                              Point<Product<L, R>> const& c);
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator<(Point<Vector> const& left, Point<Vector> const& right);
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator<=(Point<Vector> const& left,
                           Point<Vector> const& right);
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator>=(Point<Vector> const& left,
                           Point<Vector> const& right);
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator>(Point<Vector> const& left, Point<Vector> const& right);
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr Point<Vector> NextUp(Point<Vector> x);
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr Point<Vector> NextDown(Point<Vector> x);
 
 template<typename Vector>
diff --git a/geometry/point_body.hpp b/geometry/point_body.hpp
index a46c7d548e..2b8e16f07b 100644
--- a/geometry/point_body.hpp
+++ b/geometry/point_body.hpp
@@ -145,42 +145,42 @@ Point<Product<L, R>> FusedNegatedMultiplyAdd(L const& a, R const& b,
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator<(Point<Vector> const& left,
                          Point<Vector> const& right) {
   return left.coordinates_ < right.coordinates_;
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator<=(Point<Vector> const& left,
                           Point<Vector> const& right) {
   return left.coordinates_ <= right.coordinates_;
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator>=(Point<Vector> const& left,
                           Point<Vector> const& right) {
   return left.coordinates_ >= right.coordinates_;
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator>(Point<Vector> const& left,
                          Point<Vector> const& right) {
   return left.coordinates_ > right.coordinates_;
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr Point<Vector> NextUp(Point<Vector> const x) {
   using quantities::_elementary_functions::NextUp;
   return Point<Vector>(NextUp(x.coordinates_));
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr Point<Vector> NextDown(Point<Vector> const x) {
   using quantities::_elementary_functions::NextDown;
   return Point<Vector>(NextDown(x.coordinates_));
diff --git a/geometry/r3_element.hpp b/geometry/r3_element.hpp
index 17606e700d..0f8c4f0779 100644
--- a/geometry/r3_element.hpp
+++ b/geometry/r3_element.hpp
@@ -115,41 +115,41 @@ R3Element<Scalar> operator-(R3Element<Scalar> const& left,
 // product LScalar ⊗ Scalar³. Since LScalar ⊗ Scalar³ ≅ (LScalar ⊗ Scalar)³,
 // the result is an R3Element<Product<LScalar, RScalar>>.
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> operator*(LScalar const& left,
                                                R3Element<RScalar> const& right);
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> operator*(R3Element<LScalar> const& left,
                                                RScalar const& right);
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Quotient<LScalar, RScalar>> operator/(R3Element<LScalar> const& left,
                                                 RScalar const& right);
 
 // FMA for ±vector * scalar ± vector.
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
     R3Element<LScalar> const& a,
     RScalar const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
     R3Element<LScalar> const& a,
     RScalar const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
     R3Element<LScalar> const& a,
     RScalar const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
     R3Element<LScalar> const& a,
     RScalar const& b,
@@ -157,25 +157,25 @@ R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
 
 // FMA for ±scalar * vector ± vector.
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
     LScalar const& a,
     R3Element<RScalar> const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
     LScalar const& a,
     R3Element<RScalar> const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
     LScalar const& a,
     R3Element<RScalar> const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
     LScalar const& a,
     R3Element<RScalar> const& b,
diff --git a/geometry/r3_element_body.hpp b/geometry/r3_element_body.hpp
index 1b3c47a691..fbe12704e0 100644
--- a/geometry/r3_element_body.hpp
+++ b/geometry/r3_element_body.hpp
@@ -253,7 +253,7 @@ R3Element<Scalar> operator-(R3Element<Scalar> const& left,
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> operator*(
     LScalar const& left,
     R3Element<RScalar> const& right) {
@@ -269,7 +269,7 @@ R3Element<Product<LScalar, RScalar>> operator*(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> operator*(R3Element<LScalar> const& left,
                                                RScalar const& right) {
 #if PRINCIPIA_USE_SSE3_INTRINSICS()
@@ -284,7 +284,7 @@ R3Element<Product<LScalar, RScalar>> operator*(R3Element<LScalar> const& left,
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Quotient<LScalar, RScalar>> operator/(R3Element<LScalar> const& left,
                                                 RScalar const& right) {
 #if PRINCIPIA_USE_SSE3_INTRINSICS()
@@ -299,7 +299,7 @@ R3Element<Quotient<LScalar, RScalar>> operator/(R3Element<LScalar> const& left,
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
     R3Element<LScalar> const& a,
     RScalar const& b,
@@ -314,7 +314,7 @@ R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
     R3Element<LScalar> const& a,
     RScalar const& b,
@@ -329,7 +329,7 @@ R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
     R3Element<LScalar> const& a,
     RScalar const& b,
@@ -344,7 +344,7 @@ R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
     R3Element<LScalar> const& a,
     RScalar const& b,
@@ -359,7 +359,7 @@ R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
     LScalar const& a,
     R3Element<RScalar> const& b,
@@ -374,7 +374,7 @@ R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
     LScalar const& a,
     R3Element<RScalar> const& b,
@@ -389,7 +389,7 @@ R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
     LScalar const& a,
     R3Element<RScalar> const& b,
@@ -404,7 +404,7 @@ R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
     LScalar const& a,
     R3Element<RScalar> const& b,
diff --git a/geometry/r3x3_matrix.hpp b/geometry/r3x3_matrix.hpp
index 75a45d3491..89ec2ab237 100644
--- a/geometry/r3x3_matrix.hpp
+++ b/geometry/r3x3_matrix.hpp
@@ -107,15 +107,15 @@ class R3x3Matrix final {
                                               R3x3Matrix<RS> const& right);
 
   template<typename LS, typename RS>
-    requires quantity<LS>
+    requires convertible_to_quantity<LS>
   friend R3x3Matrix<Product<LS, RS>> operator*(LS const& left,
                                                R3x3Matrix<RS> const& right);
   template<typename LS, typename RS>
-    requires quantity<RS>
+    requires convertible_to_quantity<RS>
   friend R3x3Matrix<Product<LS, RS>> operator*(R3x3Matrix<LS> const& left,
                                                RS const& right);
   template<typename LS, typename RS>
-    requires quantity<RS>
+    requires convertible_to_quantity<RS>
   friend R3x3Matrix<Quotient<LS, RS>> operator/(R3x3Matrix<LS> const& left,
                                                 RS const& right);
 
@@ -158,16 +158,16 @@ R3Element<Product<LScalar, RScalar>> operator*(
     R3x3Matrix<RScalar> const& right);
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3x3Matrix<Product<LScalar, RScalar>> operator*(
     LScalar const& left,
     R3x3Matrix<RScalar> const& right);
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3x3Matrix<Product<LScalar, RScalar>> operator*(R3x3Matrix<LScalar> const& left,
                                                 RScalar const& right);
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3x3Matrix<Quotient<LScalar, RScalar>> operator/(
     R3x3Matrix<LScalar> const& left,
     RScalar const& right);
diff --git a/geometry/r3x3_matrix_body.hpp b/geometry/r3x3_matrix_body.hpp
index 90dafc872f..8c52dc8e13 100644
--- a/geometry/r3x3_matrix_body.hpp
+++ b/geometry/r3x3_matrix_body.hpp
@@ -342,7 +342,7 @@ R3Element<Product<LScalar, RScalar>> operator*(
 
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3x3Matrix<Product<LScalar, RScalar>> operator*(
     LScalar const& left,
     R3x3Matrix<RScalar> const& right) {
@@ -355,7 +355,7 @@ R3x3Matrix<Product<LScalar, RScalar>> operator*(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3x3Matrix<Product<LScalar, RScalar>> operator*(
     R3x3Matrix<LScalar> const& left,
     RScalar const& right) {
@@ -368,7 +368,7 @@ R3x3Matrix<Product<LScalar, RScalar>> operator*(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3x3Matrix<Quotient<LScalar, RScalar>> operator/(
     R3x3Matrix<LScalar> const& left,
     RScalar const& right) {
diff --git a/numerics/double_precision_body.hpp b/numerics/double_precision_body.hpp
index 271706b1a5..042083101a 100644
--- a/numerics/double_precision_body.hpp
+++ b/numerics/double_precision_body.hpp
@@ -101,7 +101,7 @@ struct ComponentwiseComparator<R3Element<T>, R3Element<U>> : not_constructible {
 };
 
 template<typename T, typename U>
-  requires quantity<T> && quantity<U>
+  requires convertible_to_quantity<T> && convertible_to_quantity<U>
 struct ComponentwiseComparator<T, U> {
   static bool GreaterThanOrEqualOrZero(T const& left, U const& right) {
     return Abs(left) >= Abs(right) || left == T{};
diff --git "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp" "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp"
index da89ecab3d..41a1499291 100644
--- "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp"
+++ "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp"
@@ -76,12 +76,12 @@ class PolynomialInЧебышёвBasis<Value_, Argument_, std::nullopt>
   // of |error_estimate| has no real roots.  This is useful if the series is an
   // approximation of some function with an L∞ error less than |error_estimate|.
   bool MayHaveRealRoots(Value error_estimate = Value{}) const
-    requires quantity<Value_>;
+    requires convertible_to_quantity<Value_>;
 
   // Returns the real roots of the polynomial, computed as the eigenvalues of
   // the Frobenius companion matrix.
   absl::btree_set<Argument> RealRoots(double ε) const
-    requires quantity<Value_>;
+    requires convertible_to_quantity<Value_>;
 
   // Compatibility deserialization: this class is the equivalent of the old
   // ЧебышёвSeries.
@@ -124,7 +124,7 @@ class PolynomialInЧебышёвBasis<Value_, Argument_, degree_>
 
   // Returns the Frobenius companion matrix suitable for the Чебышёв basis.
   FixedMatrix<double, degree_, degree_> FrobeniusCompanionMatrix() const
-    requires quantity<Value_>;
+    requires convertible_to_quantity<Value_>;
 
   void WriteToMessage(not_null<serialization::Polynomial*> message) const;
   static PolynomialInЧебышёвBasis ReadFromMessage(
diff --git "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp" "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp"
index 3f16015f7b..f934579631 100644
--- "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp"
+++ "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp"
@@ -37,7 +37,7 @@ using namespace principia::quantities::_si;
 template<typename Value_, typename Argument_>
 bool PolynomialInЧебышёвBasis<Value_, Argument_, std::nullopt>::
     MayHaveRealRoots(Value const error_estimate) const
-  requires quantity<Value_> {
+  requires convertible_to_quantity<Value_> {
   return MayHaveRealRootsOrDie(error_estimate);
 }
 
@@ -45,7 +45,7 @@ template<typename Value_, typename Argument_>
 absl::btree_set<Argument_>
 PolynomialInЧебышёвBasis<Value_, Argument_, std::nullopt>::RealRoots(
     double const ε) const
-  requires quantity<Value_> {
+  requires convertible_to_quantity<Value_> {
   return RealRootsOrDie(ε);
 }
 
@@ -207,7 +207,7 @@ PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::upper_bound() const
 template<typename Value_, typename Argument_, int degree_>
 FixedMatrix<double, degree_, degree_>
 PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::FrobeniusCompanionMatrix()
-    const requires quantity<Value_> {
+    const requires convertible_to_quantity<Value_> {
   int const N = degree();
   FixedMatrix<double, degree_, degree_> A(uninitialized);
 
@@ -299,7 +299,7 @@ PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::ReadFromMessage(
 template<typename Value_, typename Argument_, int degree_>
 bool PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::
 MayHaveRealRootsOrDie(Value const error_estimate) const {
-  if constexpr (quantity<Value>) {
+  if constexpr (convertible_to_quantity<Value>) {
     CHECK_LE(Value{}, error_estimate);
     // This code follow [Boy06], theorem 2.  Note that [Boy06] has another
     // criterion, B₁ and concludes: “There was no detectable difference between
@@ -327,7 +327,7 @@ template<typename Value_, typename Argument_, int degree_>
 absl::btree_set<Argument_>
 PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::
 RealRootsOrDie(double const ε) const {
-  if constexpr (quantity<Value>) {
+  if constexpr (convertible_to_quantity<Value>) {
     auto const companion_matrix = FrobeniusCompanionMatrix();
     auto const real_schur_decomposition =
         RealSchurDecomposition(companion_matrix, ε);
diff --git a/quantities/concepts.hpp b/quantities/concepts.hpp
index 80a3f571ac..2b46b19bbf 100644
--- a/quantities/concepts.hpp
+++ b/quantities/concepts.hpp
@@ -50,8 +50,9 @@ template<typename V>
 concept real_affine_space = affine_space<V, double>;
 
 template<typename T>
-concept quantity = std::integral<T> || std::floating_point<T> ||
-                   is_instance_of_v<Quantity, std::remove_const_t<T>>;
+concept convertible_to_quantity =
+    std::convertible_to<T, double> ||
+    is_instance_of_v<Quantity, std::remove_cvref_t<T>>;
 
 }  // namespace internal
 
@@ -59,7 +60,7 @@ using internal::additive_group;
 using internal::affine_space;
 using internal::real_affine_space;
 using internal::real_vector_space;
-using internal::quantity;
+using internal::convertible_to_quantity;
 using internal::vector_space;
 
 }  // namespace _concepts
diff --git a/quantities/concepts_test.cpp b/quantities/concepts_test.cpp
index e6815c4461..a5f224531e 100644
--- a/quantities/concepts_test.cpp
+++ b/quantities/concepts_test.cpp
@@ -12,14 +12,14 @@ using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
 TEST(Traits, IsQuantityV) {
-  static_assert(quantity<int>);
-  static_assert(quantity<double>);
-  static_assert(quantity<Area>);
-  static_assert(quantity<Frequency const>);
-  // Not sure if the following is what we want, but at least let's nail it in a
-  // test.
-  static_assert(!quantity<Entropy&>);
-  static_assert(!quantity<float const&>);
+  static_assert(convertible_to_quantity<int>);
+  static_assert(convertible_to_quantity<double>);
+  static_assert(convertible_to_quantity<Area>);
+  static_assert(convertible_to_quantity<Frequency const>);
+  static_assert(convertible_to_quantity<Entropy&>);
+  static_assert(convertible_to_quantity<float const&>);
+
+  static_assert(!convertible_to_quantity<int*>);
 }
 
 }  // namespace quantities