libff::alt_bn128_G1 Class Reference

#include <alt_bn128_g1.hpp>

Collaboration diagram for libff::alt_bn128_G1:

Public Types
typedef alt_bn128_Fq	base_field
typedef alt_bn128_Fr	scalar_field

Public Member Functions
	alt_bn128_G1 ()
	alt_bn128_G1 (const alt_bn128_Fq &X, const alt_bn128_Fq &Y, const alt_bn128_Fq &Z)
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 alt_bn128_G1 &other) const
bool	operator!= (const alt_bn128_G1 &other) const
alt_bn128_G1	operator+ (const alt_bn128_G1 &other) const
alt_bn128_G1	operator- () const
alt_bn128_G1	operator- (const alt_bn128_G1 &other) const
alt_bn128_G1	add (const alt_bn128_G1 &other) const
alt_bn128_G1	mixed_add (const alt_bn128_G1 &other) const
alt_bn128_G1	dbl () const
alt_bn128_G1	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 alt_bn128_G1 &	zero ()
static const alt_bn128_G1 &	one ()
static alt_bn128_G1	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 &, alt_bn128_G1 &)
static void	read_compressed (std::istream &, alt_bn128_G1 &)
static void	batch_to_special_all_non_zeros (std::vector< alt_bn128_G1 > &vec)

Public Attributes
alt_bn128_Fq	X
alt_bn128_Fq	Y
alt_bn128_Fq	Z

Static Public Attributes
static std::vector< size_t >	wnaf_window_table
static std::vector< size_t >	fixed_base_exp_window_table
static alt_bn128_G1	G1_zero
static alt_bn128_G1	G1_one
static alt_bn128_Fq	coeff_a
static alt_bn128_Fq	coeff_b
static const mp_size_t	h_bitcount = 1
static const mp_size_t	h_limbs
static bigint< h_limbs >	h

Detailed Description

Definition at line 21 of file alt_bn128_g1.hpp.

Member Typedef Documentation

base_field

typedef alt_bn128_Fq libff::alt_bn128_G1::base_field

Definition at line 35 of file alt_bn128_g1.hpp.

scalar_field

typedef alt_bn128_Fr libff::alt_bn128_G1::scalar_field

Definition at line 36 of file alt_bn128_g1.hpp.

Constructor & Destructor Documentation

alt_bn128_G1() [1/2]

libff::alt_bn128_G1::alt_bn128_G1

(

)

Definition at line 29 of file alt_bn128_g1.cpp.

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

Here is the caller graph for this function:

alt_bn128_G1() [2/2]

libff::alt_bn128_G1::alt_bn128_G1 ( const alt_bn128_Fq &  X, const alt_bn128_Fq &  Y, const alt_bn128_Fq &  Z  )

inline

Definition at line 48 of file alt_bn128_g1.hpp.

        : X(X), Y(Y), Z(Z){};

Member Function Documentation

add()

alt_bn128_G1 libff::alt_bn128_G1::add

(

const alt_bn128_G1 &

other

)

const

Definition at line 149 of file alt_bn128_g1.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
    if (this->operator==(other)) {
        return this->dbl();
    }
 
#ifdef PROFILE_OP_COUNTS
    this->add_cnt++;
#endif
    // NOTE: does not handle O and pts of order 2,4
    // http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-add-2007-bl
 
    // Z1Z1 = Z1^2
    const alt_bn128_Fq Z1Z1 = (this->Z).squared();
    // Z2Z2 = Z2^2
    const alt_bn128_Fq Z2Z2 = (other.Z).squared();
    // U1 = X1 * Z2Z2
    const alt_bn128_Fq U1 = (this->X) * Z2Z2;
    // U2 = X2 * Z1Z1
    const alt_bn128_Fq U2 = (other.X) * Z1Z1;
    // S1 = Y1 * Z2 * Z2Z2
    const alt_bn128_Fq S1 = (this->Y) * (other.Z) * Z2Z2;
    // S2 = Y2 * Z1 * Z1Z1
    const alt_bn128_Fq S2 = (other.Y) * (this->Z) * Z1Z1;
    // H = U2-U1
    const alt_bn128_Fq H = U2 - U1;
    const alt_bn128_Fq S2_minus_S1 = S2 - S1;
    // I = (2 * H)^2
    const alt_bn128_Fq I = (H + H).squared();
    // J = H * I
    const alt_bn128_Fq J = H * I;
    // r = 2 * (S2-S1)
    const alt_bn128_Fq r = S2_minus_S1 + S2_minus_S1;
    // V = U1 * I
    const alt_bn128_Fq V = U1 * I;
    // X3 = r^2 - J - 2 * V
    const alt_bn128_Fq X3 = r.squared() - J - (V + V);
    const alt_bn128_Fq S1_J = S1 * J;
    // Y3 = r * (V-X3)-2 S1 J
    const alt_bn128_Fq Y3 = r * (V - X3) - (S1_J + S1_J);
    // Z3 = ((Z1+Z2)^2-Z1Z1-Z2Z2) * H
    const alt_bn128_Fq Z3 = ((this->Z + other.Z).squared() - Z1Z1 - Z2Z2) * H;
 
    return alt_bn128_G1(X3, Y3, Z3);
}

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::alt_bn128_G1::base_field_char ( )

