[2.2.5.1]            Les Variables Primitives:
                               Les Variables Primitives Simples: Variable dont le nombre d'itération maximum et le nombre de dimension sont définit par au moins une Variable de Limitation et/ou une valeur égale ou inférieure au nombre maximal de Variable de Limitation Ln. Son utilité est de définir l'entrée d'un problème afin de le mesurer par la suite avec une Variable de Résolution Rn. Ce type de variable s'écrit Pn (P1, P2, ... ). Les Variables Primitives Simples, pour la résolution d'un problème en passant par la conjecture de la résolution en losange, peuvent être modifié uniquement dans les Modules suivants, sauf pour une exception que nous verrons dans un autre chapitre:
                                       - Système d'Origine SO (Initialise les variables.)
                                        - Proposition PN (Assigne des valeurs à une variable avant l'application d'un calcul.)
                               Exemple: Un sac à dos possède une capacité de supporter jusqu'à 100kg. Comment entrer des objets en ayant la plus grande valeur marchande dans le sac par résolution polynomiale?
                    Ici, P représente les objets qui sont au nombre d'une limitation L, ayant deux dimensions qui représente le poids et la valeur de chaque objet, dont le nombre maximale d'itération est de P1[L,2], dont L représente le poids et la valeur de chaque objet individuellement, et P2.2 représente le poids et la valeur total de tout les objets.
 

                               Les Variables Primitives de Résolution: Variable dont le nombre maximum d'itération est définit par le nombre d'itération d'au moins une Variable Primitive Simple ou Complexe. Son utilité est de mesurer et/ou de calculer un ou plusieurs problèmes, sans modifier les valeurs des Variables Primitives Simples P et Complexe C, afin d'apporter un résultat dans une Variable Primitive de Mémoire M. Cette variable s'écrit Rn (R1, R2, ...).
                                       Dans l'exemple précédent, R calcul selon chaque objet entrant la valeur marchande total des objets, dès que la valeur du poids restant de total de tout les objets est inférieur à la capacité du sac, il calcule et sélectionne un ou plusieurs objets à placer dans le Sac.
 

                               Les Variables Primitives Complexes: Variable Primitive étant soit Simple ou de Mémoire. Ce Type de Variable s'écrit Cn. (C1, C2, ...). Ce type de variable a pour utilité de combiner deux ou plusieurs problèmes ensembles afin d'en résoudre un autre, ou de fractionner un problème pour les résoudre indépendamment. La théorie de la résolution en losange exploite les Variables Primitives Complexes Cn afin de fractaliser ou défractaliser un problème. Cette théorie utilise normalement Cn comme Variable Primitive de Mémoire dans un premier Système d'Origine afin de l'exploité comme Variable Primitive Simple dans un ou plusieurs autres Systèmes d'Origines par la suite.
                                       Exemple de problème: Il y a 400 étudiants et 100 pupitres disponibles placés aléatoirement. Des équipes numérotées doit être fait de sorte que chaque étudiant placé ne doit pas être voisin d'un autre étudiant de la même équipe. Pour compliqué la tâche, chaque étudiant choisi, interdit un ou plusieurs étudiant d'être choisi, mais aussi chaque étudiant refuse d'être dans un numéro d'équipe.
                   Question: Comment choisir les étudiants, ou les placer, quel seront leur équipe?
                   Réponse: L1 est le nombre d'étudiant, L2 le nombre de place, et L3 le nombre maximum d'équipe.
                   P1[L1,(L1+1)] représente les incompatibilité entre les étudiants et leur valeurs d'incompatibilités. P2[(L1+1),L3] représente les numéros d'équipes que les étudiants refusent d'obtenir et la valeur total des refus des étudiants acceptés. R1[L1,(L1+1)] représente la liste des incompatibilités des étudiant en cour de calcul, et l'état du calcul de chaque étudiant (non mesuré, mesuré, en cour de calcul, calculé, trié). C[L2] représente les étudiants choisi; étudiant utilisé pour la prochaine phase de calcul.
                   Une fois les étudiants choisi, P3[L2,L2] représente les pupitres et leur voisin. R2[L2,(L2+1)] représente les équipes voisines de chaque pupitre et les priorités de choix de calcul pour chaque pupitre en cour de calcul. Et enfin, M[L2,2] représente le choix des étudiants choisi avec leur numéro d'équipe.

 
                               Les Variables Primitives de Mémoire: Variable Primitive Simple dont sa valeur ne sert pas à calculer ou mesurer un problème. Cette Variable s'écrit Mn ( M1, M2, ... ). L'utilité de la Variable Primitive de Mémoire est d'emmagasiner un résultat recherché. Dans l'exemple du sac à dos mentionné plus haut, M identifie par 0 ou 1 les objets qui sont placés dans le sac, permettant de connaître le résultat du problème en une seule variable itérée.

