Skip to main content

CalabiYau Class

This class handles various computations relating to the Calabi-Yau manifold itself. It can be used to compute intersection numbers and the toric Mori and Kähler cones, among other things.

info

Generally, objects of this class should not be constructed directly by the end user. Instead, they should be created by the get_cy function of the ToricVariety class or the get_cy function of the Triangulation class.

experimental feature

This package is focused on computations on Calabi-Yau 3-fold hypersurfaces, but there is experimental support for Calabi-Yaus of other dimensions and complete intersections. See experimental features for more details.

Constructor

cytools.calabiyau.CalabiYau

Description: Constructs a CalabiYau object. This is handled by the hidden __init__ function.

Arguments:

  • toric_var (ToricVariety): The ambient toric variety of the Calabi-Yau.
  • nef_partition (list, optional): A list of tuples of indices specifying a nef-partition of the polytope, which correspondingly defines a complete intersection Calabi-Yau.
Example

We construct a Calabi-Yau from a fine, regular, star triangulation of a polytope. Since this class is not intended to be initialized by the end user, we create it via the get_cy function of the Triangulation class. In this example we obtain the quintic hypersurface in P4\mathbb{P}^4.

from cytools import Polytope
p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t = p.triangulate()
t.get_cy()
# A Calabi-Yau 3-fold hypersurface with h11=1 and h21=101 in a 4-dimensional toric variety

Functions

ambient_dimension

Description: Returns the complex dimension of the ambient toric variety.

Arguments: None.

Returns: (int) The complex dimension of the ambient toric variety.

Aliases: ambient_dim.

Example

We construct a Calabi-Yau and find the dimension of its ambient variety.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t = p.triangulate()
cy = t.get_cy()
cy.ambient_dimension()
# 4

ambient_variety

Description: Returns the ambient toric variety.

Arguments: None.

Returns: (ToricVariety) The ambient toric variety.

Example

We construct a Calabi-Yau hypersurface in a toric variety and check that this function returns the ambient variety.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t = p.triangulate()
v = t.get_toric_variety()
cy = v.get_cy()
cy.ambient_variety() is v
# True

chi

Description: Computes the Euler characteristic of the Calabi-Yau.

note

Only Calabi-Yau hypersurfaces of dimension 2-4 are currently supported. Hodge numbers of CICYs are computed with PALP.

Arguments: None.

Returns: (int) The Euler characteristic of the Calabi-Yau manifold.

Example

We construct a Calabi-Yau hypersurface and compute its Euler characteristic.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.h31()
# -540

clear_cache

Description: Clears the cached results of any previous computation.

Arguments:

  • recursive (bool, optional, default=True): Whether to also clear the cache of the ambient toric variety, defining triangulation, and polytope. This is ignored when only_in_basis=True.
  • only_in_basis (bool, optional, default=False): Only clears the cache of computations that depend on a choice of basis.

Returns: Nothing.

Example

We construct a CY hypersurface, compute its toric Mori cone, clear the cache and then compute it again.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.toric_mori_cone()
# A 2-dimensional rational polyhedral cone in RR^7 generated by 3 rays
cy.clear_cache() # Clears the cached result
cy.toric_mori_cone() # The Mori cone is recomputed
# A 2-dimensional rational polyhedral cone in RR^7 generated by 3 rays

compute_curve_volumes

Description: Computes the volume of the curves corresponding to (not necessarily minimal) generators of the Mori cone inferred from toric geometry (i.e. the cone obtained with the toric_mori_cone function).

Arguments:

  • tloc (array_like): A vector specifying a location in the Kähler cone.
  • only_extremal (bool, optional, default=False): Use only the extremal rays of the Mori cone.

Returns: (numpy.ndarray) The list of volumes of the curves.

Example

We construct a Calabi-Yau hypersurface and find the volumes of the generators of the Mori cone at the tip of the stretched Kähler cone.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
tip = cy.toric_kahler_cone().tip_of_stretched_cone(1)
cy.compute_curve_volumes(tip)
# array([0.99997511, 3.99992091, 0.99998193])

As expected, all generators of the Mori cone have volumes greater than or equal to 1 (up to rounding errors) at the tip of the stretched Kähler cone.


