-
Notifications
You must be signed in to change notification settings - Fork 0
The Functions in QMGsurvey III
ATTENTION: This page is still under construction!
SeedRandom in advance recommended; Scans the chosen leaf via random curves.
Arguments
| Argument | Type | Description |
|---|---|---|
| X | MatConf(Dim,Nim) | a matrix configuration |
| x | Real(Dim) | an initial point in target space |
| delta | Real | a positive finite step length in the integration of discrete curves |
| nPrime | Int | the (positive) number of random curves |
| n | Int | the (positive) number of steps (initial point excluded) in the integration of discrete curves |
| m | Int | the (positive) number of intermediate steps (zero means no intermediate steps) in the integration of discrete curves |
| l | Int | a positive even integer, the effective dimension of the quantum manifold |
| leaf="TSleaf" | Str | the chosen leaf, can be "TSleaf", "QMleaf" or "GQMleaf". "TSleaf" is the hybrid leaf (using theta), "QMleaf" is the hybrid leaf using omega and "GQMleaf" is the hybrid leaf using omega and g |
cqmgScan is not parallelizable.
Output
The output is xsScan.
| Output | Type | Description |
|---|---|---|
| xsScan | Real(nPrime*n+1,Dim) | the points in the scan of the chosen leaf, xsScan(1) is the initial point x |
Description
cqmgScan constructs a scan of the chosen leaf through x. This is done via curves with random initial tangent vector and an initial point that is randomly chosen from the previously calculated points. Since random numbers are involved, it is recomended to seed a random state in advance to maintain reproducability. Compare to [1] section 3.3.
Example(s)
An example for the fuzzy sphere:
X=qmgXsu2[4];
l=2;
x={0,0,1};
delta={0.01};
nPrime=10;
n=1000;
m=3;
leaf="QMleaf";
SeedRandom[1];
cqmgScan[X,x,delta,nPrime,n,m,l,leaf]Constructs local coordinates for the chosen leaf.
Arguments
| Argument | Type | Description |
|---|---|---|
| X | MatConf(Dim,Nim) | a matrix configuration |
| x | Real(Dim) | an initial point in target space |
| delta | Real | a positive finite step length in the integration of discrete curves |
| n | Int | the (positive) number of steps (initial point excluded) in the integration of discrete curves |
| m | Int | the (positive) number of intermediate steps (zero means no intermediate steps) in the integration of discrete curves |
| l | Int | a positive even integer, the effective dimension of the quantum manifold |
| leaf="TSleaf" | Str | the chosen leaf, can be "TSleaf", "QMleaf" or "GQMleaf". "TSleaf" is the hybrid leaf (using theta), "QMleaf" is the hybrid leaf using omega and "GQMleaf" is the hybrid leaf using omega and g |
| calculateJaccobians=True | Bool | True: the Jaccobians are calculated; False: the Jaccobians are not calculated |
| epsilon=10^-8 | Real | the (positive) finite difference in the calculation of the Jaccobians |
cqmgCoordinates is not parallelizable.
Output
The output is {xssCoordinates,xssJaccobians} if calculateJaccobians=True; the output is {xssCoordinates} if calculateJaccobians=False.
| Output | Type | Description |
|---|---|---|
| xssCoordinates | Real(2*n+1,...l times...,2*n+1,Dim) | the constructed local coordinates. The first l indices parametrize the new coordinates, specifying a point in target space, xssCoordinates(n+1,...l times...,n+1) is the initial point x). The last index corresponds to the point in target space |
| xssJaccobians | Real(2*n+1,...l times...,2*n+1,l,Dim) | the constructe Jaccobians. The first l indices parametrize the new coordinates, specifying a point in target space, xssJaccobians(k_1,...,k_l) is the Jaccobian at the point xssCoordinates(k_1,...,k_l). The last two indices correspond to the Jaccobi matrix. The second but last corresponds to the new coordinates, while the last corresponds to the target space |
Description
cqmgCoordinates constructs descrete local coordinates in the chosen leaf through x. This is done by integrating discrete curves.
The output xssCoordinates should be thought of as a discretization of a map
Example(s)
An example for the fuzzy sphere:
X=qmgXsu2[4];
l=2;
x={0,0,1};
delta={0.1};
n=10;
m=3;
leaf="QMleaf";
cqmgCoordinates[X,x,delta,n,m,l,leaf]An example for the fuzzy sphere wthout calculating Jaccobians:
X=qmgXsu2[4];
l=2;
x={0,0,1};
delta={0.1};
n=10;
m=3;
leaf="QMleaf";
cqmgCoordinates[X,x,delta,n,m,l,leaf,False]For internal use; Initialzation function of cqmgPointInTileQ, cqmgPointsInTile, cqmgFindOptimalPointInTile and cqmgFilledTileQ; these perform important calculations in the context of tilings.
For internal use; Initialzation function of cqmgPointInTileQ, cqmgPointsInTile, cqmgFindOptimalPointInTile and cqmgFilledTileQ; these perform important calculations in the context of tilings.
Arguments
| Argument | Type | Description |
|---|---|---|
| X | MatConf(Dim,Nim) | a matrix configuration |
| l | Int | a positive even integer, the effective dimension of the quantum manifold |
Output
The output is {cqmgPointInTileQ,cqmgPointsInTile,cqmgFindOptimalPointInTile,cqmgFilledTileQ}.
| Output | Type | Description |
|---|---|---|
| cqmgPointInTileQ | Fx | the compiled function |
| cqmgPointsInTile | Fx | a function based on cqmgPointInTileQ |
| cqmgFindOptimalPointInTile | Fx | a function based on cqmgPointInTileQ |
| cqmgFilledTileQ | Fx | a function based on cqmgPointInTileQ |
Initialized with cqmgPointInTileQINIT; cqmgPointInTileQ checks if a point lies within a tile.
Arguments
| Argument | Type | Description |
|---|---|---|
| x | Real(Dim) | a point in target space |
| Tile | Real(Dim,2) | a tile in target space. Tile(k,1) defines the lower bound in direction k, Tile(k,2) defines the upper bound in direction a |
cqmgPointInTileQ is parallelizable in the variables x and Tile.
Output
The output is out.
| Output | Type | Description |
|---|---|---|
| out | Bool | True if for all k Tile(k,1) is smaller or equal x(k) and x(k) is smaller Tile(k,2); else False |
Initialized with cqmgPointsInTileINIT; cqmgPointsInTile selects the points of a list that lie within a tile.
Arguments
| Argument | Type | Description |
|---|---|---|
| xs | Real(k,Dim) | a list of length k consisting of points in target space |
| Tile | Real(Dim,2) | a tile in target space. Tile(k,1) defines the lower bound in direction k, Tile(k,2) defines the upper bound in direction a |
cqmgPointsInTile is not parallelizable.
Output
The output is xsInTile.
| Output | Type | Description |
|---|---|---|
| xsInTile | Real(kPrime,Dim) | a list of length kPrime consisting of points in target space. This is the list of points from xs that lie in the Tile |
Initialized with cqmgFindOptimalPointInTileINIT; cqmgFindOptimalPointInTile chooses from a list of points in a tile the point that lies most centered in the tile.
Arguments
| Argument | Type | Description |
|---|---|---|
| xsInTile | Bool(k,Dim) | a list of length k consisting of points in target space that lie in the Tile |
| Tile | Real(Dim,2) | a tile in target space. Tile(k,1) defines the lower bound in direction k, Tile(k,2) defines the upper bound in direction a |
cqmgFindOptimalPointInTile is not parallelizable.
Output
The output is x.
| Output | Type | Description |
|---|---|---|
| x | Real(Dim) | the point from xsInTile that is most centered |
| Tile | Real(Dim,2) | a tile in target space. Tile(k,1) defines the lower bound in direction k, Tile(k,2) defines the upper bound in direction a |
Initialized with cqmgFilledTileQINIT; cqmgFilledTileQ checks if some local coordinates filled a Tile.
Arguments
| Argument | Type | Description |
|---|---|---|
| CoordinatesInTileQ | Bool(2*n+1,...l times...,2*n+1) | This is the output of cqmgPointInTileQ[xssCoordinates,Tile] for some local coordinates xssCoordinates, being themselves part of the output of cqmgCoordinates |
| Tile | Real(Dim,2) | a tile in target space. Tile(k,1) defines the lower bound in direction k, Tile(k,2) defines the upper bound in direction a |
cqmgFilledTileQ is not parallelizable.
Output
The output is Filled.
| Output | Type | Description |
|---|---|---|
| Filled | Bool | True if CoordinatesInTileQ(k_1,...,k_l)=False in all cases where at least one k_j is 1 or 2*n+1; else False. This means that all border points of xssCoordinates lie outside of the Tile, thus the coordinates fill the Tile |
Description
cqmgPointInTileQ checks if a point lies within a given Tile.
cqmgPointsInTile selects all points from a list of points that lie within a given Tile.
cqmgFindOptimalPointInTile chooses from a list of points in a tile the point that lies most centered in the Tile.
This is done by minimizing
Example(s)
An example for cqmgPointInTileQ using parallelization:
X=qmgXsu2[4];
l=2;
Tile={{0,1},{-1,0},{-1,3}}
x1={0,0,1};
x2={0,1,0};
x3={0,0,1/2}
xs={x1,x2,x3}
{cqmgPointInTileQ,cqmgPointsInTile,cqmgFindOptimalPointInTile,cqmgFilledTileQ}=cqmgPointToolsINIT[X,l];
cqmgPointInTileQ[xs,Tile]An example for cqmgPointsInTile:
X=qmgXsu2[4];
l=2;
Tile={{0,1},{-1,0},{-1,3}}
x1={0,0,1};
x2={0,1,0};
x3={0,0,1/2}
xs={x1,x2,x3}
{cqmgPointInTileQ,cqmgPointsInTile,cqmgFindOptimalPointInTile,cqmgFilledTileQ}=cqmgPointToolsINIT[X,l];
cqmgPointsInTile[xs,Tile]An example for cqmgFindOptimalPointInTile:
X=qmgXsu2[4];
l=2;
Tile={{0,1},{-1,0},{-1,3}}
x1={0,0,1};
x2={0,1,0};
x3={0,0,1/2}
xs={x1,x2,x3}
{cqmgPointInTileQ,cqmgPointsInTile,cqmgFindOptimalPointInTile,cqmgFilledTileQ}=cqmgPointToolsINIT[X,l];
xsInTile=cqmgPointsInTile[xs,Tile];
cqmgPointsInTile[xsInTile,Tile]An example for cqmgFilledTileQ:
X=qmgXsu2[4];
l=2;
Tile={{0,1},{-1,0},{-1,3}}
x={1/2,-1/2,0};
delta={0.3};
n=10;
m=3;
leaf="QMleaf";
xssCoordinates=cqmgCoordinates[X,x,delta,n,m,l,leaf,False];
{cqmgPointInTileQ,cqmgPointsInTile,cqmgFindOptimalPointInTile,cqmgFilledTileQ}=cqmgPointToolsINIT[X,l];
CoordinatesInTileQ=cqmgPointInTileQ[xssCoordinates,Tile];
cqmgFilledTileQ[CoordinatesInTileQ,Tile]For internal use; Initialzation function of cqmgIntegrands; cqmgIntegrands calculates the integrands for integration over the chosen leaf.
Arguments
| Argument | Type | Description |
|---|---|---|
| X | MatConf(Dim,Nim) | a matrix configuration |
| l | Int | a positive even integer, the effective dimension of the quantum manifold |
Output
The output is cqmgIntegrands.
| Output | Type | Description |
|---|---|---|
| cqmgIntegrands | Fx | the compiled function |
For internal use; Initialized with cqmgIntegrandsINIT; cqmgIntegrands calculates the integrands for integration over the chosen leaf.
Arguments
| Argument | Type | Description |
|---|---|---|
| Jaccobi | Real(l,Dim) | the Jaccobain matrix of local coordinates at a point (as in the output of cqmgCoordinates) |
| EigState | Complex(Nim,1) | the quasi-coherent state at a point (as in the output of cqmgBasic) |
| MeasureForm | Real(Dim,Dim) | a measore form at a given point, eather omega or g (as in the output of cqmgBasic) |
| xBold | Real(Dim) | xBold at a point (as in the output of cqmgBasic) |
cqmgIntegrands is parallelizable in the variables Jaccobi, EigState, MeasureForm and xBold.
Output
The output is out.
| Output | Type | Description |
|---|---|---|
| out | Complex(Nim*Nim+Dim*Nim*Nim) | compressed output. With respect to the output of cqmgIntegrandsEXTR out=Join[Integrand,xBoldTensorIntegrand] |
For internal use; Extraction function of cqmgIntegrands; cqmgIntegrands calculates the integrands for integration over the chosen leaf.
Arguments
| Argument | Type | Description |
|---|---|---|
| out | Complex(1+Dim,Nim,Nim) | the output of cqmgIntegrands |
Output
The output is {Integrand,xBoldTensorIntegrand}.
| Output | Type | Description |
|---|---|---|
| Integrand | Complex(1+Dim,Nim,Nim) | the integrand at the point |
| xBoldTensorIntegrand | Complex(Dim,Nim,Nim) | the tensor product of xBold with the Integrand at a point |
Description
cqmgIntegrands calculates the integrand and its tensor product with xBold at a point.
At the point x Integrand is
Example(s)
An example for the fuzzy sphere:
X=qmgXsu2[4];
l=2;
x={0,0,1};
delta={0.3};
n=10;
m=3;
leaf="QMleaf";
{xssCoordinates,xssJaccobians]=cqmgCoordinates[X,x,delta,n,m,l,leaf];
xChosen=xssCoordinates[[2,3]];
Jaccobi=xssJaccobians[[2,3]];
cqmgQMleafBasic=cqmgQMleafBasicINIT[X];
out=cqmgQMleafBasic[xChosen];
{EigState,omega,xBold}=cqmgQMleafBasicEXTR[out];
cqmgIntegrands=cqmgIntegrandsINIT[X,l];
out=cqmgIntegrands[Jaccobi,EigState,omega,xBold]Integrates over a given tile.
Arguments
| Argument | Type | Description |
|---|---|---|
| X | MatConf(Dim,Nim) | a matrix configuration |
| xCollection | Real(k,Dim) | a list of length k, consising of points in target space that lie in the chosen leaf. Usually, this is the output of qmgScan |
| Tile | Real(Dim,2) | a tile in target space. Tile(k,1) defines the lower bound in direction k, Tile(k,2) defines the upper bound in direction a |
| delta | Real | a positive finite step length in the construction of discrete local coordinates |
| n | Int | the (positive) number of steps (initial point excluded) in the construction of discrete local coordinates |
| m | Int | the (positive) number of intermediate steps (zero means no intermediate steps) in the construction of discrete local coordinates |
| l | Int | a positive even integer, the effective dimension of the quantum manifold |
| leaf="TSleaf" | Str | the chosen leaf, can be "TSleaf", "QMleaf" or "GQMleaf". "TSleaf" is the hybrid leaf (using theta), "QMleaf" is the hybrid leaf using omega and "GQMleaf" is the hybrid leaf using omega and g |
| measure="omega" | Str | the chosen measure. Either "omega" for omega or "g" for g |
| epsilon=10^-8 | Real | the (positive) finite difference in the calculation of the Jaccobians in the construction of discrete local coordinates |
cqmgIntegrateTile is not parallelizable.
Output
The output is {{CompletenessTile,xBoldQuantizationTile},{xsCoordinatesInTile,xsEigStatInTile,xsIntegrandInTile},{TileNonempty,xsInTileNumber,FilledTileQ}} .
| Output | Type | Description |
|---|---|---|
| CompletenessTile | Complex(Nim,Nim) | the local quantization of the 1 function (if TileNonempty=False: ConstantArray[0,{Nim,Nim}]) |
| xBoldQuantizationTile | Complex(Dim,Nim,Nim) | the local quantization of xBold (if TileNonempty=False: ConstantArray[0,{Dim,Nim,Nim}]) |
| xsCoordinatesInTile | Real(k,Dim) | a list of length k consisting of the constructed corrdinate points that lie within the Tile (if TileNonempty=False: {}) |
| xsEigStatInTile | Complex(k,Nim) | a list of length k consisting of the quasi-coherent states at the constructed corrdinate points that lie within the Tile (if TileNonempty=False: {}) |
| xsIntegrandInTile | a list of length k consisting of the Integrands at the constructed corrdinate points that lie within the Tile (if TileNonempty=False: {}) | |
| TileNonempty | Bool | True if at least one of the points in xCollection lies within the Tile; else False |
| xsInTileNumber | Int | the number of points in xCollection that lie within the Tile (if TileNonempty=False: 0) |
| FilledTileQ | Bool | True if the constructe discrete local coordinates filled the Tile (this means that all border points lie outside of the Tile) (if TileNonempty=False: True, this is for better compatibility with other functions) |
Description
cqmgIntegrateTile chooses the optimally centered point in a given Tile from points coming from cqmgScan.
Arround that point, discrete local coordinates are constructed. Further, the maps
Example(s)
An example for the fuzzy sphere:
X=qmgXsu2[4];
l=2;
Tile={{0,1},{-1,0},{-1,3}}
x={0,0,1};
deltaScan={0.01};
nPrime=10;
nScan=1000;
mScan=3;
deltaInt={0.1};
nInt=25;
mInt=1;
leaf="QMleaf";
measure="omega";
SeedRandom[1];
xCollection=cqmgScan[X,x,deltaScan,nPrime,nScan,mScan,l,leaf];
cqmgIntegrateTile[X,xCollection,Tile,deltaInt,nInt,mInt,leaf,measure]Integrates over a tiling.
Processes the output of cqmgIntegrateTiling in the context of quantization.
Preview of cqmgIntegrateTile; only calculates local coordinates.
Preview of cqmgIntegrateTiling; only calculates a covering with local coordinates.
Integrates custom functions over a tiling via the output of cqmgIntegrateTiling.
Initialization function of cqmgKaehlerCost; cqmgKaehlerCost calculates the Kähler cost for a given linear subspace of the tangent space.
Extraction function of cqmgKaehlerCost; cqmgKaehlerCost calculates the Kähler cost for a given linear subspace of the tangent space.
Simplified function built on cqmgKaehlerCost; calculates the Kähler cost for a given linear subspace of the tangent space.
Calculates the Kähler cost for the chosen leaf.
SeedRandom in advance recommended; calculates the Kähler cost for random subspaces.
Calculates the Poisson structure induced by omega in the form of theta for a given point.
SeedRandom in advance recommended; performs various checks that validate the quality of the semiclassical limit based on the output of cqmgIntegrateTiling.
SeedRandom in advance recommended; constructs a table with the most interesting output of cqmgQuantizationValidation.