inlinestatic

Definition at line 81 of file alt_bn128_g1.hpp.

    {
        return base_field::field_char();
    }

Here is the call graph for this function:

batch_to_special_all_non_zeros()

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

static

Definition at line 456 of file alt_bn128_g1.cpp.

{
    std::vector<alt_bn128_Fq> Z_vec;
    Z_vec.reserve(vec.size());
 
    for (auto &el : vec) {
        Z_vec.emplace_back(el.Z);
    }
    batch_invert<alt_bn128_Fq>(Z_vec);
 
    const alt_bn128_Fq one = alt_bn128_Fq::one();
 
    for (size_t i = 0; i < vec.size(); ++i) {
        const alt_bn128_Fq Z2 = Z_vec[i].squared();
        const alt_bn128_Fq Z3 = Z_vec[i] * Z2;
 
        vec[i].X = vec[i].X * Z2;
        vec[i].Y = vec[i].Y * Z3;
        vec[i].Z = one;
    }
}

Here is the call graph for this function:

dbl()

alt_bn128_G1 libff::alt_bn128_G1::dbl

(

)

const

Definition at line 285 of file alt_bn128_g1.cpp.

{
#ifdef PROFILE_OP_COUNTS
    this->dbl_cnt++;
#endif
    // handle point at infinity
    if (this->is_zero()) {
        return (*this);
    }
 
    // no need to handle points of order 2,4
    // (they cannot exist in a prime-order subgroup)
 
    // NOTE: does not handle O and pts of order 2,4
    // http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#doubling-dbl-2009-l
 
    // A = X1^2
    const alt_bn128_Fq A = (this->X).squared();
    // B = Y1^2
    const alt_bn128_Fq B = (this->Y).squared();
    // C = B^2
    const alt_bn128_Fq C = B.squared();
    alt_bn128_Fq D = (this->X + B).squared() - A - C;
    // D = 2 * ((X1 + B)^2 - A - C)
    D = D + D;
    // E = 3 * A
    const alt_bn128_Fq E = A + A + A;
    // F = E^2
    const alt_bn128_Fq F = E.squared();
    // X3 = F - 2 D
    const alt_bn128_Fq X3 = F - (D + D);
    alt_bn128_Fq eightC = C + C;
    eightC = eightC + eightC;
    eightC = eightC + eightC;
    // Y3 = E * (D - X3) - 8 * C
    const alt_bn128_Fq Y3 = E * (D - X3) - eightC;
    const alt_bn128_Fq Y1Z1 = (this->Y) * (this->Z);
    // Z3 = 2 * Y1 * Z1
    const alt_bn128_Fq Z3 = Y1Z1 + Y1Z1;
 
    return alt_bn128_G1(X3, Y3, Z3);
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_in_safe_subgroup()

bool libff::alt_bn128_G1::is_in_safe_subgroup

(

)

const

Definition at line 359 of file alt_bn128_g1.cpp.

{
    // G1 is the entire group E(Fq), and so there is nothing to check here.
    return true;
}

is_special()

bool libff::alt_bn128_G1::is_special

(

)

const

Definition at line 86 of file alt_bn128_g1.cpp.

{
    return (this->is_zero() || this->Z == alt_bn128_Fq::one());
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_well_formed()

bool libff::alt_bn128_G1::is_well_formed

(

)

const

Definition at line 334 of file alt_bn128_g1.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
        const alt_bn128_Fq X2 = this->X.squared();
        const alt_bn128_Fq Y2 = this->Y.squared();
        const alt_bn128_Fq Z2 = this->Z.squared();
 
        const alt_bn128_Fq X3 = this->X * X2;
        const alt_bn128_Fq Z3 = this->Z * Z2;
        const alt_bn128_Fq Z6 = Z3.squared();
 
        return (Y2 == X3 + alt_bn128_coeff_b * Z6);
    }
}