compute_cy_volume

Description: Computes the volume of the Calabi-Yau at a location in the Kähler cone.

Arguments:

  • tloc (array_like): A vector specifying a location in the Kähler cone.

Returns: (float) The volume of the Calabi-Yau at the specified location.

Example

We construct a Calabi-Yau hypersurface and find its volume at the tip of the stretched Kähler cone.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
tip = cy.toric_kahler_cone().tip_of_stretched_cone(1)
cy.compute_cy_volume(tip)
# 3.4999999988856496

compute_divisor_volumes

Description: Computes the volume of the basis divisors at a location in the Kähler cone.

Arguments:

  • tloc (array_like): A vector specifying a location in the Kähler cone.
  • in_basis (bool, optional, default=False): When set to True, the volumes of the current basis of divisors are computed. Otherwise, the volumes of all prime toric divisors are computed.

Returns: (numpy.ndarray) The list of volumes of the prime toric divisors or of the basis divisors at the specified location.

Example

We construct a Calabi-Yau hypersurface and find the volumes of the prime toric divisors at the tip of the stretched Kähler cone.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
tip = cy.toric_kahler_cone().tip_of_stretched_cone(1)
cy.compute_divisor_volumes(tip)
# array([ 2.5 , 23.99999999, 16. , 2.5 , 2.5 ,
# 0.5 ])

compute_inverse_kahler_metric

Description: Computes the inverse Kähler metric at a location in the Kähler cone.

note

This function only supports Calabi-Yau 3-folds.

Arguments:

  • tloc (array_like): A vector specifying a location in the Kähler cone.

Returns: (numpy.ndarray) The inverse Kähler metric at the specified location.

Example

We construct a Calabi-Yau hypersurface and compute the inverse Kähler metric at the tip of the stretched Kähler cone.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
tip = cy.toric_kahler_cone().tip_of_stretched_cone(1)
cy.compute_inverse_kahler_metric(tip)
# array([[11., -9.],
# [-9., 43.]])

compute_kahler_metric

Description: Computes the Kähler metric at a location in the Kähler cone.

note

This function only supports Calabi-Yau 3-folds.

Arguments:

  • tloc (array_like): A vector specifying a location in the Kähler cone.

Returns: (numpy.ndarray) The Kähler metric at the specified location.

Example

We construct a Calabi-Yau hypersurface and compute the Kähler metric at the tip of the stretched Kähler cone.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
tip = cy.toric_kahler_cone().tip_of_stretched_cone(1)
cy.compute_kahler_metric(tip)
# array([[0.10969388, 0.02295918],
[0.02295918, 0.02806122]])

compute_kappa_matrix

Description: Computes the matrix κijktk\kappa_{ijk}t^k at a location in the Kähler cone.

note

This function only supports Calabi-Yau 3-folds.

Arguments:

  • tloc (array_like): A vector specifying a location in the Kähler cone.

Returns: (numpy.ndarray) The matrix κijktk\kappa_{ijk}t^k at the specified location.

Aliases: compute_AA.

Example

We construct a Calabi-Yau hypersurface and compute this matrix at the tip of the stretched Kähler cone.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
tip = cy.toric_kahler_cone().tip_of_stretched_cone(1)
cy.compute_kappa_matrix(tip)
# array([[ 1., 1.],
# [ 1., -3.]])

compute_kappa_vector

Description: Computes the vector κijktjtk\kappa_{ijk} t^j t^k at a location in the Kähler cone.

note

This function only supports Calabi-Yau 3-folds.

Arguments:

  • tloc (array_like): A vector specifying a location in the Kähler cone.

Returns: (numpy.ndarray) The vector κijktjtk\kappa_{ijk} t^j t^k at the specified location.

Example

We construct a Calabi-Yau hypersurface and compute this vector at the tip of the stretched Kähler cone.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
tip = cy.toric_kahler_cone().tip_of_stretched_cone(1)
cy.compute_kappa_vector(tip)
# array([5., 1.])

curve_basis

Description: Returns the current basis of curves of the Calabi-Yau.

