diff --git a/gtsam/base/Group.h b/gtsam/base/Group.h
index 3430a06ae5..e76a273da5 100644
--- a/gtsam/base/Group.h
+++ b/gtsam/base/Group.h
@@ -139,8 +139,8 @@ compose_pow(const G& g, size_t n) {
 /// Assumes nothing except group structure and Testable from G and H
 template<typename G, typename H>
 class DirectProduct: public std::pair<G, H> {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<G>);
-  GTSAM_CONCEPT_ASSERT2(IsGroup<H>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<G>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<H>);
 
 public:
   /// Default constructor yields identity
@@ -170,8 +170,8 @@ struct traits<DirectProduct<G, H> > :
 /// Assumes existence of three additive operators for both groups
 template<typename G, typename H>
 class DirectSum: public std::pair<G, H> {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<G>);  // TODO(frank): check additive
-  GTSAM_CONCEPT_ASSERT2(IsGroup<H>);  // TODO(frank): check additive
+  GTSAM_CONCEPT_ASSERT(IsGroup<G>);  // TODO(frank): check additive
+  GTSAM_CONCEPT_ASSERT(IsGroup<H>);  // TODO(frank): check additive
 
   const G& g() const { return this->first; }
   const H& h() const { return this->second;}
diff --git a/gtsam/base/ProductLieGroup.h b/gtsam/base/ProductLieGroup.h
index a8bb2ef980..beb376c199 100644
--- a/gtsam/base/ProductLieGroup.h
+++ b/gtsam/base/ProductLieGroup.h
@@ -27,8 +27,8 @@ namespace gtsam {
 /// Assumes Lie group structure for G and H
 template<typename G, typename H>
 class ProductLieGroup: public std::pair<G, H> {
-  GTSAM_CONCEPT_ASSERT1(IsLieGroup<G>);
-  GTSAM_CONCEPT_ASSERT2(IsLieGroup<H>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<G>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<H>);
   typedef std::pair<G, H> Base;
 
 protected:
diff --git a/gtsam/base/tests/testMatrix.cpp b/gtsam/base/tests/testMatrix.cpp
index a000e4864a..8f9d2bca69 100644
--- a/gtsam/base/tests/testMatrix.cpp
+++ b/gtsam/base/tests/testMatrix.cpp
@@ -1165,8 +1165,8 @@ TEST(Matrix, VectorIsVectorSpace) {
 
 TEST(Matrix, RowVectorIsVectorSpace) {
   typedef Eigen::Matrix<double, 1, -1> RowVector;
-  GTSAM_CONCEPT_ASSERT1(IsVectorSpace<RowVector>);
-  GTSAM_CONCEPT_ASSERT2(IsVectorSpace<Vector5>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<RowVector>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<Vector5>);
 }
 
 //******************************************************************************
diff --git a/gtsam/base/tests/testVector.cpp b/gtsam/base/tests/testVector.cpp
index c749a5191c..ca96bc73d1 100644
--- a/gtsam/base/tests/testVector.cpp
+++ b/gtsam/base/tests/testVector.cpp
@@ -267,8 +267,8 @@ TEST(Vector, linear_dependent3 )
 
 //******************************************************************************
 TEST(Vector, VectorIsVectorSpace) {
-  GTSAM_CONCEPT_ASSERT1(IsVectorSpace<Vector5>);
-  GTSAM_CONCEPT_ASSERT2(IsVectorSpace<Vector>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<Vector5>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<Vector>);
 }
 
 TEST(Vector, RowVectorIsVectorSpace) {
diff --git a/gtsam/geometry/tests/testCyclic.cpp b/gtsam/geometry/tests/testCyclic.cpp
index e2b250f500..b0e0ca0b11 100644
--- a/gtsam/geometry/tests/testCyclic.cpp
+++ b/gtsam/geometry/tests/testCyclic.cpp
@@ -107,8 +107,8 @@ struct traits<K4> : internal::AdditiveGroupTraits<K4> {
 TEST(Cyclic , DirectSum) {
   // The Direct sum of Z2 and Z2 is *not* Cyclic<4>, but the
   // smallest non-cyclic group called the Klein four-group:
-  GTSAM_CONCEPT_ASSERT1(IsGroup<K4>);
-  GTSAM_CONCEPT_ASSERT2(IsTestable<K4>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<K4>);
+  GTSAM_CONCEPT_ASSERT(IsTestable<K4>);
 
   // Refer to http://en.wikipedia.org/wiki/Klein_four-group
   K4 e(0,0), a(0, 1), b(1, 0), c(1, 1);
diff --git a/gtsam/geometry/tests/testPoint2.cpp b/gtsam/geometry/tests/testPoint2.cpp
index 4083970b6f..e8bbfe0e1d 100644
--- a/gtsam/geometry/tests/testPoint2.cpp
+++ b/gtsam/geometry/tests/testPoint2.cpp
@@ -34,9 +34,9 @@ TEST(Point2 , Constructor) {
 
 //******************************************************************************
 TEST(Double , Concept) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<double>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<double>);
-  GTSAM_CONCEPT_ASSERT3(IsVectorSpace<double>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<double>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<double>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<double>);
 }
 
 //******************************************************************************
@@ -48,9 +48,9 @@ TEST(Double , Invariants) {
 
 //******************************************************************************
 TEST(Point2 , Concept) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<Point2>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<Point2>);
-  GTSAM_CONCEPT_ASSERT3(IsVectorSpace<Point2>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<Point2>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Point2>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<Point2>);
 }
 
 //******************************************************************************
diff --git a/gtsam/geometry/tests/testPoint3.cpp b/gtsam/geometry/tests/testPoint3.cpp
index e4263ffd71..dcfb99105a 100644
--- a/gtsam/geometry/tests/testPoint3.cpp
+++ b/gtsam/geometry/tests/testPoint3.cpp
@@ -34,9 +34,9 @@ TEST(Point3 , Constructor) {
 
 //******************************************************************************
 TEST(Point3 , Concept) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<Point3>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<Point3>);
-  GTSAM_CONCEPT_ASSERT3(IsVectorSpace<Point3>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<Point3>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Point3>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<Point3>);
 }
 
 //******************************************************************************
diff --git a/gtsam/geometry/tests/testPose2.cpp b/gtsam/geometry/tests/testPose2.cpp
index 3985f6ba5f..8c1bdccc06 100644
--- a/gtsam/geometry/tests/testPose2.cpp
+++ b/gtsam/geometry/tests/testPose2.cpp
@@ -35,9 +35,9 @@ GTSAM_CONCEPT_LIE_INST(Pose2)
 
 //******************************************************************************
 TEST(Pose2 , Concept) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<Pose2 >);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<Pose2 >);
-  GTSAM_CONCEPT_ASSERT3(IsLieGroup<Pose2 >);
+  GTSAM_CONCEPT_ASSERT(IsGroup<Pose2 >);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Pose2 >);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<Pose2 >);
 }
 
 /* ************************************************************************* */
