public static void verifyForallPropositions(Proposition proposition) {
    { Keyword testValue000 = proposition.kind;

      if (testValue000 == Logic.KWD_FORALL) {
        { Proposition antecedent = ((Proposition)((proposition.arguments.theArray)[0]));
          Proposition consequent = ((Proposition)((proposition.arguments.theArray)[1]));
          List antvars = null;
          List cqvars = null;

          if (antecedent.kind == Logic.KWD_CONSTANT) {
            return;
          }
          antvars = List.list(Stella.NIL);
          cqvars = List.list(Stella.NIL);
          Logic.collectFreeVariables(antecedent, antvars, List.list(Stella.NIL), List.list(Stella.NIL));
          Logic.collectFreeVariables(consequent, cqvars, List.list(Stella.NIL), List.list(Stella.NIL));
          if (!(cqvars.nonEmptyP() &&
              cqvars.subsetP(antvars))) {
            { Object old$Termsourcebeingparsed$000 = Logic.$TERMSOURCEBEINGPARSED$.get();
              Object old$Termunderconstruction$000 = Logic.$TERMUNDERCONSTRUCTION$.get();
              Object old$PrintreadablyP$000 = Stella.$PRINTREADABLYp$.get();
              Object old$Printmode$000 = Logic.$PRINTMODE$.get();
              Object old$PrettyprintlogicalformsP$000 = Logic.$PRETTYPRINTLOGICALFORMSp$.get();
              Object old$PrettyprintkifP$000 = Logic.$PRETTYPRINTKIFp$.get();

              try {
                Native.setSpecial(Logic.$TERMSOURCEBEINGPARSED$, null);
                Native.setSpecial(Logic.$TERMUNDERCONSTRUCTION$, null);
                Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                Native.setSpecial(Logic.$PRINTMODE$, Logic.KWD_REALISTIC);
                Native.setBooleanSpecial(Logic.$PRETTYPRINTLOGICALFORMSp$, true);
                Native.setBooleanSpecial(Logic.$PRETTYPRINTKIFp$, true);
                cqvars = cqvars.difference(antvars);
                { Object old$PrintreadablyP$001 = Stella.$PRINTREADABLYp$.get();

                  try {
                    Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                    {
                      Stella.STANDARD_WARNING.nativeStream.println("WARNING: Potentially problematic implication rule, consequent variable(s) " + Stella.replaceSubstrings(Native.stringify(cqvars.theConsList), "?", "|V|?"));
                      Stella.STANDARD_WARNING.nativeStream.println("   are not restricted/used by the antecedent: ");
                      Stella.STANDARD_WARNING.nativeStream.println(proposition);
                    }
;
                    Logic.helpSignalPropositionError(Stella.STANDARD_WARNING, Logic.KWD_WARNING);

                  } finally {
                    Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
                  }
                }

              } finally {
                Logic.$PRETTYPRINTKIFp$.set(old$PrettyprintkifP$000);
                Logic.$PRETTYPRINTLOGICALFORMSp$.set(old$PrettyprintlogicalformsP$000);
                Logic.$PRINTMODE$.set(old$Printmode$000);
                Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
                Logic.$TERMUNDERCONSTRUCTION$.set(old$Termunderconstruction$000);
                Logic.$TERMSOURCEBEINGPARSED$.set(old$Termsourcebeingparsed$000);
              }
            }
          }
        }
      }
      else if (testValue000 == Logic.KWD_AND) {
        { Stella_Object arg = null;
          Vector vector000 = proposition.arguments;
          int index000 = 0;
          int length000 = vector000.length();

          for (;index000 < length000; index000 = index000 + 1) {
            arg = (vector000.theArray)[index000];
            Proposition.verifyForallPropositions(((Proposition)(arg)));
          }
        }
      }
      else {
      }
    }
  }