Arguments:

  • include_origin (bool, optional, default=True): Whether to include the origin in the indexing of the vector, or in the basis matrix.
  • as_matrix (bool, optional, default=False): Indicates whether to return the basis as a matrix intead of a list of indices of prime toric divisors. Note that if a matrix basis was specified, then it will always be returned as a matrix.

Returns: (numpy.ndarray) A list of column indices that form a basis. If a more generic basis has been specified with the set_divisor_basis or set_curve_basis functions then it returns a matrix where the rows are the basis elements specified as a linear combination of the canonical divisor and the prime toric divisors.

Example

We consider a simple Calabi-Yau with two independent curves. If no basis has been set, then this function finds one. If a basis has been set, then this function returns it.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.curve_basis() # We haven't set any basis
# array([1, 6])
cy.set_curve_basis([5,6]) # Here we set a basis
cy.curve_basis() # We get the basis we set
# array([5, 6])
cy.curve_basis(as_matrix=True) # We get the basis in matrix form
# array([[-18, 1, 9, 6, 1, 1, 0],
# [ -6, 0, 3, 2, 0, 0, 1]])

dimension

Description: Returns the complex dimension of the Calabi-Yau hypersurface.

Arguments: None.

Returns: (int) The complex dimension of the Calabi-Yau hypersurface.

Aliases: dim.

Example

We construct a Calabi-Yau and find its dimension.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t = p.triangulate()
cy = t.get_cy()
cy.dimension()
# 3

divisor_basis

Description: Returns the current basis of divisors of the Calabi-Yau.

Arguments:

  • include_origin (bool, optional, default=True): Whether to include the origin in the indexing of the vector, or in the basis matrix.
  • as_matrix (bool, optional, default=False): Indicates whether to return the basis as a matrix intead of a list of indices of prime toric divisors. Note that if a matrix basis was specified, then it will always be returned as a matrix.

Returns: (numpy.ndarray) A list of column indices that form a basis. If a more generic basis has been specified with the set_divisor_basis or set_curve_basis functions then it returns a matrix where the rows are the basis elements specified as a linear combination of the canonical divisor and the prime toric divisors.

Example

We consider a simple Calabi-Yau with two independent divisors. If no basis has been set, then this function finds one. If a basis has been set, then this function returns it.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.divisor_basis() # We haven't set any basis
# array([1, 6])
cy.set_divisor_basis([5,6]) # Here we set a basis
cy.divisor_basis() # We get the basis we set
# array([5, 6])
cy.divisor_basis(as_matrix=True) # We get the basis in matrix form
# array([[0, 0, 0, 0, 0, 1, 0],
# [0, 0, 0, 0, 0, 0, 1]])

glsm_charge_matrix

Description: Computes the GLSM charge matrix of the theory.

Arguments:

  • include_origin (bool, optional, default=True): Indicates whether to use the origin in the calculation. This corresponds to the inclusion of the canonical divisor.

Returns: (numpy.ndarray) The GLSM charge matrix.

Example

We construct a Calabi-Yau hypersurface and compute its GLSM charge matrix.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.glsm_charge_matrix()
# array([[-18, 1, 9, 6, 1, 1, 0],
# [ -6, 0, 3, 2, 0, 0, 1]])

glsm_linear_relations

Description: Computes the linear relations of the GLSM charge matrix.

Arguments:

  • include_origin (bool, optional, default=True): Indicates whether to use the origin in the calculation. This corresponds to the inclusion of the canonical divisor.

Returns: (numpy.ndarray) A matrix of linear relations of the columns of the GLSM charge matrix.

Example

We construct a Calabi-Yau hypersurface and compute the GLSM linear relations.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.glsm_linear_relations()
# array([[ 1, 1, 1, 1, 1, 1, 1],
# [ 0, 9, -1, 0, 0, 0, 3],
# [ 0, 6, 0, -1, 0, 0, 2],
# [ 0, 1, 0, 0, -1, 0, 0],
# [ 0, 1, 0, 0, 0, -1, 0]])

h11

Description: Returns the Hodge number h1,1h^{1,1} of the Calabi-Yau.

note

