Streamline the capitalization and stylization of jeff

Co-authored-by: Copilot <copilot@github.com>

Author: denialhaag

docs/mlir/Conversions.md

@@ -10,7 +10,7 @@
 
 ```
 
-## Jeff Conversions
+## `jeff` Conversions
 
 ```{include} Conversions/QCOToJeff.md
 

mlir/include/mlir/Conversion/JeffToQCO/JeffToQCO.td

@@ -9,13 +9,13 @@
 include "mlir/Pass/PassBase.td"
 
 def JeffToQCO : Pass<"jeff-to-qco"> {
-  let summary = "Convert Jeff operations to QCO operations";
+  let summary = "Convert `jeff` operations to QCO operations";
 
   let description = [{
-    This pass converts all operations from the Jeff dialect to their equivalent operations in the QCO dialect.
+    This pass converts all operations from the `jeff` dialect to their equivalent operations in the QCO dialect.
     It ensures that the returned module is a valid QCO module.
 
-    Note that this pass is still in development as QCO and Jeff do not have full feature parity yet.
+    Note that this pass is still in development as QCO and `jeff` do not have full feature parity yet.
 
     Known limitations:
 

mlir/include/mlir/Conversion/QCOToJeff/QCOToJeff.td

@@ -9,15 +9,16 @@
 include "mlir/Pass/PassBase.td"
 
 def QCOToJeff : Pass<"qco-to-jeff"> {
-  let summary = "Convert QCO operations to Jeff operations";
+  let summary = "Convert QCO operations to `jeff` operations";
 
   let description = [{
-    This pass converts all operations from the QCO dialect to their equivalent operations in the Jeff dialect.
-    It ensures that the returned module is a valid Jeff module that can be serialized.
+    This pass converts all operations from the QCO dialect to their equivalent operations in the `jeff` dialect.
+    It ensures that the returned module is a valid `jeff` module that can be serialized.
 
-    Note that this pass is still in development as QCO and Jeff do not have full feature parity yet.
+    Note that this pass is still in development as QCO and `jeff` do not have full feature parity yet.
 
-    `qco.static` is currently converted to `jeff.qubit_alloc` because Jeff does not yet represent static (index-based) qubits; the index is not preserved in Jeff IR. Round-tripping through Jeff therefore maps static qubits to dynamic allocation on the QCO side.
+    `qco.static` is currently converted to `jeff.qubit_alloc` because `jeff` does not yet represent static (index-based) qubits; the index is not preserved in `jeff` IR.
+    Round-tripping through `jeff` therefore maps static qubits to dynamic allocation on the QCO side.
   }];
 
   let dependentDialects = ["mlir::jeff::JeffDialect"];

mlir/lib/Conversion/JeffToQCO/JeffToQCO.cpp

@@ -48,10 +48,10 @@ using namespace qco;
 #include "mlir/Conversion/JeffToQCO/JeffToQCO.h.inc"
 
 /**
- * @brief Creates a modified QCO operation from a Jeff operation
+ * @brief Creates a modified QCO operation from a jeff operation
  *
- * @tparam JeffOpType The operation type of the Jeff operation
- * @param op The Jeff operation instance to convert
+ * @tparam JeffOpType The operation type of the jeff operation
+ * @param op The jeff operation instance to convert
  * @param rewriter The pattern rewriter
  * @param controls The control qubits of the operation
  * @param targets The target qubits of the operation
@@ -87,19 +87,19 @@ createModified(JeffOpType& op, ConversionPatternRewriter& rewriter,
 }
 
 /**
- * @brief Creates a (potentially modified) QCO operation from a Jeff operation.
+ * @brief Creates a (potentially modified) QCO operation from a jeff operation.
  *
  * @details
  * This helper centralizes the "direct vs. ctrl/inv-wrapped" decision and uses
  * index sequences to forward the desired number of targets and parameters into
  * the QCO op builder.
  *
  * @tparam QCOOpType The QCO operation type to create
- * @tparam JeffOpType The Jeff operation type to convert from
+ * @tparam JeffOpType The jeff operation type to convert from
  * @tparam TargetIndices Indices of target operands to forward
  * @tparam ParamIndices Indices of parameters to forward
  *
- * @param op The Jeff operation instance to convert
+ * @param op The jeff operation instance to convert
  * @param rewriter The pattern rewriter
  * @param controls The control qubits (type-converted) of the operation
  * @param targets The target qubits (type-converted) of the operation
@@ -137,11 +137,11 @@ createGateFromJeffArity(JeffOpType& op, ConversionPatternRewriter& rewriter,
                         ValueRange parameters = {}) {
   if (targets.size() != NumTargets) {
     return rewriter.notifyMatchFailure(
-        op, "Unexpected number of target qubits for Jeff-to-QCO conversion");
+        op, "Unexpected number of target qubits for jeff-to-QCO conversion");
   }
   if (parameters.size() != NumParams) {
     return rewriter.notifyMatchFailure(
-        op, "Unexpected number of parameters for Jeff-to-QCO conversion");
+        op, "Unexpected number of parameters for jeff-to-QCO conversion");
   }
 
   return createGateFromJeff<QCOOpType, JeffOpType>(
@@ -532,10 +532,10 @@ struct ConvertJeffGPhaseOpToQCO final : OpConversionPattern<jeff::GPhaseOp> {
 };
 
 /**
- * @brief Converts one-target, zero-parameter Jeff gate to QCO
+ * @brief Converts one-target, zero-parameter jeff gate to QCO
  *
  * @tparam QCOOpType The operation type of the QCO operation
- * @tparam JeffOpType The operation type of the Jeff operation
+ * @tparam JeffOpType The operation type of the jeff operation
  *
  * @par Example:
  * ```mlir
@@ -566,10 +566,10 @@ struct ConvertJeffOneTargetZeroParameterToQCO final
 };
 
 /**
- * @brief Converts one-target, one-parameter Jeff gate to QCO
+ * @brief Converts one-target, one-parameter jeff gate to QCO
  *
  * @tparam QCOOpType The operation type of the QCO operation
- * @tparam JeffOpType The operation type of the Jeff operation
+ * @tparam JeffOpType The operation type of the jeff operation
  *
  * @par Example:
  * ```mlir
@@ -814,7 +814,7 @@ struct ConvertJeffPPROpToQCO final : OpConversionPattern<jeff::PPROp> {
 };
 
 /**
- * @brief Converts the Jeff-style main function to a QCO-style main function
+ * @brief Converts the jeff-style main function to a QCO-style main function
  *
  * @par Example:
  * ```mlir
@@ -873,7 +873,7 @@ struct ConvertJeffMainToQCO final : OpConversionPattern<func::FuncOp> {
 };
 
 /**
- * @brief Type converter for Jeff-to-QCO conversion
+ * @brief Type converter for jeff-to-QCO conversion
  *
  * @details
  * Converts `!jeff.qubit` to `!qco.qubit` and `!jeff.qureg` to
@@ -896,7 +896,7 @@ class JeffToQCOTypeConverter final : public TypeConverter {
 };
 
 /**
- * @brief Pass for converting Jeff operations to QCO operations
+ * @brief Pass for converting jeff operations to QCO operations
  */
 struct JeffToQCO final : impl::JeffToQCOBase<JeffToQCO> {
   using JeffToQCOBase::JeffToQCOBase;

mlir/lib/Conversion/QCOToJeff/QCOToJeff.cpp

@@ -170,13 +170,13 @@ template <size_t NumParams, typename OpAdaptor>
 }
 
 /**
- * @brief Lowers QCO gates to matching Jeff ops.
+ * @brief Lowers QCO gates to matching jeff ops.
  *
  * @details Uses `getEffectiveTargetOperands` and forwards target and parameter
  * indices into `JeffOpType::create`.
  *
  * @tparam QCOOpType The QCO gate op type
- * @tparam JeffOpType The Jeff op type
+ * @tparam JeffOpType The jeff op type
  * @tparam ExtraAdjoint Whether to XOR the adjoint flag
  * @tparam TargetIndices QCO target indices to forward
  * @tparam ParamIndices QCO parameter indices to forward
@@ -201,7 +201,7 @@ convertJeffGate(QCOOpType op, typename QCOOpType::Adaptor adaptor,
       /*is_adjoint=*/state.inInvOp ^ ExtraAdjoint,
       /*power=*/1);
 
-  // Jeff well-known gates: leading results are transformed targets, then ctrl
+  // jeff well-known gates: leading results are transformed targets, then ctrl
   // outs (same ordering as `getOutQubit` / `getOutCtrlQubits` accessors).
   constexpr std::size_t numTargets = sizeof...(TargetIndices);
   auto results = jeffOp->getResults();
@@ -490,10 +490,10 @@ struct ConvertQCOAllocOpToJeff final : StatefulOpConversionPattern<AllocOp> {
  * @brief Converts qco.static to jeff.qubit_alloc
  *
  * @details
- * The Jeff dialect does not model hardware-mapped or fixed-index static
+ * The jeff dialect does not model hardware-mapped or fixed-index static
  * qubits yet. As a temporary workaround (see discussion on #1626), this
  * lowers `qco.static` to the same `jeff.qubit_alloc` operation used for
- * `qco.alloc`. The static index is not represented in Jeff IR; if Jeff gains
+ * `qco.alloc`. The static index is not represented in jeff IR; if jeff gains
  * static qubit support, this conversion should be revisited.
  *
  * @par Example:
@@ -628,10 +628,10 @@ struct ConvertQCOGPhaseOpToJeff final : StatefulOpConversionPattern<GPhaseOp> {
 };
 
 /**
- * @brief Converts a QCO gate that lowers to a well-known Jeff op.
+ * @brief Converts a QCO gate that lowers to a well-known jeff op.
  *
  * @tparam QCOOpType QCO operation type.
- * @tparam JeffOpType Jeff op type passed to `convertJeffGate` /
+ * @tparam JeffOpType jeff op type passed to `convertJeffGate` /
  * `JeffOpType::create`.
  * @tparam NumTargets Number of target operands (1 or 2 for supported gates).
  * @tparam NumParams Number of real parameters on the QCO op.
@@ -855,7 +855,7 @@ struct ConvertQCOBarrierOpToJeff final
 };
 
 /**
- * @brief Converts qco.ctrl to Jeff by inlining the region
+ * @brief Converts qco.ctrl to jeff by inlining the region
  *
  * @par Example:
  * ```mlir
@@ -905,7 +905,7 @@ struct ConvertQCOCtrlOpToJeff final : StatefulOpConversionPattern<CtrlOp> {
 };
 
 /**
- * @brief Converts qco.inv to Jeff by inlining the region
+ * @brief Converts qco.inv to jeff by inlining the region
  *
  * @par Example:
  * ```mlir
@@ -990,7 +990,7 @@ struct ConvertQCOYieldOpToJeff final : StatefulOpConversionPattern<YieldOp> {
 };
 
 /**
- * @brief Converts the QCO-style main function to a Jeff-style main function
+ * @brief Converts the QCO-style main function to a jeff-style main function
  *
  * @par Example:
  * ```mlir
@@ -1052,7 +1052,7 @@ struct ConvertQCOMainToJeff final : StatefulOpConversionPattern<func::FuncOp> {
 };
 
 /**
- * @brief Type converter for QCO-to-Jeff conversion
+ * @brief Type converter for QCO-to-jeff conversion
  *
  * @details
  * Converts `!qco.qubit` to `!jeff.qubit` and `tensor<?x!qco.qubit>` to
@@ -1088,7 +1088,7 @@ template <auto...> struct AlwaysFalse : std::false_type {};
 
 /** @brief QCO→Jeff gate lowering category. */
 enum class JeffKind : std::uint8_t {
-  /// Lower to a Jeff gate from the standard `WellKnownGate` set (Jeff spec:
+  /// Lower to a jeff gate from the standard `WellKnownGate` set (jeff spec:
   /// `QubitGate.gate.wellKnown`).
   WellKnown,
   Custom,       //!< Lower to jeff.custom with a name string.
@@ -1108,14 +1108,14 @@ struct PPRPaulis {
  * @brief Registers one QCO→Jeff rewrite pattern for a gate described at compile
  * time.
  *
- * @tparam Kind How to lower: well-known Jeff op, `jeff.custom`, `jeff.ppr`, or
+ * @tparam Kind How to lower: well-known jeff op, `jeff.custom`, `jeff.ppr`, or
  *        special-case `qco.u2` → `jeff.u`.
  * @tparam Targets Number of target qubits for the QCO op.
  * @tparam Params Number of real parameters on the QCO op.
  * @tparam QCOOpType MLIR QCO operation type.
- * @tparam JeffOpType Jeff operation type for `JeffKind::WellKnown` (or `void`
+ * @tparam JeffOpType jeff operation type for `JeffKind::WellKnown` (or `void`
  * for custom/PPR paths that do not use it).
- * @tparam JeffBaseAdjoint For well-known ops: whether the Jeff op represents
+ * @tparam JeffBaseAdjoint For well-known ops: whether the jeff op represents
  * the adjoint of the QCO base gate (e.g. S† as `jeff.s` with adjoint set).
  * @param patterns Pattern set to add to.
  * @param typeConverter QCO→Jeff type converter passed to patterns.
@@ -1172,7 +1172,7 @@ static void addQCOToJeffGatePattern(RewritePatternSet& patterns,
 namespace {
 
 /**
- * @brief Pass for converting QCO operations to Jeff operations
+ * @brief Pass for converting QCO operations to jeff operations
  */
 struct QCOToJeff final : impl::QCOToJeffBase<QCOToJeff> {
   using QCOToJeffBase::QCOToJeffBase;

mlir/lib/Conversion/QCToQCO/QCToQCO.cpp

@@ -1033,7 +1033,7 @@ struct QCToQCO final : impl::QCToQCOBase<QCToQCO> {
              ConvertQCCtrlOp, ConvertQCInvOp, ConvertQCYieldOp>(
             typeConverter, context, &state);
 
-    // Not part of the central gate table (no Jeff/QIR lowering).
+    // Not part of the central gate table.
     patterns.add<ConvertQCGateToQCO<qc::GPhaseOp, qco::GPhaseOp, 0, 1>>(
         typeConverter, context, &state);
 

mlir/unittests/Conversion/JeffRoundTrip/test_jeff_round_trip.cpp

@@ -101,7 +101,7 @@ TEST_P(JeffRoundTripTest, ProgramEquivalence) {
   EXPECT_TRUE(verify(*program).succeeded());
 
   EXPECT_TRUE(succeeded(convertQCOToJeff(program.get())));
-  printer.record(program.get(), "Converted Jeff IR" + name);
+  printer.record(program.get(), "Converted jeff IR" + name);
   EXPECT_TRUE(verify(*program).succeeded());
 
   PassManager pm(context.get());
@@ -110,7 +110,7 @@ TEST_P(JeffRoundTripTest, ProgramEquivalence) {
   pm.addPass(createRemoveDeadValuesPass());
   EXPECT_TRUE(pm.run(program.get()).succeeded());
 
-  printer.record(program.get(), "Canonicalized Converted Jeff IR" + name);
+  printer.record(program.get(), "Canonicalized Converted jeff IR" + name);
   EXPECT_TRUE(verify(*program).succeeded());
 
   // Serialize and deserialize to ensure the jeff program is valid