/* Auteur: Nicolas JANEY          */
/* nicolas.janey@univ-fcomte.fr   */
/* Fevrier 2005                   */

import java.io.*;

public class TestReflexivite {
  static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));

  /* Fonction de creation d'une matrice carrée            */
  /* de booleens initialisee avec des valeurs aleatoires  */
  /* n : nombres de lignes et de colonnes de la matrice   */
  /* Resultat fonction : Matrice de booleens              */

  public static boolean [][] creationMatriceAleatoire(int n) {
  /* Allocation de la matrice                             */
    boolean [][] m = new boolean[n][n];
  /* Pour toutes les lignes de la matrice a initialiser   */                                    
    for ( int i = 0 ; i < n ; i++ )
  /* Pour toutes les colonnes de la matrice a initialiser */
      for ( int j = 0 ; j < n ; j++ ) {
  /* Initialisation avec un booleen aleatoire             */
        m[i][j] = (Math.random() > 0.5); }
  /* Resultat de la fonction                              */
    return(m);
  }

  /* Fonction de creation d'une matrice carrée            */
  /* de booleens initialisee avec des valeurs aleatoires  */
  /* sauf sur la diagonale ou les valeurs sont vrai       */
  /* n : nombres de lignes et de colonnes de la matrice   */
  /* Resultat fonction : Matrice de booleens              */

  public static boolean [][] creationMatriceReflexive(int n) {
  /* Allocation de la matrice                             */
    boolean [][] m = new boolean[n][n];
  /* Pour toutes les lignes de la matrice a initialiser   */                                    
    for ( int i = 0 ; i < n ; i++ )
  /* Pour toutes les colonnes de la matrice a initialiser */
      for ( int j = 0 ; j < n ; j++ ) {
  /* Sin on est sur la diagonale                          */
        if ( i == j )
  /* Initialisation avec vrai                             */
          m[i][j] = true;
          else
  /* Initialisation avec un booleen aleatoire             */
          m[i][j] = (Math.random() > 0.5); }
  /* Resultat de la fonction                              */
    return(m);
  }

  /* Fonction d'affichage d'une matrice de booleens       */
  /* m : tableau de booleens a afficher                   */
  
  public static void affichageMatrice(boolean [][] m) {
    for ( int i = 0 ; i < m.length ; i++ ) {
  /* Pour toute les lignes de la matrice a afficher       */
      for ( int j = 0 ; j < m[0].length ; j++ ) {
  /* Affichage d'un booleen de la ligne i                 */
  /* (sans aller a la ligne)                              */
        if ( m[i][j] )
          System.out.print("Vrai ");
          else
          System.out.print("Faux "); }
  /* On va a la ligne quand tous les entiers d'une ligne  */
  /* ont ete affiches                                     */
      System.out.println(); }
  }

  /* Fonction de test de reflexivite                      */
  /* m : tableau de booleens a tester                     */
  
  public static boolean testReflexite(boolean [][] m) {
  /* Declaration et initialisation du booleen resultat    */
  /* a la valeur vrai                                     */
    boolean res = true;
  /* Declaration et initialisation a 0 d'un entier        */
  /* pour indicer sur les valeurs de la diagonale         */
    int i = 0;
  /* Boucle tant que pour parcourir la diagonale tant que */
  /* on trouve des booleens a vrai                        */
  /* et                                                   */
  /* il reste des valeurs a parcourir                     */
    while ( ( i < m.length ) && res ) {
  /* res est affecte avec m[i][i] ->                      */
  /* Il peut rester a vrai et le tant que continue        */
  /* ou
  /* il peut passer a faux, le tant que s'arrete et       */
  /* la fonction rend faux                                */
      res = m[i][i];
  /* Incrementation de i pour aller a la valeur suivante  */
  /* de la diagonale                                      */
      i++; }
  /* Resultat de la fonction                              */
    return(res);
  }

  /* Fonction principale                                  */

  public static void main(String [] args) throws IOException {
  /* Lecture au clavier de la taille de la matrice        */
    System.out.print("Taille de la matrice  : ");
    int n = Integer.valueOf(flux.readLine()).intValue();
  /* Creation d'une matrice de taille n                   */
    boolean [][] m1 = creationMatriceAleatoire(n);
  /* Affichage de la matrice                              */
    affichageMatrice(m1);
  /* Affichage du resultat du test de reflexivite         */
    System.out.println("Relation reflexive ? : "+testReflexite(m1));
  /* Creation d'une matrice de taille n                   */
    boolean [][] m2 = creationMatriceReflexive(n);
  /* Affichage de la matrice                              */
    affichageMatrice(m2);
  /* Affichage du resultat du test de reflexivite         */
    System.out.println("Relation reflexive ? : "+testReflexite(m2));
  }
}