Ouverture Bird/Partie I
Une première idée : e4 !
L'objectif des Blancs de jouer e4 est une idée phare de la Bird. Le jeu se trouve libéré, et la contestation du centre Noir permettra en général de prendre totalement le contrôle de ce centre.
Le coup e4 sera généralement suivi de la poussée e5, qui prend une grande part de l'espace au centre, au défaut de permettre aux Noirs de l'attaquer facilement au moyen de f6.
Au moment de l'avancé de e4, les Noirs ont le choix entre la prise "d5xe4", la poussée "d4", ou l'inactivité. Le plus souvent, les Noirs choisissent de diminuer la pression au centre par la prise. Cependant, les deux autres choix sont tout à fait envisageables et mènent à des positions très différentes. Ainsi, si les Noirs ne réagissent pas à e4, la poussée e5 qui suivra mènera à une transposition en Française, dont l'ordre de coups modifié peut amener à des complications pour les deux camps (non étudié dans la suite)
Ceci n'est qu'un exemple de transposition possible, d'autres peuvent également avoir lieu, comme la transposition en Est-Indienne inversée, étudié dans le dernier chapitre de la partie.
Plan de la partie I.
Variante de Leningrad.
La Leningrad tient son nom de la variante éponyme de la Hollandaise (1.d4.f5) qui a valu le renouveau de l'ouverture.
La Leningrad, comme un certain nombre de variantes de la Bird, peut s'apparenter un système. En effet, le même schéma est inlassablement répété, et les modifications nécessaires pour s'adapter au plan des Noirs sont en général infimes.
La suite classique est : Fg2, d3, 0-0, c3, De1, Ca3, e4 !
Il existe cependant plusieurs déviances, qui permettent d'animer magnifiquement la variante, notamment le coup c4 joué au moment opportun, qui amène à l'atomisation du centre.
e4 hyper-accéléré.
Il n'existe pas de nom officiel à cette variante, qui est cependant extrêmement dynamique, et ne peut pas être jouée si facilement dans la Hollandaise.
L'idée est simple : jouer e4 si vite que les Noirs sont dans l'incapacité de l'empêcher.
La variante amène très facilement à l'Est-Indienne inversée si les Noirs poussent d4 après e4.
Bien que l'ouverture semble aux premiers coups uniquement dynamique, elle apparaît ensuite offrir un jeu stratégique positionnel qui demande de la subtilité pour prendre l'avantage.
Une unique partie est jouée dans cette variante à haut ELO (>2200, donc amateur) selon la base de Lichess : Prochazka - Dalibor, qui se solda par la défaite des Noirs bien que Stockfish évalue la position à +7 jusqu'au 35ème coup, rien à voir avec l'ouverture donc... Celle-ci est d'ailleurs bien jouée par Prochazka et constitue un excellent exemple, où l'avantage est pris par les Blancs de manière très simple.
Variante Antoshin.
Une variante dont le nom vient de la symétrie avec la variante éponyme de la Hollandaise.
La variante se veut comme une solution au problème présenté par le fianchetto noir.
Elle semble amener aux mêmes positions que la variante e4 hyper-accéléré, mais l'ordre des coups différant, seul la structure de pion reste identique. Les Blancs se voient dans l'Antoshin confrontés à des problèmes qu'ils n'avaient pas dans l'hyper-accéléré (par exemple le mauvais placement de la Dame en c2 au lieu de e2), mais se libèrent d'autres contraintes. comme la nécessité de jouer Cbd2 qui empêche la sortie du Fou c1 en e3 (la Dame en c2 dans l'Antoshin permet alors la défense du pion b2).
Variante Classique.
La variante classique dans la Hollandaise, qui se trouve un peu moins jouée que la Leningrad à haut ELO, mais tout de même plus jouée que l'Antoshin ou l'hyper-accéléré.
L'idée est de prendre le temps de jouer e4 et de miser sur un jeu positionnel, avec contrairement aux autres variantes le coup Cc3 au lieu de Cbd2, qui profite de la solidité de la case e3.
En général, la position se joue sans fianchetto.

Mathc matrices/c10a
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00b.c */
void fun(int r)
double a[R2*C2]={ 2,1,
 1,1};
double v[R2*C1]={ 3,
 2}; 
double w[R2*C1]={ 0,
 -1};
double k = 3; 
double **A = ca_A_mR(a, i_mR(R2,C2));
double **V = ca_A_mR(v, i_mR(R2,C1));
double **kV = smul_mR(k,V,i_mR(R2,C1));
double **W = ca_A_mR(w, i_mR(R2,C1));
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" V :");
 p_mR(V,S3,P0,C6); 
 printf(" W :");
 p_mR(W,S3,P0,C6);
 printf(" %.0f V :",k);
 p_mR(kV,S3,P0,C6); 
 printf(" <kV,W> = k<V,W> [Homogeneity axiom] \n\n");
 printf(" <kV,W> = %.0f \n", dot_Au_R(A,kV,W));
 printf(" k<V,W> = %.0f \n\n", k*dot_Au_R(A,V, W));

