151 lines
4.6 KiB
Markdown
151 lines
4.6 KiB
Markdown
# Calabi-Yau-Period-Geometry
|
|
|
|
This project collects code used for analysing Calabi–Yau families.
|
|
It allows for computation of discriminant loci and topological data of manifolds defined as hypersurfaces or complete intersections in toric ambient spaces.
|
|
|
|
## toric_topdata
|
|
|
|
Supported initialisations are represented by the following examples.
|
|
|
|
```python
|
|
elliptic_curve_D = ToricPolytopeProjectiveSpace([1, 2, 3], model_name="elliptic_curve_D")
|
|
|
|
CY3_quintic = ToricPolytopeProjectiveSpace([1, 1, 1, 1, 1], model_name="quintic")
|
|
CY3_bicubic = ToricPolytopeCICY([[3, 3]], model_name="bi-cubic")
|
|
CICY3_two_parameter_manual_nef = ToricPolytope(
|
|
[
|
|
[1, 0, 0, 0, 0, 0],
|
|
[0, 1, 0, 0, 0, 0],
|
|
[0, 0, 1, 0, 0, 0],
|
|
[0, 0, 0, 1, 0, 0],
|
|
[0, 0, 0, 0, 1, 0],
|
|
[0, 0, 0, 0, 0, 1],
|
|
[-1, -1, 0, 0, 0, 0],
|
|
[0, 0, -1, -1, -1, -1],
|
|
],
|
|
nef_partition=[[0, 1, 2, 3], [4, 5, 6, 7]],
|
|
)
|
|
|
|
CICY5_two_parameter = ToricPolytopeCICY([[6, 1], [0, 2]])
|
|
```
|
|
|
|
The discriminant factors and topological data, e.g. for the quintic, can then be computed with the methods below.
|
|
```python
|
|
CY3_quintic.disc()
|
|
|
|
CY3_quintic.topdata()
|
|
```
|
|
|
|
We list the output of above two lines.
|
|
|
|
```term
|
|
INFO:__main__:Discriminant factors: [[z1 + 1/3125, 0]]
|
|
INFO:__main__:
|
|
|
|
--- Polytope and GLSM table ------------------
|
|
1|1|1|1|1|| 1
|
|
|
|
-1|1|0|0|0|| 0
|
|
-1|0|1|0|0|| 0
|
|
-1|0|0|1|0|| 0
|
|
-1|0|0|0|1|| 0
|
|
--------------
|
|
1,1,1,1,1; -5
|
|
|
|
--- L-vectors (GLSM charges) -----------------
|
|
[[1, 1, 1, 1, 1, -5]]
|
|
|
|
--- Intersection numbers CY ------------------
|
|
{(0, 0, 0): 5}
|
|
|
|
--- Intersection ring ------------------------
|
|
5*t0^3
|
|
|
|
--- Intersection ring no multiplicities ------
|
|
5*t0^3
|
|
|
|
--- Chern polynomials ------------------------
|
|
[[0], [10*t0^3], [-40*t0^3]]
|
|
|
|
--- Integrated Chern classes -----------------
|
|
[[0], [50], [-200]]
|
|
DEBUG:__main__:
|
|
|
|
--- Kähler cone generators (ambient space) ---
|
|
['[z4]']
|
|
|
|
--- Intersection numbers ambient space -------
|
|
{(0, 0, 0, 0): 1}
|
|
```
|
|
|
|
The result is saved in the folder `data/topdata` as a JSON file — giving a model name helps keeping
|
|
track of these outputs.
|
|
Note that for Calabi–Yau dimensions larger than four, the additional
|
|
|
|
## period_computation
|
|
|
|
`period_computation.sage` provides classes for working with Picard–Fuchs operators and their
|
|
period solutions: `PFOperator`, `PFIdeal` and `Period`, together with Ansatz variants of the first and
|
|
last (`PFOperatorAnsatz`, `PeriodAnsatz`) used to search for unknown operators or periods of a given
|
|
z- and theta-degree.
|
|
|
|
A `PFOperator` is parsed from a string in the variables `z0, ..., z<n-1>` and `theta0, ..., theta<n-1>`,
|
|
the logarithmic derivatives theta_i = z_i d/dz_i. For example, the quintic's Picard–Fuchs operator:
|
|
|
|
```python
|
|
L = PFOperator(
|
|
"theta0^4 - 3125*z0*theta0^4 - 6250*z0*theta0^3 - 4375*z0*theta0^2 - 1250*z0*theta0 - 120*z0",
|
|
no_variables=1,
|
|
)
|
|
|
|
L.simplify().operator_string
|
|
```
|
|
|
|
```term
|
|
'-5*(5*theta0 + 4)*(5*theta0 + 3)*(5*theta0 + 2)*(5*theta0 + 1)*z0 + theta0^4'
|
|
```
|
|
|
|
An operator (or a `PFIdeal` of several) can be solved for its power series solution at given indicial
|
|
exponents and order.
|
|
|
|
```python
|
|
ideal = PFIdeal([L])
|
|
period = ideal.find_power_series_solution(indicials=[0], order=3)[0]
|
|
|
|
period.period_string
|
|
```
|
|
|
|
```term
|
|
'168168000*z0^3 + 113400*z0^2 + 120*z0 + 1'
|
|
```
|
|
|
|
The reverse direction is supported too: given a `Period`, `find_annihilating_operators` searches for
|
|
`PFOperator`s of a given z- and theta-degree that annihilate it, by solving an Ansatz of unknown
|
|
coefficients via linear algebra. Both directions extend to several moduli, e.g. for the two-parameter
|
|
model P_{2,2,2,1,1}[8]:
|
|
|
|
```python
|
|
M1 = PFOperator(
|
|
"theta1*(-2*theta0 + 2*theta1 - 1) + 2*(theta0 - 2*theta1 - 1)*(theta0 - 2*theta1)*z1",
|
|
no_variables=2,
|
|
)
|
|
M2 = PFOperator(
|
|
"theta0^2*(2*(theta0 - 2*theta1)*z1 - theta1) - 16*(2*theta0 + 1)*(4*theta0 + 1)*(4*theta0 + 3)*z0*z1",
|
|
no_variables=2,
|
|
)
|
|
ideal = PFIdeal([M1, M2])
|
|
|
|
period = ideal.find_power_series_solution(indicials=[0, 1 / 2], order=6)[0]
|
|
recovered = period.find_annihilating_operators(z_degree=1, theta_degree=2)
|
|
|
|
period.period_string
|
|
recovered[0].simplify().operator_string
|
|
```
|
|
|
|
```term
|
|
'-1/45045*(60886425600*z0^3*z1^3 - 2767564800*z0^2*z1^4 + 100638720*z0*z1^5 - 14192640*z1^6 + 830269440*z0^2*z1^3 - 30750720*z0*z1^4 + 4193280*z1^5 - 242161920*z0^2*z1^2 + 9884160*z0*z1^3 - 1281280*z1^4 - 3459456*z0*z1^2 + 411840*z1^3 + 1441440*z0*z1 - 144144*z1^2 + 60060*z1 - 45045)*sqrt(z1)'
|
|
'-2*(theta0 - 2*theta1)*(theta0 - 2*theta1 - 1)*z1 + (2*theta0 - 2*theta1 + 1)*theta1'
|
|
```
|
|
|
|
`recovered[0]` is, up to scale, `M1` — recovered purely from `M1`, `M2`'s shared power series
|
|
solution. |