The exceptions or what is going on in the background

As it has been mentioned, the assignment statements, LET rules and rule lists can be applied in the simple forms in almost all the cases. However there are two types of problems which cannot be solved by them and the solution of the first one offers the true insight of the simple statements.

Let us assume first that there are relations between the component of a quantity and other objects:

$g$_$\mu$$\nu$ = $\{(ff$ \omega $$_i f $\omega$_j - $\{1f\}\; h$_ij + f $\omega$_i $\omega$_j $\}$ $\Rightarrow$ g₀₀ = f, g_0i = f $\omega$_i, g_ij = - $\{1f\}\; h$_ij + f $\omega$_i $\omega$_j. g^$\mu$$\nu$ = $\{($ \{1f\}\; -\; f\; hkl$ \omega $$$_k $\omega$_l f h^ik$\omega$_k f h^jk$\omega$_k - f h^ij $\}$ $\Rightarrow$ g⁰⁰ = $\{1f\}\; -\; f\; hkl$ \omega $$_k $\omega$_l, g⁰ⁱ = f h^ik$\omega$_k, g^ij = - f h^ij.

How could we write LET statements or rule lists which express these relations in RICCIR?

The cases with covariant indices are simple, because the minuses before the indices exclude the indices to be contravariant ones:

At the second equation we have to exclude the value 0 for I but otherwise I must be handled as an arbitrary variable:

The third equation is quite similar to the second one:

In the case of contravariant indices an auxiliary function CONTRAV must be applied to exclude the covariant indices, because they too would match the conditions like FOR ALL I SUCH THAT I NEQ 0 LET ...:

There is another auxiliary function DUMMY also to exclude the concrete index values for the dummy indices on the left hand side in the LET statements:

One may ask of the assignment statements if one wants to express these relations as assignments and not as LET rules according to the terminology of REDUCE. The solution is quite simple in RICCIR: if one would like to use assignment statements instead of LET rules then one has to change the equal sign $=$ to the assignment sign $:=$ in the LET statements only, e.g.

(In the first case, the word LET can be omitted from the command.)

The rules which RICCIR obey in evaluating these statements are as follows:

• If there is a FOR ALL clause of the LET rule or the assignment statement, or there is a variable with tilde in the rule list then the condition for the indices is determined absolutely by the user.
• If there is no abstract index in the expression on the left hand side then it is a simple LET rule, assignment statement or rule list.
• Otherwise the system generates a boolean expression as a condition according to the abstract indices of the expression on the left hand side of the signs $=$, $:=$ or $=>$. Only the case of LET <expr> = <epxr>; is being illustrated for the sake of simplicity.
  ( $T$_ij is a tensor and $S$_ij is a symbol then

  $T$_ij := S_ij ⇒ T_ij := g_i^{/ur k} g_j^{/ur l} S_kl

  • the contravariant indices I,J,... from symbols generate a condition like

    

  • the dummy indices K,L,... give the condition

    

  • all the abstract indices M,N,... differing from the cases (b),(c) generate the condition

    

  • the results of (b),(c),(d) are collected as the final real condition for the indices of the expression:

    

The second case, when simple LET <expr> = <expr> declaration cannot be applied, has already been illustrated on page : it is the declaration of a differential rule for an user defined operator.

The system would be unable to find out the scope of the validity of the rule from the objects and their arguments, therefore the user him or herself has to write a complete FOR ALL ... LET ... rule. Naturally differential rules for tensors and symbols can be defined by simple LET <expr> = <expr> commands as well.