f_mR(A);
 f_mR(V);
 f_mR(kV);
 f_mR(W);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
 fun(rp_I(R3)+R1);
 stop();
 return 0;
/* ------------------------------------ */

Exemple de sortie écran :
 A :
 +2 +1 
 +1 +1 
 V :
 +3 
 +2 
 W :
 +0 
 -1 
 3 V :
 +9 
 +6 
 <kV,W> = k<V,W> [Homogeneity axiom] 
 <kV,W> = -39 
 k<V,W> = -39 
 Press return to continue.

Mathc matrices/c10b
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00c.c */
void fun(int r)
double a[R2*C2]={ 2,1,
 1,1};
double u[R2*C1]={ 1,
 1};
double v[R2*C1]={ 3,
 2}; 
double w[R2*C1]={ 0,
 -1};
double **A = ca_A_mR(a,i_mR(R2,C2));
double **U = ca_A_mR(u,i_mR(R2,C1));
double **V = ca_A_mR(v,i_mR(R2,C1));
double **W = ca_A_mR(w,i_mR(R2,C1));
double **UplsV = add_mR(U,V,i_mR(R2,C1));
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" U :");
 p_mR(U,S3,P0,C6); 
 printf(" V :");
 p_mR(V,S3,P0,C6); 
 printf(" W :");
 p_mR(W,S3,P0,C6); 
 printf(" UplsV :");
 p_mR(UplsV,S3,P0,C6); 
 stop();
 clrscrn(); 
 printf(" <U+V,W> = <U,W>+<V+W> [Additivity axiom] \n\n");
 printf(" <u+v,w> = %.0f \n", dot_Au_R(A,UplsV,W));
 printf(" <u,w>+<v+w> = %.0f \n\n", dot_Au_R(A,U, W)+
 dot_Au_R(A,V, W));
 f_mR(A);
 f_mR(U);
 f_mR(V);
 f_mR(W);
 f_mR(UplsV); 
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
 fun(rp_I(R3)+R1);
 stop();
 return 0;
/* ------------------------------------ */

Exemple de sortie écran :
 A :
 +2 +1 
 +1 +1 
 U :
 +1 
 +1 
 V :
 +3 
 +2 
 W :
 +0 
 -1 
 UplsV :
 +4 
 +3 
 Press return to continue. 
 <U+V,W> = <U,W>+<V+W> [Additivity axiom] 
 <u+v,w> = -18 
 <u,w>+<v+w> = -18 
 Press return to continue.

Mathc matrices/c10c
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00d.c */
void fun(int r)
double a[R2*C2]={ 2,1,
 1,1};
double v[R2*C1]={ 3,
 2}; 
double **A = ca_A_mR(a,i_mR(R2,C2));
double **V = ca_A_mR(v,i_mR(R2,C1));
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" V :");
 p_mR(V,S3,P0,C6);
 printf(" ||u|| = sqrt(%.0f) \n\n", dot_Au_R(A,V,V));
 f_mR(A);
 f_mR(V);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
 fun(rp_I(R3)+R1);
 stop();
 return 0;
/* ------------------------------------ */

Exemple de sortie écran :
 A :
 +2 +1 
 +1 +1 
 V :
 +3 
 +2 
 ||u|| = sqrt(89) 
 Press return to continue.

Mathc matrices/c10d
Installer et compiler ces fichiers dans votre répertoire de travail.
/* ------------------------------------ */
/* Save as : c00e.c */
void fun(int r)
double a[R2*C2]={ 2,1,
 1,1};
double u[R2*C1]={ 1,
 1};
double v[R2*C1]={ 3,
 2}; 
double **A = ca_A_mR(a,i_mR(R2,C2));
double **U = ca_A_mR(u,i_mR(R2,C1));
double **V = ca_A_mR(v,i_mR(R2,C1));
 clrscrn();
 printf(" A :");
 p_mR(A,S3,P0,C6);
 printf(" U :");
 p_mR(U,S3,P0,C6);
 printf(" V :");
 p_mR(V,S3,P0,C6);
 printf(" d(U,V) = ||U-V|| = (<U-V,U-V>)^1/2 \n\n");
 printf(" d(U,V) = %.3f = sqrt(34.)\n", dist_Au_R(A,U,V));
 printf(" d(V,U) = %.3f = %.3f \n\n", dist_Au_R(A,V,U), 
 sqrt(34.)); 
 f_mR(A);
 f_mR(U);
 f_mR(V);
/* ------------------------------------ */
int main(void)
time_t t;
 srand(time(&t));
 fun(rp_I(R3)+R1);
 stop();
 return 0;
/* ------------------------------------ */