Eco ltz

packages/client/libclient-py/quickmpc/pandas/parser.py

@@ -75,11 +75,12 @@ def to_float(val: str) -> float:
         # Due to the limitation of comparison operation,
         # k bits are taken out and divided by 2^m.
         k: int = 48
-        m: int = 20
+        # m: int = 20
         hs: str = sha512(val.encode()).hexdigest()
         val_int: int = int(hs[:(k >> 2)], 16)
-        val_float: float = val_int / pow(2, m)
-        return val_float
+        # val_float: float = val_int / pow(2, m)
+        # return val_float
+        return val_int
 
 
 def to_int(val: str, encoding='utf-8') -> int:

packages/client/libclient-py/quickmpc/share/random.py

@@ -46,9 +46,14 @@ def __get_int(self, a: int, b: int) -> int:
     @get.register(Decimal)
     def __get_decimal(self, a: Decimal, b: Decimal) -> Decimal:
         # 256bit整数を取り出して[a,b]に正規化する
+        # self.__exception_check(a, b)
+        # val: int = self.get(self.mn, self.mx)
+        # return Decimal(val-self.mn)/(self.mx-self.mn)*(b-a)+a
         self.__exception_check(a, b)
-        val: int = self.get(self.mn, self.mx)
-        return Decimal(val-self.mn)/(self.mx-self.mn)*(b-a)+a
+        interval_byte = self.__get_byte_size(b-a)
+        byte_val: bytes = random(interval_byte)
+        int_val = int.from_bytes(byte_val, "big")
+        return int_val % (b - a) + a
 
     @methoddispatch()
     def get_list(self, a, b, size: int):
@@ -71,10 +76,17 @@ def __get_list_int(self, a: int, b: int, size: int) -> List[int]:
     def __get_list_decimal(self, a: Decimal, b: Decimal, size: int) \
             -> List[Decimal]:
         # 128bit整数を取り出して[a,b]に正規化する
+        # self.__exception_check(a, b)
+        # valList: List[int] = self.get_list(self.mn, self.mx, size)
+        # return [Decimal(val-self.mn)/(self.mx-self.mn)*(b-a)+a
+        #         for val in valList]
+        byte_size: int = self.__get_byte_size(b-a)
         self.__exception_check(a, b)
-        valList: List[int] = self.get_list(self.mn, self.mx, size)
-        return [Decimal(val-self.mn)/(self.mx-self.mn)*(b-a)+a
-                for val in valList]
+        seed: bytes = self.__get_32byte()
+        bytes_list: bytes = randombytes_deterministic(size*byte_size, seed)
+        int_list = [int.from_bytes(bytes_list[i:i+byte_size], "big")
+                    for i in range(0, len(bytes_list), byte_size)]
+        return [Decimal(int(x) % int(b-a))+a for x in int_list]
 
     def __get_byte_size(self, x: int) -> int:
         # 整数の byte サイズを取得

packages/server/computation_container/fixed_point/fixed_point.hpp

@@ -72,7 +72,16 @@ class FixedPointImpl : private boost::operators<FixedPointImpl<>>
             }
         }
         else