Only Calabi-Yau hypersurfaces of dimension 2-4 are currently supported. Hodge numbers of CICYs are computed with PALP.

Arguments: None.

Returns: (int) The Hodge number h1,1h^{1,1} of Calabi-Yau manifold.

Example

We construct a Calabi-Yau hypersurface and compute its h1,1h^{1,1}.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.h11()
# 2

h12

Description: Returns the Hodge number h1,2h^{1,2} of the Calabi-Yau.

note

Only Calabi-Yau hypersurfaces of dimension 2-4 are currently supported. Hodge numbers of CICYs are computed with PALP.

Arguments: None.

Returns: (int) The Hodge number h1,2h^{1,2} of Calabi-Yau manifold.

Aliases: h21.

Example

We construct a Calabi-Yau hypersurface and compute its h1,2h^{1,2}.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.h12()
# 272

h13

Description: Returns the Hodge number h1,3h^{1,3} of the Calabi-Yau.

note

Only Calabi-Yau hypersurfaces of dimension 2-4 are currently supported. Hodge numbers of CICYs are computed with PALP.

Arguments: None.

Returns: (int) The Hodge number h1,3h^{1,3} of Calabi-Yau manifold.

Aliases: h31.

Example

We construct a Calabi-Yau hypersurface and compute its h1,3h^{1,3}.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.h13()
# 0

h22

Description: Returns the Hodge number h2,2h^{2,2} of the Calabi-Yau.

note

Only Calabi-Yau hypersurfaces of dimension 2-4 are currently supported. Hodge numbers of CICYs are computed with PALP.

Arguments: None.

Returns: (int) The Hodge number h2,2h^{2,2} of Calabi-Yau manifold.

Example

We construct a Calabi-Yau hypersurface and compute its h2,2h^{2,2}.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.h22()
# 0

hpq

Description: Returns the Hodge number hp,qh^{p,q} of the Calabi-Yau.

notes
  • Only Calabi-Yau hypersurfaces of dimension 2-4 are currently supported. Hodge numbers of CICYs are computed with PALP.
  • This function always computes Hodge numbers from scratch, unless they were computed with PALP. The functions h11, h21, h12, h13, and h22 cache the results so they offer improved performance.

Arguments:

  • p (int): The holomorphic index of the Dolbeault cohomology of interest.
  • q (int): The anti-holomorphic index of the Dolbeault cohomology of interest.

Returns: (int) The Hodge number hp,qh^{p,q} of the arising Calabi-Yau manifold.

Example

We construct a Calabi-Yau and check some of its Hodge numbers.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.hpq(0,0)
# 1
cy.hpq(0,1)
# 0
cy.hpq(1,1)
# 2
cy.hpq(1,2)
# 272

intersection_numbers

Description: Returns the intersection numbers of the Calabi-Yau manifold.

experimental feature

The intersection numbers are computed as integers when the Calabi-Yau is smooth, and a subset of the prime toric divisors is used as the basis. Otherwise, they are computed as floating-point numbers. There is the option to turn them into rationals. The process is fairly quick, but it is unreliable at large h1,1h^{1,1}. Furthermore, verifying that they are correct becomes very slow at large h1,1h^{1,1}.

Arguments:

  • in_basis (bool, optional, default=False): Return the intersection numbers in the current basis of divisors.
  • format (str, optional, default="dok"): The output format of the intersection numbers. The options are "dok", "coo", and "dense". When set to "dok" (Dictionary Of Keys), it returns a dictionary where the keys are divisor indices in ascending order and the corresponding value is their intersection number. When set to "coo" (COOrdinate format), it returns a numpy array in the format [[a,b,...,c,K_ab...c],...], i.e. all but the last entry of each row correspond to divisor indices in ascending order, with the last entry of the row being their intersection number. Lastly, when set to "dense", it returns the full dense array of intersection numbers.
  • zero_as_anticanonical (bool, optional, default=False): Treat the zeroth index as corresponding to the anticanonical divisor instead of the canonical divisor.
  • backend (str, optional, default="all"): The sparse linear solver to use. Options are "all", "sksparse" and "scipy". When set to "all" every solver is tried in order until one succeeds.
  • check (bool, optional, default=True): Whether to explicitly check the solution to the linear system.
  • backend_error_tol (float, optional, default=1e-3): Error tolerance for the solution of the linear system.
  • round_to_zero_threshold (float, optional, default=1e-3): Intersection numbers with magnitude smaller than this threshold are rounded to zero.
  • round_to_integer_error_tol (float, optional, default=5e-2): All intersection numbers of the Calabi-Yau hypersurface must be integers up to errors less than this value, when the CY is smooth.
  • verbose (int, optional, default=0): The verbosity level.
    • verbose = 0: Do not print anything.
    • verbose = 1: Print linear backend warnings.
  • exact_arithmetic (bool, optional, default=False): Converts the intersection numbers into exact rational fractions.