[2.2.5.2]            Les Variables Secondaires:
                               Les Variables de Limitation: Variable définissant sous forme de valeur la limitation d'un autre type de variable. Ce type de variable s'écriera toujours Ln ( L1, L2 , ... ), et a pour utilité de définir une limite de calcul ou d'itération à un problème. Dans la théorie de la résolution en losange, cette variable peut être initialisée dans un Système d'Origine et modifiée dans une Proposition, mais aucun autre Module Primitif ne peut modifier la valeur.
                                       Exemple #1: si nous disons qu'il y a 400 étudiants dans un problème donné, les étudiants sont représentés par P, et leur nombre est d'une limitation L.

 
                                       NOTE: Il est possible de modifier la valeur de L n'importe où, dans l'unique cas où nous souhaitons économiser de la place en terme de variable, et que la Variable de Limitation concernée est réinitialisée par une Proposition à chaque nouveau calcul. Mais lorsque nous appliquons la résolution en losange, L ne peut être modifier uniquement dans une Proposition ou dans un Système d'Origine.

 
                                        Exemple #2: Yan achète 10 pommes et 15 poires pour 7$. Si les pommes coûtent 2 fois plus cher que les poires, combien coûte une seule poire?
                                        P.1 et P.2 représente les pommes et les poires; L1 et L2 leurs nombres; L3 le coût total. M reçoit la réponse et le calcul:
                                       /* Les chapitres 3,4 et 5 de ce référentiel expliquent la syntaxe et les structure des modules primitifs.
                                             Il n'est donc pas nécessaire de les retenir à ce stade-ci.
                                       */
                                        SO()==    // Système d'Origine
                                                 OL(15,10,7) ;
                                                          // L1=15     L2=10     L3=7
                                                 OP( ²01 ¦ 0 ) ;
                                                          // P.1 = 0      P.2 = 0
                                                          // M = 0
                                                 PN() ;
                                        PN()==    // Proposition
                                                 P.1 = L1        // Poire
                                                 P.2 = L2 ;      // Pomme
                                                 AF() ;
                                        AF()==    // Application Finale
                                                 M = L3 / ((P.2 * 2) + P.1)
                                                          // M = 0,20

                               Les Variables Secondaires de Mémoires servent à définir des valeurs itérées, ou à mémoriser de manière temporaire un résultat. Nous utilisons les lettres minuscules à partir de i pour la représenter (i, j, k, l, ...).

                               Les Arguments: Cette classe contient les variables de type Argument (Arg) s'écrivent an ( a1, a2, ... ). Représenté en bleu argenté, son utilité est de préserver une valeur entre au moins deux Modules Primitifs, sans dépendre des autres variables, permettant de réutiliser une variable tout en mémorisant temporairement sa valeur d'origine.
         NOTE: Lorsque nous utilisons les règles de la Théorie de la Résolution en Losange, il est interdit de modifier la valeur d'un argument en passant par son propre module primitif en cour de calcul.
                                        Exemple :
                                                SO()==        // Module Primitif SO().
                                                         i = 10
                                                         P = 2 ;
                                                                // la valeur de i est mémorisée dans a1 de SLP().
                                                         SLP( i ) ;
                                              SLP()==        // Module Primitif SLP().
                                                         i = P * 2 ;
                                                         P = i * a1 ;
                                                             // P = 40

