libff::bn128_G2 Class Reference

#include <bn128_g2.hpp>

Collaboration diagram for libff::bn128_G2:

Public Types
typedef bn128_Fq	base_field
typedef bn128_Fr	scalar_field

Public Member Functions
void	fill_coord (bn::Fp2 coord[3]) const
	bn128_G2 ()
	bn128_G2 (bn::Fp2 coord[3])
void	print () const
void	print_coordinates () const
void	to_affine_coordinates ()
void	to_special ()
bool	is_special () const
bool	is_zero () const
bool	operator== (const bn128_G2 &other) const
bool	operator!= (const bn128_G2 &other) const
bn128_G2	operator+ (const bn128_G2 &other) const
bn128_G2	operator- () const
bn128_G2	operator- (const bn128_G2 &other) const
bn128_G2	add (const bn128_G2 &other) const
bn128_G2	mixed_add (const bn128_G2 &other) const
bn128_G2	dbl () const
bn128_G2	mul_by_cofactor () const
bool	is_well_formed () const
bool	is_in_safe_subgroup () const
void	write_uncompressed (std::ostream &) const
void	write_compressed (std::ostream &) const

Static Public Member Functions
static const bn128_G2 &	zero ()
static const bn128_G2 &	one ()
static bn128_G2	random_element ()
static size_t	size_in_bits ()
static bigint< base_field::num_limbs >	base_field_char ()
static bigint< scalar_field::num_limbs >	order ()
static void	read_uncompressed (std::istream &, bn128_G2 &)
static void	read_compressed (std::istream &, bn128_G2 &)
static void	batch_to_special_all_non_zeros (std::vector< bn128_G2 > &vec)

Public Attributes
bn::Fp2	X
bn::Fp2	Y
bn::Fp2	Z

Static Public Attributes
static std::vector< size_t >	wnaf_window_table
static std::vector< size_t >	fixed_base_exp_window_table
static bn128_G2	G2_zero
static bn128_G2	G2_one
static const mp_size_t	h_bitcount = 256
static const mp_size_t	h_limbs
static bigint< h_limbs >	h

Detailed Description

Definition at line 24 of file bn128_g2.hpp.

Member Typedef Documentation

base_field

typedef bn128_Fq libff::bn128_G2::base_field

Definition at line 39 of file bn128_g2.hpp.

scalar_field

typedef bn128_Fr libff::bn128_G2::scalar_field

Definition at line 40 of file bn128_g2.hpp.

Constructor & Destructor Documentation

bn128_G2() [1/2]

libff::bn128_G2::bn128_G2

(

)

Definition at line 72 of file bn128_g2.cpp.

{
    this->X = G2_zero.X;
    this->Y = G2_zero.Y;
    this->Z = G2_zero.Z;
}

bn128_G2() [2/2]

libff::bn128_G2::bn128_G2 ( bn::Fp2  coord[3] )

inline

Definition at line 57 of file bn128_g2.hpp.

: X(coord[0]), Y(coord[1]), Z(coord[2]){};

Member Function Documentation

add()

bn128_G2 libff::bn128_G2::add

(

const bn128_G2 &

other

)

const

Definition at line 195 of file bn128_g2.cpp.

