diff options
Diffstat (limited to 'theta_lib/isogenies_dim2')
| -rw-r--r-- | theta_lib/isogenies_dim2/gluing_isogeny_dim2.py | 292 | ||||
| -rw-r--r-- | theta_lib/isogenies_dim2/isogeny_chain_dim2.py | 178 | ||||
| -rw-r--r-- | theta_lib/isogenies_dim2/isogeny_dim2.py | 229 |
3 files changed, 699 insertions, 0 deletions
diff --git a/theta_lib/isogenies_dim2/gluing_isogeny_dim2.py b/theta_lib/isogenies_dim2/gluing_isogeny_dim2.py new file mode 100644 index 0000000..2dac387 --- /dev/null +++ b/theta_lib/isogenies_dim2/gluing_isogeny_dim2.py @@ -0,0 +1,292 @@ +""" +This code is based on a copy of: +https://github.com/ThetaIsogenies/two-isogenies + +MIT License + +Copyright (c) 2023 Pierrick Dartois, Luciano Maino, Giacomo Pope and Damien Robert + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +from sage.all import * +from ..theta_structures.Tuple_point import TuplePoint +from ..theta_structures.Theta_dim2 import ThetaStructureDim2, ThetaPointDim2 +from ..theta_structures.theta_helpers_dim2 import batch_inversion +from ..basis_change.base_change_dim2 import montgomery_to_theta_matrix_dim2, apply_base_change_theta_dim2 +from ..theta_structures.montgomery_theta import lift_kummer_montgomery_point + +class GluingThetaIsogenyDim2: + """ + Compute the gluing isogeny from E1 x E2 (Elliptic Product) -> A (Theta Model) + + Expected input: + + - (K1_8, K2_8) The 8-torsion above the kernel generating the isogeny + - M (Optional) a base change matrix, if this is not including, it can + be derived from [2](K1_8, K2_8) + """ + + def __init__(self, K1_8, K2_8, Theta12, N): + # Double points to get four-torsion, we always need one of these, used + # for the image computations but we'll need both if we wish to derived + # the base change matrix as well + K1_4 = 2*K1_8 + + # Initalise self + # This is the base change matrix for product Theta coordinates (not used, except in the dual) + self._base_change_matrix_theta = N + # Here, base change matrix directly applied to the Montgomery coordinates. null_point_bc is the + # theta null point obtained after applying the base change to the product Theta-structure. + self._base_change_matrix, null_point_bc = montgomery_to_theta_matrix_dim2(Theta12.zero().coords(),N, return_null_point = True) + self._domain_bc = ThetaStructureDim2(null_point_bc) + self.T_shift = K1_4 + self._precomputation = None + self._zero_idx = 0 + self._domain_product = Theta12 + self._domain=(K1_8[0].curve(), K1_8[1].curve()) + + # Map points from elliptic product onto the product theta structure + # using the base change matrix + T1_8 = self.base_change(K1_8) + T2_8 = self.base_change(K2_8) + + # Compute the codomain of the gluing isogeny + self._codomain = self._special_compute_codomain(T1_8, T2_8) + + def apply_base_change(self, coords): + """ + Apply the basis change by acting with matrix multiplication, treating + the coordinates as a vector + """ + N = self._base_change_matrix + x, y, z, t = coords + X = N[0, 0] * x + N[0, 1] * y + N[0, 2] * z + N[0, 3] * t + Y = N[1, 0] * x + N[1, 1] * y + N[1, 2] * z + N[1, 3] * t + Z = N[2, 0] * x + N[2, 1] * y + N[2, 2] * z + N[2, 3] * t + T = N[3, 0] * x + N[3, 1] * y + N[3, 2] * z + N[3, 3] * t + + return (X, Y, Z, T) + + def base_change(self, P): + """ + Compute the basis change on a TuplePoint to recover a ThetaPointDim2 of + compatible form + """ + if not isinstance(P, TuplePoint): + raise TypeError("Function assumes that the input is of type `TuplePoint`") + + # extract X,Z coordinates on pairs of points + P1, P2 = P.points() + X1, Z1 = P1[0], P1[2] + X2, Z2 = P2[0], P2[2] + + # Correct in the case of (0 : 0) + if X1 == 0 and Z1 == 0: + X1 = 1 + Z1 = 0 + if X2 == 0 and Z2 == 0: + X2 = 1 + Z2 = 0 + + # Apply the basis transformation on the product + coords = self.apply_base_change([X1 * X2, X1 * Z2, Z1 * X2, Z1 * Z2]) + return coords + + def _special_compute_codomain(self, T1, T2): + """ + Given twzero_matro isotropic points of 8-torsion T1 and T2, compatible with + the theta null point, compute the level two theta null point A/K_2 + """ + xAxByCyD = ThetaPointDim2.to_squared_theta(*T1) + zAtBzYtD = ThetaPointDim2.to_squared_theta(*T2) + + # Find the value of the non-zero index + zero_idx = next((i for i, x in enumerate(xAxByCyD) if x == 0), None) + self._zero_idx = zero_idx + + # Dumb check to make sure everything is OK + assert xAxByCyD[self._zero_idx] == zAtBzYtD[self._zero_idx] == 0 + + # Initialize lists + # The zero index described the permutation + ABCD = [0 for _ in range(4)] + precomp = [0 for _ in range(4)] + + # Compute non-trivial numerators (Others are either 1 or 0) + num_1 = zAtBzYtD[1 ^ self._zero_idx] + num_2 = xAxByCyD[2 ^ self._zero_idx] + num_3 = zAtBzYtD[3 ^ self._zero_idx] + num_4 = xAxByCyD[3 ^ self._zero_idx] + + # Compute and invert non-trivial denominators + den_1, den_2, den_3, den_4 = batch_inversion([num_1, num_2, num_3, num_4]) + + # Compute A, B, C, D + ABCD[0 ^ self._zero_idx] = 0 + ABCD[1 ^ self._zero_idx] = num_1 * den_3 + ABCD[2 ^ self._zero_idx] = num_2 * den_4 + ABCD[3 ^ self._zero_idx] = 1 + + # Compute precomputation for isogeny images + precomp[0 ^ self._zero_idx] = 0 + precomp[1 ^ self._zero_idx] = den_1 * num_3 + precomp[2 ^ self._zero_idx] = den_2 * num_4 + precomp[3 ^ self._zero_idx] = 1 + self._precomputation = precomp + + # Final Hadamard of the above coordinates + a, b, c, d = ThetaPointDim2.to_hadamard(*ABCD) + + return ThetaStructureDim2([a, b, c, d]) + + def special_image(self, P, translate): + """ + When the domain is a non product theta structure on a product of + elliptic curves, we will have one of A,B,C,D=0, so the image is more + difficult. We need to give the coordinates of P but also of + P+Ti, Ti one of the point of 4-torsion used in the isogeny + normalisation + """ + AxByCzDt = ThetaPointDim2.to_squared_theta(*P) + + # We are in the case where at most one of A, B, C, D is + # zero, so we need to account for this + # + # To recover values, we use the translated point to get + AyBxCtDz = ThetaPointDim2.to_squared_theta(*translate) + + # Directly compute y,z,t + y = AxByCzDt[1 ^ self._zero_idx] * self._precomputation[1 ^ self._zero_idx] + z = AxByCzDt[2 ^ self._zero_idx] * self._precomputation[2 ^ self._zero_idx] + t = AxByCzDt[3 ^ self._zero_idx] + + # We can compute x from the translation + # First we need a normalisation + if z != 0: + zb = AyBxCtDz[3 ^ self._zero_idx] + lam = z / zb + else: + tb = AyBxCtDz[2 ^ self._zero_idx] * self._precomputation[2 ^ self._zero_idx] + lam = t / tb + + # Finally we recover x + xb = AyBxCtDz[1 ^ self._zero_idx] * self._precomputation[1 ^ self._zero_idx] + x = xb * lam + + xyzt = [0 for _ in range(4)] + xyzt[0 ^ self._zero_idx] = x + xyzt[1 ^ self._zero_idx] = y + xyzt[2 ^ self._zero_idx] = z + xyzt[3 ^ self._zero_idx] = t + + image = ThetaPointDim2.to_hadamard(*xyzt) + return self._codomain(image) + + def __call__(self, P): + """ + Take into input the theta null point of A/K_2, and return the image + of the point by the isogeny + """ + if not isinstance(P, TuplePoint): + raise TypeError( + "Isogeny image for the gluing isogeny is defined to act on TuplePoints" + ) + + # Compute sum of points on elliptic curve + P_sum_T = P + self.T_shift + + # Push both the point and the translation through the + # completion + iso_P = self.base_change(P) + iso_P_sum_T = self.base_change(P_sum_T) + + return self.special_image(iso_P, iso_P_sum_T) + + def dual(self): + domain = self._codomain.hadamard() + codomain_bc = self._domain_bc.hadamard() + codomain = self._domain + + precomputation = batch_inversion(codomain_bc.null_point_dual()) + + N_split = self._base_change_matrix.inverse() + + return DualGluingThetaIsogenyDim2(domain, codomain_bc, codomain, N_split, precomputation) + + +class DualGluingThetaIsogenyDim2: + def __init__(self, domain, codomain_bc, codomain, N_split, precomputation): + self._domain = domain + self._codomain_bc = codomain_bc # Theta structure + self._codomain = codomain # Elliptic curves E1 and E2 + self._precomputation = precomputation + self._splitting_matrix = N_split + + def __call__(self,P): + # Returns a TuplePoint. + if not isinstance(P, ThetaPointDim2): + raise TypeError("Isogeny evaluation expects a ThetaPointDim2 as input") + + xx, yy, zz, tt = P.squared_theta() + + Ai, Bi, Ci, Di = self._precomputation + + xx = xx * Ai + yy = yy * Bi + zz = zz * Ci + tt = tt * Di + + image_coords = (xx, yy, zz, tt) + + X1X2, X1Z2, Z1X2, Z1Z2 = apply_base_change_theta_dim2(self._splitting_matrix, image_coords) + + E1, E2 = self._codomain + + if Z1Z2!=0: + #Z1=1, Z2=Z1Z2 + + Z2_inv=1/Z1Z2 + X2=Z1X2*Z2_inv# Normalize (X2:Z2)=(X2/Z2:1) + + X1=X1Z2*Z2_inv + + assert X1*Z1X2==X1X2 + P1 = lift_kummer_montgomery_point(E1, X1) + P2 = lift_kummer_montgomery_point(E2, X2) + return TuplePoint(P1,P2) + elif Z1X2==0 and X1Z2!=0: + # Case (X1:Z1)=0, X1!=0 and (X2:Z2)!=0 + + X2=X1X2/X1Z2 + P2 = lift_kummer_montgomery_point(E2, X2) + return TuplePoint(E1(0),P2) + elif Z1X2!=0 and X1Z2==0: + # Case (X1:Z1)!=0 and (X2:Z2)=0, X2!=0 + + X1=X1X2/Z1X2 + P1 = lift_kummer_montgomery_point(E1, X1) + return TuplePoint(P1,E2(0)) + else: + return TuplePoint(E1(0),E2(0)) + + + + + diff --git a/theta_lib/isogenies_dim2/isogeny_chain_dim2.py b/theta_lib/isogenies_dim2/isogeny_chain_dim2.py new file mode 100644 index 0000000..23adb23 --- /dev/null +++ b/theta_lib/isogenies_dim2/isogeny_chain_dim2.py @@ -0,0 +1,178 @@ +""" +This code is based on a copy of: +https://github.com/ThetaIsogenies/two-isogenies + +MIT License + +Copyright (c) 2023 Pierrick Dartois, Luciano Maino, Giacomo Pope and Damien Robert + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +from sage.all import * +from ..theta_structures.Tuple_point import TuplePoint +from ..theta_structures.Theta_dim2 import ThetaPointDim2 +from .gluing_isogeny_dim2 import GluingThetaIsogenyDim2 +from .isogeny_dim2 import ThetaIsogenyDim2 +from ..utilities.strategy import optimised_strategy + + +class IsogenyChainDim2: + r""" + Given (P1, P2), (Q1, Q2) in (E1 x E2)[2^(n+2)] as the generators of a kernel + of a (2^n, 2^n)-isogeny + + ker(Phi) = <(P1, P2), (Q1, Q2)> + + Input: + + - kernel = TuplePoint(P1, P2), TuplePoint(Q1, Q2): + where points are on the elliptic curves E1, E2 of order 2^(n+2) + - n: the length of the chain + - strategy: the optimises strategy to compute a walk through the graph of + images and doublings with a quasli-linear number of steps + """ + + def __init__(self, kernel, Theta12, M, n, strategy=None): + self.n = n + self.E1, self.E2 = kernel[0].parent_curves() + assert kernel[1].parent_curves() == [self.E1, self.E2] + + self._domain = (self.E1, self.E2) + + if strategy is None: + strategy = self.get_strategy() + self.strategy = strategy + + self._phis = self.isogeny_chain(kernel, Theta12, M) + + self._codomain=self._phis[-1]._codomain + + def get_strategy(self): + return optimised_strategy(self.n) + + def isogeny_chain(self, kernel, Theta12, M): + """ + Compute the isogeny chain and store intermediate isogenies for evaluation + """ + # Extract the CouplePoints from the Kernel + Tp1, Tp2 = kernel + + # Store chain of (2,2)-isogenies + isogeny_chain = [] + + # Bookkeeping for optimal strategy + strat_idx = 0 + level = [0] + ker = (Tp1, Tp2) + kernel_elements = [ker] + + for k in range(self.n): + prev = sum(level) + ker = kernel_elements[-1] + + while prev != (self.n - 1 - k): + level.append(self.strategy[strat_idx]) + + # Perform the doublings + Tp1 = ker[0].double_iter(self.strategy[strat_idx]) + Tp2 = ker[1].double_iter(self.strategy[strat_idx]) + + ker = (Tp1, Tp2) + + # Update kernel elements and bookkeeping variables + kernel_elements.append(ker) + prev += self.strategy[strat_idx] + strat_idx += 1 + + # Compute the codomain from the 8-torsion + Tp1, Tp2 = ker + if k == 0: + phi = GluingThetaIsogenyDim2(Tp1, Tp2, Theta12, M) + else: + phi = ThetaIsogenyDim2(Th, Tp1, Tp2) + + # Update the chain of isogenies + Th = phi._codomain + isogeny_chain.append(phi) + + # Remove elements from list + kernel_elements.pop() + level.pop() + + # Push through points for the next step + kernel_elements = [(phi(T1), phi(T2)) for T1, T2 in kernel_elements] + + return isogeny_chain + + def evaluate_isogeny(self, P): + """ + Given a point P, of type TuplePoint on the domain E1 x E2, computes the + ThetaPointDim2 on the codomain ThetaStructureDim2. + """ + if not isinstance(P, TuplePoint): + raise TypeError( + "IsogenyChainDim2 isogeny expects as input a TuplePoint on the domain product E1 x E2" + ) + n=len(self._phis) + for i in range(n): + P = self._phis[i](P) + return P + + def __call__(self, P): + """ + Evaluate a TuplePoint under the action of this isogeny. + """ + return self.evaluate_isogeny(P) + + def dual(self): + domain = self._codomain + codomain = self._domain + n=len(self._phis) + isogenies=[] + for i in range(n): + isogenies.append(self._phis[n-1-i].dual()) + return DualIsogenyChainDim2(domain, codomain, isogenies) + + +class DualIsogenyChainDim2: + def __init__(self, domain, codomain, isogenies): + self._domain = domain + self._codomain = codomain + self._phis = isogenies + + def evaluate_isogeny(self, P): + """ + Given a ThetaPointDim2 point P on the codomain ThetaStructureDim2, + computes the image TuplePoint on the codomain E1 x E2. + """ + if not isinstance(P, ThetaPointDim2): + raise TypeError( + "DualIsogenyChainDim2 isogeny expects as input a ThetaPointDim2." + ) + n=len(self._phis) + for i in range(n): + P = self._phis[i](P) + return P + + def __call__(self, P): + """ + Evaluate a ThetaPointDim2 under the action of this isogeny. + """ + return self.evaluate_isogeny(P) diff --git a/theta_lib/isogenies_dim2/isogeny_dim2.py b/theta_lib/isogenies_dim2/isogeny_dim2.py new file mode 100644 index 0000000..b740ab1 --- /dev/null +++ b/theta_lib/isogenies_dim2/isogeny_dim2.py @@ -0,0 +1,229 @@ +""" +This code is based on a copy of: +https://github.com/ThetaIsogenies/two-isogenies + +MIT License + +Copyright (c) 2023 Pierrick Dartois, Luciano Maino, Giacomo Pope and Damien Robert + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +from sage.all import ZZ +from ..theta_structures.Theta_dim2 import ThetaStructureDim2, ThetaPointDim2 +from ..theta_structures.theta_helpers_dim2 import batch_inversion + + +class ThetaIsogenyDim2: + def __init__(self, domain, T1_8, T2_8, hadamard=(False, True)): + """ + Compute a (2,2)-isogeny in the theta model. Expects as input: + + - domain: the ThetaStructureDim2 from which we compute the isogeny + - (T1_8, T2_8): points of 8-torsion above the kernel generating the isogeny + + When the 8-torsion is not available (for example at the end of a long + (2,2)-isogeny chain), the the helper functions in isogeny_sqrt.py + must be used. + + NOTE: on the hadamard bools: + + The optional parameter 'hadamard' controls if we are in standard or dual + coordinates, and if the codomain is in standard or dual coordinates. By + default this is (False, True), meaning we use standard coordinates on + the domain A and the codomain B. + + The kernel is then the kernel K_2 where the action is by sign. Other + possibilities: - (False, False): standard coordinates on A, dual + coordinates on B - (True, True): start in dual coordinates on A + (alternatively: standard coordinates on A but quotient by K_1 whose + action is by permutation), and standard coordinates on B. - (True, + False): dual coordinates on A and B + + These can be composed as follows for A -> B -> C: + + - (False, True) -> (False, True) (False, False) -> (True, True): + - standard coordinates on A and C, + - standard/resp dual coordinates on B + - (False, True) -> (False, False) (False, False) -> (True, False): + - standard coordinates on A, + - dual coordinates on C, + - standard/resp dual coordinates on B + - (True, True) -> (False, True) (True, False) -> (True, True): + - dual coordinates on A, + - standard coordinates on C, + - standard/resp dual coordiantes on B + - (True, True) -> (False, False) (True, False) -> (True, False): + - dual coordinates on A and C + - standard/resp dual coordinates on B + + On the other hand, these gives the multiplication by [2] on A: + + - (False, False) -> (False, True) (False, True) -> (True, True): + - doubling in standard coordinates on A + - going through dual/standard coordinates on B=A/K_2 + - (True, False) -> (False, False) (True, True) -> (True, False): + - doubling in dual coordinates on A + - going through dual/standard coordinates on B=A/K_2 + (alternatively: doubling in standard coordinates on A going + through B'=A/K_1) + - (False, False) -> (False, False) (False, True) -> (True, False): + - doubling from standard to dual coordinates on A + - (True, False) -> (False, True) (True, True) -> (True, True): + - doubling from dual to standard coordinates on A + """ + if not isinstance(domain, ThetaStructureDim2): + raise ValueError + self._domain = domain + + self._hadamard = hadamard + self._precomputation = None + self._codomain = self._compute_codomain(T1_8, T2_8) + + def _compute_codomain(self, T1, T2): + """ + Given two isotropic points of 8-torsion T1 and T2, compatible with + the theta null point, compute the level two theta null point A/K_2 + """ + if self._hadamard[0]: + xA, xB, _, _ = ThetaPointDim2.to_squared_theta( + *ThetaPointDim2.to_hadamard(*T1.coords()) + ) + zA, tB, zC, tD = ThetaPointDim2.to_squared_theta( + *ThetaPointDim2.to_hadamard(*T2.coords()) + ) + else: + xA, xB, _, _ = T1.squared_theta() + zA, tB, zC, tD = T2.squared_theta() + + if not self._hadamard[0] and self._domain._precomputation: + # Batch invert denominators + xA_inv, zA_inv, tB_inv = batch_inversion([xA, zA, tB]) + + # Compute A, B, C, D + A = ZZ(1) + B = xB * xA_inv + C = zC * zA_inv + D = tD * tB_inv * B + + _, _, _, BBinv, CCinv, DDinv = self._domain._arithmetic_precomputation() + B_inv = BBinv * B + C_inv = CCinv * C + D_inv = DDinv * D + else: + # Batch invert denominators + xA_inv, zA_inv, tB_inv, xB_inv, zC_inv, tD_inv = batch_inversion([xA, zA, tB, xB, zC, tD]) + + # Compute A, B, C, D + A = ZZ(1) + B = xB * xA_inv + C = zC * zA_inv + D = tD * tB_inv * B + B_inv = xB_inv * xA + C_inv = zC_inv * zA + D_inv = tD_inv * tB * B_inv + + # NOTE: some of the computations we did here could be reused for the + # arithmetic precomputations of the codomain However, we are always + # in the mode (False, True) except the very last isogeny, so we do + # not lose much by not doing this optimisation Just in case we need + # it later: + # - for hadamard=(False, True): we can reuse the arithmetic + # precomputation; we do this already above + # - for hadamard=(False, False): we can reuse the arithmetic + # precomputation as above, and furthermore we could reuse B_inv, + # C_inv, D_inv for the precomputation of the codomain + # - for hadamard=(True, False): we could reuse B_inv, C_inv, D_inv + # for the precomputation of the codomain + # - for hadamard=(True, True): nothing to reuse! + + self._precomputation = (B_inv, C_inv, D_inv) + if self._hadamard[1]: + a, b, c, d = ThetaPointDim2.to_hadamard(A, B, C, D) + return ThetaStructureDim2([a, b, c, d], null_point_dual=[A, B, C, D]) + else: + return ThetaStructureDim2([A, B, C, D]) + + def __call__(self, P): + """ + Take into input the theta null point of A/K_2, and return the image + of the point by the isogeny + """ + if not isinstance(P, ThetaPointDim2): + raise TypeError("Isogeny evaluation expects a ThetaPointDim2 as input") + + if self._hadamard[0]: + xx, yy, zz, tt = ThetaPointDim2.to_squared_theta( + *ThetaPointDim2.to_hadamard(*P.coords()) + ) + else: + xx, yy, zz, tt = P.squared_theta() + + Bi, Ci, Di = self._precomputation + + yy = yy * Bi + zz = zz * Ci + tt = tt * Di + + image_coords = (xx, yy, zz, tt) + if self._hadamard[1]: + image_coords = ThetaPointDim2.to_hadamard(*image_coords) + return self._codomain(image_coords) + + def dual(self): + # Returns the dual isogeny (domain and codomain are inverted). + # By convention, the new domain and codomain are in standard coordinates. + if self._hadamard[1]: + domain=self._codomain.hadamard() + else: + domain=self._codomain + if self._hadamard[0]: + codomain=self._domain + else: + codomain=self._domain.hadamard() + + precomputation = batch_inversion(self._domain.null_point().coords()) + + return DualThetaIsogenyDim2(domain,codomain,precomputation) + +class DualThetaIsogenyDim2: + def __init__(self,domain,codomain,precomputation): + self._domain=domain + self._codomain=codomain + self._precomputation=precomputation + + def __call__(self,P): + if not isinstance(P, ThetaPointDim2): + raise TypeError("Isogeny evaluation expects a ThetaPointDim2 as input") + + xx, yy, zz, tt = P.squared_theta() + + Ai, Bi, Ci, Di = self._precomputation + + xx = xx * Ai + yy = yy * Bi + zz = zz * Ci + tt = tt * Di + + image_coords = (xx, yy, zz, tt) + image_coords = ThetaPointDim2.to_hadamard(*image_coords) + + return self._codomain(image_coords) + + |