[2.3] Les valeurs.
        Le dernier type de node primitif est les valeurs, qui sont aussi représentées en bleu. Il existe deux types de valeur calculable:
                 Les valeurs numériques: Ce type de valeur est représenté par des nombres. Par exemple:
                          P = (1+4) ;
                                    La valeur numérique la plus petite est la singularité s de la conjecture des hexels. Si s est additionné à un nombre, ce nombre ne bouge pas; si s est soustrait à un nombre décimal, il ne bouge pas; si s est soustrait à un nombre entier, alors le résultat 1 est retiré, et possède une infinité de 9 derrière. Par exemple:
                          8 - s = 7,99999...
                Les valeurs scripturales: Ces valeurs sont représentées par des lettres ou des symboles, auquel chaque caractère correspond à un nombre. Ce type de valeur doit être placé entre des guillemets, afin de les différencier des variables, par exemple:
                          P = "Hello" ;

                                    Si Chaque lettre de l'alphabet dans l'exemple ci-dessus correspondrait à leur position dans l'alphabet, nous pourrions lire la valeur comme cela:
                          P = [8,5,12,12,15] ;

                                    De même qu'une variable peut être itérée, la valeur d'une variable peut l'être également. Nous pouvons par exemple modifier les valeurs de l'exemple ci-dessus selon leur position:
                          P += [1,0,0,¬3] ;
                                    Le résultat de P devient donc:
                          P = [9,5,12,9,15]

                                    Le nombre d'itération d'une valeur peut varier au cour d'un calcul. Pour cela, nous utilisons le module composé « end ». Par exemple, pour P = [1,3,26,4] , nous pouvons retirer les deux dernières itérations comme précisé ici:
                          Variante #1:
                                   P = [ P1 , P2 , end ] ;
                                             // L'exposant P à gauche d'une valeur sert à prendre la valeur P à la position énoncé par la dite valeur.
                           Variante #2:
                                   P = [ 1 , 3 , end ] ;

