PtxtArray serialisation

Co-authored-by: Hamish Hunt <[email protected]>

Author: jlhcrawford

examples/tutorial/07_ckks_serialization.cpp

@@ -71,15 +71,14 @@ int main(int argc, char* argv[])
   std::cout << "\n\n*** Public Key:\n";
   std::cout << public_key.writeToJSON().pretty() << std::endl;
 
-  // Create a Ptxt data object
+  // Create a data object
   std::vector<long> data(context.getNSlots());
 
   // Generate some data
   std::iota(data.begin(), data.end(), 0);
 
-  // Create a ptxt. Note that in this tutorial we make use of the
-  // alternative ptxt API.
-  helib::Ptxt<helib::CKKS> ptxt(context, data);
+  // Create a PtxtArray.
+  helib::PtxtArray ptxt(context, data);
 
   // Print the ptxt to stdout
   std::cout << "\n\n*** Ptxt:\n";
@@ -89,7 +88,7 @@ int main(int argc, char* argv[])
   helib::Ctxt ctxt(public_key);
 
   // Encrypt `data` into the ciphertext
-  public_key.Encrypt(ctxt, ptxt);
+  ptxt.encrypt(ctxt);
 
   // Print the ctxt to stdout
   std::cout << "\n\n*** Ctxt:\n";

examples/tutorial/08_ckks_deserialization.cpp

@@ -151,21 +151,23 @@ int main(int argc, char* argv[])
   // inspect the file.
   std::remove("pk.json");
 
-  // Create a Ptxt data object
+  // Create a data object
   std::vector<long> data(context.getNSlots());
 
   // Generate some data
   std::iota(data.begin(), data.end(), 0);
 
