fix(compiler): fix mixed-up (g)lwe dimension/size

add dimension -> size conversion rename k -> glweDimension, polynomialSize -> logPolynomialSize remove (in/out)putLweSize from KeySwitchLweOp remove GlweSizeType from LowLFHE
2026-02-09 12:15:09 -05:00 · 2021-11-29 16:27:14 +01:00
parent ec8614f2ea
commit f193fd71a2
32 changed files with 152 additions and 115 deletions
--- a/compiler/include/zamalang/Conversion/HLFHEToMidLFHE/Patterns.h
+++ b/compiler/include/zamalang/Conversion/HLFHEToMidLFHE/Patterns.h
@@ -70,7 +70,8 @@ createApplyLookupTableGLWEOpFromHLFHE(mlir::PatternRewriter &rewriter,
  auto context = rewriter.getContext();
  auto unset = mlir::IntegerAttr::get(IntegerType::get(context, 32), -1);
  mlir::SmallVector<mlir::NamedAttribute, 6> attrs{
-      mlir::NamedAttribute(mlir::Identifier::get("k", context), unset),
+      mlir::NamedAttribute(mlir::Identifier::get("glweDimension", context),
+                           unset),
      mlir::NamedAttribute(mlir::Identifier::get("polynomialSize", context),
                           unset),
      mlir::NamedAttribute(mlir::Identifier::get("levelKS", context), unset),
--- a/compiler/include/zamalang/Conversion/MidLFHEToLowLFHE/Patterns.h
+++ b/compiler/include/zamalang/Conversion/MidLFHEToLowLFHE/Patterns.h
@@ -187,7 +187,7 @@ mlir::Value createMulClearLweCiphertext(mlir::PatternRewriter &rewriter,
 // from:
 // ```
 // "%result = MidLFHE.apply_lookup_table"(% arg0, % tlu){
-//   k = 1 : i32,
+//   glweDimension = 1 : i32,
 //   polynomialSize = 2048 : i32,
 //   levelKS = 3 : i32,
 //   baseLogKS = 2 : i32,
@@ -201,30 +201,31 @@ mlir::Value createMulClearLweCiphertext(mlir::PatternRewriter &rewriter,
 // ```
 // % accumulator =
 //     "LowLFHE.glwe_from_table"(
-//         % [[TABLE]]){k = 1 : i32, p = 4 : i32, polynomialSize = 2048 : i32}
+//         % [[TABLE]]){glweDimension = 1 : i32, p = 4 : i32, polynomialSize =
+//         2048 : i32}
 //     : (tensor<16xi4>)
 //           ->!LowLFHE.glwe_ciphertext
 // % keyswitched = "LowLFHE.keyswitch_lwe"(% arg0){
 //   baseLog = 2 : i32,
-//   inputLweSize = 1 : i32,
-//   level = 3 : i32,
-//   outputLweSize = 600 : i32
+//   level = 3 : i32
 // } : (!LowLFHE.lwe_ciphertext<2048, 4>)
 //         ->!LowLFHE.lwe_ciphertext<600, 4>
 // % result = "LowLFHE.bootstrap_lwe"(% keyswitched, % accumulator){
 //   baseLog = 4 : i32,
-//   k = 1 : i32,
+//   glweDimension = 1 : i32,
 //   level = 5 : i32,
 //   polynomialSize = 2048 : i32
 // } : (!LowLFHE.lwe_ciphertext<600, 4>, !LowLFHE.glwe_ciphertext)
 //         ->!LowLFHE.lwe_ciphertext<2048, 4>
 // ```
 mlir::Value createPBS(mlir::PatternRewriter &rewriter, mlir::Location loc,
-                      mlir::Value ct, mlir::Value table, mlir::IntegerAttr k,
+                      mlir::Value ct, mlir::Value table,
+                      mlir::IntegerAttr glweDimension,
                      mlir::IntegerAttr polynomialSize,
                      mlir::IntegerAttr levelKS, mlir::IntegerAttr baseLogKS,
                      mlir::IntegerAttr levelBS, mlir::IntegerAttr baseLogBS,
-                      mlir::IntegerAttr outputSizeKS, mlir::OpResult result) {
+                      mlir::IntegerAttr outputDimensionKS,
+                      mlir::OpResult result) {
  // convert result type
  LweCiphertextType lwe_type =
      convertTypeToLWE(rewriter.getContext(), result.getType());
@@ -234,17 +235,12 @@ mlir::Value createPBS(mlir::PatternRewriter &rewriter, mlir::Location loc,
      rewriter
          .create<mlir::zamalang::LowLFHE::GlweFromTable>(
              loc, LowLFHE::GlweCiphertextType::get(rewriter.getContext()),
-              table, polynomialSize, k, precision)
+              table, polynomialSize, glweDimension, precision)
          .result();

  // keyswitch
  mlir::SmallVector<mlir::Value> ksArgs{ct};
  mlir::SmallVector<mlir::NamedAttribute> ksAttrs{
-      mlir::NamedAttribute(
-          mlir::Identifier::get("inputLweSize", rewriter.getContext()), k),
-      mlir::NamedAttribute(
-          mlir::Identifier::get("outputLweSize", rewriter.getContext()),
-          outputSizeKS),
      mlir::NamedAttribute(
          mlir::Identifier::get("level", rewriter.getContext()), levelKS),
      mlir::NamedAttribute(
@@ -252,7 +248,7 @@ mlir::Value createPBS(mlir::PatternRewriter &rewriter, mlir::Location loc,
  };
  // convert result type
  LweCiphertextType ksOutType = LweCiphertextType::get(
-      rewriter.getContext(), outputSizeKS.getInt(), precision.getInt());
+      rewriter.getContext(), outputDimensionKS.getInt(), precision.getInt());
  convertTypeToLWE(rewriter.getContext(), result.getType());
  mlir::Value keyswitched =
      rewriter
@@ -263,8 +259,9 @@ mlir::Value createPBS(mlir::PatternRewriter &rewriter, mlir::Location loc,
  // bootstrap operation
  mlir::SmallVector<mlir::Value> bsArgs{keyswitched, accumulator};
  mlir::SmallVector<mlir::NamedAttribute> bsAttrs{
-      mlir::NamedAttribute(mlir::Identifier::get("k", rewriter.getContext()),
-                           k),
+      mlir::NamedAttribute(
+          mlir::Identifier::get("glweDimension", rewriter.getContext()),
+          glweDimension),
      mlir::NamedAttribute(
          mlir::Identifier::get("polynomialSize", rewriter.getContext()),
          polynomialSize),
--- a/compiler/include/zamalang/Conversion/MidLFHEToLowLFHE/Patterns.td
+++ b/compiler/include/zamalang/Conversion/MidLFHEToLowLFHE/Patterns.td
@@ -44,7 +44,7 @@ def NegGLWEPattern : Pat<
 def createPBS : NativeCodeCall<"mlir::zamalang::createPBS($_builder, $_loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9)">;

 def ApplyLookupTableGLWEPattern : Pat<
-    (ApplyLookupTable:$result $ct, $table, $k, $polynomialSize, $levelKS, $baseLogKS, $levelBS, $baseLogBS, $outputSizeKS),
-    (createPBS $ct, $table, $k, $polynomialSize, $levelKS, $baseLogKS, $levelBS, $baseLogBS, $outputSizeKS, $result)>;
+    (ApplyLookupTable:$result $ct, $table, $glweDimension, $polynomialSize, $levelKS, $baseLogKS, $levelBS, $baseLogBS, $outputDimensionKS),
+    (createPBS $ct, $table, $glweDimension, $polynomialSize, $levelKS, $baseLogKS, $levelBS, $baseLogBS, $outputDimensionKS, $result)>;

 #endif
--- a/compiler/include/zamalang/Conversion/Utils/GlobalFHEContext.h
+++ b/compiler/include/zamalang/Conversion/Utils/GlobalFHEContext.h
@@ -11,8 +11,8 @@ struct V0FHEConstraint {
 };

 struct V0Parameter {
-  size_t k;
-  size_t polynomialSize;
+  size_t glweDimension;
+  size_t logPolynomialSize;
  size_t nSmall;
  size_t brLevel;
  size_t brLogBase;
@@ -21,13 +21,17 @@ struct V0Parameter {

  V0Parameter() = delete;

-  V0Parameter(size_t k, size_t polynomialSize, size_t nSmall, size_t brLevel,
-              size_t brLogBase, size_t ksLevel, size_t ksLogBase)
-      : k(k), polynomialSize(polynomialSize), nSmall(nSmall), brLevel(brLevel),
-        brLogBase(brLogBase), ksLevel(ksLevel), ksLogBase(ksLogBase) {}
+  V0Parameter(size_t glweDimension, size_t logPolynomialSize, size_t nSmall,
+              size_t brLevel, size_t brLogBase, size_t ksLevel,
+              size_t ksLogBase)
+      : glweDimension(glweDimension), logPolynomialSize(logPolynomialSize),
+        nSmall(nSmall), brLevel(brLevel), brLogBase(brLogBase),
+        ksLevel(ksLevel), ksLogBase(ksLogBase) {}

  // TODO remove the shift when we have true polynomial size
-  size_t getNBigGlweSize() { return k * (1 << polynomialSize); }
+  size_t getNBigGlweDimension() {
+    return glweDimension * (1 << logPolynomialSize);
+  }
 };

 struct V0FHEContext {
--- a/compiler/include/zamalang/Dialect/LowLFHE/IR/LowLFHEOps.td
+++ b/compiler/include/zamalang/Dialect/LowLFHE/IR/LowLFHEOps.td
@@ -36,7 +36,7 @@ def NegateLweCiphertextOp : LowLFHE_Op<"negate_lwe_ciphertext"> {
 }

 def GlweFromTable : LowLFHE_Op<"glwe_from_table"> {
-    let arguments = (ins TensorOf<[AnyInteger]>:$table, I32Attr:$polynomialSize, I32Attr:$k, I32Attr:$p);
+    let arguments = (ins TensorOf<[AnyInteger]>:$table, I32Attr:$polynomialSize, I32Attr:$glweDimension, I32Attr:$p);
    let results = (outs GlweCiphertextType:$result);
 }

@@ -45,7 +45,7 @@ def BootstrapLweOp : LowLFHE_Op<"bootstrap_lwe"> {
        // LweBootstrapKeyType:$bootstrap_key,
        LweCiphertextType:$input_ciphertext,
        GlweCiphertextType:$accumulator,
-        I32Attr:$k,
+        I32Attr:$glweDimension,
        I32Attr:$polynomialSize,
        I32Attr:$level,
        I32Attr:$baseLog
@@ -57,8 +57,6 @@ def KeySwitchLweOp : LowLFHE_Op<"keyswitch_lwe"> {
    let arguments = (ins
        // LweKeySwitchKeyType:$keyswitch_key,
        LweCiphertextType:$ciphertext,
-        I32Attr:$inputLweSize,
-        I32Attr:$outputLweSize,
        I32Attr:$level,
        I32Attr:$baseLog
    );
--- a/compiler/include/zamalang/Dialect/LowLFHE/IR/LowLFHETypes.td
+++ b/compiler/include/zamalang/Dialect/LowLFHE/IR/LowLFHETypes.td
@@ -36,16 +36,16 @@ def LweCiphertextType : LowLFHE_Type<"LweCiphertext", [MemRefElementTypeInterfac


    let parameters = (ins
-        // The size of the lwe ciphertext
-        "signed":$size,
+        // The dimension of the lwe ciphertext
+        "signed":$dimension,
        // Precision of the lwe ciphertext
        "signed":$p
    );

    let printer = [{
        $_printer << "lwe_ciphertext<";
-        if (getImpl()->size == -1) $_printer << "_";
-        else $_printer << getImpl()->size;
+        if (getImpl()->dimension == -1) $_printer << "_";
+        else $_printer << getImpl()->dimension;
        $_printer << ",";
        if (getImpl()->p == -1) $_printer << "_";
        else $_printer << getImpl()->p;
@@ -55,8 +55,8 @@ def LweCiphertextType : LowLFHE_Type<"LweCiphertext", [MemRefElementTypeInterfac
    let parser = [{
        if ($_parser.parseLess())
            return Type();
-        int size = -1;
-        if ($_parser.parseOptionalKeyword("_") && $_parser.parseInteger(size))
+        int dimension = -1;
+        if ($_parser.parseOptionalKeyword("_") && $_parser.parseInteger(dimension))
            return Type();
        if ($_parser.parseComma())
            return Type();
@@ -66,7 +66,7 @@ def LweCiphertextType : LowLFHE_Type<"LweCiphertext", [MemRefElementTypeInterfac
        if ($_parser.parseGreater())
            return Type();
        Location loc = $_parser.getEncodedSourceLoc($_parser.getNameLoc());
-        return getChecked(loc, loc.getContext(), size, p);
+        return getChecked(loc, loc.getContext(), dimension, p);
    }];
 }

--- a/compiler/include/zamalang/Dialect/MidLFHE/IR/MidLFHEOps.td
+++ b/compiler/include/zamalang/Dialect/MidLFHE/IR/MidLFHEOps.td
@@ -74,7 +74,7 @@ def MulGLWEIntOp : MidLFHE_Op<"mul_glwe_int"> {
 def ApplyLookupTable : MidLFHE_Op<"apply_lookup_table"> {
    let arguments = (ins GLWECipherTextType:$ct,
        TensorOf<[AnyInteger]>:$l_cst,
-        I32Attr:$k, I32Attr:$polynomialSize,
+        I32Attr:$glweDimension, I32Attr:$polynomialSize,
        I32Attr:$levelKS, I32Attr:$baseLogKS,
        I32Attr:$levelBS, I32Attr:$baseLogBS,
        I32Attr:$outputSizeKS);
--- a/compiler/include/zamalang/Runtime/context.h
+++ b/compiler/include/zamalang/Runtime/context.h
@@ -4,8 +4,8 @@
 #include "concrete-ffi.h"

 typedef struct RuntimeContext {
-  struct LweKeyswitchKey_u64 *ksk;
-  struct LweBootstrapKey_u64 *bsk;
+  LweKeyswitchKey_u64 *ksk;
+  LweBootstrapKey_u64 *bsk;
 } RuntimeContext;

 LweKeyswitchKey_u64 *get_keyswitch_key(RuntimeContext *context);
--- a/compiler/include/zamalang/Support/ClientParameters.h
+++ b/compiler/include/zamalang/Support/ClientParameters.h
@@ -19,7 +19,7 @@ typedef size_t Precision;
 typedef double Variance;

 typedef uint64_t LweSize;
-typedef uint64_t GLWESize;
+typedef uint64_t GlweDimension;

 typedef std::string LweSecretKeyID;
 struct LweSecretKeyParam {
@@ -32,7 +32,7 @@ struct BootstrapKeyParam {
  LweSecretKeyID outputSecretKeyID;
  DecompositionLevelCount level;
  DecompositionBaseLog baseLog;
-  GLWESize k;
+  GlweDimension glweDimension;
  Variance variance;
 };

--- a/compiler/include/zamalang/Support/V0Curves.h
+++ b/compiler/include/zamalang/Support/V0Curves.h
@@ -26,8 +26,9 @@ struct V0Curves {
      : securityLevel(securityLevel), linearTerm1(linearTerm1),
        linearTerm2(linearTerm2), nAlpha(nAlpha), keyFormat(keyFormat) {}

-  double getVariance(int k, int polynomialSize, int logQ) {
-    auto a = std::pow(2, (linearTerm1 * k * polynomialSize + linearTerm2) * 2);
+  double getVariance(int glweDimension, int polynomialSize, int logQ) {
+    auto a = std::pow(
+        2, (linearTerm1 * glweDimension * polynomialSize + linearTerm2) * 2);
    auto b = std::pow(2, -2 * (logQ - 2));
    return a > b ? a : b;
  }
--- a/compiler/lib/Conversion/HLFHETensorOpsToLinalg/TensorOpsToLinalg.cpp
+++ b/compiler/lib/Conversion/HLFHETensorOpsToLinalg/TensorOpsToLinalg.cpp
@@ -310,9 +310,9 @@ struct HLFHELinalgOpToLinalgGeneric
 //         %arg4: i64, %arg5: !HLFHE.eint<2>):
 //             %lut = tensor.from_elements %arg1, %arg2, %arg3, %arg4 :
 //             tensor<4xi64> %0 = "MidLFHE.apply_lookup_table"(%arg0, %lut)
-//             {baseLogBS = -1 : i32, baseLogKS = -1 : i32, k = -1 : i32,
-//             levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32,
-//             polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>,
+//             {baseLogBS = -1 : i32, baseLogKS = -1 : i32, glweDimension = -1 :
+//             i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 :
+//             i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>,
 //             tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
 //         linalg.yield %0 : !HLFHE.eint<2>
 //     }
--- a/compiler/lib/Conversion/HLFHEToMidLFHE/HLFHEToMidLFHE.cpp
+++ b/compiler/lib/Conversion/HLFHEToMidLFHE/HLFHEToMidLFHE.cpp
@@ -22,7 +22,7 @@ using mlir::zamalang::HLFHE::EncryptedIntegerType;
 using mlir::zamalang::MidLFHE::GLWECipherTextType;

 /// HLFHEToMidLFHETypeConverter is a TypeConverter that transform
-/// `HLFHE.eint<p>` to `MidLFHE.gwle<{_,_,_}{p}>`
+/// `HLFHE.eint<p>` to `MidLFHE.glwe<{_,_,_}{p}>`
 class HLFHEToMidLFHETypeConverter : public mlir::TypeConverter {

 public:
--- a/compiler/lib/Conversion/LowLFHEToConcreteCAPI/LowLFHEToConcreteCAPI.cpp
+++ b/compiler/lib/Conversion/LowLFHEToConcreteCAPI/LowLFHEToConcreteCAPI.cpp
@@ -352,9 +352,12 @@ struct LowLFHEOpToConcreteCAPICallPattern : public mlir::OpRewritePattern<Op> {
      // Create the err value
      auto errOp = rewriter.create<mlir::arith::ConstantOp>(
          op.getLoc(), rewriter.getIndexAttr(0));
+      // Get the size from the dimension
+      int64_t lweDimension = lweResultType.getDimension();
+      int64_t lweSize = lweDimension + 1;
+      mlir::Value lweSizeOp = rewriter.create<mlir::arith::ConstantOp>(
+          op.getLoc(), rewriter.getIndexAttr(lweSize));
      // Add the call to the allocation
-      auto lweSizeOp = rewriter.create<mlir::arith::ConstantOp>(
-          op.getLoc(), rewriter.getIndexAttr(lweResultType.getSize()));
      mlir::SmallVector<mlir::Value> allocOperands{errOp, lweSizeOp};
      auto allocGeneric = rewriter.create<mlir::CallOp>(
          op.getLoc(), allocName,
@@ -412,9 +415,12 @@ struct LowLFHEZeroOpPattern
    // Create the err value
    auto errOp = rewriter.create<mlir::arith::ConstantOp>(
        op.getLoc(), rewriter.getIndexAttr(0));
+    // Get the size from the dimension
+    int64_t lweDimension = lweResultType.getDimension();
+    int64_t lweSize = lweDimension + 1;
+    mlir::Value lweSizeOp = rewriter.create<mlir::arith::ConstantOp>(
+        op.getLoc(), rewriter.getIndexAttr(lweSize));
    // Allocate a fresh new ciphertext
-    auto lweSizeOp = rewriter.create<mlir::arith::ConstantOp>(
-        op.getLoc(), rewriter.getIndexAttr(lweResultType.getSize()));
    mlir::SmallVector<mlir::Value> allocOperands{errOp, lweSizeOp};
    auto allocGeneric = rewriter.create<mlir::CallOp>(
        op.getLoc(), "allocate_lwe_ciphertext_u64",
@@ -508,9 +514,13 @@ struct GlweFromTableOpPattern

    auto errOp = rewriter.create<mlir::arith::ConstantOp>(
        op.getLoc(), rewriter.getIndexAttr(0));
+    // Get the size from the dimension
+    int64_t glweDimension =
+        op->getAttr("glweDimension").cast<mlir::IntegerAttr>().getInt();
+    int64_t glweSize = glweDimension + 1;
+    mlir::Value glweSizeOp = rewriter.create<mlir::arith::ConstantOp>(
+        op.getLoc(), rewriter.getI32IntegerAttr(glweSize));
    // allocate two glwe to build accumulator
-    auto glweSizeOp =
-        rewriter.create<mlir::arith::ConstantOp>(op.getLoc(), op->getAttr("k"));
    auto polySizeOp = rewriter.create<mlir::arith::ConstantOp>(
        op.getLoc(), op->getAttr("polynomialSize"));
    mlir::SmallVector<mlir::Value> allocGlweOperands{errOp, glweSizeOp,
@@ -599,14 +609,17 @@ struct LowLFHEBootstrapLweOpPattern
  matchAndRewrite(mlir::zamalang::LowLFHE::BootstrapLweOp op,
                  mlir::PatternRewriter &rewriter) const override {
    auto resultType = op->getResultTypes().front();
-    auto bstOutputSize =
-        resultType.cast<mlir::zamalang::LowLFHE::LweCiphertextType>().getSize();
    auto errOp = rewriter.create<mlir::arith::ConstantOp>(
        op.getLoc(), rewriter.getIndexAttr(0));
+    // Get the size from the dimension
+    int64_t outputLweDimension =
+        resultType.cast<mlir::zamalang::LowLFHE::LweCiphertextType>()
+            .getDimension();
+    int64_t outputLweSize = outputLweDimension + 1;
+    mlir::Value lweSizeOp = rewriter.create<mlir::arith::ConstantOp>(
+        op.getLoc(), rewriter.getIndexAttr(outputLweSize));
    // allocate the result lwe ciphertext, should be of a generic type, to cast
    // before return
-    auto lweSizeOp = rewriter.create<mlir::arith::ConstantOp>(
-        op.getLoc(), rewriter.getIndexAttr(bstOutputSize));
    mlir::SmallVector<mlir::Value> allocLweCtOperands{errOp, lweSizeOp};
    auto allocateGenericLweCtOp = rewriter.create<mlir::CallOp>(
        op.getLoc(), "allocate_lwe_ciphertext_u64",
@@ -660,12 +673,17 @@ struct LowLFHEKeySwitchLweOpPattern
                  mlir::PatternRewriter &rewriter) const override {
    auto errOp = rewriter.create<mlir::arith::ConstantOp>(
        op.getLoc(), rewriter.getIndexAttr(0));
+    // Get the size from the dimension
+    int64_t lweDimension =
+        op.getResult()
+            .getType()
+            .cast<mlir::zamalang::LowLFHE::LweCiphertextType>()
+            .getDimension();
+    int64_t lweSize = lweDimension + 1;
+    mlir::Value lweSizeOp = rewriter.create<mlir::arith::ConstantOp>(
+        op.getLoc(), rewriter.getIndexAttr(lweSize));
    // allocate the result lwe ciphertext, should be of a generic type, to cast
    // before return
-    auto lweSizeOp = rewriter.create<mlir::arith::ConstantOp>(
-        op.getLoc(),
-        rewriter.getIndexAttr(
-            op->getAttr("outputLweSize").cast<mlir::IntegerAttr>().getInt()));
    mlir::SmallVector<mlir::Value> allocLweCtOperands{errOp, lweSizeOp};
    auto allocateGenericLweCtOp = rewriter.create<mlir::CallOp>(
        op.getLoc(), "allocate_lwe_ciphertext_u64",
--- a/compiler/lib/Conversion/MidLFHEGlobalParametrization/MidLFHEGlobalParametrization.cpp
+++ b/compiler/lib/Conversion/MidLFHEGlobalParametrization/MidLFHEGlobalParametrization.cpp
@@ -22,8 +22,8 @@ struct MidLFHEGlobalParametrizationPass
 using mlir::zamalang::MidLFHE::GLWECipherTextType;

 /// MidLFHEGlobalParametrizationTypeConverter is a TypeConverter that transform
-/// `MidLFHE.gwle<{_,_,_}{p}>` to
-/// `MidLFHE.gwle<{glweSize,polynomialSize,bits}{p'}>`
+/// `MidLFHE.glwe<{_,_,_}{p}>` to
+/// `MidLFHE.glwe<{glweDimension,polynomialSize,bits}{p'}>`
 class MidLFHEGlobalParametrizationTypeConverter : public mlir::TypeConverter {

 public:
@@ -31,14 +31,14 @@ public:
      mlir::zamalang::V0FHEContext &fheContext) {
    auto convertGLWECiphertextType =
        [](GLWECipherTextType type, mlir::zamalang::V0FHEContext &fheContext) {
-          auto glweSize = fheContext.parameter.getNBigGlweSize();
+          auto glweDimension = fheContext.parameter.getNBigGlweDimension();
          auto p = fheContext.constraint.p;
-          if (type.getDimension() == (signed)glweSize &&
+          if (type.getDimension() == (signed)glweDimension &&
              type.getP() == (signed)p) {
            return type;
          }
          return GLWECipherTextType::get(
-              type.getContext(), glweSize,
+              type.getContext(), glweDimension,
              1 /*for the v0, is always lwe ciphertext*/,
              64 /*for the v0 we handle only q=64*/, p);
        };
@@ -101,12 +101,13 @@ struct MidLFHEApplyLookupTableParametrizationPattern
    }

    mlir::SmallVector<mlir::NamedAttribute, 6> newAttributes{
-        mlir::NamedAttribute(rewriter.getIdentifier("k"),
-                             rewriter.getI32IntegerAttr(v0Parameter.k)),
+        mlir::NamedAttribute(
+            rewriter.getIdentifier("glweDimension"),
+            rewriter.getI32IntegerAttr(v0Parameter.glweDimension)),
        mlir::NamedAttribute(
            rewriter.getIdentifier("polynomialSize"),
            // TODO remove the shift when we have true polynomial size
-            rewriter.getI32IntegerAttr(1 << v0Parameter.polynomialSize)),
+            rewriter.getI32IntegerAttr(1 << v0Parameter.logPolynomialSize)),
        mlir::NamedAttribute(rewriter.getIdentifier("levelKS"),
                             rewriter.getI32IntegerAttr(v0Parameter.ksLevel)),
        mlir::NamedAttribute(rewriter.getIdentifier("baseLogKS"),
@@ -212,9 +213,9 @@ void populateWithMidLFHEApplyLookupTableParametrizationPattern(
      patterns.getContext(), typeConverter, v0Parameter);
  target.addDynamicallyLegalOp<mlir::zamalang::MidLFHE::ApplyLookupTable>(
      [&](mlir::zamalang::MidLFHE::ApplyLookupTable op) {
-        if (op.k() != v0Parameter.k ||
+        if (op.glweDimension() != v0Parameter.glweDimension ||
            // TODO remove the shift when we have true polynomial size
-            op.polynomialSize() != (1 << v0Parameter.polynomialSize) ||
+            op.polynomialSize() != (1 << v0Parameter.logPolynomialSize) ||
            op.levelKS() != v0Parameter.ksLevel ||
            op.baseLogKS() != v0Parameter.ksLogBase ||
            op.levelBS() != v0Parameter.brLevel ||
--- a/compiler/lib/Conversion/MidLFHEToLowLFHE/MidLFHEToLowLFHE.cpp
+++ b/compiler/lib/Conversion/MidLFHEToLowLFHE/MidLFHEToLowLFHE.cpp
@@ -23,7 +23,7 @@ using mlir::zamalang::LowLFHE::LweCiphertextType;
 using mlir::zamalang::MidLFHE::GLWECipherTextType;

 /// MidLFHEToLowLFHETypeConverter is a TypeConverter that transform
-/// `MidLFHE.gwle<{_,_,_}{p}>` to LowLFHE.lwe_ciphertext
+/// `MidLFHE.glwe<{_,_,_}{p}>` to LowLFHE.lwe_ciphertext
 class MidLFHEToLowLFHETypeConverter : public mlir::TypeConverter {

 public:
--- a/compiler/lib/Support/ClientParameters.cpp
+++ b/compiler/lib/Support/ClientParameters.cpp
@@ -77,13 +77,13 @@ createClientParametersForV0(V0FHEContext fheContext, llvm::StringRef name,
                            mlir::ModuleOp module) {
  auto v0Param = fheContext.parameter;
  Variance encryptionVariance =
-      v0Curve->getVariance(1, 1 << v0Param.polynomialSize, 64);
+      v0Curve->getVariance(1, 1 << v0Param.logPolynomialSize, 64);
  Variance keyswitchVariance = v0Curve->getVariance(1, v0Param.nSmall, 64);
  // Static client parameters from global parameters for v0
  ClientParameters c = {};
  c.secretKeys = {
      {"small", {/*.size = */ v0Param.nSmall}},
-      {"big", {/*.size = */ v0Param.getNBigGlweSize()}},
+      {"big", {/*.size = */ v0Param.getNBigGlweDimension()}},
  };
  c.bootstrapKeys = {
      {
@@ -93,7 +93,7 @@ createClientParametersForV0(V0FHEContext fheContext, llvm::StringRef name,
              /*.outputSecretKeyID = */ "big",
              /*.level = */ v0Param.brLevel,
              /*.baseLog = */ v0Param.brLogBase,
-              /*.k = */ v0Param.k,
+              /*.glweDimension = */ v0Param.glweDimension,
              /*.variance = */ encryptionVariance,
          },
      },
--- a/compiler/lib/Support/KeySet.cpp
+++ b/compiler/lib/Support/KeySet.cpp
@@ -112,10 +112,13 @@ llvm::Error KeySet::generateSecretKey(LweSecretKeyID id,
                                      LweSecretKeyParam param,
                                      SecretRandomGenerator *generator) {
  LweSecretKey_u64 *sk;
-  CAPI_ERR_TO_LLVM_ERROR(sk = allocate_lwe_secret_key_u64(&err, {param.size}),
-                         "cannot allocate secret key");
+  CAPI_ERR_TO_LLVM_ERROR(
+      sk = allocate_lwe_secret_key_u64(&err, {param.size + 1}),
+      "cannot allocate secret key");
+
  CAPI_ERR_TO_LLVM_ERROR(fill_lwe_secret_key_u64(&err, sk, generator),
-                         "cannot fill secret key with random generator")
+                         "cannot fill secret key with random generator");
+
  secretKeys[id] = {param, sk};
  return llvm::Error::success();
 }
@@ -138,20 +141,34 @@ llvm::Error KeySet::generateBootstrapKey(BootstrapKeyID id,
  }
  // Allocate the bootstrap key
  LweBootstrapKey_u64 *bsk;
+
+  uint64_t total_dimension = outputSk->second.first.size;
+
+  assert(total_dimension % param.glweDimension == 0);
+
+  uint64_t polynomialSize = total_dimension / param.glweDimension;
+
  CAPI_ERR_TO_LLVM_ERROR(
      bsk = allocate_lwe_bootstrap_key_u64(
-          &err, {param.level}, {param.baseLog}, {param.k},
-          {inputSk->second.first.size},
-          {outputSk->second.first.size /*TODO: size / k ?*/}),
+          &err, {param.level}, {param.baseLog}, {param.glweDimension + 1},
+          {inputSk->second.first.size + 1}, {polynomialSize}),
      "cannot allocate bootstrap key");
+
  // Store the bootstrap key
  bootstrapKeys[id] = {param, bsk};
+
  // Convert the output lwe key to glwe key
  GlweSecretKey_u64 *glwe_sk;
+
  CAPI_ERR_TO_LLVM_ERROR(
-      glwe_sk = allocate_glwe_secret_key_u64(&err, {param.k},
-                                             {outputSk->second.first.size}),
+      glwe_sk = allocate_glwe_secret_key_u64(&err, {param.glweDimension + 1},
+                                             {polynomialSize}),
      "cannot allocate glwe key for initiliazation of bootstrap key");
+
+  CAPI_ERR_TO_LLVM_ERROR(fill_glwe_secret_key_with_lwe_secret_key_u64(
+                             &err, glwe_sk, outputSk->second.second),
+                         "cannot fill glwe key with big key");
+
  // Initialize the bootstrap key
  CAPI_ERR_TO_LLVM_ERROR(
      fill_lwe_bootstrap_key_u64(&err, bsk, inputSk->second.second, glwe_sk,
@@ -183,8 +200,8 @@ llvm::Error KeySet::generateKeyswitchKey(KeyswitchKeyID id,
  LweKeyswitchKey_u64 *ksk;
  CAPI_ERR_TO_LLVM_ERROR(
      ksk = allocate_lwe_keyswitch_key_u64(&err, {param.level}, {param.baseLog},
-                                           {inputSk->second.first.size},
-                                           {outputSk->second.first.size}),
+                                           {inputSk->second.first.size + 1},
+                                           {outputSk->second.first.size + 1}),
      "cannot allocate keyswitch key");
  // Store the keyswitch key
  keyswitchKeys[id] = {param, ksk};
@@ -206,7 +223,7 @@ llvm::Error KeySet::allocate_lwe(size_t argPos,
  }
  auto inputSk = inputs[argPos];
  CAPI_ERR_TO_LLVM_ERROR(*ciphertext = allocate_lwe_ciphertext_u64(
-                             &err, {std::get<1>(inputSk)->size}),
+                             &err, {std::get<1>(inputSk)->size + 1}),
                         "cannot allocate ciphertext");
  return llvm::Error::success();
 }
--- a/compiler/lib/Support/V0Parameters.cpp
+++ b/compiler/lib/Support/V0Parameters.cpp
@@ -148,7 +148,7 @@ const V0Parameter *getV0Parameter(V0FHEConstraint constraint) {
  }
  // - 1 is an offset as p is in [1, ...] and not [0, ...]
  auto param = &parameters[constraint.norm2][constraint.p - 1];
-  if (param->k == 0) {
+  if (param->glweDimension == 0) {
    return nullptr;
  }
  return param;
--- a/compiler/tests/Conversion/HLFHELinalgToLinalg/apply_multi_lut_to_linalg.mlir
+++ b/compiler/tests/Conversion/HLFHELinalgToLinalg/apply_multi_lut_to_linalg.mlir
@@ -11,7 +11,7 @@
 //CHECK-NEXT:     %[[V1:.*]] = linalg.generic {indexing_maps = [#map0, #map1, #map2, #map3, #map4, #map0], iterator_types = ["parallel", "parallel"]} ins(%arg0, %arg1, %arg1, %arg1, %arg1 : tensor<4x4x!MidLFHE.glwe<{_,_,_}{2}>>, tensor<4x4x4xi64>, tensor<4x4x4xi64>, tensor<4x4x4xi64>, tensor<4x4x4xi64>) outs(%[[V0]] : tensor<4x4x!MidLFHE.glwe<{_,_,_}{2}>>) {
 //CHECK-NEXT:     ^bb0(%arg2: !MidLFHE.glwe<{_,_,_}{2}>, %arg3: i64, %arg4: i64, %arg5: i64, %arg6: i64, %arg7: !MidLFHE.glwe<{_,_,_}{2}>):  // no predecessors
 //CHECK-NEXT:       %[[V2:.*]] = tensor.from_elements %arg3, %arg4, %arg5, %arg6 : tensor<4xi64>
-//CHECK-NEXT:       %[[V3:.*]] = "MidLFHE.apply_lookup_table"(%arg2, %[[V2]]) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, k = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>, tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
+//CHECK-NEXT:       %[[V3:.*]] = "MidLFHE.apply_lookup_table"(%arg2, %[[V2]]) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, glweDimension = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>, tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
 //CHECK-NEXT:       linalg.yield %[[V3]] : !MidLFHE.glwe<{_,_,_}{2}>
 //CHECK-NEXT:     } -> tensor<4x4x!MidLFHE.glwe<{_,_,_}{2}>>
 //CHECK-NEXT:     return %[[V1]] : tensor<4x4x!MidLFHE.glwe<{_,_,_}{2}>>
--- a/compiler/tests/Conversion/HLFHELinalgToLinalg/apply_multi_lut_to_linalg_broadcast.mlir
+++ b/compiler/tests/Conversion/HLFHELinalgToLinalg/apply_multi_lut_to_linalg_broadcast.mlir
@@ -11,7 +11,7 @@
 //CHECK-NEXT:     %[[V1:.*]] = linalg.generic {indexing_maps = [#map0, #map1, #map2, #map3, #map4, #map0], iterator_types = ["parallel", "parallel"]} ins(%arg0, %arg1, %arg1, %arg1, %arg1 : tensor<4x3x!MidLFHE.glwe<{_,_,_}{2}>>, tensor<3x4xi64>, tensor<3x4xi64>, tensor<3x4xi64>, tensor<3x4xi64>) outs(%[[V0]] : tensor<4x3x!MidLFHE.glwe<{_,_,_}{2}>>) {
 //CHECK-NEXT:     ^bb0(%arg2: !MidLFHE.glwe<{_,_,_}{2}>, %arg3: i64, %arg4: i64, %arg5: i64, %arg6: i64, %arg7: !MidLFHE.glwe<{_,_,_}{2}>):  // no predecessors
 //CHECK-NEXT:       %[[V2:.*]] = tensor.from_elements %arg3, %arg4, %arg5, %arg6 : tensor<4xi64>
-//CHECK-NEXT:       %[[V3:.*]] = "MidLFHE.apply_lookup_table"(%arg2, %[[V2]]) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, k = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>, tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
+//CHECK-NEXT:       %[[V3:.*]] = "MidLFHE.apply_lookup_table"(%arg2, %[[V2]]) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, glweDimension = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>, tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
 //CHECK-NEXT:       linalg.yield %[[V3]] : !MidLFHE.glwe<{_,_,_}{2}>
 //CHECK-NEXT:     } -> tensor<4x3x!MidLFHE.glwe<{_,_,_}{2}>>
 //CHECK-NEXT:     return %[[V1]] : tensor<4x3x!MidLFHE.glwe<{_,_,_}{2}>>
--- a/compiler/tests/Conversion/HLFHEToMidLFHE/apply_univariate.mlir
+++ b/compiler/tests/Conversion/HLFHEToMidLFHE/apply_univariate.mlir
@@ -2,7 +2,7 @@

 // CHECK-LABEL: func @apply_lookup_table(%arg0: !MidLFHE.glwe<{_,_,_}{2}>, %arg1: tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
 func @apply_lookup_table(%arg0: !HLFHE.eint<2>, %arg1: tensor<4xi64>) -> !HLFHE.eint<2> {
-  // CHECK-NEXT: %[[V1:.*]] = "MidLFHE.apply_lookup_table"(%arg0, %arg1) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, k = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>, tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
+  // CHECK-NEXT: %[[V1:.*]] = "MidLFHE.apply_lookup_table"(%arg0, %arg1) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, glweDimension = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>, tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
  // CHECK-NEXT: return %[[V1]] : !MidLFHE.glwe<{_,_,_}{2}>

  %1 = "HLFHE.apply_lookup_table"(%arg0, %arg1): (!HLFHE.eint<2>, tensor<4xi64>) -> (!HLFHE.eint<2>)
--- a/compiler/tests/Conversion/HLFHEToMidLFHE/apply_univariate_cst.mlir
+++ b/compiler/tests/Conversion/HLFHEToMidLFHE/apply_univariate_cst.mlir
@@ -3,7 +3,7 @@
 // CHECK-LABEL: func @apply_lookup_table_cst(%arg0: !MidLFHE.glwe<{_,_,_}{7}>) -> !MidLFHE.glwe<{_,_,_}{7}>
 func @apply_lookup_table_cst(%arg0: !HLFHE.eint<7>) -> !HLFHE.eint<7> {
  // CHECK-NEXT: %[[TABLE:.*]] = arith.constant dense<"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tensor<128xi64>
-  // CHECK-NEXT: %[[V0:.*]] = "MidLFHE.apply_lookup_table"(%arg0, %[[TABLE]]) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, k = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{7}>, tensor<128xi64>) -> !MidLFHE.glwe<{_,_,_}{7}>
+  // CHECK-NEXT: %[[V0:.*]] = "MidLFHE.apply_lookup_table"(%arg0, %[[TABLE]]) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, glweDimension = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{7}>, tensor<128xi64>) -> !MidLFHE.glwe<{_,_,_}{7}>
  // CHECK-NEXT: return %[[V0]] : !MidLFHE.glwe<{_,_,_}{7}>
  %tlu = arith.constant dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]> : tensor<128xi64>
  %1 = "HLFHE.apply_lookup_table"(%arg0, %tlu): (!HLFHE.eint<7>, tensor<128xi64>) -> (!HLFHE.eint<7>)
--- a/compiler/tests/Conversion/LowLFHEToConcreteCAPI/bootstrap.mlir
+++ b/compiler/tests/Conversion/LowLFHEToConcreteCAPI/bootstrap.mlir
@@ -9,7 +9,7 @@
 // CHECK-LABEL: func @bootstrap_lwe(%arg0: !LowLFHE.lwe_ciphertext<1024,4>, %arg1: !LowLFHE.glwe_ciphertext, %arg2: !LowLFHE.context) -> !LowLFHE.lwe_ciphertext<1024,4>
 func @bootstrap_lwe(%arg0: !LowLFHE.lwe_ciphertext<1024,4>, %arg1: !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<1024,4> {
  // CHECK-NEXT: %[[ERR:.*]] = arith.constant 0 : index
-  // CHECK-NEXT: %[[C0:.*]] = arith.constant 1024 : index
+  // CHECK-NEXT: %[[C0:.*]] = arith.constant 1025 : index
  // CHECK-NEXT: %[[V1:.*]] = call @allocate_lwe_ciphertext_u64(%[[ERR]], %[[C0]]) : (index, index) -> !LowLFHE.lwe_ciphertext<_,_>
  // CHECK-NEXT: %[[V2:.*]] = call @get_bootstrap_key(%arg2) : (!LowLFHE.context) -> !LowLFHE.lwe_bootstrap_key
  // CHECK-NEXT: %[[V3:.*]] = builtin.unrealized_conversion_cast %arg0 : !LowLFHE.lwe_ciphertext<1024,4> to !LowLFHE.lwe_ciphertext<_,_>
@@ -17,6 +17,6 @@ func @bootstrap_lwe(%arg0: !LowLFHE.lwe_ciphertext<1024,4>, %arg1: !LowLFHE.glwe
  // CHECK-NEXT: call @bootstrap_lwe_u64(%[[ERR]], %[[V2]], %[[V1]], %[[V3]], %[[V4]]) : (index, !LowLFHE.lwe_bootstrap_key, !LowLFHE.lwe_ciphertext<_,_>, !LowLFHE.lwe_ciphertext<_,_>, !LowLFHE.glwe_ciphertext) -> ()
  // CHECK-NEXT: %[[RES:.*]] = builtin.unrealized_conversion_cast %[[V1]] : !LowLFHE.lwe_ciphertext<_,_> to !LowLFHE.lwe_ciphertext<1024,4>
  // CHECK-NEXT: return %[[RES]] : !LowLFHE.lwe_ciphertext<1024,4>
-  %1 = "LowLFHE.bootstrap_lwe"(%arg0, %arg1) {baseLog = 2 : i32, k = 1 : i32, level = 3 : i32, polynomialSize = 1024 : i32} : (!LowLFHE.lwe_ciphertext<1024,4>, !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<1024,4>
+  %1 = "LowLFHE.bootstrap_lwe"(%arg0, %arg1) {baseLog = 2 : i32, glweDimension = 1 : i32, level = 3 : i32, polynomialSize = 1024 : i32} : (!LowLFHE.lwe_ciphertext<1024,4>, !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<1024,4>
  return %1: !LowLFHE.lwe_ciphertext<1024,4>
 }
--- a/compiler/tests/Conversion/LowLFHEToConcreteCAPI/glwe_from_table.mlir
+++ b/compiler/tests/Conversion/LowLFHEToConcreteCAPI/glwe_from_table.mlir
@@ -9,7 +9,7 @@
 // CHECK-LABEL: func @glwe_from_table(%arg0: tensor<16xi64>, %arg1: !LowLFHE.context) -> !LowLFHE.glwe_ciphertext
 func @glwe_from_table(%arg0: tensor<16xi64>) -> !LowLFHE.glwe_ciphertext {
  // CHECK-NEXT: %[[V0:.*]] = arith.constant 0 : index
-  // CHECK-NEXT: %[[C0:.*]] = arith.constant 1 : i32
+  // CHECK-NEXT: %[[C0:.*]] = arith.constant 2 : i32
  // CHECK-NEXT: %[[C1:.*]] = arith.constant 1024 : i32
  // CHECK-NEXT: %[[V1:.*]] = call @allocate_glwe_ciphertext_u64(%[[V0]], %[[C0]], %[[C1]]) : (index, i32, i32) -> !LowLFHE.glwe_ciphertext
  // CHECK-NEXT: %[[V2:.*]] = call @allocate_glwe_ciphertext_u64(%[[V0]], %[[C0]], %[[C1]]) : (index, i32, i32) -> !LowLFHE.glwe_ciphertext
@@ -20,6 +20,6 @@ func @glwe_from_table(%arg0: tensor<16xi64>) -> !LowLFHE.glwe_ciphertext {
  // CHECK-NEXT: call @fill_plaintext_list_with_expansion_u64(%[[V0]], %[[V3]], %[[V4]]) : (index, !LowLFHE.plaintext_list, !LowLFHE.foreign_plaintext_list) -> ()
  // CHECK-NEXT: call @add_plaintext_list_glwe_ciphertext_u64(%[[V0]], %[[V1]], %[[V2]], %[[V3]]) : (index, !LowLFHE.glwe_ciphertext, !LowLFHE.glwe_ciphertext, !LowLFHE.plaintext_list) -> ()
  // CHECK-NEXT: return %[[V1]] : !LowLFHE.glwe_ciphertext
-  %1 = "LowLFHE.glwe_from_table"(%arg0) {k = 1 : i32, p = 4 : i32, polynomialSize = 1024 : i32} : (tensor<16xi64>) -> !LowLFHE.glwe_ciphertext
+  %1 = "LowLFHE.glwe_from_table"(%arg0) {glweDimension = 1 : i32, p = 4 : i32, polynomialSize = 1024 : i32} : (tensor<16xi64>) -> !LowLFHE.glwe_ciphertext
  return %1: !LowLFHE.glwe_ciphertext
 }
--- a/compiler/tests/Conversion/LowLFHEToConcreteCAPI/keyswitch_lwe.mlir
+++ b/compiler/tests/Conversion/LowLFHEToConcreteCAPI/keyswitch_lwe.mlir
@@ -9,7 +9,7 @@
 // CHECK-LABEL: func @keyswitch_lwe(%arg0: !LowLFHE.lwe_ciphertext<1024,4>, %arg1: !LowLFHE.context) -> !LowLFHE.lwe_ciphertext<1024,4>
 func @keyswitch_lwe(%arg0: !LowLFHE.lwe_ciphertext<1024,4>) -> !LowLFHE.lwe_ciphertext<1024,4> {
  // CHECK-NEXT: %[[ERR:.*]] = arith.constant 0 : index
-  // CHECK-NEXT: %[[C0:.*]] = arith.constant 1 : index
+  // CHECK-NEXT: %[[C0:.*]] = arith.constant 1025 : index
  // CHECK-NEXT: %[[V1:.*]] = call @allocate_lwe_ciphertext_u64(%[[ERR]], %[[C0]]) : (index, index) -> !LowLFHE.lwe_ciphertext<_,_>
  // CHECK-NEXT: %[[V2:.*]] = call @get_keyswitch_key(%arg1) : (!LowLFHE.context) -> !LowLFHE.lwe_key_switch_key
  // CHECK-NEXT: %[[V3:.*]] = builtin.unrealized_conversion_cast %arg0 : !LowLFHE.lwe_ciphertext<1024,4> to !LowLFHE.lwe_ciphertext<_,_>
--- a/compiler/tests/Conversion/MidLFHEToLowLFHE/apply_lookup_table.mlir
+++ b/compiler/tests/Conversion/MidLFHEToLowLFHE/apply_lookup_table.mlir
@@ -2,10 +2,10 @@

 // CHECK-LABEL: func @apply_lookup_table(%arg0: !LowLFHE.lwe_ciphertext<1024,4>, %arg1: tensor<16xi64>) -> !LowLFHE.lwe_ciphertext<1024,4>
 func @apply_lookup_table(%arg0: !MidLFHE.glwe<{1024,1,64}{4}>, %arg1: tensor<16xi64>) -> !MidLFHE.glwe<{1024,1,64}{4}> {
-  // CHECK-NEXT: %[[V1:.*]] = "LowLFHE.glwe_from_table"(%arg1) {k = 1 : i32, p = 4 : i32, polynomialSize = 1024 : i32} : (tensor<16xi64>) -> !LowLFHE.glwe_ciphertext
-  // CHECK-NEXT: %[[V2:.*]] = "LowLFHE.keyswitch_lwe"(%arg0) {baseLog = 2 : i32, inputLweSize = 1 : i32, level = 3 : i32, outputLweSize = 600 : i32} : (!LowLFHE.lwe_ciphertext<1024,4>) -> !LowLFHE.lwe_ciphertext<600,4>
-  // CHECK-NEXT: %[[V3:.*]] = "LowLFHE.bootstrap_lwe"(%[[V2]], %[[V1]]) {baseLog = 4 : i32, k = 1 : i32, level = 5 : i32, polynomialSize = 1024 : i32} : (!LowLFHE.lwe_ciphertext<600,4>, !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<1024,4>
+  // CHECK-NEXT: %[[V1:.*]] = "LowLFHE.glwe_from_table"(%arg1) {glweDimension = 1 : i32, p = 4 : i32, polynomialSize = 1024 : i32} : (tensor<16xi64>) -> !LowLFHE.glwe_ciphertext
+  // CHECK-NEXT: %[[V2:.*]] = "LowLFHE.keyswitch_lwe"(%arg0) {baseLog = 2 : i32, level = 3 : i32} : (!LowLFHE.lwe_ciphertext<1024,4>) -> !LowLFHE.lwe_ciphertext<600,4>
+  // CHECK-NEXT: %[[V3:.*]] = "LowLFHE.bootstrap_lwe"(%[[V2]], %[[V1]]) {baseLog = 4 : i32, glweDimension = 1 : i32, level = 5 : i32, polynomialSize = 1024 : i32} : (!LowLFHE.lwe_ciphertext<600,4>, !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<1024,4>
  // CHECK-NEXT: return %[[V3]] : !LowLFHE.lwe_ciphertext<1024,4>
-  %1 = "MidLFHE.apply_lookup_table"(%arg0, %arg1){k=1:i32, polynomialSize=1024:i32, levelKS=3:i32, baseLogKS=2:i32, levelBS=5:i32, baseLogBS=4:i32, outputSizeKS=600:i32}: (!MidLFHE.glwe<{1024,1,64}{4}>, tensor<16xi64>) -> (!MidLFHE.glwe<{1024,1,64}{4}>)
+  %1 = "MidLFHE.apply_lookup_table"(%arg0, %arg1){glweDimension=1:i32, polynomialSize=1024:i32, levelKS=3:i32, baseLogKS=2:i32, levelBS=5:i32, baseLogBS=4:i32, outputSizeKS=600:i32}: (!MidLFHE.glwe<{1024,1,64}{4}>, tensor<16xi64>) -> (!MidLFHE.glwe<{1024,1,64}{4}>)
  return %1: !MidLFHE.glwe<{1024,1,64}{4}>
 }
--- a/compiler/tests/Conversion/MidLFHEToLowLFHE/apply_lookup_table_cst.mlir
+++ b/compiler/tests/Conversion/MidLFHEToLowLFHE/apply_lookup_table_cst.mlir
@@ -3,11 +3,11 @@
 // CHECK-LABEL: func @apply_lookup_table_cst(%arg0: !LowLFHE.lwe_ciphertext<2048,4>) -> !LowLFHE.lwe_ciphertext<2048,4>
 func @apply_lookup_table_cst(%arg0: !MidLFHE.glwe<{2048,1,64}{4}>) -> !MidLFHE.glwe<{2048,1,64}{4}> {
  // CHECK-NEXT: %[[TABLE:.*]] = arith.constant dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : tensor<16xi64>
-  // CHECK-NEXT: %[[V1:.*]] = "LowLFHE.glwe_from_table"(%[[TABLE]]) {k = 1 : i32, p = 4 : i32, polynomialSize = 2048 : i32} : (tensor<16xi64>) -> !LowLFHE.glwe_ciphertext
-  // CHECK-NEXT: %[[V2:.*]] = "LowLFHE.keyswitch_lwe"(%arg0) {baseLog = 2 : i32, inputLweSize = 1 : i32, level = 3 : i32, outputLweSize = 600 : i32} : (!LowLFHE.lwe_ciphertext<2048,4>) -> !LowLFHE.lwe_ciphertext<600,4>
-  // CHECK-NEXT: %[[V3:.*]] = "LowLFHE.bootstrap_lwe"(%[[V2]], %[[V1]]) {baseLog = 4 : i32, k = 1 : i32, level = 5 : i32, polynomialSize = 2048 : i32} : (!LowLFHE.lwe_ciphertext<600,4>, !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<2048,4>
+  // CHECK-NEXT: %[[V1:.*]] = "LowLFHE.glwe_from_table"(%[[TABLE]]) {glweDimension = 1 : i32, p = 4 : i32, polynomialSize = 2048 : i32} : (tensor<16xi64>) -> !LowLFHE.glwe_ciphertext
+  // CHECK-NEXT: %[[V2:.*]] = "LowLFHE.keyswitch_lwe"(%arg0) {baseLog = 2 : i32, level = 3 : i32} : (!LowLFHE.lwe_ciphertext<2048,4>) -> !LowLFHE.lwe_ciphertext<600,4>
+  // CHECK-NEXT: %[[V3:.*]] = "LowLFHE.bootstrap_lwe"(%[[V2]], %[[V1]]) {baseLog = 4 : i32, glweDimension = 1 : i32, level = 5 : i32, polynomialSize = 2048 : i32} : (!LowLFHE.lwe_ciphertext<600,4>, !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<2048,4>
  // CHECK-NEXT: return %[[V3]] : !LowLFHE.lwe_ciphertext<2048,4>
  %tlu = arith.constant dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]> : tensor<16xi64>
-  %1 = "MidLFHE.apply_lookup_table"(%arg0, %tlu){k=1:i32, polynomialSize=2048:i32, levelKS=3:i32, baseLogKS=2:i32, levelBS=5:i32, baseLogBS=4:i32, outputSizeKS=600:i32}: (!MidLFHE.glwe<{2048,1,64}{4}>, tensor<16xi64>) -> (!MidLFHE.glwe<{2048,1,64}{4}>)
+  %1 = "MidLFHE.apply_lookup_table"(%arg0, %tlu){glweDimension=1:i32, polynomialSize=2048:i32, levelKS=3:i32, baseLogKS=2:i32, levelBS=5:i32, baseLogBS=4:i32, outputSizeKS=600:i32}: (!MidLFHE.glwe<{2048,1,64}{4}>, tensor<16xi64>) -> (!MidLFHE.glwe<{2048,1,64}{4}>)
  return %1: !MidLFHE.glwe<{2048,1,64}{4}>
 }
--- a/compiler/tests/Dialect/HLFHELinalg/apply_multi_lut_to_linalg.mlir
+++ b/compiler/tests/Dialect/HLFHELinalg/apply_multi_lut_to_linalg.mlir
@@ -11,7 +11,7 @@
 //CHECK-NEXT:     %[[V1:.*]] = linalg.generic {indexing_maps = [#map0, #map1, #map2, #map3, #map4, #map0], iterator_types = ["parallel", "parallel"]} ins(%arg0, %arg1, %arg1, %arg1, %arg1 : tensor<4x4x!MidLFHE.glwe<{_,_,_}{2}>>, tensor<4x4x4xi64>, tensor<4x4x4xi64>, tensor<4x4x4xi64>, tensor<4x4x4xi64>) outs(%[[V0]] : tensor<4x4x!MidLFHE.glwe<{_,_,_}{2}>>) {
 //CHECK-NEXT:     ^bb0(%arg2: !MidLFHE.glwe<{_,_,_}{2}>, %arg3: i64, %arg4: i64, %arg5: i64, %arg6: i64, %arg7: !MidLFHE.glwe<{_,_,_}{2}>):  // no predecessors
 //CHECK-NEXT:       %[[V2:.*]] = tensor.from_elements %arg3, %arg4, %arg5, %arg6 : tensor<4xi64>
-//CHECK-NEXT:       %[[V3:.*]] = "MidLFHE.apply_lookup_table"(%arg2, %[[V2]]) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, k = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>, tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
+//CHECK-NEXT:       %[[V3:.*]] = "MidLFHE.apply_lookup_table"(%arg2, %[[V2]]) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, glweDimension = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>, tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
 //CHECK-NEXT:       linalg.yield %[[V3]] : !MidLFHE.glwe<{_,_,_}{2}>
 //CHECK-NEXT:     } -> tensor<4x4x!MidLFHE.glwe<{_,_,_}{2}>>
 //CHECK-NEXT:     return %[[V1]] : tensor<4x4x!MidLFHE.glwe<{_,_,_}{2}>>
--- a/compiler/tests/Dialect/HLFHELinalg/apply_multi_lut_to_linalg_broadcast.mlir
+++ b/compiler/tests/Dialect/HLFHELinalg/apply_multi_lut_to_linalg_broadcast.mlir
@@ -11,7 +11,7 @@
 //CHECK-NEXT:     %[[V1:.*]] = linalg.generic {indexing_maps = [#map0, #map1, #map2, #map3, #map4, #map0], iterator_types = ["parallel", "parallel"]} ins(%arg0, %arg1, %arg1, %arg1, %arg1 : tensor<4x3x!MidLFHE.glwe<{_,_,_}{2}>>, tensor<3x4xi64>, tensor<3x4xi64>, tensor<3x4xi64>, tensor<3x4xi64>) outs(%[[V0]] : tensor<4x3x!MidLFHE.glwe<{_,_,_}{2}>>) {
 //CHECK-NEXT:     ^bb0(%arg2: !MidLFHE.glwe<{_,_,_}{2}>, %arg3: i64, %arg4: i64, %arg5: i64, %arg6: i64, %arg7: !MidLFHE.glwe<{_,_,_}{2}>):  // no predecessors
 //CHECK-NEXT:       %[[V2:.*]] = tensor.from_elements %arg3, %arg4, %arg5, %arg6 : tensor<4xi64>
-//CHECK-NEXT:       %[[V3:.*]] = "MidLFHE.apply_lookup_table"(%arg2, %[[V2]]) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, k = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>, tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
+//CHECK-NEXT:       %[[V3:.*]] = "MidLFHE.apply_lookup_table"(%arg2, %[[V2]]) {baseLogBS = -1 : i32, baseLogKS = -1 : i32, glweDimension = -1 : i32, levelBS = -1 : i32, levelKS = -1 : i32, outputSizeKS = -1 : i32, polynomialSize = -1 : i32} : (!MidLFHE.glwe<{_,_,_}{2}>, tensor<4xi64>) -> !MidLFHE.glwe<{_,_,_}{2}>
 //CHECK-NEXT:       linalg.yield %[[V3]] : !MidLFHE.glwe<{_,_,_}{2}>
 //CHECK-NEXT:     } -> tensor<4x3x!MidLFHE.glwe<{_,_,_}{2}>>
 //CHECK-NEXT:     return %[[V1]] : tensor<4x3x!MidLFHE.glwe<{_,_,_}{2}>>
--- a/compiler/tests/Dialect/LowLFHE/ops.mlir
+++ b/compiler/tests/Dialect/LowLFHE/ops.mlir
@@ -38,19 +38,19 @@ func @negate_lwe_ciphertext(%arg0: !LowLFHE.lwe_ciphertext<2048,7>) -> !LowLFHE.

 // CHECK-LABEL: func @bootstrap_lwe(%arg0: !LowLFHE.lwe_ciphertext<2048,7>, %arg1: !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<2048,7>
 func @bootstrap_lwe(%arg0: !LowLFHE.lwe_ciphertext<2048,7>, %arg1: !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<2048,7> {
-  // CHECK-NEXT: %[[V1:.*]] = "LowLFHE.bootstrap_lwe"(%arg0, %arg1) {baseLog = -1 : i32, k = 1 : i32, level = -1 : i32, polynomialSize = 1024 : i32} : (!LowLFHE.lwe_ciphertext<2048,7>, !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<2048,7>
+  // CHECK-NEXT: %[[V1:.*]] = "LowLFHE.bootstrap_lwe"(%arg0, %arg1) {baseLog = -1 : i32, glweDimension = 1 : i32, level = -1 : i32, polynomialSize = 1024 : i32} : (!LowLFHE.lwe_ciphertext<2048,7>, !LowLFHE.glwe_ciphertext) -> !LowLFHE.lwe_ciphertext<2048,7>
  // CHECK-NEXT: return %[[V1]] : !LowLFHE.lwe_ciphertext<2048,7>

-  %1 = "LowLFHE.bootstrap_lwe"(%arg0, %arg1) {baseLog = -1 : i32, k = 1 : i32, level = -1 : i32, polynomialSize = 1024 : i32} : (!LowLFHE.lwe_ciphertext<2048,7>, !LowLFHE.glwe_ciphertext) -> (!LowLFHE.lwe_ciphertext<2048,7>)
+  %1 = "LowLFHE.bootstrap_lwe"(%arg0, %arg1) {baseLog = -1 : i32, glweDimension = 1 : i32, level = -1 : i32, polynomialSize = 1024 : i32} : (!LowLFHE.lwe_ciphertext<2048,7>, !LowLFHE.glwe_ciphertext) -> (!LowLFHE.lwe_ciphertext<2048,7>)
  return %1: !LowLFHE.lwe_ciphertext<2048,7>
 }

 // CHECK-LABEL: func @keyswitch_lwe(%arg0: !LowLFHE.lwe_ciphertext<2048,7>) -> !LowLFHE.lwe_ciphertext<2048,7>
 func @keyswitch_lwe(%arg0: !LowLFHE.lwe_ciphertext<2048,7>) -> !LowLFHE.lwe_ciphertext<2048,7> {
-  // CHECK-NEXT: %[[V1:.*]] = "LowLFHE.keyswitch_lwe"(%arg0) {baseLog = 2 : i32, inputLweSize = 1 : i32, level = 3 : i32, outputLweSize = 1 : i32} : (!LowLFHE.lwe_ciphertext<2048,7>) -> !LowLFHE.lwe_ciphertext<2048,7>
+  // CHECK-NEXT: %[[V1:.*]] = "LowLFHE.keyswitch_lwe"(%arg0) {baseLog = 2 : i32, level = 3 : i32} : (!LowLFHE.lwe_ciphertext<2048,7>) -> !LowLFHE.lwe_ciphertext<2048,7>
  // CHECK-NEXT: return %[[V1]] : !LowLFHE.lwe_ciphertext<2048,7>

-  %1 = "LowLFHE.keyswitch_lwe"(%arg0){baseLog = 2 : i32, inputLweSize = 1 : i32, level = 3 : i32, outputLweSize = 1 : i32}: (!LowLFHE.lwe_ciphertext<2048,7>) -> (!LowLFHE.lwe_ciphertext<2048,7>)
+  %1 = "LowLFHE.keyswitch_lwe"(%arg0){baseLog = 2 : i32, level = 3 : i32}: (!LowLFHE.lwe_ciphertext<2048,7>) -> (!LowLFHE.lwe_ciphertext<2048,7>)
  return %1: !LowLFHE.lwe_ciphertext<2048,7>
 }

--- a/compiler/tests/Dialect/MidLFHE/op_apply_lookup_table.invalid.mlir
+++ b/compiler/tests/Dialect/MidLFHE/op_apply_lookup_table.invalid.mlir
@@ -3,7 +3,7 @@
 // Bad dimension of the lookup table
 func @apply_lookup_table(%arg0: !MidLFHE.glwe<{1024,12,64}{7}>, %arg1: tensor<4xi2>) -> !MidLFHE.glwe<{512,10,64}{2}> {
  // expected-error @+1 {{'MidLFHE.apply_lookup_table' op should have as `l_cst` argument a shape of one dimension equals to 2^p, where p is the width of the `ct` argument}}
-  %1 = "MidLFHE.apply_lookup_table"(%arg0, %arg1) {k = 1 : i32, polynomialSize = 1024 : i32, levelKS = 2 : i32, baseLogKS = -82 : i32, levelBS = 3 : i32, baseLogBS = -83 : i32, outputSizeKS = 600 : i32}: (!MidLFHE.glwe<{1024,12,64}{7}>, tensor<4xi2>) -> (!MidLFHE.glwe<{512,10,64}{2}>)
+  %1 = "MidLFHE.apply_lookup_table"(%arg0, %arg1) {glweDimension = 1 : i32, polynomialSize = 1024 : i32, levelKS = 2 : i32, baseLogKS = -82 : i32, levelBS = 3 : i32, baseLogBS = -83 : i32, outputSizeKS = 600 : i32}: (!MidLFHE.glwe<{1024,12,64}{7}>, tensor<4xi2>) -> (!MidLFHE.glwe<{512,10,64}{2}>)
  return %1: !MidLFHE.glwe<{512,10,64}{2}>
 }

--- a/compiler/tests/Dialect/MidLFHE/op_apply_lookup_table.mlir
+++ b/compiler/tests/Dialect/MidLFHE/op_apply_lookup_table.mlir
@@ -2,9 +2,9 @@

 // CHECK-LABEL: func @apply_lookup_table(%arg0: !MidLFHE.glwe<{1024,12,64}{7}>, %arg1: tensor<128xi64>) -> !MidLFHE.glwe<{512,10,64}{2}>
 func @apply_lookup_table(%arg0: !MidLFHE.glwe<{1024,12,64}{7}>, %arg1: tensor<128xi64>) -> !MidLFHE.glwe<{512,10,64}{2}> {
-  // CHECK-NEXT: %[[V1:.*]] = "MidLFHE.apply_lookup_table"(%arg0, %arg1) {baseLogBS = -83 : i32, baseLogKS = -82 : i32, k = 1 : i32, levelBS = 3 : i32, levelKS = 2 : i32, outputSizeKS = 600 : i32, polynomialSize = 1024 : i32} : (!MidLFHE.glwe<{1024,12,64}{7}>, tensor<128xi64>) -> !MidLFHE.glwe<{512,10,64}{2}>
+  // CHECK-NEXT: %[[V1:.*]] = "MidLFHE.apply_lookup_table"(%arg0, %arg1) {baseLogBS = -83 : i32, baseLogKS = -82 : i32, glweDimension = 1 : i32, levelBS = 3 : i32, levelKS = 2 : i32, outputSizeKS = 600 : i32, polynomialSize = 1024 : i32} : (!MidLFHE.glwe<{1024,12,64}{7}>, tensor<128xi64>) -> !MidLFHE.glwe<{512,10,64}{2}>
  // CHECK-NEXT: return %[[V1]] : !MidLFHE.glwe<{512,10,64}{2}>

-  %1 = "MidLFHE.apply_lookup_table"(%arg0, %arg1) {k = 1 : i32, polynomialSize = 1024 : i32, levelKS = 2 : i32, baseLogKS = -82 : i32, levelBS = 3 : i32, baseLogBS = -83 : i32, outputSizeKS = 600 : i32} : (!MidLFHE.glwe<{1024,12,64}{7}>, tensor<128xi64>) -> (!MidLFHE.glwe<{512,10,64}{2}>)
+  %1 = "MidLFHE.apply_lookup_table"(%arg0, %arg1) {glweDimension = 1 : i32, polynomialSize = 1024 : i32, levelKS = 2 : i32, baseLogKS = -82 : i32, levelBS = 3 : i32, baseLogBS = -83 : i32, outputSizeKS = 600 : i32} : (!MidLFHE.glwe<{1024,12,64}{7}>, tensor<128xi64>) -> (!MidLFHE.glwe<{512,10,64}{2}>)
  return %1: !MidLFHE.glwe<{512,10,64}{2}>
 }