diff --git a/gtsam/geometry/tests/testQuaternion.cpp b/gtsam/geometry/tests/testQuaternion.cpp
index 546a1f5b54..c99c67e0fb 100644
--- a/gtsam/geometry/tests/testQuaternion.cpp
+++ b/gtsam/geometry/tests/testQuaternion.cpp
@@ -29,9 +29,9 @@ typedef traits<Q>::ChartJacobian QuaternionJacobian;
 
 //******************************************************************************
 TEST(Quaternion , Concept) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<Quaternion >);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<Quaternion >);
-  GTSAM_CONCEPT_ASSERT3(IsLieGroup<Quaternion >);
+  GTSAM_CONCEPT_ASSERT(IsGroup<Quaternion >);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Quaternion >);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<Quaternion >);
 }
 
 //******************************************************************************
diff --git a/gtsam/geometry/tests/testRot3.cpp b/gtsam/geometry/tests/testRot3.cpp
index 39cc05fde4..49b9785679 100644
--- a/gtsam/geometry/tests/testRot3.cpp
+++ b/gtsam/geometry/tests/testRot3.cpp
@@ -38,9 +38,9 @@ static double error = 1e-9, epsilon = 0.001;
 
 //******************************************************************************
 TEST(Rot3 , Concept) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<Rot3 >);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<Rot3 >);
-  GTSAM_CONCEPT_ASSERT3(IsLieGroup<Rot3 >);
+  GTSAM_CONCEPT_ASSERT(IsGroup<Rot3 >);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Rot3 >);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<Rot3 >);
 }
 
 /* ************************************************************************* */