{
#ifdef PROFILE_OP_COUNTS
    this->add_cnt++;
#endif
 
    bn::Fp2 this_coord[3], other_coord[3], result_coord[3];
    this->fill_coord(this_coord);
    other.fill_coord(other_coord);
    bn::ecop::ECAdd(result_coord, this_coord, other_coord);
 
    bn128_G2 result(result_coord);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

base_field_char()

static bigint<base_field::num_limbs> libff::bn128_G2::base_field_char ( )

inlinestatic

Definition at line 88 of file bn128_g2.hpp.

    {
        return base_field::field_char();
    }

Here is the call graph for this function:

batch_to_special_all_non_zeros()

void libff::bn128_G2::batch_to_special_all_non_zeros ( std::vector< bn128_G2 > &  vec )

static

Definition at line 483 of file bn128_g2.cpp.

{
    std::vector<bn::Fp2> Z_vec;
    Z_vec.reserve(vec.size());
 
    for (auto &el : vec) {
        Z_vec.emplace_back(el.Z);
    }
    bn_batch_invert<bn::Fp2>(Z_vec);
 
    const bn::Fp2 one = 1;
 
    for (size_t i = 0; i < vec.size(); ++i) {
        bn::Fp2 Z2, Z3;
        bn::Fp2::square(Z2, Z_vec[i]);
        bn::Fp2::mul(Z3, Z2, Z_vec[i]);
 
        bn::Fp2::mul(vec[i].X, vec[i].X, Z2);
        bn::Fp2::mul(vec[i].Y, vec[i].Y, Z3);
        vec[i].Z = one;
    }
}

Here is the call graph for this function:

dbl()

bn128_G2 libff::bn128_G2::dbl

(

)

const

Definition at line 295 of file bn128_g2.cpp.

{
#ifdef PROFILE_OP_COUNTS
    this->dbl_cnt++;
#endif
 
    bn::Fp2 this_coord[3], result_coord[3];
    this->fill_coord(this_coord);
    bn::ecop::ECDouble(result_coord, this_coord);
 
    bn128_G2 result(result_coord);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fill_coord()

void libff::bn128_G2::fill_coord ( bn::Fp2  coord[3] ) const

inline

Definition at line 49 of file bn128_g2.hpp.

    {
        coord[0] = this->X;
        coord[1] = this->Y;
        coord[2] = this->Z;
    };

Here is the caller graph for this function:

is_in_safe_subgroup()

bool libff::bn128_G2::is_in_safe_subgroup

(

)

const

Definition at line 338 of file bn128_g2.cpp.

{
    return zero() == scalar_field::mod * (*this);
}

Here is the call graph for this function:

is_special()

bool libff::bn128_G2::is_special

(

)

const

Definition at line 121 of file bn128_g2.cpp.

{ return (this->is_zero() || this->Z == 1); }

Here is the call graph for this function:

Here is the caller graph for this function:

is_well_formed()

bool libff::bn128_G2::is_well_formed

(

)

const

Definition at line 311 of file bn128_g2.cpp.

{
    if (this->is_zero()) {
        return true;
    } else {
        // y^2 = x^3 + b
        //
        // We are using Jacobian coordinates, so equation we need to check is
        // actually
        //
        // (y/z^3)^2 = (x/z^2)^3 + b
        // y^2 / z^6 = x^3 / z^6 + b
        // y^2 = x^3 + b z^6
        bn::Fp2 X2, Y2, Z2;
        bn::Fp2::square(X2, this->X);
        bn::Fp2::square(Y2, this->Y);
        bn::Fp2::square(Z2, this->Z);
 
        bn::Fp2 X3, Z3, Z6;
        bn::Fp2::mul(X3, X2, this->X);
        bn::Fp2::mul(Z3, Z2, this->Z);
        bn::Fp2::square(Z6, Z3);
 
        return (Y2 == X3 + bn128_twist_coeff_b * Z6);
    }
}

Here is the call graph for this function:

is_zero()

bool libff::bn128_G2::is_zero

(

)

const

Definition at line 123 of file bn128_g2.cpp.

{ return Z.isZero(); }

Here is the caller graph for this function:

mixed_add()

bn128_G2 libff::bn128_G2::mixed_add

(

const bn128_G2 &

other

)

const

Definition at line 210 of file bn128_g2.cpp.

{
    if (this->is_zero()) {
        return other;
    }
 
    if (other.is_zero()) {
        return *this;
    }
 
    // no need to handle points of order 2,4
    // (they cannot exist in a prime-order subgroup)
 
#ifdef DEBUG
    assert(other.is_special());
#endif
 
    // check for doubling case
 
    // using Jacobian coordinates so:
    //   (X1:Y1:Z1) = (X2:Y2:Z2)
    //   iff
    //   X1/Z1^2 == X2/Z2^2 and Y1/Z1^3 == Y2/Z2^3
    //   iff
    //   X1 * Z2^2 == X2 * Z1^2 and Y1 * Z2^3 == Y2 * Z1^3
 
    // we know that Z2 = 1
 
    bn::Fp2 Z1Z1;
    bn::Fp2::square(Z1Z1, this->Z);
    const bn::Fp2 &U1 = this->X;
    bn::Fp2 U2;
    bn::Fp2::mul(U2, other.X, Z1Z1);
    bn::Fp2 Z1_cubed;
    bn::Fp2::mul(Z1_cubed, this->Z, Z1Z1);
 
    const bn::Fp2 &S1 = this->Y;
    bn::Fp2 S2;
    // S2 = Y2*Z1*Z1Z1
    bn::Fp2::mul(S2, other.Y, Z1_cubed);
 
    if (U1 == U2 && S1 == S2) {
        // dbl case; nothing of above can be reused
        return this->dbl();
    }
 
#ifdef PROFILE_OP_COUNTS
    this->add_cnt++;
#endif
 
    bn128_G2 result;
    bn::Fp2 H, HH, I, J, r, V, tmp;
    // H = U2-X1
    bn::Fp2::sub(H, U2, this->X);
    // HH = H^2
    bn::Fp2::square(HH, H);
    // I = 4*HH
    bn::Fp2::add(tmp, HH, HH);
    bn::Fp2::add(I, tmp, tmp);
    // J = H*I
    bn::Fp2::mul(J, H, I);
    // r = 2*(S2-Y1)
    bn::Fp2::sub(tmp, S2, this->Y);
    bn::Fp2::add(r, tmp, tmp);
    // V = X1*I
    bn::Fp2::mul(V, this->X, I);
    // X3 = r^2-J-2*V
    bn::Fp2::square(result.X, r);
    bn::Fp2::sub(result.X, result.X, J);
    bn::Fp2::sub(result.X, result.X, V);
    bn::Fp2::sub(result.X, result.X, V);
    // Y3 = r*(V-X3)-2*Y1*J
    bn::Fp2::sub(tmp, V, result.X);
    bn::Fp2::mul(result.Y, r, tmp);
    bn::Fp2::mul(tmp, this->Y, J);
    bn::Fp2::sub(result.Y, result.Y, tmp);
    bn::Fp2::sub(result.Y, result.Y, tmp);
    // Z3 = (Z1+H)^2-Z1Z1-HH
    bn::Fp2::add(tmp, this->Z, H);
    bn::Fp2::square(result.Z, tmp);
    bn::Fp2::sub(result.Z, result.Z, Z1Z1);
    bn::Fp2::sub(result.Z, result.Z, HH);
    return result;
}

Here is the call graph for this function:

mul_by_cofactor()

bn128_G2 libff::bn128_G2::mul_by_cofactor

(

)

const

Definition at line 309 of file bn128_g2.cpp.

{ return bn128_G2::h * (*this); }

one()

const bn128_G2 & libff::bn128_G2::one ( )

static

Definition at line 345 of file bn128_g2.cpp.

{ return G2_one; }

Here is the caller graph for this function:

operator!=()

bool libff::bn128_G2::operator!=

(

const bn128_G2 &

other

)

const

Definition at line 156 of file bn128_g2.cpp.

{
    return !(operator==(other));
}

Here is the call graph for this function:

operator+()

bn128_G2 libff::bn128_G2::operator+

(

const bn128_G2 &

other

)

const

Definition at line 161 of file bn128_g2.cpp.

{
    // handle special cases having to do with O
    if (this->is_zero()) {
        return other;
    }
 
    if (other.is_zero()) {
        return *this;
    }
 
    // no need to handle points of order 2,4
    // (they cannot exist in a prime-order subgroup)
 
    // handle double case, and then all the rest
    if (this->operator==(other)) {
        return this->dbl();
    } else {
        return this->add(other);
    }
}

Here is the call graph for this function:

operator-() [1/2]

bn128_G2 libff::bn128_G2::operator-

(

)

const

Definition at line 183 of file bn128_g2.cpp.

{
    bn128_G2 result(*this);
    bn::Fp2::neg(result.Y, result.Y);
    return result;
}

operator-() [2/2]

bn128_G2 libff::bn128_G2::operator-

(

const bn128_G2 &

other

)

const

Definition at line 190 of file bn128_g2.cpp.

{
    return (*this) + (-other);
}

operator==()

bool libff::bn128_G2::operator==

(

const bn128_G2 &

other

)

const

Definition at line 125 of file bn128_g2.cpp.

{
    if (this->is_zero()) {
        return other.is_zero();
    }
 
    if (other.is_zero()) {
        return false;
    }
 
    // now neither is O
 
    bn::Fp2 Z1sq, Z2sq, lhs, rhs;
    bn::Fp2::square(Z1sq, this->Z);
    bn::Fp2::square(Z2sq, other.Z);
    bn::Fp2::mul(lhs, Z2sq, this->X);
    bn::Fp2::mul(rhs, Z1sq, other.X);
 
    if (lhs != rhs) {
        return false;
    }
 
    bn::Fp2 Z1cubed, Z2cubed;
    bn::Fp2::mul(Z1cubed, Z1sq, this->Z);
    bn::Fp2::mul(Z2cubed, Z2sq, other.Z);
    bn::Fp2::mul(lhs, Z2cubed, this->Y);
    bn::Fp2::mul(rhs, Z1cubed, other.Y);
 
    return (lhs == rhs);
}

Here is the call graph for this function:

Here is the caller graph for this function:

order()

static bigint<scalar_field::num_limbs> libff::bn128_G2::order ( )

inlinestatic

Definition at line 92 of file bn128_g2.hpp.

    {
        return scalar_field::field_char();
    }

Here is the call graph for this function:

print()

void libff::bn128_G2::print

(

)

const

Definition at line 79 of file bn128_g2.cpp.

{
    if (this->is_zero()) {
        printf("O\n");
    } else {
        bn128_G2 copy(*this);
        copy.to_affine_coordinates();
        std::cout << "(" << copy.X.toString(10) << " : " << copy.Y.toString(10)
                  << " : " << copy.Z.toString(10) << ")\n";
    }
}

Here is the call graph for this function:

print_coordinates()

void libff::bn128_G2::print_coordinates

(

)

const

Definition at line 91 of file bn128_g2.cpp.

{
    if (this->is_zero()) {
        printf("O\n");
    } else {
        std::cout << "(" << X.toString(10) << " : " << Y.toString(10) << " : "
                  << Z.toString(10) << ")\n";
    }
}

Here is the call graph for this function:

random_element()

bn128_G2 libff::bn128_G2::random_element ( )

static

Definition at line 347 of file bn128_g2.cpp.

{
    return bn128_Fr::random_element().as_bigint() * G2_one;
}

Here is the call graph for this function:

read_compressed()

void libff::bn128_G2::read_compressed ( std::istream &  in, bn128_G2 &  g  )

static

Definition at line 419 of file bn128_g2.cpp.

{
    char is_zero;
    // this reads is_zero;
    in.read((char *)&is_zero, 1);
    is_zero -= '0';
    consume_OUTPUT_SEPARATOR(in);
 
    bn::Fp2 tX;
#ifndef BINARY_OUTPUT
    in >> tX.a_;
    consume_OUTPUT_SEPARATOR(in);
    in >> tX.b_;
#else
    in.read((char *)&tX.a_, sizeof(tX.a_));
    in.read((char *)&tX.b_, sizeof(tX.b_));
#endif
    consume_OUTPUT_SEPARATOR(in);
    unsigned char Y_lsb;
    in.read((char *)&Y_lsb, 1);
    Y_lsb -= '0';
 
    // y = +/- sqrt(x^3 + b)
    if (!is_zero) {
        g.X = tX;
        bn::Fp2 tX2, tY2;
        bn::Fp2::square(tX2, tX);
        bn::Fp2::mul(tY2, tX2, tX);
        bn::Fp2::add(tY2, tY2, bn128_twist_coeff_b);
 
        g.Y = bn128_G2::sqrt(tY2);
        if ((((unsigned char *)&g.Y.a_)[0] & 1) != Y_lsb) {
            bn::Fp2::neg(g.Y, g.Y);
        }
    }
 
    // finalize
    if (!is_zero) {
        g.Z = bn::Fp2(bn::Fp(1), bn::Fp(0));
    } else {
        g = bn128_G2::zero();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_uncompressed()

void libff::bn128_G2::read_uncompressed ( std::istream &  in, bn128_G2 &  g  )

static

Definition at line 388 of file bn128_g2.cpp.

{
    char is_zero;
    // this reads is_zero;
    in.read((char *)&is_zero, 1);
    is_zero -= '0';
    consume_OUTPUT_SEPARATOR(in);
 
#ifndef BINARY_OUTPUT
    in >> g.X.a_;
    consume_OUTPUT_SEPARATOR(in);
    in >> g.X.b_;
    consume_OUTPUT_SEPARATOR(in);
    in >> g.Y.a_;
    consume_OUTPUT_SEPARATOR(in);
    in >> g.Y.b_;
#else
    in.read((char *)&g.X.a_, sizeof(g.X.a_));
    in.read((char *)&g.X.b_, sizeof(g.X.b_));
    in.read((char *)&g.Y.a_, sizeof(g.Y.a_));
    in.read((char *)&g.Y.b_, sizeof(g.Y.b_));
#endif
 
    // finalize
    if (!is_zero) {
        g.Z = bn::Fp2(bn::Fp(1), bn::Fp(0));
    } else {
        g = bn128_G2::zero();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_in_bits()

static size_t libff::bn128_G2::size_in_bits ( )

inlinestatic

Definition at line 87 of file bn128_g2.hpp.

{ return 2 * base_field::size_in_bits() + 1; }

Here is the call graph for this function:

to_affine_coordinates()

void libff::bn128_G2::to_affine_coordinates

(

)

Definition at line 101 of file bn128_g2.cpp.

{
    if (this->is_zero()) {
        X = 0;
        Y = 1;
        Z = 0;
    } else {
        bn::Fp2 r;
        r = Z;
        r.inverse();
        bn::Fp2::square(Z, r);
        X *= Z;
        r *= Z;
        Y *= r;
        Z = 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_special()

void libff::bn128_G2::to_special

(

)

Definition at line 119 of file bn128_g2.cpp.

{ this->to_affine_coordinates(); }

Here is the call graph for this function:

write_compressed()

void libff::bn128_G2::write_compressed

(

std::ostream &

out

)

const

Definition at line 371 of file bn128_g2.cpp.

{
    bn128_G2 gcopy(*this);
    gcopy.to_affine_coordinates();
 
    out << (gcopy.is_zero() ? '1' : '0') << OUTPUT_SEPARATOR;
 
#ifndef BINARY_OUTPUT
    out << gcopy.X.a_ << OUTPUT_SEPARATOR << gcopy.X.b_;
#else
    out.write((char *)&gcopy.X.a_, sizeof(gcopy.X.a_));
    out.write((char *)&gcopy.X.b_, sizeof(gcopy.X.b_));
#endif
    out << OUTPUT_SEPARATOR
        << (((unsigned char *)&gcopy.Y.a_)[0] & 1 ? '1' : '0');
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_uncompressed()

void libff::bn128_G2::write_uncompressed

(

std::ostream &

out

)

const

Definition at line 352 of file bn128_g2.cpp.

{
    bn128_G2 gcopy(*this);
    gcopy.to_affine_coordinates();
 
    out << (gcopy.is_zero() ? '1' : '0') << OUTPUT_SEPARATOR;
 
    /* no point compression case */
#ifndef BINARY_OUTPUT
    out << gcopy.X.a_ << OUTPUT_SEPARATOR << gcopy.X.b_ << OUTPUT_SEPARATOR;
    out << gcopy.Y.a_ << OUTPUT_SEPARATOR << gcopy.Y.b_;
#else
    out.write((char *)&gcopy.X.a_, sizeof(gcopy.X.a_));
    out.write((char *)&gcopy.X.b_, sizeof(gcopy.X.b_));
    out.write((char *)&gcopy.Y.a_, sizeof(gcopy.Y.a_));
    out.write((char *)&gcopy.Y.b_, sizeof(gcopy.Y.b_));
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

zero()

const bn128_G2 & libff::bn128_G2::zero ( )

static

Definition at line 343 of file bn128_g2.cpp.

{ return G2_zero; }

Here is the caller graph for this function:

Member Data Documentation

fixed_base_exp_window_table

std::vector< size_t > libff::bn128_G2::fixed_base_exp_window_table

static

Definition at line 35 of file bn128_g2.hpp.

G2_one

bn128_G2 libff::bn128_G2::G2_one

static

Definition at line 37 of file bn128_g2.hpp.

G2_zero

bn128_G2 libff::bn128_G2::G2_zero

static

Definition at line 36 of file bn128_g2.hpp.

h

bigint< bn128_G2::h_limbs > libff::bn128_G2::h

static

Definition at line 46 of file bn128_g2.hpp.

h_bitcount

const mp_size_t libff::bn128_G2::h_bitcount = 256

static

Definition at line 43 of file bn128_g2.hpp.

h_limbs

const mp_size_t libff::bn128_G2::h_limbs

static

Initial value:

=
        (h_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 44 of file bn128_g2.hpp.

wnaf_window_table

std::vector< size_t > libff::bn128_G2::wnaf_window_table

static

Definition at line 34 of file bn128_g2.hpp.

X

bn::Fp2 libff::bn128_G2::X

Definition at line 48 of file bn128_g2.hpp.

Y

bn::Fp2 libff::bn128_G2::Y

Definition at line 48 of file bn128_g2.hpp.

Z

bn::Fp2 libff::bn128_G2::Z

Definition at line 48 of file bn128_g2.hpp.

---

The documentation for this class was generated from the following files:

• /home/runner/work/libff/libff/libff/algebra/curves/bn128/bn128_g2.hpp
• /home/runner/work/libff/libff/libff/algebra/curves/bn128/bn128_g2.cpp