[2.4] Différence entre les termes « Formule de SCI » et « Équation de SCI ».
         Il est important de savoir différencier une Formule de SCI et une Équation de SCI, afin de pouvoir appliquer une conversion par le billet de la Résolution en Losange.

 
                  Une Formule de SCI se caractérise par un nombre d'opérateurs relatif aux valeurs des variables de l'Origine Primitive (comprenant l'initialisation des variables Primitives) et de l'Origine de Limitation (Comprenant l'initialisation des variables de Limitation) du problème en question. Une Formule de SCI sera toujours une géodésie logique, c'est-à-dire une résolution polynomiale, lorsque nous exploitons des nodes composés. Ces nodes composés sont définit dans le prochain sous-chapitre.

 
                 Une Équation de SCI se caractérise par un nombre d'opérations invariables peu importe les valeurs des variables de votre équation, mais aussi par le fait qu'il s'agira toujours d'une géodésie logique pour l'ensemble des valeurs possibles pour les variables de l'Origine Primitive, et par le fait qu'elle ne possède aucun node composé, sauf dans le cas où la réponse est itérée, dans ce cas précis uniquement, l'Équation de SCI peut posséder des Priorités de Réaction.
       NOTE: Pour plus d'informations sur les Formules de SCI et les Équations de SCI, voir la conjecture de la résolution en losange.

[2.5]    La classe des Nodes Composés: Ces nodes ont comme particularité d'effectuer une suite logique d'au moins deux opérations différentes, et possèdent souvent une variable secondaire de mémoire ou argumentaire (a1, a2, i, j , k ...) servant à son exécution unique.

         Les fonctions: Une fonction est un node faisant appel à des Arguments et une Opération pouvant faire appel à d'autres Nodes et/ou des Modules. Un Argument est la valeur mémorisée d'une Variable, ou le résultat d'une ou plusieurs Opérations Logiques.

                  RA(Arg1 Op Arg2) et ! : Vérifie une condition et retourne par vrai (1) ou faux (0) l'équation.
                          p.ex: RA( X > 0 ){ X += 1 ; } ! { X -= 1 ; }  Nous vérifions si X est plus grand que 0 pour lui ajouter 1, sinon, nous lui retirons 1).
                                        Note : ! peut également être écrit else .
          Variant : RA( Var1 ): Cette variante regarde si la variable est égal à True (1).
                           Note: RA( arg1 ) correspond à RA( arg1 = True ).

                  & : Fonction définissant une addition de condition RA. Par exemple « RA( (a=1) & (b=2) ){ LOGIQUE_A }!{ LOGIQUE_B } », la logique_a ne sera exécutée que si a est égal à 1 et b égal à 2; sinon il exécutera la logique_b. En remplacent & par | la fonction RA retournera vrai ( 1 ) si seulement l'une des conditions est vraie au lieu de la totalité.
                Exemple d'application de la fonction RA:
                          Variante #1:
                                        RA( P = 1 )          // Si P = 1 :
                                         {         R++ ;        // Alors ajoute +1 à R.
                                         }
                                                 // Indépendamment de la condition RA, appel le Module Primitif SL.1().
                                         SL.1() ;
                           Variante #2:
                                        RA( P = 1 )         // Si P = 1 :
                                                  R++ ;        // Alors ajoute +1 à R.
                                                  // Indépendamment de la condition RA, appel le Module Primitif SL.1().
                                         SL.1() ;
                  Une Règle d'Application peut avoir différent Opérateur pour comparer, par exemple:
                          RA(Arg1 = Arg2) : Vérifie si Arg1 est égal à Arg2.
                          RA(Arg1 != Arg2) : Vérifie si Arg1 n'est pas égal à Arg2.
                          RA(Arg1 > Arg2) : Vérifie si Arg1 est plus grand que Arg2.

                           RA(Arg1 !> Arg2) : Vérifie si Arg1 n'est pas plus grand que Arg2.
                          RA(Arg1 >= Arg2) : Vérifie si Arg1 est plus grand ou égal à Arg2.
                          RA(Arg1 < Arg2) : Vérifie si Arg1 est plus petit que Arg2.
                          RA(Arg1 <= Arg2) : Vérifie si Arg1 est plus petit ou égal à Arg2.
       Lorsqu'une fonction RA n'utilise pas de fonction « ! », et qu'il n'y a qu'un node primitif, il est inutile d'ajouter des accolades (parenthèses composées). Voici un autre exemple:
                           Variante #1:
                                    RA( ( P < L ) & ( i=j ) )
                                    {         AF( P ) ;
                                    }
                                    SL.1() ;
                           Variante #2:
                                    RA( P < L )
                                    &( i=j )
                                    {         AF( P ) ;
                                    }
                                    SL.1() ;
                           Variante #3:
                                    RA( P < L )
                                            RA( i=j )
                                                     AF( P ) ;
                                   SL.1() ;
                          Variante #4:
                                   RA( ( P < L )&( i=j ) )
                                            AF( P ) ;
                                   SL.1() ;
                          Variante #5:
                                   RA( P < L )
                                   & ( i=j )
                                            AF( P ) ;
                                   SL.1() ;

                  PR : En Mathématique de SCI, cette fonction possède deux versions:
                          PR(arg1) : Remplacez Arg1 par une variable, une valeur ou une opération et il répètera l'instruction selon la valeur de l'Arg1.
                          p.ex : PR( A ) { X += 1 ; } ici nous verrons ajouter +1 à X et il le répètera le nombre A de fois.
                          PR(arg1, var1) : Arg1 définit le nombre de répétition et mémorise la boucle dans la variable var1. Cette dernière retiendra en mémoire la valeur de répétition de la boucle
                          p.ex: PR( A , B ) { RA( B != A ){ B += (A*B) ; } } 
           NOTE: les virgules exploitées pour la fonction PR sont considérées comme un opérateur.
                                   Lorsqu'une Priorité de Réaction appel uniquement une autre Priorité de Réaction, et que cette dernière possède les mêmes valeurs, nous ajoutons un exposant dans une Priorité de Réaction, et des arguments pour la mémorisation.
                                   Exemple sans la syntaxe de la règle:
                                            PR( L1 , i )
                                            {         PR( L1 , j )
                                                     {         P.i += j ;
                                                               SL.2( i ) ;
                                                     }
                                            }
                                   Exemple avec la syntaxe de la règle:
                                            PR²( L1 , i , j )
                                            {         P.i += j ;
                                                      SL.2( i ) ;
                                            }

                                    Nous pouvons ajouter autant d'argument que l'ont veut à la fonction PR pour ajuster son utilisation, mais cette dernière ne peut plus offrir d'avantage de possibilité additionnel. Voici un exemple d'exploitation de la fonction PR avec plus de deux arguments:
                                            Variante #1:
                                                     PR(i,L)
                                                     {         PR(j,L)
                                                               {         P[i,j] = (i+j) ;
                                                               }
                                                     }
                                                     SL.1() ;
                                            Variante #2:
                                                     PR(i,L)
                                                              PR(j,L)
                                                                       P[i,j] = (i+j) ;
                                                     SL.1() ;
                                            Variante #3:
                                                     PR²(i,j,L)
                                                              P[i,j] = (i+j) ;
                                                     SL.1() ;
   UTILE: les fonctions RA et PR sont un écho des règles de SCI sur la syntaxe logique de la résolution d'un problème:
               Fonc ( Arg1 OP Arg2 ) { Arg3 OP Arg4 ; } ou Fonc représente une fonction et les 4 arguments définissent l'ensemble des possibilités logiques de notre univers. L'équation peut être fractionnée en deux parties lors de la résolution d'un problème, ou l'application d'une loi universelle des principes de SCI: Fonc ( Arg1 OP Arg2 )   , Arg3 OP Arg4 et ; . Voir la conjecture de la résolution en losange pour plus de précision.

                  W(Var1 Op Var2): exécute en boucle une ou plusieurs opération tant que la condition Var1 Op Var2 sera respectée (p.ex: W( i < 50 ) { i += A ; } ). Toutefois, cette fonction n'est qu'utilisée qu'en programmation; dans l'application de la résolution en losange, elle n'est pas utilisable pour construire une Formule de SCI.
   BON À SAVOIR: En mathématique de SCI, le symbole « ; » représentant le facteur temps, effectuant l'opération " t ++" en Mécanique de SCI. Le facteur temps découle du point de vue de sa projection, d'un avancement temporel à l'autre, il n'y a pas nécessairement le même nombre de node exploité ou d'opération effectué. La variable « t » représente le temps en image, permettent en Mécanique de SCI de localiser le déplacement d'état d'un hexel en fonction du temps.
   Utile: L'opération « ++ » signifie "ajouter +1" ; et « -- » "retirer 1".

                  Les Déclencheurs Composés:
                          Les Déclencheurs Composés sont utilisés uniquement pour expliquer le fonctionnement des lois de l'univers, tel la théorie des champs unifiés ou encore l'Alchimie de SCI. Elles sont donc applicables uniquement en Mécanique de SCI, et sont inutiles dans les Mathématiques de SCI « traditionnelle ».
                          Collision: Vérifie si une Condition RA est vrai. Il existe deux variantes:
                                   Collision ( arg1 ): Vérifie si un hexel est en collision avec l'état arg1.
                                   Note: retourne 1 lorsque la collision à lieu.
                         Collision ( arg1 , arg2 ): Vérifie si le hexel arg1 est en collision avec un hexel d'état arg2.

 
                           Il existe d'autres nodes composés tel que « with(Arg1) » ou encore « Δ », et d'autre Déclencheur Composé comme « create(Arg1,Arg2) », qui sont généralement utilisés avec des Modules Composés tel que « destroy ». et «other», et d'autres nodes primitifs comme « xyz ». Mais ces nodes seront expliqués dans le prochain volume, car ils n'ont d'utilité que de définir et exploiter la Mécanique de SCI et l'Alchimie de SCI.