public static boolean helpClosedPropositionP(Proposition self, Cons activeterms) {
    if (activeterms.membP(self)) {
      return (false);
    }
    else {
      activeterms = Cons.cons(self, activeterms);
    }
    { Keyword testValue000 = self.kind;

      if ((testValue000 == Logic.KWD_AND) ||
          ((testValue000 == Logic.KWD_OR) ||
           ((testValue000 == Logic.KWD_NOT) ||
            ((testValue000 == Logic.KWD_FORALL) ||
             (testValue000 == Logic.KWD_EXISTS))))) {
        { boolean alwaysP000 = true;

          { Stella_Object arg = null;
            Vector vector000 = self.arguments;
            int index000 = 0;
            int length000 = vector000.length();

            loop000 : for (;index000 < length000; index000 = index000 + 1) {
              arg = (vector000.theArray)[index000];
              if (!Proposition.helpClosedPropositionP(((Proposition)(arg)), activeterms)) {
                alwaysP000 = false;
                break loop000;
              }
            }
          }
          { boolean value000 = alwaysP000;

            return (value000);
          }
        }
      }
      else if ((testValue000 == Logic.KWD_PREDICATE) ||
          ((testValue000 == Logic.KWD_FUNCTION) ||
           (testValue000 == Logic.KWD_ISA))) {
        if (((Surrogate)(self.operator)) == Logic.SGT_PL_KERNEL_KB_MEMBER_OF) {
          { Stella_Object collectionarg = (self.arguments.theArray)[1];
            Stella_Object collectionvalue = Logic.safeArgumentBoundTo(collectionarg);

            if (collectionvalue != null) {
              return (Logic.helpClosedTermP(collectionvalue, activeterms));
            }
            else {
              { boolean foundP000 = false;

                { Proposition prop = null;
                  Iterator iter000 = Logic.unfilteredDependentPropositions(collectionarg, null).allocateIterator();

                  loop001 : while (iter000.nextP()) {
                    prop = ((Proposition)(iter000.value));
                    if (Stella_Object.eqlP(collectionarg, prop.arguments.last()) &&
                        Proposition.collectionofPropositionP(prop)) {
                      foundP000 = true;
                      break loop001;
                    }
                  }
                }
                { boolean value001 = foundP000;

                  return (value001);
                }
              }
            }
          }
        }
        else {
          return (Logic.helpClosedTermP(Logic.getDescription(((Surrogate)(self.operator))), activeterms));
        }
      }
      else if (testValue000 == Logic.KWD_FAIL) {
        return (true);
      }
      else {
        return (false);
      }
    }
  }