-            value = static_cast<T>(v) * shift;
+        {
+            if constexpr(std::is_same_v<U,T>)
+            {
+                value = v * shift;
+            }
+            else
+            {
+                value = static_cast<T>(v) * shift;
+            }
+        }
     }
     FixedPointImpl(const std::string &str)
     {

packages/server/computation_container/server/computation_to_computation_container/server.cpp

@@ -71,6 +71,7 @@ grpc::Status Server::ExchangeShares(
     }
 
     std::lock_guard<std::mutex> lock(mtx);  // mutex発動
+    assert(!first);
     if (!first)
     {
         shares_vec[std::make_tuple(party_id, share_id, job_id, thread_id)] = share_str_vec;

packages/server/computation_container/share/compare.cpp

@@ -1,143 +1,143 @@
 
 #include "compare.hpp"
 
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/multiprecision/cpp_dec_float.hpp>
+#include <boost/multiprecision/cpp_int.hpp>
+#include <boost/operators.hpp>
 #include "config_parse/config_parse.hpp"
 #include "logging/logger.hpp"
 
 namespace qmpc::Share
 {
+const int bit_length = 48;
+using mp_int = boost::multiprecision::cpp_int;
 
-auto convertFpToBool(const FixedPoint &fp, const std::string &op_name)
+Share<mp_int> right_shift(const Share<mp_int>&x)
 {
-    if (fp.getDoubleVal() > 0.95)
-    {
-        return true;
-    }
-    else if (fp.getDoubleVal() >= 0.5)
+    Share<mp_int> r = getRandBitShare<mp_int>();
+    Share<bool> b(((x.getVal() ^ r.getVal()) & 1) == 1);
+
+    int sum = open_and_recons(b);
+    bool c = sum & 1;
+
+    Share<mp_int> y = x - r + (c ? 2*r : Share<mp_int>(0)) - Share<mp_int>(b.getVal());
+    Config *conf = Config::getInstance();
+    y += mp_int(sum - c);
+    assert(y.getVal() % 2 == 0);
+    return y / 2;
+}
+
+std::vector<Share<mp_int>> right_shift(const std::vector<Share<mp_int>>&x)
+{
+    size_t n=x.size();
+    std::vector<Share<mp_int>> r = getRandBitShare<mp_int>(n);
+
+    std::vector<Share<bool>> b(n);
+    for(size_t i=0;i<n;i++)
     {
-        QMPC_LOG_ERROR(
-            "This operation (%s) determined to be true, but it could be false.", op_name
-        );
-        QMPC_LOG_ERROR(
-            "If you want to ignore the error and continue the calculation, replace 'exit' with "
-            "'return true;'. "
-        );
-        std::exit(EXIT_FAILURE);
-        // return true;
+        b[i] = ((x[i].getVal() ^ r[i].getVal()) & 1) == 1;
     }
-    else if (fp.getDoubleVal() >= 0.05)
+
+    std::vector<int> sum = open_and_recons(b);
+    std::vector<bool> c(n);
+    for(size_t i=0;i<n;i++)
     {
-        QMPC_LOG_ERROR(
-            "This operation (%s) determined to be false, but it could be true.", op_name
-        );
-        QMPC_LOG_ERROR(
-            "If you want to ignore the error and continue the calculation, replace 'exit' with "
-            "'return false;'. "
-        );
-        std::exit(EXIT_FAILURE);
-        // return false;
+        c[i] = sum[i] & 1;
     }
-    else
+
+    Config *conf = Config::getInstance();
+    std::vector<Share<mp_int>> y(n);
+    for(size_t i=0;i<n;i++)
     {
-        return false;
+        y[i] = x[i] - r[i] + (c[i] ? 2*r[i] : Share<mp_int>(0)) - Share<mp_int>(b[i].getVal());
+        y[i] += mp_int(sum[i] - c[i]);
+        assert(y[i].getVal() % 2 == 0);
+        y[i] /= 2;
     }
-}
 
-// アルゴリズムの詳細はこちら:
-// docs/faster-comparison-operators.md
-bool operator<(const Share<FixedPoint> &left, const Share<FixedPoint> &right)
-{
-    Share<FixedPoint> s = left - right;
-    Share s_ltz = LTZ(s);
-    auto ret = open_and_recons(s_ltz);
-    return convertFpToBool(ret, "Share < Share");
+    return y;
 }
 
-// [left == right] <=> [not (left < right)] and [not (right < left)]
-// アルゴリズムの詳細はこちら:
-// docs/faster-comparison-operators.md
-bool operator==(const Share<FixedPoint> &left, const Share<FixedPoint> &right)
+bool LTZ(Share<mp_int> x)
 {
-    auto x_ret = (left < right);
-    auto y_ret = (right < left);
-    auto ret = (FixedPoint(1) - x_ret) * (FixedPoint(1) - y_ret);
-    return convertFpToBool(ret, "Share == Share");
+    x += 1LL << bit_length;
+    for(int i=0;i<bit_length;i++)
+    {
+        x = right_shift(x);
+    }
+    Share<FixedPoint> x_fp(x.getVal());
+    FixedPoint res = open_and_recons(x_fp);
+    assert(res == 0 || res == 1);
+    return res == 0;
 }
 
-bool operator<(const Share<FixedPoint> &left, const FixedPoint &right)
+std::vector<bool> LTZ(std::vector<Share<mp_int>> x)
 {
-    Share<FixedPoint> s = left - right;
-    Share s_ltz = LTZ(s);
-    auto ret = open_and_recons(s_ltz);
-    return convertFpToBool(ret, "Share < FixedPoint");
-}
+    size_t n = x.size();
+    for(size_t i=0;i<n;i++)
+    {
+        x[i] += 1LL << bit_length;
+    }
 
-bool operator==(const Share<FixedPoint> &left, const FixedPoint &right)
-{
-    auto x_ret = (left < right);
-    auto y_ret = (right < left);
-    auto ret = (FixedPoint(1) - x_ret) * (FixedPoint(1) - y_ret);
-    return convertFpToBool(ret, "Share == FixedPoint");
+    for(int i=0;i<bit_length;i++)
+    {
+        x = right_shift(x);
+    }
+    std::vector<Share<FixedPoint>> x_fp(n);
+    for(size_t i=0;i<n;i++)
+    {
+        x_fp[i] = Share<FixedPoint>(x[i].getVal());
+    }
+    std::vector<FixedPoint> res = open_and_recons(x_fp);
+    std::vector<bool> b(n);
+    for(size_t i=0;i<n;i++)
+    {
+        if(!(res[i]==0 || res[i]==1))
+        {
+            //for(int i=0;i<n;i++)std::cerr<<res[i]<<" ";std::cerr<<std::endl;
+            assert(false);
+        }
+        b[i] = res[i]==0;
+    }
+    return b;
 }
 
 std::vector<bool> allLess(
     const std::vector<Share<FixedPoint>> &left, const std::vector<Share<FixedPoint>> &right
 )
 {
-    auto s = left - right;
-    auto s_ltz = LTZ(s);
-    auto fpv = open_and_recons(s_ltz);
-    std::vector<bool> ret;
-    ret.reserve(fpv.size());
-    for (const auto &fp : fpv)
+    size_t n = left.size();
+    std::vector<Share<mp_int>> v(n);
+    for(size_t i=0;i<n;i++)
     {
-        ret.emplace_back(convertFpToBool(fp, "Share < Share"));
+        v[i] = mp_int((left[i] - right[i]).getVal().getRoundValue());
+        //std::cerr<<v[i].getVal()<<" "<<left[i].getVal()<<" "<<right[i].getVal()<<std::endl;
     }
-    return ret;
+    return LTZ(v);
 }
 
 std::vector<bool> allGreater(
     const std::vector<Share<FixedPoint>> &left, const std::vector<Share<FixedPoint>> &right
 )
 {
-    auto s = right - left;
-    auto s_ltz = LTZ(s);
-    auto fpv = open_and_recons(s_ltz);
-    std::vector<bool> ret;
-    ret.reserve(fpv.size());
-    for (const auto &fp : fpv)
-    {
-        ret.emplace_back(convertFpToBool(fp, "Share > Share"));
-    }
-    return ret;
+    return allLess(right, left);
 }
 
 std::vector<bool> allLessEq(
     const std::vector<Share<FixedPoint>> &left, const std::vector<Share<FixedPoint>> &right
 )
 {
-    auto gtv = allGreater(left, right);
-    std::vector<bool> ret;
-    ret.reserve(gtv.size());
-    for (const auto &gt : gtv)
-    {
-        ret.emplace_back(gt ^ true);
-    }
-    return ret;
+    auto res = allGreater(left,right);
+    for(size_t i=0;i<res.size();i++)res[i] = !res[i];
+    return res;
 }
 
 std::vector<bool> allGreaterEq(
     const std::vector<Share<FixedPoint>> &left, const std::vector<Share<FixedPoint>> &right
 )
 {
-    auto ltv = allLess(left, right);
-    std::vector<bool> ret;
-    ret.reserve(ltv.size());
-    for (const auto &lt : ltv)
-    {
-        ret.emplace_back(lt ^ true);
-    }
-    return ret;
+    return allLessEq(right, left);
 }
 
 std::vector<bool> allEq(
@@ -154,46 +154,4 @@ std::vector<bool> allEq(
     }
     return ret;
 }
-
-// Less Than Zero ([s < 0])
-// アルゴリズムの詳細はこちら:
-// docs/faster-comparison-operators.md
-Share<FixedPoint> LTZ(const Share<FixedPoint> &s)
-{
-    // Experimented and adjusted.
-    int m = 20;
-    int k = 48;
-
-    // s に 2^m をかけて整数化を試みる
-    Share<FixedPoint> x = s * FixedPoint(std::to_string(1LL << m));
-    Share<FixedPoint> y = FixedPoint(std::to_string(1LL << k)) + x;
-    Share<FixedPoint> z = getLSBShare(y);
-    y = (y - z) * FixedPoint(0.5);
-    for (int i = 1; i < k; ++i)
-    {
-        Share<FixedPoint> b = getLSBShare(y);
-        z += (b * FixedPoint(std::to_string(1LL << i)));
-        y = (y - b) * FixedPoint(0.5);
-    }
-    return (z - x) / FixedPoint(std::to_string(1LL << k));
-}
-
-std::vector<Share<FixedPoint>> LTZ(const std::vector<Share<FixedPoint>> &s)
-{
-    // Experimented and adjusted.
-    int m = 20;
-    int k = 48;
-
-    auto x = s * FixedPoint(std::to_string(1LL << m));
-    auto y = FixedPoint(std::to_string(1LL << k)) + x;
-    auto z = getLSBShare(y);
-    y = (y - z) * FixedPoint(0.5);
-    for (int i = 1; i < k; ++i)
-    {
-        auto b = getLSBShare(y);
-        z = z + (b * FixedPoint(std::to_string(1LL << i)));
-        y = (y - b) * FixedPoint(0.5);
-    }
-    return (z - x) / FixedPoint(std::to_string(1LL << k));
-}
-}  // namespace qmpc::Share
+}

packages/server/computation_container/share/compare.hpp

@@ -29,6 +29,6 @@ std::vector<bool> allEq(
     const std::vector<Share<FixedPoint>> &left, const std::vector<Share<FixedPoint>> &right
 );
 
-Share<FixedPoint> LTZ(const Share<FixedPoint> &s);
-std::vector<Share<FixedPoint>> LTZ(const std::vector<Share<FixedPoint>> &s);
+bool LTZ(const Share<FixedPoint> &s);
+std::vector<bool> LTZ(const std::vector<Share<FixedPoint>> &s);
 }  // namespace qmpc::Share

packages/server/computation_container/share/share.hpp

@@ -184,10 +184,10 @@ class Share : boost::totally_ordered<Share<SV>>,
         ret += left;
         return ret;
     }
-    friend bool operator<(const Share<FixedPoint> &left, const Share<FixedPoint> &right);
-    friend bool operator==(const Share<FixedPoint> &left, const Share<FixedPoint> &right);
-    friend bool operator<(const Share<FixedPoint> &left, const FixedPoint &right);
-    friend bool operator==(const Share<FixedPoint> &left, const FixedPoint &right);
+    //friend bool operator<(const Share<FixedPoint> &left, const Share<FixedPoint> &right);
+    //friend bool operator==(const Share<FixedPoint> &left, const Share<FixedPoint> &right);
+    //friend bool operator<(const Share<FixedPoint> &left, const FixedPoint &right);
+    //friend bool operator==(const Share<FixedPoint> &left, const FixedPoint &right);
 
     friend std::vector<Share> operator+(
         const std::vector<Share> &obj1, const std::vector<Share> &obj2