Returns: (dict or numpy.array) When format is set to "dok" (Dictionary Of Keys), it returns a dictionary where the keys are divisor indices in ascending order and the corresponding value is their intersection number. When format is set to "coo" (COOrdinate format), it returns a numpy array in the format [[a,b,...,c,K_ab...c],...], i.e. all but the last entry of each row correspond to divisor indices in ascending order, with the last entry of the row being their intersection number. Lastly, when set to "dense", it returns the full dense array of intersection numbers.

Example

We construct a toric variety and compute its intersection numbers We demonstrate the usage of the in_basis flag and the different available output formats.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
# By default this function computes the intersection numbers of the canonical and prime toric divisors
intnum_nobasis = cy.intersection_numbers()
# Let's print the output and see how to interpret it
print(intnum_nobasis)
# {(1, 2, 3): 18, (2, 3, 4): 18, (1, 3, 4): 2, (1, 2, 4): 3, (1, 2, 5): 3, (2, 3, 5): 18, [the output is too long so we truncate it]
# The above output means that the intersection number of divisors 1, 2, 3 is 18, and so on
# Let us now compute the intersection numbers in a given basis of divisors
# First, let's check the current basis of divisors
cy.divisor_basis()
# array([1, 6])
# Now, setting in_basis=True we only compute the intersection numbers of divisors 1 and 6
intnum_basis = cy.intersection_numbers(in_basis=True)
# Let's print the output and see how to interpret it
print(intnum_basis)
# {(0, 0, 1): 1, (0, 1, 1): -3, (1, 1, 1): 9}
# Here, the indices correspond to indices of the basis divisors
# So the intersection of 1, 1, 6 is 1, and so on
# Now, let's look at the different output formats. The default one is the "dok" (Dictionary Of Keys) format shown above
# There is also the "coo" (COOrdinate format)
print(cy.intersection_numbers(in_basis=True, format="coo"))
# [[ 0 0 1 1]
# [ 0 1 1 -3]
# [ 1 1 1 9]]
# In this format, all but the last entry of each row are the indices and the last entry of the row is the intersection number
# Lastrly, there is the "dense" format where it outputs the full dense array
print(cy.intersection_numbers(in_basis=True, format="dense"))
# [[[ 0 1]
# [ 1 -3]]
#
# [[ 1 -3]
# [-3 9]]]

is_smooth

Description: Returns True if the Calabi-Yau is smooth.

Arguments: None.

Returns: (bool) The truth value of the CY being smooth.

Example

We construct a Calabi-Yau hypersurface and check if it is smooth.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.is_smooth()
# True

is_trivially_equivalent

Description: Checks if the Calabi-Yaus are trivially equivalent by checking if the restrictions of the triangulations to codimension-2 faces are the same. Polytope automorphisms are also taken into account. This function is only implemented for CY hypersurfaces.

info

This function only provides a fairly trivial equivalence check. When this function returns False, there is still the possibility of the Calabi-Yaus being equivalent, but is only made evident with a change of basis. The full equivalence check is generically very difficult, so it is not implemented.

Arguments:

  • other (CalabiYau): The other CY that is being compared.

Returns: (boolean) The truth value of the CYs being trivially equivalent.

Example

We construct two Calabi-Yaus and compare them. We also show how to get the set of Calabi-Yaus that are not trivially equivalent. As previously mentioned, if two CYs are not trivially equivalent it does not mean that they are actually inequivalent as there might exist some more complicated basis transformation that relates them.

