diff --git a/qulacs/gate/constant.hpp b/qulacs/gate/constant.hpp
index 35f1b5ff..16769695 100644
--- a/qulacs/gate/constant.hpp
+++ b/qulacs/gate/constant.hpp
@@ -27,47 +27,48 @@ KOKKOS_INLINE_FUNCTION
 double SINPI8() { return 0.382683432365090; }
 
 //! identity matrix
-matrix_2_2 I_GATE = {1, 0, 0, 1};
+inline matrix_2_2 I_GATE = {1, 0, 0, 1};
 //! Pauli matrix X
-matrix_2_2 X_GATE = {0, 1, 1, 0};
+inline matrix_2_2 X_GATE = {0, 1, 1, 0};
 //! Pauli matrix Y
-matrix_2_2 Y_GATE = {0, Complex(0, -1), Complex(0, 1), 0};
+inline matrix_2_2 Y_GATE = {0, Complex(0, -1), Complex(0, 1), 0};
 //! Pauli matrix Z
-matrix_2_2 Z_GATE = {1, 0, 0, -1};
+inline matrix_2_2 Z_GATE = {1, 0, 0, -1};
 
 //! list of Pauli matrix I,X,Y,Z
 // std::array<matrix_2_2, 4> PAULI_MATRIX = {I_GATE, X_GATE, Y_GATE, Z_GATE};
 
 //! S-gate
-matrix_2_2 S_GATE_MATRIX = {1, 0, 0, Complex(0, 1)};
+inline matrix_2_2 S_GATE_MATRIX = {1, 0, 0, Complex(0, 1)};
 //! Sdag-gate
-matrix_2_2 S_DAG_GATE_MATRIX = {1, 0, 0, Complex(0, -1)};
+inline matrix_2_2 S_DAG_GATE_MATRIX = {1, 0, 0, Complex(0, -1)};
 //! T-gate