Here is the call graph for this function:

is_zero()

bool libff::alt_bn128_G1::is_zero

(

)

const

Definition at line 91 of file alt_bn128_g1.cpp.

{ return (this->Z.is_zero()); }

Here is the call graph for this function:

Here is the caller graph for this function:

mixed_add()

alt_bn128_G1 libff::alt_bn128_G1::mixed_add

(

const alt_bn128_G1 &

other

)

const

Definition at line 208 of file alt_bn128_g1.cpp.

{
#ifdef DEBUG
    assert(other.is_special());
#endif
 
    // 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)
 
    // 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
 
    const alt_bn128_Fq Z1Z1 = (this->Z).squared();
 
    const alt_bn128_Fq &U1 = this->X;
    const alt_bn128_Fq U2 = other.X * Z1Z1;
 
    const alt_bn128_Fq Z1_cubed = (this->Z) * Z1Z1;
 
    // S1 = Y1 * Z2 * Z2Z2
    const alt_bn128_Fq &S1 = (this->Y);
    // S2 = Y2 * Z1 * Z1Z1
    const alt_bn128_Fq 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
 
    // NOTE: does not handle O and pts of order 2,4
    // http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-madd-2007-bl
    // H = U2-X1
    const alt_bn128_Fq H = U2 - (this->X);
    // HH = H&2
    const alt_bn128_Fq HH = H.squared();
    // I = 4*HH
    alt_bn128_Fq I = HH + HH;
    I = I + I;
    // J = H*I
    const alt_bn128_Fq J = H * I;
    // r = 2*(S2-Y1)
    alt_bn128_Fq r = S2 - (this->Y);
    r = r + r;
    // V = X1*I
    const alt_bn128_Fq V = (this->X) * I;
    // X3 = r^2-J-2*V
    const alt_bn128_Fq X3 = r.squared() - J - V - V;
    // Y3 = r*(V-X3)-2*Y1*J
    alt_bn128_Fq Y3 = (this->Y) * J;
    Y3 = r * (V - X3) - Y3 - Y3;
    // Z3 = (Z1+H)^2-Z1Z1-HH
    const alt_bn128_Fq Z3 = ((this->Z) + H).squared() - Z1Z1 - HH;
 
    return alt_bn128_G1(X3, Y3, Z3);
}

Here is the call graph for this function:

mul_by_cofactor()

alt_bn128_G1 libff::alt_bn128_G1::mul_by_cofactor

(

)

const

Definition at line 328 of file alt_bn128_g1.cpp.

{
    // Cofactor = 1
    return *this;
}

one()

const alt_bn128_G1 & libff::alt_bn128_G1::one ( )

static

Definition at line 367 of file alt_bn128_g1.cpp.

{ return G1_one; }

Here is the caller graph for this function:

operator!=()

bool libff::alt_bn128_G1::operator!=

(

const alt_bn128_G1 &

other

)

const

Definition at line 129 of file alt_bn128_g1.cpp.

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

Here is the call graph for this function:

operator+()

alt_bn128_G1 libff::alt_bn128_G1::operator+

(

const alt_bn128_G1 &

other

)

const

Definition at line 134 of file alt_bn128_g1.cpp.

{
    return add(other);
}

Here is the call graph for this function:

operator-() [1/2]

alt_bn128_G1 libff::alt_bn128_G1::operator-

(

)

const

Definition at line 139 of file alt_bn128_g1.cpp.

{
    return alt_bn128_G1(this->X, -(this->Y), this->Z);
}

Here is the call graph for this function:

operator-() [2/2]

alt_bn128_G1 libff::alt_bn128_G1::operator-

(

const alt_bn128_G1 &

other

)

const

Definition at line 144 of file alt_bn128_g1.cpp.

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

operator==()

bool libff::alt_bn128_G1::operator==