diff --git a/gtsam/geometry/tests/testSO3.cpp b/gtsam/geometry/tests/testSO3.cpp
index 2086318cbc..27c143d315 100644
--- a/gtsam/geometry/tests/testSO3.cpp
+++ b/gtsam/geometry/tests/testSO3.cpp
@@ -36,9 +36,9 @@ TEST(SO3, Identity) {
 
 //******************************************************************************
 TEST(SO3, Concept) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<SO3>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<SO3>);
-  GTSAM_CONCEPT_ASSERT3(IsLieGroup<SO3>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<SO3>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<SO3>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<SO3>);
 }
 
 //******************************************************************************
diff --git a/gtsam/geometry/tests/testSO4.cpp b/gtsam/geometry/tests/testSO4.cpp
index 17d9694bea..7a3198901e 100644
--- a/gtsam/geometry/tests/testSO4.cpp
+++ b/gtsam/geometry/tests/testSO4.cpp
@@ -42,9 +42,9 @@ TEST(SO4, Identity) {
 
 //******************************************************************************
 TEST(SO4, Concept) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<SO4>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<SO4>);
-  GTSAM_CONCEPT_ASSERT3(IsLieGroup<SO4>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<SO4>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<SO4>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<SO4>);
 }
 
 //******************************************************************************
diff --git a/gtsam/geometry/tests/testSOn.cpp b/gtsam/geometry/tests/testSOn.cpp
index eb453d8c64..741ddd3d08 100644
--- a/gtsam/geometry/tests/testSOn.cpp
+++ b/gtsam/geometry/tests/testSOn.cpp
@@ -84,9 +84,9 @@ TEST(SOn, SO5) {
 
 //******************************************************************************
 TEST(SOn, Concept) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<SOn>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<SOn>);
-  GTSAM_CONCEPT_ASSERT3(IsLieGroup<SOn>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<SOn>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<SOn>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<SOn>);
 }
 
 //******************************************************************************
diff --git a/gtsam/geometry/tests/testSimilarity2.cpp b/gtsam/geometry/tests/testSimilarity2.cpp
index 8d537fd72f..9a64ba1c91 100644
--- a/gtsam/geometry/tests/testSimilarity2.cpp
+++ b/gtsam/geometry/tests/testSimilarity2.cpp
@@ -35,9 +35,9 @@ static const double s = 4;
 
 //******************************************************************************
 TEST(Similarity2, Concepts) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<Similarity2>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<Similarity2>);
-  GTSAM_CONCEPT_ASSERT3(IsLieGroup<Similarity2>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<Similarity2>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Similarity2>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<Similarity2>);
 }
 
 //******************************************************************************
diff --git a/gtsam/geometry/tests/testSimilarity3.cpp b/gtsam/geometry/tests/testSimilarity3.cpp
index d0f6617878..e4f68f22f1 100644
--- a/gtsam/geometry/tests/testSimilarity3.cpp
+++ b/gtsam/geometry/tests/testSimilarity3.cpp
@@ -54,9 +54,9 @@ const double degree = M_PI / 180;
 
 //******************************************************************************
 TEST(Similarity3, Concepts) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<Similarity3 >);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<Similarity3 >);
-  GTSAM_CONCEPT_ASSERT3(IsLieGroup<Similarity3 >);
+  GTSAM_CONCEPT_ASSERT(IsGroup<Similarity3 >);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Similarity3 >);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<Similarity3 >);
 }
 
 //******************************************************************************
diff --git a/gtsam/geometry/tests/testStereoPoint2.cpp b/gtsam/geometry/tests/testStereoPoint2.cpp
index 236ea8b012..3977589a8b 100644
--- a/gtsam/geometry/tests/testStereoPoint2.cpp
+++ b/gtsam/geometry/tests/testStereoPoint2.cpp
@@ -31,9 +31,9 @@ GTSAM_CONCEPT_TESTABLE_INST(StereoPoint2)
 
 //******************************************************************************
 TEST(StereoPoint2 , Concept) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<StereoPoint2>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<StereoPoint2 >);
-  GTSAM_CONCEPT_ASSERT3(IsVectorSpace<StereoPoint2>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<StereoPoint2>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<StereoPoint2 >);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<StereoPoint2>);
 }
 
 /* ************************************************************************* */
