keySwitching.h

/* Copyright (C) 2012-2020 IBM Corp.
 * This program is Licensed under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *   http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. See accompanying LICENSE file.
 */
 
#ifndef HELIB_KEY_SWITCHING_H
#define HELIB_KEY_SWITCHING_H
#include <climits>
#include <helib/DoubleCRT.h>
#include <helib/Context.h>
#include <helib/Ctxt.h>
 
namespace helib {
 
class KeySwitch
{
public:
  static constexpr std::string_view typeName = "KeySwitch";
 
  SKHandle fromKey; // A handle for the key s'
  long toKeyID;     // Index of the key s that we are switching into
  long ptxtSpace;   // either p or p^r
 
  std::vector<DoubleCRT> b; // The top row, consisting of the bi's
  NTL::ZZ prgSeed; // a seed to generate the random ai's in the bottom row
  NTL::xdouble noiseBound; // high probability bound on noise magnitude
  // in each column
 
  explicit KeySwitch(long sPow = 0,
                     long xPow = 0,
                     long fromID = 0,
                     long toID = 0,
                     long p = 0);
  explicit KeySwitch(const SKHandle& _fromKey,
                     long fromID = 0,
                     long toID = 0,
                     long p = 0);
 
  bool operator==(const KeySwitch& other) const;
  bool operator!=(const KeySwitch& other) const;
 
  unsigned long NumCols() const;
 
  static const KeySwitch& dummy();
  bool isDummy() const;
 
  void verify(SecKey& sk);
 
  void readMatrix(std::istream& str, const Context& context);
 
 
  void writeTo(std::ostream& str) const;
 
  static KeySwitch readFrom(std::istream& str, const Context& context);
 
  void writeToJSON(std::ostream& str) const;
 
  JsonWrapper writeToJSON() const;
 
  static KeySwitch readFromJSON(std::istream& str, const Context& context);
 
  static KeySwitch readFromJSON(const JsonWrapper& j, const Context& context);
 
  void readJSON(std::istream& str, const Context& context);
 
  void readJSON(const JsonWrapper& j, const Context& context);
};
std::ostream& operator<<(std::ostream& str, const KeySwitch& matrix);
// We DO NOT have std::istream& operator>>(std::istream& str, KeySwitch&
// matrix); instead must use the readMatrix method above, where you can specify
// context
 
 
#define HELIB_KEYSWITCH_THRESH (50)
 
#define HELIB_KEYSWITCH_MIN_THRESH (8)
 
long KSGiantStepSize(long D);
 
void addAllMatrices(SecKey& sKey, long keyID = 0);
 
void addFewMatrices(SecKey& sKey, long keyID = 0);
 
void addSome1DMatrices(SecKey& sKey,
                       long bound = HELIB_KEYSWITCH_THRESH,
                       long keyID = 0);
 
void add1DMatrices(SecKey& sKey, long keyID = 0);
 
void addBSGS1DMatrices(SecKey& sKey, long keyID = 0);
 
void addSomeFrbMatrices(SecKey& sKey,
                        long bound = HELIB_KEYSWITCH_THRESH,
                        long keyID = 0);
 
void addFrbMatrices(SecKey& sKey, long keyID = 0);
 
void addBSGSFrbMatrices(SecKey& sKey, long keyID = 0);
 
void addMinimal1DMatrices(SecKey& sKey, long keyID = 0);
void addMinimalFrbMatrices(SecKey& sKey, long keyID = 0);
 
class PermNetwork;
void addMatrices4Network(SecKey& sKey, const PermNetwork& net, long keyID = 0);
 
void addTheseMatrices(SecKey& sKey,
                      const std::set<long>& automVals,
                      long keyID = 0);
 
} // namespace helib
 
#endif // HELIB_KEY_SWITCHING_H