From cb6080eaa4f326d9fce5f0a9157be46e91d55e09 Mon Sep 17 00:00:00 2001
From: Pierrick-Dartois <pierrickdartois@icloud.com>
Date: Thu, 22 May 2025 18:51:58 +0200
Subject: Clean up PEGASIS submodule inclusion

---
 theta_lib/theta_structures/Theta_dim4.py | 351 -------------------------------
 1 file changed, 351 deletions(-)
 delete mode 100644 theta_lib/theta_structures/Theta_dim4.py

(limited to 'theta_lib/theta_structures/Theta_dim4.py')

diff --git a/theta_lib/theta_structures/Theta_dim4.py b/theta_lib/theta_structures/Theta_dim4.py
deleted file mode 100644
index 7851c56..0000000
--- a/theta_lib/theta_structures/Theta_dim4.py
+++ /dev/null
@@ -1,351 +0,0 @@
-from sage.all import *
-from sage.structure.element import get_coercion_model
-
-from .theta_helpers_dim4 import (
-    hadamard,
-    batch_inversion,
-    product_theta_point_dim4,
-    product_to_theta_points_dim4,
-    product_theta_point_dim2_dim4,
-    product_to_theta_points_dim4_dim2,
-    act_point,
-    squared,
-)
-from .Theta_dim1 import ThetaStructureDim1
-from .Tuple_point import TuplePoint
-from ..basis_change.base_change_dim4 import (
-    apply_base_change_theta_dim4,
-    random_symplectic_matrix,
-    base_change_theta_dim4,
-)
-
-cm = get_coercion_model()
-
-
-class ThetaStructureDim4:
-	def __init__(self,null_point,null_point_dual=None,inv_null_point_dual_sq=None):
-		r"""
-		INPUT:
-		- null_point: theta-constants.
-		- inv_null_point_dual_sq: inverse of the squares of dual theta-constants, if provided 
-		(meant to prevent duplicate computation, since this data is already computed when the 
-		codomain of an isogeny is computed).
-		"""
-		if not len(null_point) == 16:
-			raise ValueError("Entry null_point should have 16 coordinates.")
-
-		self._base_ring = cm.common_parent(*(c.parent() for c in null_point))
-		self._point = ThetaPointDim4
-		self._null_point = self._point(self, null_point)
-		self._null_point_dual=null_point_dual
-		self._inv_null_point=None
-		self._inv_null_point_dual_sq=inv_null_point_dual_sq
-
-	def null_point(self):
-		"""
-		"""
-		return self._null_point
-
-	def null_point_dual(self):
-		if self._null_point_dual==None:
-			self._null_point_dual=hadamard(self._null_point.coords())
-		return self._null_point_dual
-
-	def base_ring(self):
-		"""
-		"""
-		return self._base_ring
-
-	def zero(self):
-		"""
-		"""
-		return self.null_point()
-
-	def zero_dual(self):
-		return self.null_point_dual()
-
-	def __repr__(self):
-		return f"Theta structure over {self.base_ring()} with null point: {self.null_point()}"
-
-	def __call__(self,coords):
-		return self._point(self,coords)
-
-	def act_null(self,I,J):
-		r"""
-		Point of 2-torsion.
-
-		INPUT:
-		- I, J: two 4-tuples of indices in {0,1}.
-
-		OUTPUT: the action of (I,\chi_J) on the theta null point given by:
-		(I,\chi_J)*P=(\chi_J(I+K)^{-1}P[I+K])_K
-		"""
-		return self.null_point().act_point(I,J)
-
-	def is_K2(self,B):
-		r"""
-		Given a symplectic decomposition A[2]=K_1\oplus K_2 canonically 
-		induced by the theta-null point, determines if B is the canonical
-		basis of K_2 given by act_nul(0,\delta_i)_{1\leq i\leq 4}.
-
-		INPUT:
-		- B: Basis of 4 points of 2-torsion.
-
-		OUTPUT: Boolean True if and only if B is the canonical basis of K_2.
-		"""
-		I0=(0,0,0,0)
-		if B[0]!=self.act_null(I0,(1,0,0,0)):
-			return False
-		if B[1]!=self.act_null(I0,(0,1,0,0)):
-			return False
-		if B[2]!=self.act_null(I0,(0,0,1,0)):
-			return False
-		if B[3]!=self.act_null(I0,(0,0,0,1)):
-			return False
-		return True
-
-	def base_change_struct(self,N):
-		null_coords=self.null_point().coords()
-		new_null_coords=apply_base_change_theta_dim4(N,null_coords)
-		return ThetaStructureDim4(new_null_coords)
-
-	def base_change_coords(self,N,P):
-		coords=P.coords()
-		new_coords=apply_base_change_theta_dim4(N,coords)
-		return self.__call__(new_coords)
-
-	#@cached_method
-	def _arithmetic_precomputation(self):
-		r"""
-		Initializes the precomputation containing the inverse of the theta-constants in standard
-		and dual (Hadamard transformed) theta-coordinates. Assumes no theta-constant is zero.
-		"""
-		O=self.null_point()
-		if all([O[k]!=0 for k in range(16)]):
-			self._inv_null_point=batch_inversion(O.coords())
-			if self._inv_null_point_dual_sq==None:
-				U_chi_0_sq=hadamard(squared(O.coords()))
-				if all([U_chi_0_sq[k]!=0 for k in range(16)]):	
-					self._inv_null_point_dual_sq=batch_inversion(U_chi_0_sq)
-					self._arith_base_change=False
-				else:
-					self._arith_base_change=True
-					self._arithmetic_base_change()
-					#print("Zero dual theta constants.\nRandom symplectic base change is being used for duplication.\nDoublings are more costly than expected.")
-		else:
-			self._arith_base_change=True
-			self._arithmetic_base_change()
-			#print("Zero theta constants.\nRandom symplectic base change is being used for duplication.\nDoublings are more costly than expected.")
-
-	def _arithmetic_base_change(self,max_iter=50):
-		F=self._base_ring
-		if F.degree() == 2:
-			i=self._base_ring.gen()
-		else:
-			assert(F.degree() == 1)
-			Fp2 = GF((F.characteristic(), 2), name='i', modulus=var('x')**2 + 1)
-			i=Fp2.gen()
-
-		count=0
-		O=self.null_point()
-		while count<max_iter:
-			count+=1
-			M=random_symplectic_matrix(4)
-			N=base_change_theta_dim4(M,i)
-
-			NO=apply_base_change_theta_dim4(N,O)
-			NU_chi_0_sq=hadamard(squared(NO))
-
-			if all([NU_chi_0_sq[k]!=0 for k in range(16)]) and all([NO[k]!=0 for k in range(16)]):
-				self._arith_base_change_matrix=N
-				self._arith_base_change_matrix_inv=N.inverse()
-				self._inv_null_point=batch_inversion(NO)
-				self._inv_null_point_dual_sq=batch_inversion(NU_chi_0_sq)
-				break
-
-	def has_suitable_doubling(self):
-		O=self.null_point()
-		UO=hadamard(O.coords())
-		if all([O[k]!=0 for k in range(16)]) and all([UO[k]!=0 for k in range(16)]):
-			return True
-		else:
-			return False
-
-	def hadamard(self):
-		return ThetaStructureDim4(self.null_point_dual())
-
-	def hadamard_change_coords(self,P):
-		new_coords=hadamard(P)
-		return self.__call__(new_coords)
-
-
-class ProductThetaStructureDim1To4(ThetaStructureDim4):
-	def __init__(self,*args):
-		r"""Defines the product theta structure at level 2 of 4 elliptic curves.
-
-		Input: Either
-		- 4 theta structures of dimension 1: T0, T1, T2, T3;
-		- 4 elliptic curves: E0, E1, E2, E3.
-		- 4 elliptic curves E0, E1, E2, E3 and their respective canonical 4-torsion basis B0, B1, B2, B3.
-		"""
-		if len(args)==4:
-			theta_structures=list(args)
-			for k in range(4):
-				if not isinstance(theta_structures[k],ThetaStructureDim1):
-					try:
-						theta_structures[k]=ThetaStructureDim1(theta_structures[k])
-					except:
-						pass
-		elif len(args)==8:
-			theta_structures=[ThetaStructureDim1(args[k],args[4+k][0],args[4+k][1]) for k in range(4)]
-		else:
-			raise ValueError("4 or 8 arguments expected but {} were given.\nYou should enter a list of 4 elliptic curves or ThetaStructureDim1\nor a list of 4 elliptic curves with a 4-torsion basis for each of them.".format(len(args)))
-
-		self._theta_structures=theta_structures
-
-		null_point=product_theta_point_dim4(theta_structures[0].zero().coords(),theta_structures[1].zero().coords(),
-			theta_structures[2].zero().coords(),theta_structures[3].zero().coords())
-
-		ThetaStructureDim4.__init__(self,null_point)
-
-	def product_theta_point(self,theta_points):
-		return self._point(self,product_theta_point_dim4(theta_points[0].coords(),theta_points[1].coords(),
-			theta_points[2].coords(),theta_points[3].coords()))
-
-	def __call__(self,point):
-		if isinstance(point,TuplePoint):
-			theta_points=[]
-			theta_structures=self._theta_structures
-			for i in range(4):
-				theta_points.append(theta_structures[i](point[i]))
-			return self.product_theta_point(theta_points)
-		else:
-			return self._point(self,point)
-
-	def to_theta_points(self,P):
-		theta_coords=product_to_theta_points_dim4(P)
-		theta_points=[self._theta_structures[i](theta_coords[i]) for i in range(4)]
-		return theta_points
-
-	def to_tuple_point(self,P):
-		theta_points=self.to_theta_points(P)
-		montgomery_points=[self._theta_structures[i].to_montgomery_point(theta_points[i]) for i in range(4)]
-		return TuplePoint(montgomery_points)
-
-class ProductThetaStructureDim2To4(ThetaStructureDim4):
-	def __init__(self,theta1,theta2):
-		self._theta_structures=(theta1,theta2)
-
-		null_point=product_theta_point_dim2_dim4(theta1.zero().coords(),theta2.zero().coords())
-
-		ThetaStructureDim4.__init__(self,null_point)
-
-	def product_theta_point(self,P1,P2):
-		return self._point(self,product_theta_point_dim2_dim4(P1.coords(),P2.coords()))
-
-	def __call__(self,point):
-		return self._point(self,point)
-
-	def to_theta_points(self,P):
-		theta_coords=product_to_theta_points_dim4_dim2(P)
-		theta_points=[self._theta_structures[i](theta_coords[i]) for i in range(2)]
-		return theta_points
-
-class ThetaPointDim4:
-    def __init__(self, parent, coords):
-        """
-        """
-        if not isinstance(parent, ThetaStructureDim4):
-            raise ValueError("Entry parent should be a ThetaStructureDim4 object.")
-
-        self._parent = parent
-        self._coords = tuple(coords)
-
-    def parent(self):
-        """
-        """
-        return self._parent
-    
-    def theta(self):
-        """
-        """
-        return self.parent()
-    
-    def coords(self):
-        """
-        """
-        return self._coords
-    
-    def is_zero(self):
-        """
-        """
-        return self == self.parent().zero()
-
-    def __eq__(self, other):
-    	P=self.coords()
-    	Q=other.coords()
-    	
-    	k0=0
-    	while k0<15 and P[k0]==0:
-    		k0+=1
-
-    	for l in range(16):
-    		if P[l]*Q[k0]!=Q[l]*P[k0]:
-    			return False
-    	return True
-
-    def __repr__(self):
-    	return f"Theta point with coordinates: {self.coords()}"
-
-    def __getitem__(self,i):
-    	return self._coords[i]
-
-    def scale(self,lamb):
-    	if lamb==0:
-    		raise ValueError("Entry lamb should be non-zero.")
-
-    	P=self.coords()
-    	return self._parent([lamb*x for x in P])
-
-    def act_point(self,I,J):
-    	r"""
-		Translation by a point of 2-torsion.
-
-		Input:
-		- I, J: two 4-tuples of indices in {0,1}.
-
-		Output: the action of (I,\chi_J) on P given by:
-		(I,\chi_J)*P=(\chi_J(I+K)^{-1}P[I+K])_K
-		"""
-    	return self._parent(act_point(self._coords,I,J))
-
-    def double(self):
-    	## This formula is projective.
-    	## Works only when theta constants are non-zero.
-    	P=self.coords()
-    	if self.parent()._inv_null_point==None or self.parent()._inv_null_point_dual_sq==None:
-    		self.parent()._arithmetic_precomputation()
-    	inv_O,inv_U_chi_0_sq=self.parent()._inv_null_point,self.parent()._inv_null_point_dual_sq
-
-    	if self.parent()._arith_base_change:
-    		P=apply_base_change_theta_dim4(self.parent()._arith_base_change_matrix,P)
-
-    	U_chi_P=squared(hadamard(squared(P)))
-    	for chi in range(16):
-    		U_chi_P[chi]*=inv_U_chi_0_sq[chi]
-
-    	theta_2P = list(hadamard(U_chi_P))
-    	for i in range(16):
-    		theta_2P[i] *= inv_O[i]
-
-    	if self.parent()._arith_base_change:
-    		theta_2P=apply_base_change_theta_dim4(self.parent()._arith_base_change_matrix_inv,theta_2P)
-
-    	return self._parent(theta_2P)
-
-    def double_iter(self,n):
-    	## Computes 2**n*self
-    	Q=self
-    	for i in range(n):
-    		Q=Q.double()
-    	return Q
-- 
cgit v1.2.3-70-g09d2