-  // Create a ptxt. Note that in this tutorial we make use of the
-  // alternative ptxt API.
-  helib::Ptxt<helib::CKKS> ptxt(context, data);
+  // Create a ptxt.
+  helib::PtxtArray ptxt(context, data);
 
   std::ofstream outPtxtFile;
   outPtxtFile.open("ptxt.json", std::ios::out);
   if (outPtxtFile.is_open()) {
     // Write the ptxt to a file
     ptxt.writeToJSON(outPtxtFile);
+    // Alternatively one can use
+    // outPtxtFile << ptxt;
+
     // Close the ofstream
     outPtxtFile.close();
   } else {
@@ -176,11 +178,11 @@ int main(int argc, char* argv[])
   inPtxtFile.open("ptxt.json");
   if (inPtxtFile.is_open()) {
     // Read in the ptxt from the file
-    helib::Ptxt<helib::CKKS> deserializedPtxt =
-        helib::Ptxt<helib::CKKS>::readFromJSON(inPtxtFile, context);
+    helib::PtxtArray deserializedPtxt =
+        helib::PtxtArray::readFromJSON(inPtxtFile, context);
     // Note there are alternative methods for deserialization of Ptxt objects.
     // After initialization
-    // helib::Ptxt<helib::CKKS> deserializedPtxt(publicKey);
+    // helib::PtxtArray deserializedPtxt(publicKey);
     // One can write
     // inPtxtFile >> deserializedPtxt;
     // Or alternatively
@@ -199,7 +201,7 @@ int main(int argc, char* argv[])
   helib::Ctxt ctxt(publicKey);
 
   // Encrypt `data` into the ciphertext
-  publicKey.Encrypt(ctxt, ptxt);
+  ptxt.encrypt(ctxt);
 
   std::ofstream outCtxtFile;
   outCtxtFile.open("ctxt.json", std::ios::out);

include/helib/EncryptedArray.h

@@ -2144,6 +2144,12 @@ void runningSums(const EncryptedArray& ea, PlaintextArray& pa);
 class PtxtArray
 {
 public:
+  /**
+   * @brief Class label to be added to JSON serialization as object type
+   * information.
+   */
+  static constexpr std::string_view typeName = "PtxtArray";
+
   // These two data fields should really be private, but there are
   // a lot of internal functions that need to access them
   const EncryptedArray& ea;
@@ -2189,6 +2195,8 @@ class PtxtArray
   const EncryptedArray& getView() const { return ea; }
   const EncryptedArray& getEA() const { return ea; }
 
+  long size() const { return ea.size(); }
+
   // direct encode, encrypt, and decrypt methods
   void encode(EncodedPtxt& eptxt,
               double mag = -1,
@@ -2256,6 +2264,7 @@ class PtxtArray
   void random() { helib::random(ea, pa); }
 
   //======== load ========
+  // Puts vector or scalar data into a PtxtArray
 
   void load(const std::vector<int>& array)
   {
@@ -2349,6 +2358,7 @@ class PtxtArray
   }
 
   //============== store ============
+  // Puts data into a std::vector aka `unload`
 
   void store(std::vector<long>& array) const { decode(ea, array, pa); }
 
@@ -2362,12 +2372,23 @@ class PtxtArray
 
   // this is here for consistency with Ctxt class
   void negate() { helib::negate(ea, pa); }
-};
 
-inline std::ostream& operator<<(std::ostream& s, const PtxtArray& a)
-{
-  return s << a.pa;
-}
+  void writeToJSON(std::ostream& os) const;
+
+  JsonWrapper writeToJSON() const;
+
+  static PtxtArray readFromJSON(std::istream& is, const Context& context);
+
+  static PtxtArray readFromJSON(const JsonWrapper& jw, const Context& context);
+
+  void readJSON(std::istream& is);
+
+  void readJSON(const JsonWrapper& jw);
+
+  friend std::istream& operator>>(std::istream& is, PtxtArray& pa);
+
+  friend std::ostream& operator<<(std::ostream& os, const PtxtArray& pa);
+};
 
 inline void rotate(PtxtArray& a, long k) { rotate(a.ea, a.pa, k); }
 

src/EncryptedArray.cpp

@@ -19,6 +19,8 @@
 #include <helib/norms.h>
 #include <helib/exceptions.h>
 
+#include "io.h"
+
 namespace helib {
 
 EncryptedArrayBase* buildEncryptedArray(const Context& context,
@@ -547,6 +549,147 @@ void EncryptedArrayDerived<type>::initNormalBasisMatrix() const
   } while (0);
 }
 
+// PtxtArray member functions
+
+void PtxtArray::writeToJSON(std::ostream& os) const
+{
+  executeRedirectJsonError<void>([&]() { os << this->writeToJSON(); });
+}
+
+JsonWrapper PtxtArray::writeToJSON() const
+{
+  auto body = [this]() {
+    json jslots;
+
+    if (ea.isCKKS()) {
+      // When it is CKKS
+      std::vector<std::complex<double>> data;
+      store(data);
+      jslots = data;
+    } else {
+      // When is it BGV
+      std::vector<NTL::ZZX> data;
+      store(data);
+      std::vector<std::vector<long>> slots(data.size());
+      for (std::size_t i = 0; i < data.size(); ++i) {
+        long deg = NTL::deg(data[i]);
+        if (deg == -1) {
+          slots[i].emplace_back(0);
+        }
+        for (long j = 0; j <= deg; ++j) {
+          slots[i].emplace_back(NTL::conv<long>(data[i][j]));
+        }
+      }
+      jslots = slots;
+    }
+
+    json j{{"scheme", (ea.isCKKS() ? "CKKS" : "BGV")}, {"slots", jslots}};
+
+    return wrap(toTypedJson<PtxtArray>(j));
+  };
+
+  return executeRedirectJsonError<JsonWrapper>(body);
+}
+
+PtxtArray PtxtArray::readFromJSON(std::istream& is, const Context& context)
+{
+  PtxtArray ret{context};
+  ret.readJSON(is);
+  return ret;
+}
+
+PtxtArray PtxtArray::readFromJSON(const JsonWrapper& tjw,
+                                  const Context& context)
+{
+  PtxtArray ret{context};
+  ret.readJSON(tjw);
+  return ret;
+}
+
+void PtxtArray::readJSON(std::istream& is)
+{
+  executeRedirectJsonError<void>([&]() {
+    json j;
+    is >> j;
+    this->readJSON(wrap(j));
+  });
+}
+
+void PtxtArray::readJSON(const JsonWrapper& tjw)
+{
+  auto body = [&]() {
+    json tj = unwrap(tjw);
+    json jslots;
+    // if the input is just an array short-circuit to slot deserialization
+    // (assuming there is no type-header).
+    if (tj.is_array()) {
+      jslots = tj;
+
+    } else {
+      json j = fromTypedJson<PtxtArray>(tj);
+
+      std::string expected_scheme{j.at("scheme").get<std::string>()};
+      assertTrue<IOError>(
+          expected_scheme == (ea.isCKKS() ? "CKKS" : "BGV"),
+          "Scheme mismatch in deserialization.\nExpected: " + expected_scheme +
+              ", actual: " + std::string(ea.isCKKS() ? "CKKS" : "BGV") + ".");
+
+      jslots = j.at("slots");
+
+      if (!jslots.is_array()) {
+        throw IOError("Slot content is not a JSON array");
+      }
+    }
+
+    if (static_cast<long>(jslots.size()) > this->getEA().size()) {
+      std::stringstream err_msg;
+      err_msg << "Cannot deserialize to PtxtArray: not enough slots.  "
+              << "Trying to deserialize " << jslots.size() << " elements.  "
+              << "Got " << this->getEA().size() << " slots.";
+      throw IOError(err_msg.str());
+    }
+
+    if (ea.isCKKS()) {
+      // Scheme is CKKS
+      this->load(jslots.get<std::vector<std::complex<double>>>());
+    } else {
+      // Scheme is BGV
+      auto json2data = [](const json& jslots) {
+        std::vector<NTL::ZZX> data;
+        data.reserve(jslots.size());
+        for (const auto& jslot : jslots) {
+          NTL::ZZX slot;
+          if (jslot.is_array()) {
+            for (std::size_t i = 0; i < jslot.size(); ++i) {
+              NTL::SetCoeff(slot, i, static_cast<long>(jslot[i]));
+            }
+          } else {
+            // Slot is a single number
+            slot = static_cast<long>(jslot);
+          }
+          data.emplace_back(slot);
+        }
+        return data;
+      };
+      this->load(json2data(jslots));
+    }
+  };
+
+  executeRedirectJsonError<void>(body);
+}
+
+std::istream& operator>>(std::istream& is, PtxtArray& pa)
+{
+  pa.readJSON(is);
+  return is;
+}
+
+std::ostream& operator<<(std::ostream& os, const PtxtArray& pa)
+{
+  pa.writeToJSON(os);
+  return os;
+}
+
 // Other functions...
 
 void runningSums(const EncryptedArray& ea, Ctxt& ctxt)