-matrix_2_2 T_GATE_MATRIX = {
+inline matrix_2_2 T_GATE_MATRIX = {
     COSPI8() - Complex(0, SINPI8()), 0., 0., COSPI8() + Complex(0, SINPI8()) * SINPI8()};
 //! Tdag-gate
-matrix_2_2 T_DAG_GATE_MATRIX = {
+inline matrix_2_2 T_DAG_GATE_MATRIX = {
     COSPI8() + Complex(0, SINPI8()), 0., 0., COSPI8() - Complex(0, SINPI8())};
 //! Hadamard gate
-matrix_2_2 HADAMARD_MATRIX = {INVERSE_SQRT2(), INVERSE_SQRT2(), INVERSE_SQRT2(), -INVERSE_SQRT2()};
+inline matrix_2_2 HADAMARD_MATRIX = {
+    INVERSE_SQRT2(), INVERSE_SQRT2(), INVERSE_SQRT2(), -INVERSE_SQRT2()};
 //! square root of X gate
-matrix_2_2 SQRT_X_GATE_MATRIX = {
+inline matrix_2_2 SQRT_X_GATE_MATRIX = {
     Complex(0.5, 0.5), Complex(0.5, -0.5), Complex(0.5, -0.5), Complex(0.5, 0.5)};
 //! square root of Y gate
-matrix_2_2 SQRT_Y_GATE_MATRIX = {
+inline matrix_2_2 SQRT_Y_GATE_MATRIX = {
     Complex(0.5, 0.5), Complex(-0.5, -0.5), Complex(0.5, 0.5), Complex(0.5, 0.5)};
 //! square root dagger of X gate
-matrix_2_2 SQRT_X_DAG_GATE_MATRIX = {
+inline matrix_2_2 SQRT_X_DAG_GATE_MATRIX = {
     Complex(0.5, -0.5), Complex(0.5, 0.5), Complex(0.5, 0.5), Complex(0.5, -0.5)};
 //! square root dagger of Y gate
-matrix_2_2 SQRT_Y_DAG_GATE_MATRIX = {
+inline matrix_2_2 SQRT_Y_DAG_GATE_MATRIX = {
     Complex(0.5, -0.5), Complex(0.5, -0.5), Complex(-0.5, 0.5), Complex(0.5, -0.5)};
 //! Projection to 0
-matrix_2_2 PROJ_0_MATRIX = {1, 0, 0, 0};
+inline matrix_2_2 PROJ_0_MATRIX = {1, 0, 0, 0};
 //! Projection to 1
-matrix_2_2 PROJ_1_MATRIX = {0, 0, 0, 1};
+inline matrix_2_2 PROJ_1_MATRIX = {0, 0, 0, 1};
 //! complex values for exp(j * i*pi/4 )
-matrix_2_2 PHASE_90ROT = {1., Complex(0, 1), -1, Complex(0, -1)};
+inline matrix_2_2 PHASE_90ROT = {1., Complex(0, 1), -1, Complex(0, -1)};
 //! complex values for exp(-j * i*pi/4 )
-matrix_2_2 PHASE_M90ROT = {1., Complex(0, -1), -1, Complex(0, 1)};
+inline matrix_2_2 PHASE_M90ROT = {1., Complex(0, -1), -1, Complex(0, 1)};
 }  // namespace qulacs
diff --git a/qulacs/gate/gate.hpp b/qulacs/gate/gate.hpp
index 2aed66d5..17baf020 100644
--- a/qulacs/gate/gate.hpp
+++ b/qulacs/gate/gate.hpp
@@ -4,11 +4,14 @@
 #include "../types.hpp"
 
 namespace qulacs {
-using GatePtr = std::unique_ptr<class QuantumGate>;
+namespace internal {
+using GatePtr = std::unique_ptr<class GateBase>;
+}
 
-class QuantumGate {
+namespace internal {
+class GateBase {
 public:
-    virtual ~QuantumGate() = default;
+    virtual ~GateBase() = default;
 
     [[nodiscard]] virtual std::vector<UINT> get_target_qubit_list() const = 0;
     [[nodiscard]] virtual std::vector<UINT> get_control_qubit_list() const = 0;
@@ -26,4 +29,29 @@ class QuantumGate {
 
     virtual void update_quantum_state(StateVector& state_vector) const = 0;
 };
+
+template <typename T>
+concept GateImpl = std::derived_from<T, GateBase>;
+
+class GateFactory;
+}  // namespace internal
+
+class Gate {
+    friend class internal::GateFactory;
+
+private:
+    internal::GatePtr _gate_ptr;
+    Gate(internal::GatePtr&& gate_ptr) : _gate_ptr(std::move(gate_ptr)) {}
+
+public:
+    std::vector<UINT> get_control_qubit_list() const { return _gate_ptr->get_control_qubit_list(); }
+    std::vector<UINT> get_target_qubit_list() const { return _gate_ptr->get_target_qubit_list(); }
+    UINT n_qubits() const { return _gate_ptr->n_qubits(); }
+    Gate copy() const { return _gate_ptr->copy(); }
+    Gate get_inverse() const { return _gate_ptr->get_inverse(); }
+    void update_quantum_state(StateVector& state_vector) const {
+        _gate_ptr->update_quantum_state(state_vector);
+    }
+};
+
 }  // namespace qulacs
diff --git a/qulacs/gate/gate_factory.hpp b/qulacs/gate/gate_factory.hpp
index c8de9f72..fb302d81 100644
--- a/qulacs/gate/gate_factory.hpp
+++ b/qulacs/gate/gate_factory.hpp
@@ -6,33 +6,57 @@
 #include "gate/gate_quantum_matrix.hpp"
 
 namespace qulacs {
-namespace gate {
-GatePtr I(UINT target) { return std::make_unique<qulacs::I>(target); }
-GatePtr X(UINT target) { return std::make_unique<qulacs::X>(target); }
-GatePtr Y(UINT target) { return std::make_unique<qulacs::Y>(target); }
-GatePtr Z(UINT target) { return std::make_unique<qulacs::Z>(target); }
-GatePtr H(UINT target) { return std::make_unique<qulacs::H>(target); }
-GatePtr S(UINT target) { return std::make_unique<qulacs::S>(target); }
-GatePtr Sdag(UINT target) { return std::make_unique<qulacs::Sdag>(target); }
-GatePtr T(UINT target) { return std::make_unique<qulacs::T>(target); }
-GatePtr Tdag(UINT target) { return std::make_unique<qulacs::Tdag>(target); }
-GatePtr sqrtX(UINT target) { return std::make_unique<qulacs::sqrtX>(target); }
-GatePtr sqrtXdag(UINT target) { return std::make_unique<qulacs::sqrtXdag>(target); }
-GatePtr sqrtY(UINT target) { return std::make_unique<qulacs::sqrtY>(target); }
-GatePtr sqrtYdag(UINT target) { return std::make_unique<qulacs::sqrtYdag>(target); }
-GatePtr P0(UINT target) { return std::make_unique<qulacs::P0>(target); }
-GatePtr P1(UINT target) { return std::make_unique<qulacs::P1>(target); }
-GatePtr RX(UINT target, double angle) { return std::make_unique<qulacs::RX>(target, angle); }
-GatePtr RY(UINT target, double angle) { return std::make_unique<qulacs::RY>(target, angle); }
-GatePtr RZ(UINT target, double angle) { return std::make_unique<qulacs::RZ>(target, angle); }
-GatePtr U1(UINT target, double lambda) { return std::make_unique<qulacs::U1>(target, lambda); }
-GatePtr U2(UINT target, double phi, double lambda) {
-    return std::make_unique<qulacs::U2>(target, phi, lambda);
-}
-GatePtr U3(UINT target, double theta, double phi, double lambda) {
-    return std::make_unique<qulacs::U3>(target, theta, phi, lambda);
-}
-GatePtr CNOT(UINT control, UINT target) { return std::make_unique<qulacs::CNOT>(control, target); }
-GatePtr CZ(UINT control, UINT target) { return std::make_unique<qulacs::CZ>(control, target); }
-}  // namespace gate
+namespace internal {
+class GateFactory {
+public:
+    template <GateImpl T, typename... Args>
+    static Gate create_gate(Args... args) {
+        return {std::make_unique<T>(args...)};
+    }
+};
+}  // namespace internal
+
+Gate I(UINT target) { return internal::GateFactory::create_gate<internal::IGate>(target); }
+Gate X(UINT target) { return internal::GateFactory::create_gate<internal::XGate>(target); }
+Gate Y(UINT target) { return internal::GateFactory::create_gate<internal::YGate>(target); }
+Gate Z(UINT target) { return internal::GateFactory::create_gate<internal::ZGate>(target); }
+Gate H(UINT target) { return internal::GateFactory::create_gate<internal::HGate>(target); }
+Gate S(UINT target) { return internal::GateFactory::create_gate<internal::SGate>(target); }
+Gate Sdag(UINT target) { return internal::GateFactory::create_gate<internal::SdagGate>(target); }
+Gate T(UINT target) { return internal::GateFactory::create_gate<internal::TGate>(target); }
+Gate Tdag(UINT target) { return internal::GateFactory::create_gate<internal::TdagGate>(target); }
+Gate sqrtX(UINT target) { return internal::GateFactory::create_gate<internal::sqrtXGate>(target); }
+Gate sqrtXdag(UINT target) {
+    return internal::GateFactory::create_gate<internal::sqrtXdagGate>(target);
+}
+Gate sqrtY(UINT target) { return internal::GateFactory::create_gate<internal::sqrtYGate>(target); }
+Gate sqrtYdag(UINT target) {
+    return internal::GateFactory::create_gate<internal::sqrtYdagGate>(target);
+}
+Gate P0(UINT target) { return internal::GateFactory::create_gate<internal::P0Gate>(target); }
+Gate P1(UINT target) { return internal::GateFactory::create_gate<internal::P1Gate>(target); }
+Gate RX(UINT target, double angle) {
+    return internal::GateFactory::create_gate<internal::RXGate>(target, angle);
+}
+Gate RY(UINT target, double angle) {
+    return internal::GateFactory::create_gate<internal::RYGate>(target, angle);
+}
+Gate RZ(UINT target, double angle) {
+    return internal::GateFactory::create_gate<internal::RZGate>(target, angle);
+}
+Gate U1(UINT target, double lambda) {
+    return internal::GateFactory::create_gate<internal::U1Gate>(target, lambda);
+}
+Gate U2(UINT target, double phi, double lambda) {
+    return internal::GateFactory::create_gate<internal::U2Gate>(target, phi, lambda);
+}
+Gate U3(UINT target, double theta, double phi, double lambda) {
+    return internal::GateFactory::create_gate<internal::U3Gate>(target, theta, phi, lambda);
+}
+Gate CNOT(UINT control, UINT target) {
+    return internal::GateFactory::create_gate<internal::CNOTGate>(control, target);
+}
+Gate CZ(UINT control, UINT target) {
+    return internal::GateFactory::create_gate<internal::CZGate>(control, target);
+}
 }  // namespace qulacs
diff --git a/qulacs/gate/gate_one_control_one_target.cpp b/qulacs/gate/gate_one_control_one_target.cpp
index 368c5eca..b4cc522c 100644
--- a/qulacs/gate/gate_one_control_one_target.cpp
+++ b/qulacs/gate/gate_one_control_one_target.cpp
@@ -3,11 +3,13 @@
 #include "update_ops.hpp"
 
 namespace qulacs {
-void CNOT::update_quantum_state(StateVector& state_vector) const {
+namespace internal {
+void CNOTGate::update_quantum_state(StateVector& state_vector) const {
     cnot_gate(this->_control, this->_target, state_vector);
 }
 
-void CZ::update_quantum_state(StateVector& state_vector) const {
+void CZGate::update_quantum_state(StateVector& state_vector) const {
     cz_gate(this->_control, this->_target, state_vector);
 }
+}  // namespace internal
 }  // namespace qulacs
diff --git a/qulacs/gate/gate_one_control_one_target.hpp b/qulacs/gate/gate_one_control_one_target.hpp
index 89a8a4de..d1ccc0c4 100644
--- a/qulacs/gate/gate_one_control_one_target.hpp
+++ b/qulacs/gate/gate_one_control_one_target.hpp
@@ -5,13 +5,13 @@
 #include "gate.hpp"
 
 namespace qulacs {
-class QuantumGateOneControlOneTarget : public QuantumGate {
+namespace internal {
+class OneControlOneTargetGateBase : public GateBase {
 protected:
     UINT _control, _target;
 
 public:
-    QuantumGateOneControlOneTarget(UINT control, UINT target)
-        : _control(control), _target(target){};
+    OneControlOneTargetGateBase(UINT control, UINT target) : _control(control), _target(target){};
 
     UINT control() const { return _control; }
     UINT target() const { return _target; }
@@ -20,23 +20,24 @@ class QuantumGateOneControlOneTarget : public QuantumGate {
     std::vector<UINT> get_control_qubit_list() const override { return {_control}; };
 };
 
-class CNOT : public QuantumGateOneControlOneTarget {
+class CNOTGate : public OneControlOneTargetGateBase {
 public:
-    CNOT(UINT control, UINT target) : QuantumGateOneControlOneTarget(control, target) {}
+    CNOTGate(UINT control, UINT target) : OneControlOneTargetGateBase(control, target) {}
 
-    GatePtr copy() const override { return std::make_unique<CNOT>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<CNOT>(*this); }
+    GatePtr copy() const override { return std::make_unique<CNOTGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<CNOTGate>(*this); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class CZ : public QuantumGateOneControlOneTarget {
+class CZGate : public OneControlOneTargetGateBase {
 public:
-    CZ(UINT control, UINT target) : QuantumGateOneControlOneTarget(control, target) {}
+    CZGate(UINT control, UINT target) : OneControlOneTargetGateBase(control, target) {}
 
-    GatePtr copy() const override { return std::make_unique<CZ>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<CZ>(*this); }
+    GatePtr copy() const override { return std::make_unique<CZGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<CZGate>(*this); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
+}  // namespace internal
 }  // namespace qulacs
diff --git a/qulacs/gate/gate_one_qubit.cpp b/qulacs/gate/gate_one_qubit.cpp
index 8f3f153d..8a72a7e9 100644
--- a/qulacs/gate/gate_one_qubit.cpp
+++ b/qulacs/gate/gate_one_qubit.cpp
@@ -3,80 +3,82 @@
 #include "update_ops.hpp"
 
 namespace qulacs {
-GatePtr S::get_inverse() const { return std::make_unique<Sdag>(_target); }
-GatePtr T::get_inverse() const { return std::make_unique<Tdag>(_target); }
-GatePtr sqrtX::get_inverse() const { return std::make_unique<sqrtXdag>(_target); }
-GatePtr sqrtY::get_inverse() const { return std::make_unique<sqrtYdag>(_target); }
+namespace internal {
+GatePtr SGate::get_inverse() const { return std::make_unique<SdagGate>(_target); }
+GatePtr TGate::get_inverse() const { return std::make_unique<TdagGate>(_target); }
+GatePtr sqrtXGate::get_inverse() const { return std::make_unique<sqrtXdagGate>(_target); }
+GatePtr sqrtYGate::get_inverse() const { return std::make_unique<sqrtYdagGate>(_target); }
 
-void I::update_quantum_state(StateVector& state_vector) const {
+void IGate::update_quantum_state(StateVector& state_vector) const {
     i_gate(this->_target, state_vector);
 }
 
-void X::update_quantum_state(StateVector& state_vector) const {
+void XGate::update_quantum_state(StateVector& state_vector) const {
     x_gate(this->_target, state_vector);
 }
 
-void Y::update_quantum_state(StateVector& state_vector) const {
+void YGate::update_quantum_state(StateVector& state_vector) const {
     y_gate(this->_target, state_vector);
 }
 
-void Z::update_quantum_state(StateVector& state_vector) const {
+void ZGate::update_quantum_state(StateVector& state_vector) const {
     z_gate(this->_target, state_vector);
 }
 
-void H::update_quantum_state(StateVector& state_vector) const {
+void HGate::update_quantum_state(StateVector& state_vector) const {
     h_gate(this->_target, state_vector);
 }
 
-void S::update_quantum_state(StateVector& state_vector) const {
+void SGate::update_quantum_state(StateVector& state_vector) const {
     s_gate(this->_target, state_vector);
 }
 
-void Sdag::update_quantum_state(StateVector& state_vector) const {
+void SdagGate::update_quantum_state(StateVector& state_vector) const {
     sdag_gate(this->_target, state_vector);
 }
 
-void T::update_quantum_state(StateVector& state_vector) const {
+void TGate::update_quantum_state(StateVector& state_vector) const {
     t_gate(this->_target, state_vector);
 }
 
-void Tdag::update_quantum_state(StateVector& state_vector) const {
+void TdagGate::update_quantum_state(StateVector& state_vector) const {
     tdag_gate(this->_target, state_vector);
 }
 
-void sqrtX::update_quantum_state(StateVector& state_vector) const {
+void sqrtXGate::update_quantum_state(StateVector& state_vector) const {
     sqrtx_gate(this->_target, state_vector);
 }
 
-void sqrtXdag::update_quantum_state(StateVector& state_vector) const {
+void sqrtXdagGate::update_quantum_state(StateVector& state_vector) const {
     sqrtxdag_gate(this->_target, state_vector);
 }
 
-void sqrtY::update_quantum_state(StateVector& state_vector) const {
+void sqrtYGate::update_quantum_state(StateVector& state_vector) const {
     sqrty_gate(this->_target, state_vector);
 }
 
-void sqrtYdag::update_quantum_state(StateVector& state_vector) const {
+void sqrtYdagGate::update_quantum_state(StateVector& state_vector) const {
     sqrtydag_gate(this->_target, state_vector);
 }
 
-void P0::update_quantum_state(StateVector& state_vector) const {
+void P0Gate::update_quantum_state(StateVector& state_vector) const {
     p0_gate(this->_target, state_vector);
 }
 
-void P1::update_quantum_state(StateVector& state_vector) const {
+void P1Gate::update_quantum_state(StateVector& state_vector) const {
     p1_gate(this->_target, state_vector);
 }
 
-void RX::update_quantum_state(StateVector& state_vector) const {
+void RXGate::update_quantum_state(StateVector& state_vector) const {
     rx_gate(this->_target, this->_angle, state_vector);
 }
 
-void RY::update_quantum_state(StateVector& state_vector) const {
+void RYGate::update_quantum_state(StateVector& state_vector) const {
     ry_gate(this->_target, this->_angle, state_vector);
 }
 
-void RZ::update_quantum_state(StateVector& state_vector) const {
+void RZGate::update_quantum_state(StateVector& state_vector) const {
     rz_gate(this->_target, this->_angle, state_vector);
 }
+}  // namespace internal
 }  // namespace qulacs
diff --git a/qulacs/gate/gate_one_qubit.hpp b/qulacs/gate/gate_one_qubit.hpp
index 027f7f7b..6ec5242d 100644
--- a/qulacs/gate/gate_one_qubit.hpp
+++ b/qulacs/gate/gate_one_qubit.hpp
@@ -3,12 +3,13 @@
 #include "gate.hpp"
 
 namespace qulacs {
-class QuantumGateOneQubit : public QuantumGate {
+namespace internal {
+class OneQubitGateBase : public GateBase {
 protected:
     UINT _target;
 
 public:
-    QuantumGateOneQubit(UINT target) : _target(target){};
+    OneQubitGateBase(UINT target) : _target(target){};
 
     UINT target() const { return _target; }
 
@@ -16,152 +17,151 @@ class QuantumGateOneQubit : public QuantumGate {
     std::vector<UINT> get_control_qubit_list() const override { return {}; };
 };
 
-class QuantumGateOneQubitRotation : public QuantumGateOneQubit {
+class OneQubitRotationGateBase : public OneQubitGateBase {
 protected:
     double _angle;
 
 public:
-    QuantumGateOneQubitRotation(UINT target, double angle)
-        : QuantumGateOneQubit(target), _angle(angle){};
+    OneQubitRotationGateBase(UINT target, double angle) : OneQubitGateBase(target), _angle(angle){};
 
     double angle() const { return _angle; }
 };
 
-class I : public QuantumGateOneQubit {
+class IGate : public OneQubitGateBase {
 public:
-    I(UINT target) : QuantumGateOneQubit(target){};
+    IGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<I>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<I>(*this); }
+    GatePtr copy() const override { return std::make_unique<IGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<IGate>(*this); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class X : public QuantumGateOneQubit {
+class XGate : public OneQubitGateBase {
 public:
-    X(UINT target) : QuantumGateOneQubit(target){};
+    XGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<X>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<X>(*this); }
+    GatePtr copy() const override { return std::make_unique<XGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<XGate>(*this); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class Y : public QuantumGateOneQubit {
+class YGate : public OneQubitGateBase {
 public:
-    Y(UINT target) : QuantumGateOneQubit(target){};
+    YGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<Y>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<Y>(*this); }
+    GatePtr copy() const override { return std::make_unique<YGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<YGate>(*this); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class Z : public QuantumGateOneQubit {
+class ZGate : public OneQubitGateBase {
 public:
-    Z(UINT target) : QuantumGateOneQubit(target){};
+    ZGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<Z>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<Z>(*this); }
+    GatePtr copy() const override { return std::make_unique<ZGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<ZGate>(*this); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class H : public QuantumGateOneQubit {
+class HGate : public OneQubitGateBase {
 public:
-    H(UINT target) : QuantumGateOneQubit(target){};
+    HGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<H>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<H>(*this); }
+    GatePtr copy() const override { return std::make_unique<HGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<HGate>(*this); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class S : public QuantumGateOneQubit {
+class SGate : public OneQubitGateBase {
 public:
-    S(UINT target) : QuantumGateOneQubit(target){};
+    SGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<S>(*this); }
+    GatePtr copy() const override { return std::make_unique<SGate>(*this); }
     GatePtr get_inverse() const override;
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class Sdag : public QuantumGateOneQubit {
+class SdagGate : public OneQubitGateBase {
 public:
-    Sdag(UINT target) : QuantumGateOneQubit(target){};
+    SdagGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<Sdag>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<S>(_target); }
+    GatePtr copy() const override { return std::make_unique<SdagGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<SGate>(_target); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class T : public QuantumGateOneQubit {
+class TGate : public OneQubitGateBase {
 public:
-    T(UINT target) : QuantumGateOneQubit(target){};
+    TGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<T>(*this); }
+    GatePtr copy() const override { return std::make_unique<TGate>(*this); }
     GatePtr get_inverse() const override;
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class Tdag : public QuantumGateOneQubit {
+class TdagGate : public OneQubitGateBase {
 public:
-    Tdag(UINT target) : QuantumGateOneQubit(target){};
+    TdagGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<Tdag>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<T>(_target); }
+    GatePtr copy() const override { return std::make_unique<TdagGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<TGate>(_target); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class sqrtX : public QuantumGateOneQubit {
+class sqrtXGate : public OneQubitGateBase {
 public:
-    sqrtX(UINT target) : QuantumGateOneQubit(target){};
+    sqrtXGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<sqrtX>(*this); }
+    GatePtr copy() const override { return std::make_unique<sqrtXGate>(*this); }
     GatePtr get_inverse() const override;
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class sqrtXdag : public QuantumGateOneQubit {
+class sqrtXdagGate : public OneQubitGateBase {
 public:
-    sqrtXdag(UINT target) : QuantumGateOneQubit(target){};
+    sqrtXdagGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<sqrtXdag>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<sqrtX>(_target); }
+    GatePtr copy() const override { return std::make_unique<sqrtXdagGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<sqrtXGate>(_target); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class sqrtY : public QuantumGateOneQubit {
+class sqrtYGate : public OneQubitGateBase {
 public:
-    sqrtY(UINT target) : QuantumGateOneQubit(target){};
+    sqrtYGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<sqrtY>(*this); }
+    GatePtr copy() const override { return std::make_unique<sqrtYGate>(*this); }
     GatePtr get_inverse() const override;
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class sqrtYdag : public QuantumGateOneQubit {
+class sqrtYdagGate : public OneQubitGateBase {
 public:
-    sqrtYdag(UINT target) : QuantumGateOneQubit(target){};
+    sqrtYdagGate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<sqrtYdag>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<sqrtY>(_target); }
+    GatePtr copy() const override { return std::make_unique<sqrtYdagGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<sqrtYGate>(_target); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class P0 : public QuantumGateOneQubit {
+class P0Gate : public OneQubitGateBase {
 public:
-    P0(UINT target) : QuantumGateOneQubit(target){};
+    P0Gate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<P0>(*this); }
+    GatePtr copy() const override { return std::make_unique<P0Gate>(*this); }
     GatePtr get_inverse() const override {
         throw std::runtime_error("P0::get_inverse: Projection gate doesn't have inverse gate");
     }
@@ -169,11 +169,11 @@ class P0 : public QuantumGateOneQubit {
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class P1 : public QuantumGateOneQubit {
+class P1Gate : public OneQubitGateBase {
 public:
-    P1(UINT target) : QuantumGateOneQubit(target){};
+    P1Gate(UINT target) : OneQubitGateBase(target){};
 
-    GatePtr copy() const override { return std::make_unique<P1>(*this); }
+    GatePtr copy() const override { return std::make_unique<P1Gate>(*this); }
     GatePtr get_inverse() const override {
         throw std::runtime_error("P1::get_inverse: Projection gate doesn't have inverse gate");
     }
@@ -181,33 +181,34 @@ class P1 : public QuantumGateOneQubit {
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class RX : public QuantumGateOneQubitRotation {
+class RXGate : public OneQubitRotationGateBase {
 public:
-    RX(UINT target, double angle) : QuantumGateOneQubitRotation(target, angle){};
+    RXGate(UINT target, double angle) : OneQubitRotationGateBase(target, angle){};
 
-    GatePtr copy() const override { return std::make_unique<RX>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<RX>(_target, -_angle); }
+    GatePtr copy() const override { return std::make_unique<RXGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<RXGate>(_target, -_angle); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class RY : public QuantumGateOneQubitRotation {
+class RYGate : public OneQubitRotationGateBase {
 public:
-    RY(UINT target, double angle) : QuantumGateOneQubitRotation(target, angle){};
+    RYGate(UINT target, double angle) : OneQubitRotationGateBase(target, angle){};
 
-    GatePtr copy() const override { return std::make_unique<RY>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<RY>(_target, -_angle); }
+    GatePtr copy() const override { return std::make_unique<RYGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<RYGate>(_target, -_angle); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class RZ : public QuantumGateOneQubitRotation {
+class RZGate : public OneQubitRotationGateBase {
 public:
-    RZ(UINT target, double angle) : QuantumGateOneQubitRotation(target, angle){};
+    RZGate(UINT target, double angle) : OneQubitRotationGateBase(target, angle){};
 
-    GatePtr copy() const override { return std::make_unique<RZ>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<RZ>(_target, -_angle); }
+    GatePtr copy() const override { return std::make_unique<RZGate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<RZGate>(_target, -_angle); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
+}  // namespace internal
 }  // namespace qulacs
diff --git a/qulacs/gate/gate_quantum_matrix.cpp b/qulacs/gate/gate_quantum_matrix.cpp
index 0633f78c..263028fc 100644
--- a/qulacs/gate/gate_quantum_matrix.cpp
+++ b/qulacs/gate/gate_quantum_matrix.cpp
@@ -1,15 +1,17 @@
 #include "gate_quantum_matrix.hpp"
 
 namespace qulacs {
-void U1::update_quantum_state(StateVector& state_vector) const {
+namespace internal {
+void U1Gate::update_quantum_state(StateVector& state_vector) const {
     u_gate(this->_target, this->_matrix, state_vector);
 }
 
-void U2::update_quantum_state(StateVector& state_vector) const {
+void U2Gate::update_quantum_state(StateVector& state_vector) const {
     u_gate(this->_target, this->_matrix, state_vector);
 }
 
-void U3::update_quantum_state(StateVector& state_vector) const {
+void U3Gate::update_quantum_state(StateVector& state_vector) const {
     u_gate(this->_target, this->_matrix, state_vector);
 }
+}  // namespace internal
 }  // namespace qulacs
diff --git a/qulacs/gate/gate_quantum_matrix.hpp b/qulacs/gate/gate_quantum_matrix.hpp
index 1d2e9a9e..08597f32 100644
--- a/qulacs/gate/gate_quantum_matrix.hpp
+++ b/qulacs/gate/gate_quantum_matrix.hpp
@@ -8,50 +8,51 @@
 #include "update_ops.hpp"
 
 namespace qulacs {
-class U1 : public QuantumGateOneQubit {
+namespace internal {
+class U1Gate : public OneQubitGateBase {
     double _lambda;
     matrix_2_2 _matrix;
 
 public:
-    U1(UINT target, double lambda) : QuantumGateOneQubit(target), _lambda(lambda) {
+    U1Gate(UINT target, double lambda) : OneQubitGateBase(target), _lambda(lambda) {
         _matrix = get_IBMQ_matrix(0, 0, lambda);
     };
 
     double lambda() const { return _lambda; }
 
-    GatePtr copy() const override { return std::make_unique<U1>(*this); }
-    GatePtr get_inverse() const override { return std::make_unique<U1>(_target, -_lambda); }
+    GatePtr copy() const override { return std::make_unique<U1Gate>(*this); }
+    GatePtr get_inverse() const override { return std::make_unique<U1Gate>(_target, -_lambda); }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
-class U2 : public QuantumGateOneQubit {
+class U2Gate : public OneQubitGateBase {
     double _phi, _lambda;
     matrix_2_2 _matrix;
 
 public:
-    U2(UINT target, double phi, double lambda)
-        : QuantumGateOneQubit(target), _phi(phi), _lambda(lambda) {
+    U2Gate(UINT target, double phi, double lambda)
+        : OneQubitGateBase(target), _phi(phi), _lambda(lambda) {
         _matrix = get_IBMQ_matrix(PI() / 2.0, phi, lambda);
     };
 
     double phi() const { return _phi; }
     double lambda() const { return _lambda; }
 
-    GatePtr copy() const override { return std::make_unique<U2>(*this); }
+    GatePtr copy() const override { return std::make_unique<U2Gate>(*this); }
     GatePtr get_inverse() const override {
-        return std::make_unique<U2>(_target, -_lambda - PI(), -_phi + PI());
+        return std::make_unique<U2Gate>(_target, -_lambda - PI(), -_phi + PI());
     }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
 
-class U3 : public QuantumGateOneQubit {
+class U3Gate : public OneQubitGateBase {
     double _theta, _phi, _lambda;
     matrix_2_2 _matrix;
 
 public:
-    U3(UINT target, double theta, double phi, double lambda)
-        : QuantumGateOneQubit(target), _theta(theta), _phi(phi), _lambda(lambda) {
+    U3Gate(UINT target, double theta, double phi, double lambda)
+        : OneQubitGateBase(target), _theta(theta), _phi(phi), _lambda(lambda) {
         _matrix = get_IBMQ_matrix(theta, phi, lambda);
     };
 
@@ -59,11 +60,12 @@ class U3 : public QuantumGateOneQubit {
     double phi() const { return _phi; }
     double lambda() const { return _lambda; }
 
-    GatePtr copy() const override { return std::make_unique<U3>(*this); }
+    GatePtr copy() const override { return std::make_unique<U3Gate>(*this); }
     GatePtr get_inverse() const override {
-        return std::make_unique<U3>(_target, -_theta, -_lambda, -_phi);
+        return std::make_unique<U3Gate>(_target, -_theta, -_lambda, -_phi);
     }
 
     void update_quantum_state(StateVector& state_vector) const override;
 };
+}  // namespace internal
 }  // namespace qulacs
diff --git a/tests/gate/gate_test.cpp b/tests/gate/gate_test.cpp
index b24419a7..c172e1c8 100644
--- a/tests/gate/gate_test.cpp
+++ b/tests/gate/gate_test.cpp
@@ -3,7 +3,7 @@
 #include <Eigen/Core>
 #include <functional>
 #include <gate/gate.hpp>
-#include <gate/gate_one_qubit.hpp>
+#include <gate/gate_factory.hpp>
 #include <state/state_vector.hpp>
 #include <types.hpp>
 #include <util/random.hpp>
@@ -16,7 +16,7 @@ using namespace qulacs;
 const auto eps = 1e-12;
 using CComplex = std::complex<double>;
 
-template <class QuantumGateConstructor>
+template <Gate (*QuantumGateConstructor)(UINT)>
 void run_random_gate_apply(UINT n_qubits, std::function<Eigen::MatrixXcd()> matrix_factory) {
     const auto matrix = matrix_factory();
     const int dim = 1ULL << n_qubits;
@@ -31,7 +31,7 @@ void run_random_gate_apply(UINT n_qubits, std::function<Eigen::MatrixXcd()> matr
         }
 
         const UINT target = random.int64() % n_qubits;
-        const QuantumGateConstructor gate(target);
+        const Gate gate = QuantumGateConstructor(target);
         gate.update_quantum_state(state);
         state_cp = state.amplitudes();
 
@@ -43,7 +43,7 @@ void run_random_gate_apply(UINT n_qubits, std::function<Eigen::MatrixXcd()> matr
     }
 }
 
-template <class QuantumGateConstructor>
+template <Gate (*QuantumGateConstructor)(UINT, double)>
 void run_random_gate_apply(UINT n_qubits, std::function<Eigen::MatrixXcd(double)> matrix_factory) {
     const int dim = 1ULL << n_qubits;
     Random random;
@@ -59,7 +59,7 @@ void run_random_gate_apply(UINT n_qubits, std::function<Eigen::MatrixXcd(double)
         const double angle = M_PI * random.uniform();
         const auto matrix = matrix_factory(angle);
         const UINT target = random.int64() % n_qubits;
-        const QuantumGateConstructor gate(target, angle);
+        const Gate gate = QuantumGateConstructor(target, angle);
         gate.update_quantum_state(state);
         state_cp = state.amplitudes();