p = Polytope([[-1,0,0,0],[-1,1,0,0],[-1,0,1,0],[2,-1,0,-1],[2,0,-1,-1],[2,-1,-1,-1],[-1,0,0,1],[-1,1,0,1],[-1,0,1,1]])
triangs = p.all_triangulations(as_list=True)
cy0 = triangs[0].get_cy()
cy1 = triangs[1].get_cy()
print(cy0.is_trivially_equivalent(cy1))
# False
cys_not_triv_eq = {t.get_cy() for t in triangs} # Not trivially equivalent, but not necessarily inequivalent
print(len(triangs),len(cys_not_triv_eq)) # We see that many CYs from these triangulations can be trivially equated
# 102 5

polytope

Description: Returns the polytope whose triangulation gives rise to the ambient toric variety.

Arguments: None.

Returns: (Polytope) The polytope whose triangulation gives rise to the ambient toric variety.

Example

We construct a Calabi-Yau and check that the polytope that this function returns is the same as the one we used to construct it.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t = p.triangulate()
cy = t.get_cy()
cy.polytope() is p
# True

prime_toric_divisors

Description: Returns the list of inherited prime toric divisors. Due to the sorting of points in the polytope class, this list is trivial for hypersurfaces, but may be non-trivial for CICYs. The indices in the returned tuple correspond to indices of the corresponding points of the polytope (i.e. if nn is in the tuple, then the nnth point in p.points() is a prime toric divisor that intersects the CY).

Arguments: None

Returns: (tuple) A list of indices indicating the points in the polytope whose corresponding prime toric divisor intersects the CY.

Example

We construct a Calabi-Yau hypersurface and find the list of prime toric divisors.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.prime_toric_divisors()
# (1, 2, 3, 4, 5, 6)

second_chern_class

Description: Computes the second Chern class of the CY hypersurface. Returns the integral of the second Chern class over the prime effective divisors.

note

This function currently only supports CY 3-folds.

Arguments:

  • in_basis (bool, optional, default=False): Only return the integrals over a basis of divisors.
  • include_origin (bool, optional, default=True): Include the origin in the vector, which corresponds to the canonical divisor.

Returns: (numpy.ndarray) A vector containing the integrals.

Example

We construct a Calabi-Yau hypersurface and compute its second Chern class.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.second_chern_class()
# array([-612, 36, 306, 204, 36, 36, -6])

set_curve_basis

Description: Specifies a basis of curves of the Calabi-Yau, which in turn induces a basis of divisors. This can be done with a vector specifying the indices of the standard basis of the lattice dual to the lattice of prime toric divisors. Note that this case is equivalent to using the same vector in the set_divisor_basis function.

note

Only integral bases are supported by CYTools, meaning that all toric curves must be able to be written as an integral linear combination of the basis curves.

Arguments:

  • basis (array_like): Vector or matrix specifying a basis. When a vector is used, the entries will be taken as indices of the standard basis of the dual to the lattice of prime toric divisors. When a matrix is used, the rows are taken as linear combinations of the aforementioned elements.
  • include_origin (bool, optional, default=True): Whether to interpret the indexing specified by the input vector as including the origin.

Returns: Nothing.

Example

We consider a simple Calabi-Yau with two independent curves. We first find the default basis of curves it picks and then set a basis of our choice.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.curve_basis() # We haven't set any basis
# array([1, 6])
cy.set_curve_basis([5,6]) # Here we set a basis
cy.curve_basis() # We get the basis we set
# array([5, 6])
cy.curve_basis(as_matrix=True) # We get the basis in matrix form
# array([[-18, 1, 9, 6, 1, 1, 0],
# [ -6, 0, 3, 2, 0, 0, 1]])

Note that when setting a curve basis in this way, the function behaves exactly the same as set_divisor_basis. For a more advanced example involving generic bases these two functions differ. An example can be found in the experimental features section.


set_divisor_basis

Description: Specifies a basis of divisors of the Calabi-Yau. This can be done with a vector specifying the indices of the prime toric divisors.

note