(

const alt_bn128_G1 &

other

)

const

Definition at line 93 of file alt_bn128_g1.cpp.

{
    if (this->is_zero()) {
        return other.is_zero();
    }
 
    if (other.is_zero()) {
        return false;
    }
 
    // now neither is O
 
    // 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
 
    const alt_bn128_Fq Z1_squared = (this->Z).squared();
    const alt_bn128_Fq Z2_squared = (other.Z).squared();
 
    if ((this->X * Z2_squared) != (other.X * Z1_squared)) {
        return false;
    }
 
    const alt_bn128_Fq Z1_cubed = (this->Z) * Z1_squared;
    const alt_bn128_Fq Z2_cubed = (other.Z) * Z2_squared;
 
    if ((this->Y * Z2_cubed) != (other.Y * Z1_cubed)) {
        return false;
    }
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

order()

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

inlinestatic

Definition at line 85 of file alt_bn128_g1.hpp.

    {
        return scalar_field::field_char();
    }

Here is the call graph for this function:

print()

void libff::alt_bn128_G1::print

(

)

const

Definition at line 36 of file alt_bn128_g1.cpp.

{
    if (this->is_zero()) {
        printf("O\n");
    } else {
        alt_bn128_G1 copy(*this);
        copy.to_affine_coordinates();
        gmp_printf(
            "(%Nd , %Nd)\n",
            copy.X.as_bigint().data,
            alt_bn128_Fq::num_limbs,
            copy.Y.as_bigint().data,
            alt_bn128_Fq::num_limbs);
    }
}

Here is the call graph for this function:

print_coordinates()

void libff::alt_bn128_G1::print_coordinates

(

)

const

Definition at line 52 of file alt_bn128_g1.cpp.

{
    if (this->is_zero()) {
        printf("O\n");
    } else {
        gmp_printf(
            "(%Nd : %Nd : %Nd)\n",
            this->X.as_bigint().data,
            alt_bn128_Fq::num_limbs,
            this->Y.as_bigint().data,
            alt_bn128_Fq::num_limbs,
            this->Z.as_bigint().data,
            alt_bn128_Fq::num_limbs);
    }
}

Here is the call graph for this function:

random_element()

alt_bn128_G1 libff::alt_bn128_G1::random_element ( )

static

Definition at line 369 of file alt_bn128_g1.cpp.

{
    return (scalar_field::random_element().as_bigint()) * G1_one;
}

Here is the call graph for this function:

read_compressed()

void libff::alt_bn128_G1::read_compressed ( std::istream &  in, alt_bn128_G1 &  out  )

static

Definition at line 409 of file alt_bn128_g1.cpp.

{
    // <flags> | <x-coord>
    char flags_char;
    in.read(&flags_char, 1) >> out.X;
    ;
    consume_OUTPUT_SEPARATOR(in);
    const uint8_t flags = flags_char - '0';
 
    // y = +/- sqrt(x^3 + b)
    if (0 == (flags & G1_ZERO_FLAG)) {
        // flags >> 1
        const uint8_t Y_lsb = 0 != (flags & G1_Y_LSB_FLAG);
        const alt_bn128_Fq tX2 = out.X.squared();
        const alt_bn128_Fq tY2 = tX2 * out.X + alt_bn128_coeff_b;
        out.Y = tY2.sqrt();
 
        if ((uint8_t)(out.Y.as_bigint().data[0] & 1) != Y_lsb) {
            out.Y = -out.Y;
        }
 
        out.Z = alt_bn128_Fq::one();
    } else {
        out = alt_bn128_G1::zero();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_uncompressed()

void libff::alt_bn128_G1::read_uncompressed ( std::istream &  in, alt_bn128_G1 &  out  )

static

Definition at line 395 of file alt_bn128_g1.cpp.

{
    // <is_zero> | <x-coord> | <y-coord>
    char is_zero_char;
    in.read(&is_zero_char, 1) >> out.X >> out.Y;
    const uint8_t is_zero = (is_zero_char - '0') & G1_ZERO_FLAG;
 
    if (!is_zero) {
        out.Z = alt_bn128_Fq::one();
    } else {
        out = alt_bn128_G1::zero();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_in_bits()

static size_t libff::alt_bn128_G1::size_in_bits ( )

inlinestatic

Definition at line 80 of file alt_bn128_g1.hpp.

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

Here is the call graph for this function:

to_affine_coordinates()

void libff::alt_bn128_G1::to_affine_coordinates

(

)

Definition at line 68 of file alt_bn128_g1.cpp.

{
    if (this->is_zero()) {
        this->X = alt_bn128_Fq::zero();
        this->Y = alt_bn128_Fq::one();
        this->Z = alt_bn128_Fq::zero();
    } else {
        const alt_bn128_Fq Z_inv = Z.inverse();
        const alt_bn128_Fq Z2_inv = Z_inv.squared();
        const alt_bn128_Fq Z3_inv = Z2_inv * Z_inv;
        this->X = this->X * Z2_inv;
        this->Y = this->Y * Z3_inv;
        this->Z = alt_bn128_Fq::one();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_special()

void libff::alt_bn128_G1::to_special

(

)

Definition at line 84 of file alt_bn128_g1.cpp.

{ this->to_affine_coordinates(); }

Here is the call graph for this function:

write_compressed()

void libff::alt_bn128_G1::write_compressed

(

std::ostream &

out

)

const

Definition at line 383 of file alt_bn128_g1.cpp.

{
    // <flags> | <x-coord>
    alt_bn128_G1 copy((*this));
    copy.to_affine_coordinates();
    const uint8_t flags =
        (copy.is_zero() ? G1_ZERO_FLAG : 0) |
        ((copy.Y.as_bigint().data[0] & 1) ? G1_Y_LSB_FLAG : 0);
    const char flags_char = '0' + flags;
    out.write(&flags_char, 1) << copy.X;
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_uncompressed()

void libff::alt_bn128_G1::write_uncompressed

(

std::ostream &

out

)

const

Definition at line 374 of file alt_bn128_g1.cpp.

{
    // <is_zero> | <x-coord> | <y-coord>
    alt_bn128_G1 copy((*this));
    copy.to_affine_coordinates();
    const char is_zero = '0' + (copy.is_zero() ? G1_ZERO_FLAG : 0);
    out.write(&is_zero, 1) << copy.X << copy.Y;
}

Here is the call graph for this function:

Here is the caller graph for this function:

zero()

const alt_bn128_G1 & libff::alt_bn128_G1::zero ( )

static

Definition at line 365 of file alt_bn128_g1.cpp.

{ return G1_zero; }

Here is the caller graph for this function:

Member Data Documentation

coeff_a

alt_bn128_Fq libff::alt_bn128_G1::coeff_a

static

Definition at line 32 of file alt_bn128_g1.hpp.

coeff_b

alt_bn128_Fq libff::alt_bn128_G1::coeff_b

static

Definition at line 33 of file alt_bn128_g1.hpp.

fixed_base_exp_window_table

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

static

Definition at line 29 of file alt_bn128_g1.hpp.

G1_one

alt_bn128_G1 libff::alt_bn128_G1::G1_one

static

Definition at line 31 of file alt_bn128_g1.hpp.

G1_zero

alt_bn128_G1 libff::alt_bn128_G1::G1_zero

static

Definition at line 30 of file alt_bn128_g1.hpp.

h

bigint< alt_bn128_G1::h_limbs > libff::alt_bn128_G1::h

static

Definition at line 42 of file alt_bn128_g1.hpp.

h_bitcount

const mp_size_t libff::alt_bn128_G1::h_bitcount = 1

static

Definition at line 39 of file alt_bn128_g1.hpp.

h_limbs

const mp_size_t libff::alt_bn128_G1::h_limbs

static

Initial value:

=
        (h_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 40 of file alt_bn128_g1.hpp.

wnaf_window_table

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

static

Definition at line 28 of file alt_bn128_g1.hpp.

X

alt_bn128_Fq libff::alt_bn128_G1::X

Definition at line 44 of file alt_bn128_g1.hpp.

Y

alt_bn128_Fq libff::alt_bn128_G1::Y

Definition at line 44 of file alt_bn128_g1.hpp.

Z

alt_bn128_Fq libff::alt_bn128_G1::Z

Definition at line 44 of file alt_bn128_g1.hpp.

---

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

• /home/runner/work/libff/libff/libff/algebra/curves/alt_bn128/alt_bn128_g1.hpp
• /home/runner/work/libff/libff/libff/algebra/curves/alt_bn128/alt_bn128_g1.cpp