diff --git a/gtsam/nonlinear/ExtendedKalmanFilter.h b/gtsam/nonlinear/ExtendedKalmanFilter.h
index a270bc4b15..6dc79cd52f 100644
--- a/gtsam/nonlinear/ExtendedKalmanFilter.h
+++ b/gtsam/nonlinear/ExtendedKalmanFilter.h
@@ -44,8 +44,8 @@ namespace gtsam {
 template <class VALUE>
 class ExtendedKalmanFilter {
   // Check that VALUE type is a testable Manifold
-  GTSAM_CONCEPT_ASSERT1(IsTestable<VALUE>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<VALUE>);
+  GTSAM_CONCEPT_ASSERT(IsTestable<VALUE>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<VALUE>);
 
  public:
   typedef std::shared_ptr<ExtendedKalmanFilter<VALUE> > shared_ptr;
diff --git a/gtsam/slam/BetweenFactor.h b/gtsam/slam/BetweenFactor.h
index ee533c2157..6eaa5c01b8 100644
--- a/gtsam/slam/BetweenFactor.h
+++ b/gtsam/slam/BetweenFactor.h
@@ -40,8 +40,8 @@ namespace gtsam {
   class BetweenFactor: public NoiseModelFactorN<VALUE, VALUE> {
 
     // Check that VALUE type is a testable Lie group
-    GTSAM_CONCEPT_ASSERT1(IsTestable<VALUE>);
-    GTSAM_CONCEPT_ASSERT2(IsLieGroup<VALUE>);
+    GTSAM_CONCEPT_ASSERT(IsTestable<VALUE>);
+    GTSAM_CONCEPT_ASSERT(IsLieGroup<VALUE>);
 
   public:
 
diff --git a/tests/testLie.cpp b/tests/testLie.cpp
index f411bd6ef1..ae934d66a4 100644
--- a/tests/testLie.cpp
+++ b/tests/testLie.cpp
@@ -47,9 +47,9 @@ template<> struct traits<Product> : internal::LieGroupTraits<Product> {
 
 //******************************************************************************
 TEST(Lie, ProductLieGroup) {
-  GTSAM_CONCEPT_ASSERT1(IsGroup<Product>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<Product>);
-  GTSAM_CONCEPT_ASSERT3(IsLieGroup<Product>);
+  GTSAM_CONCEPT_ASSERT(IsGroup<Product>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Product>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<Product>);
   Product pair1;
   Vector5 d;
   d << 1, 2, 0.1, 0.2, 0.3;
diff --git a/tests/testManifold.cpp b/tests/testManifold.cpp
index 6b853061bf..5e93da2f53 100644
--- a/tests/testManifold.cpp
+++ b/tests/testManifold.cpp
@@ -38,26 +38,26 @@ typedef PinholeCamera<Cal3Bundler> Camera;
 //******************************************************************************
 TEST(Manifold, SomeManifoldsGTSAM) {
   //GTSAM_CONCEPT_ASSERT(IsManifold<int>); // integer is not a manifold
-  GTSAM_CONCEPT_ASSERT1(IsManifold<Camera>);
-  GTSAM_CONCEPT_ASSERT2(IsManifold<Cal3_S2>);
-  GTSAM_CONCEPT_ASSERT3(IsManifold<Cal3Bundler>);
-  GTSAM_CONCEPT_ASSERT4(IsManifold<Camera>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Camera>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Cal3_S2>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Cal3Bundler>);
+  GTSAM_CONCEPT_ASSERT(IsManifold<Camera>);
 }
 
 //******************************************************************************
 TEST(Manifold, SomeLieGroupsGTSAM) {
-  GTSAM_CONCEPT_ASSERT1(IsLieGroup<Rot2>);
-  GTSAM_CONCEPT_ASSERT2(IsLieGroup<Pose2>);
-  GTSAM_CONCEPT_ASSERT3(IsLieGroup<Rot3>);
-  GTSAM_CONCEPT_ASSERT4(IsLieGroup<Pose3>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<Rot2>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<Pose2>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<Rot3>);
+  GTSAM_CONCEPT_ASSERT(IsLieGroup<Pose3>);
 }
 
 //******************************************************************************
 TEST(Manifold, SomeVectorSpacesGTSAM) {
-  GTSAM_CONCEPT_ASSERT1(IsVectorSpace<double>);
-  GTSAM_CONCEPT_ASSERT2(IsVectorSpace<float>);
-  GTSAM_CONCEPT_ASSERT3(IsVectorSpace<Point2>);
-  GTSAM_CONCEPT_ASSERT4(IsVectorSpace<Matrix24>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<double>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<float>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<Point2>);
+  GTSAM_CONCEPT_ASSERT(IsVectorSpace<Matrix24>);
 }
 
 //******************************************************************************