Only integral bases are supported by CYTools, meaning that all prime toric divisors must be able to be written as an integral linear combination of the basis divisors.

Arguments:

  • basis (array_like): Vector or matrix specifying a basis. When a vector is used, the entries will be taken as the indices of points of the polytope or prime divisors of the toric variety. When a matrix is used, the rows are taken as linear combinations of the aforementioned divisors.
  • include_origin (bool, optional, default=True): Whether to interpret the indexing specified by the input vector as including the origin.

Returns: Nothing.

Example

We consider a simple Calabi-Yau with two independent divisors. We first find the default basis it picks and then we set a basis of our choice.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.divisor_basis() # We haven't set any basis
# array([1, 6])
cy.set_divisor_basis([5,6]) # Here we set a basis
cy.divisor_basis() # We get the basis we set
# array([5, 6])
cy.divisor_basis(as_matrix=True) # We get the basis in matrix form
# array([[0, 0, 0, 0, 0, 1, 0],
# [0, 0, 0, 0, 0, 0, 1]])

An example for more generic basis choices can be found in the experimental features section.


toric_effective_cone

Description: Returns the cone of effective divisors, aka the effective cone, inferred from toric geometry.

Arguments: None.

Returns: (Cone) The toric effective cone.

Example

We construct a Calabi-Yau hypersurface and find its toric effective cone.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.toric_effective_cone()
# A 2-dimensional rational polyhedral cone in RR^2 generated by 6 rays

toric_kahler_cone

Description: Returns the Kähler cone inferred from toric geometry in the current basis of divisors.

Arguments: None.

Returns: (Cone) The Kähler cone inferred from toric geometry.

Example

We construct a Calabi-Yau hypersurface and find its Kähler cone.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.toric_kahler_cone()
# A rational polyhedral cone in RR^2 defined by 3 hyperplanes normals

toric_mori_cone

Description: Returns the Mori cone inferred from toric geometry.

Arguments:

  • in_basis (bool, optional, default=False): Use the current basis of curves, which is dual to what the basis returned by the divisor_basis function.
  • include_origin (bool, optional, default=True): Includes the origin of the polytope in the computation, which corresponds to the canonical divisor.
  • from_intersection_numbers (bool, optional, default=False): Compute the rays of the Mori cone using the intersection numbers of the variety. This can be faster if they are already computed. The set of rays may be different, but they define the same cone.

Returns: (Cone) The Mori cone inferred from toric geometry.

Example

We construct a Calabi-Yau hypersurface and find its Mori cone in an h1,1+d+1h^{1,1}+d+1 dimensional lattice (i.e. without a particular choice of basis) and in an h1,1h^{1,1} dimensional lattice (i.e. after picking a basis of curves).

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-6,-9]])
t = p.triangulate()
cy = t.get_cy()
cy.toric_mori_cone() # By default it does not use a basis of curves.
# A 2-dimensional rational polyhedral cone in RR^7 generated by 3 rays
cy.toric_mori_cone(in_basis=True) # It uses the dual basis of curves to the current divisor basis
# A 2-dimensional rational polyhedral cone in RR^2 generated by 3 rays

triangulation

Description: Returns the triangulation giving rise to the ambient toric variety.

Arguments: None.

Returns: (Triangulation) The triangulation giving rise to the ambient toric variety.

Example

We construct a Calabi-Yau and check that the triangulation that this function returns is the same as the one we used to construct it.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t = p.triangulate()
cy = t.get_cy()
cy.triangulation() is t
# True

Hidden Functions

__eq__

Description: Implements comparison of Calabi-Yaus with ==.

info

This function provides only a fairly trivial comparison using the is_trivially_equivalent function. It is not recommended to compare CYs with ==, and a warning will be printed every time it evaluates to False. This is only implemented so that sets and dictionaries of CYs can be created. The is_trivially_equivalent function should be used to avoid confusion.

Arguments:

  • other (CalabiYau): The other CY that is being compared.

Returns: (bool) The truth value of the CYs being equal.

Example

