public static void normalizeHoldsProposition(Proposition self) {
    { Vector holdsarguments = self.arguments;
      Stella_Object relationterm = (holdsarguments.theArray)[0];
      int nofarguments = holdsarguments.length() - 1;
      Surrogate surrogate = Logic.evaluateRelationTerm(relationterm, self);
      Vector predicatearguments = Vector.newVector(nofarguments);
      Description description = null;

      if ((surrogate == null) &&
          ((!Stella_Object.isaP(relationterm, Logic.SGT_LOGIC_DESCRIPTION)) ||
           (!Logic.argumentBoundP(relationterm)))) {
        return;
      }
      { int i = Stella.NULL_INTEGER;
        int iter000 = 1;
        int upperBound000 = nofarguments;
        boolean unboundedP000 = upperBound000 == Stella.NULL_INTEGER;

        for (;unboundedP000 ||
                  (iter000 <= upperBound000); iter000 = iter000 + 1) {
          i = iter000;
          (predicatearguments.theArray)[(i - 1)] = ((holdsarguments.theArray)[i]);
        }
      }
      if (surrogate != null) {
        description = ((Description)(Logic.evaluatePredicate(surrogate, (holdsarguments.theArray)[1])));
        if (description == null) {
          { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

            { Object old$PrintreadablyP$000 = Stella.$PRINTREADABLYp$.get();

              try {
                Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                stream000.nativeStream.println("ERROR: Relation argument `" + surrogate.symbolName + "' in HOLDS proposition is not defined as a relation: `" + self + "'.");
                Logic.helpSignalPropositionError(stream000, Logic.KWD_ERROR);

              } finally {
                Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
              }
            }
            throw ((PropositionError)(PropositionError.newPropositionError(stream000.theStringReader()).fillInStackTrace()));
          }
        }
        if (Logic.classP(description)) {
          self.kind = Logic.KWD_ISA;
        }
        else if (Logic.functionP(description)) {
          Proposition.helpNormalizePredicateProposition(self, description.surrogateValueInverse, predicatearguments);
          return;
        }
        self.operator = description.surrogateValueInverse;
        self.arguments = predicatearguments;
        Proposition.normalizeProposition(self);
        return;
      }
      else {
        description = ((Description)(relationterm));
        if (!(description.arity() == nofarguments)) {
          { OutputStringStream stream001 = OutputStringStream.newOutputStringStream();

            { Object old$PrintreadablyP$001 = Stella.$PRINTREADABLYp$.get();

              try {
                Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                stream001.nativeStream.println("ERROR: Arity violation in HOLDS proposition: `" + self + "'.");
                Logic.helpSignalPropositionError(stream001, Logic.KWD_ERROR);

              } finally {
                Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
              }
            }
            throw ((PropositionError)(PropositionError.newPropositionError(stream001.theStringReader()).fillInStackTrace()));
          }
        }
        Proposition.overlayProposition(self, Logic.conjoinPropositions(Logic.inheritDescriptionPropositions(predicatearguments, description, new Object[1])));
        Proposition.normalizeProposition(self);
      }
    }
  }