Data type that represents the individual \(\eta^{ab}\) tensor. The indices are labeled not by characters but by integers.

Data type that represents the individual \(\epsilon^{abcd}\) tensor. The indices are labeled not by characters but by integers.

Data type that represents variables that multiply the individual ansätze to form a general linear combination. The 2nd Int argument labels the variables the first Int is a factor that multiplies the variable.

Data type that represents a general linear combination of ansätze that involve one \(\epsilon^{abcd}\) in each individual product.

Data type that represents a general linear combination of ansätze that involve no \(\epsilon^{abcd}\).

Flatten an AnsatzForestEta to a list that contains the individual branches.

Flatten an AnsatzForestEpsilon to a list that contains the individual branches.

Return one representative, i.e. one individual product for each of the basis ansätze in an AnsatzForestEta. The function thus returns the contained individual ansätze without their explicit symmetrization.

Return one representative, i.e. one individual product for each of the basis ansätze in an AnsatzForestEpsilon. The function thus returns the contained individual ansätze without their explicit symmetrization.

Outputs the forestEtaList in \( \LaTeX \) format. The String argument is used to label the individual indices.

Outputs the forestEpsList in \( \LaTeX \) format. The String argument is used to label the individual indices.

Returns an ASCII drawing of the AnsatzForestEta in the fashion explained in Data.Tree. The ansatz \( x_1 \cdot 8 \{ \eta^{ac}\eta^{bd}\eta^{pq} - \eta^{ad}\eta^{bc}\eta^{pq} \} + x_2 \cdot 2 \{\eta^{ac}\eta^{bp}\eta^{dq} + \eta^{ac}\eta^{bq}\eta^{dp} - \eta^{bc}\eta^{ap}\eta^{dq} - \eta^{bc}\eta^{aq}\eta^{dp} - \eta^{ad}\eta^{bp}\eta^{cq} - \eta^{ad}\eta^{bq}\eta^{cp} + \eta^{bd}\eta^{ap}\eta^{cq} + \eta^{bd}\eta^{aq}\eta^{cp} \} \) is drawn to

(1,3)
|
+---- (2,4)
|  |
|  `---- (5,6) * (8) * x[1]
|
+---- (2,5)
|  |
|  `---- (4,6) * (2) * x[2]
|
`---- (2,6)
   |
   `---- (4,5) * (2) * x[2]

(1,4)
|
+---- (2,3)
|  |
|  `---- (5,6) * (-8) * x[1]
|
+---- (2,5)
|  |
|  `---- (3,6) * (-2) * x[2]
|
`---- (2,6)
   |
   `---- (3,5) * (-2) * x[2]

(1,5)
|
+---- (2,3)
|  |
|  `---- (4,6) * (-2) * x[2]
|
`---- (2,4)
   |
   `---- (3,6) * (2) * x[2]

(1,6)
|
+---- (2,3)
|  |
|  `---- (4,5) * (-2) * x[2]
|
`---- (2,4)
   |
   `---- (3,5) * (2) * x[2]

Returns an ASCII drawing of the AnsatzForestEpsilon in the fashion explained in Data.Tree. The ansatz \( x_3 \cdot 16 \epsilon^{abcd}\eta^{pq} \) is drawn as:

(1,2,3,4)
|
`---- (5,6) * (16) * x[3]

Return a list of the labels of all variables that are contained in the AnsatzForestEta.

Return a list of the labels of all variables that are contained in the AnsatzForestEpsilon.

Remove the branches with variable label contained in the argument Int list from the AnsatzForestEta.

Remove the branches with variable label contained in the argument Int list from the AnsatzForestEpsilon.

Shift the variable labels of all variables that are contained in the AnsatzForestEta by the amount specified.

Shift the variable labels of all variables that are contained in the AnsatzForestEpsilon by the amount specified.

Map a general function over all variables that are contained in the AnsatzForestEta.

Map a general function over all variables that are contained in the AnsatzForestEpsilon.

Return the rank, i.e. the number of different variables that is contained in the AnsatzForestEta.

Return the rank, i.e. the number of different variables that is contained in the AnsatzForestEpsilon.

Encode an AnsatzForestEta employing the Serialize instance.

Encode an AnsatzForestEpsilon employing the Serialize instance.

Decode an AnsatzForestEta employing the Serialize instance.

Decode an AnsatzForestEpsilon employing the Serialize instance.

The function computes all linear independent ansätze that have rank specified by the first integer argument and further satisfy the symmetry specified by the Symmetry value. The additional argument of type [[Int]] is used to provide the information of all (by means of the symmetry at hand) independent components of the ansätze. Explicit examples how this information can be computed are provided by the functions for areaList4, ... and also by metricList2, ... . The output is given as spacetime tensor STTens and is explicitly symmetrized.

This function provides the same functionality as mkAnsatzTensorFast but without explicit symmetrization of the result. In other words from each symmetrization sum only the first summand is returned. This is advantageous as for large expressions explicit symmetrization might be expensive and further is sometime simply not needed as the result might for instance be contracted against a symmetric object, which thus enforces the symmetry, in further steps of the computation.

This function provides the same functionality as mkAnsatzTensorFast but returns the result as tensor of type ATens AnsVarR. This is achieved by explicitly providing not only the list of individual index combinations but also their representation using more abstract index types as input. The input list consists of triplets where the first element as before labels the independent index combinations, the second element labels the corresponding multiplicity under the present symmetry. The multiplicity simply encodes how many different combinations of spacetime indices correspond to the same abstract index tuple. The last element of the input triplets labels the individual abstract index combinations that then correspond to the provided spacetime indices. If some of the initial symmetries are still present when using abstract indices this last element might consists of more then one index combination. The appropriate value that is retrieved from the two ansatz forests is then written to each of the provided index combinations.

Provides the same functionality as mkAnsatzTensorFastSym with the difference that the list of independent index combinations is automatically computed form the present symmetry. Note that this yields slightly higher computation costs.

Provides the same functionality as mkAnsatzTensorFast with the difference that the list of independent index combinations is automatically computed form the present symmetry. Note that this yields slightly higher computation costs.

The function is similar to mkAnsatzTensorFastSym yet it uses an algorithm that prioritizes memory usage over fast computation times.

The function is similar to mkAnsatzTensorFast yet it uses an algorithm that prioritizes memory usage over fast computation times.

The function is similar to mkAnsatzTensorFastAbs yet it uses an algorithm that prioritizes memory usage over fast computation times.

The function is similar to mkAnsatzTensorFastSym' yet it uses an algorithm that prioritizes memory usage over fast computation times.

The function is similar to mkAnsatzTensorFast' yet it uses an algorithm that prioritizes memory usage over fast computation times.

Type alias to encode the symmetry information. The individual Int values label the individual spacetime indices, the Symmetry type is the compromised of (SymPairs, ASymPairs, BlockSyms, CyclicSyms, CyclicBlockSyms).

Evaluation list for \(a^A \).

Evaluation list for \(a^{AI} \).

Evaluation list for \(a^{A B}\). Note that also when using the abstract indices this ansatz still features the \( A \leftrightarrow B \) symmetry.

Evaluation list for \(a^{Ap Bq}\). Note that also when using the abstract indices this ansatz still features the \( (Ap) \leftrightarrow (Bq) \) symmetry.

Evaluation list for \(a^{ABI} \).

Evaluation list for \(a^{ABC} \). Note that also when using the abstract indices this ansatz still features the symmetry under arbitrary permutations of \( ABC\).

Evaluation list for \(a^{ABp Cq}\). Note that also when using the abstract indices this ansatz still features the \( (Bp) \leftrightarrow (Cq) \) symmetry.

Evaluation list for \(a^{A B C I}\). Note that also when using the abstract indices this ansatz still features the \( (A) \leftrightarrow (B) \) symmetry.

Evaluation list for \(a^{A} \).

Evaluation list for \(a^{AI} \).

Evaluation list for \(a^{A B}\). Note that also when using the abstract indices this ansatz still features the \( A \leftrightarrow B \) symmetry.

Evaluation list for \(a^{Ap Bq}\). Note that also when using the abstract indices this ansatz still features the \( (Ap) \leftrightarrow (Bq) \) symmetry.

Evaluation list for \(a^{ABI} \).

Evaluation list for \(a^{ABC} \). Note that also when using the abstract indices this ansatz still features the symmetry under arbitrary permutations of \( ABC\).

Evaluation list for \(a^{ABp Cq}\). Note that also when using the abstract indices this ansatz still features the \( (Bp) \leftrightarrow (Cq) \) symmetry.

Evaluation list for \(a^{A B C I}\). Note that also when using the abstract indices this ansatz still features the \( (A) \leftrightarrow (B) \) symmetry.

Symmetry list for areaList4.

Symmetry list for areaList6.

Symmetry list for areaList8.

Symmetry list for areaList10_1.

Symmetry list for areaList10_2.

Symmetry list for areaList12.

Symmetry list for areaList14_1.

Symmetry list for areaList14_2.

Symmetry list for metricList2.

Symmetry list for metricList4_1.

Symmetry list for metricList4_2.

Symmetry list for metricList6_1.

Symmetry list for metricList6_2.

Symmetry list for metricList6_3.

Symmetry list for metricList8_1.

Symmetry list for metricList8_2.