We construct two Calabi-Yaus and compare them. We use the is_trivially_equivalent instead of this function, since it is recommended to avoid confusion.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t1 = p.triangulate(backend="qhull")
cy1 = t1.get_cy()
t2 = p.triangulate(backend="topcom")
cy2 = t2.get_cy()
cy1.is_trivially_equivalent(cy2)
# True

__hash__

Description: Implements the ability to obtain hash values from Calabi-Yaus.

Arguments: None.

Returns: (int) The hash value of the CY.

Example

We compute the hash value of a Calabi-Yau. Also, we construct a set and a dictionary with a Calabi-Yau, which make use of the hash function.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t = p.triangulate()
cy = t.get_cy()
h = hash(cy) # Obtain hash value
d = {cy: 1} # Create dictionary with Calabi-Yau keys
s = {cy} # Create a set of Calabi-Yaus

__init__

Description: Initializes a CalabiYau object.

Arguments:

  • toric_var (ToricVariety): The ambient toric variety of the Calabi-Yau.
  • nef_partition (list, optional): A list of tuples of indices specifying a nef-partition of the polytope, which correspondingly defines a complete intersection Calabi-Yau.

Returns: Nothing.

Example

This is the function that is called when creating a new ToricVariety object. We construct a Calabi-Yau from a fine, regular, star triangulation of a polytope. Since this class is not intended to be initialized by the end user, we create it via the get_cy function of the Triangulation class. In this example we obtain the quintic hypersurface in P4\mathbb{P}^4.

from cytools import Polytope
p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t = p.triangulate()
t.get_cy()
# A Calabi-Yau 3-fold hypersurface with h11=1 and h21=101 in a 4-dimensional toric variety

__ne__

Description: Implements comparison of Calabi-Yaus with !=.

info

This function provides only a fairly trivial comparison using the is_trivially_equivalent function. It is not recommended to compare CYs with !=, and a warning will be printed every time it evaluates to False. This is only implemented so that sets and dictionaries of CYs can be created. The is_trivially_equivalent function should be used to avoid confusion.

Arguments:

  • other (Polytope): The other CY that is being compared.

Returns: (bool) The truth value of the CYs being different.

Example

We construct two Calabi-Yaus and compare them. We use the is_trivially_equivalent instead of this function, since it is recommended to avoid confusion.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t1 = p.triangulate(backend="qhull")
cy1 = t1.get_cy()
t2 = p.triangulate(backend="topcom")
cy2 = t2.get_cy()
cy1.is_trivially_equivalent(cy2)
# True

__repr__

Description: Returns a string describing the Calabi-Yau manifold.

Arguments: None.

Returns: (str) A string describing the Calabi-Yau manifold.

Example

This function can be used to convert the Calabi-Yau to a string or to print information about the Calabi-Yau.

p = Polytope([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1],[-1,-1,-1,-1]])
t = p.triangulate()
cy = t.get_cy()
cy_info = str(cy) # Converts to string
print(cy) # Prints Calabi-Yau info
# A Calabi-Yau 3-fold hypersurface with h11=1 and h21=101 in a 4-dimensional toric variety

_compute_cicy_hodge_numbers

Description: Computes the Hodge numbers of a CICY using PALP. The results are stored in a hidden dictionary.

note

This function should generally not be called by the user. Instead, it is called by hpq and other Hodge number functions when necessary.

Arguments:

  • only_from_cache (bool, optional, default=False): Check if the Hodge numbers of the CICY were previously computed and are stored in the cache of the polytope object. Only if this flag is false and the Hodge numbers are not cached, then PALP is used to compute them.

Returns: Nothing.

Example

This function is not intended to be directly used, but it is used in the following example. We construct a CICY and compute some of its Hodge numbers.

p = Polytope([[1,0,0,0,0],[0,1,0,0,0],[0,0,1,0,0],[0,0,0,1,0],[-1,-1,-6,-9,0],[0,0,0,0,1],[0,0,0,0,-1]])
nef_part = p.nef_partitions(compute_hodge_numbers=False)
t = p.triangulate(include_points_interior_to_facets=True)
cy = t.get_cy(nef_part[0])
cy.h11() # The function is called here since the Hodge numbers have not been computed
# 4
cy.h21() # It is not called here because the Hodge numbers are already cached
# 544