Ejemplo n.º 1
0
  private Gdl getInstantiationAux(Gdl gdl, Map<GdlVariable, GdlConstant> varInstantiation) {
    if (gdl instanceof GdlRelation) {
      GdlRelation relation = (GdlRelation) gdl;

      List<GdlTerm> body = new ArrayList<>();
      for (int i = 0; i < relation.arity(); i++) {
        body.add((GdlTerm) getInstantiationAux(relation.get(i), varInstantiation));
      }
      return GdlPool.getRelation(relation.getName(), body);
    } else if (gdl instanceof GdlRule) {
      GdlRule rule = (GdlRule) gdl;
      GdlSentence head = (GdlSentence) getInstantiationAux(rule.getHead(), varInstantiation);

      List<GdlLiteral> body = new ArrayList<>();
      for (int i = 0; i < rule.arity(); i++) {
        body.add((GdlLiteral) getInstantiationAux(rule.get(i), varInstantiation));
      }
      return GdlPool.getRule(head, body);
    } else if (gdl instanceof GdlDistinct) {
      GdlDistinct distinct = (GdlDistinct) gdl;
      GdlTerm arg1 = (GdlTerm) getInstantiationAux(distinct.getArg1(), varInstantiation);
      GdlTerm arg2 = (GdlTerm) getInstantiationAux(distinct.getArg2(), varInstantiation);
      return GdlPool.getDistinct(arg1, arg2);
    } else if (gdl instanceof GdlNot) {
      GdlNot not = (GdlNot) gdl;
      GdlLiteral body = (GdlLiteral) getInstantiationAux(not.getBody(), varInstantiation);
      return GdlPool.getNot(body);
    } else if (gdl instanceof GdlOr) {
      GdlOr or = (GdlOr) gdl;
      List<GdlLiteral> body = new ArrayList<>();
      for (int i = 0; i < or.arity(); i++) {
        body.add((GdlLiteral) getInstantiationAux(or.get(i), varInstantiation));
      }
      return GdlPool.getOr(body);
    } else if (gdl instanceof GdlProposition) {
      return gdl;
    } else if (gdl instanceof GdlConstant) {
      return gdl;
    } else if (gdl instanceof GdlFunction) {
      GdlFunction func = (GdlFunction) gdl;
      List<GdlTerm> body = new ArrayList<>();
      for (int i = 0; i < func.arity(); i++) {
        body.add((GdlTerm) getInstantiationAux(func.get(i), varInstantiation));
      }
      return GdlPool.getFunction(func.getName(), body);
    } else if (gdl instanceof GdlVariable) {
      GdlVariable variable = (GdlVariable) gdl;
      return varInstantiation.get(variable);
    } else
      throw new RuntimeException(
          "Someone went and extended the GDL hierarchy without updating this code.");
  }
Ejemplo n.º 2
0
  private static GdlRelation substituteRelation(GdlRelation relation, Substitution theta) {
    if (relation.isGround()) {
      return relation;
    }
    GdlConstant name = substituteConstant(relation.getName(), theta);

    List<GdlTerm> body = new ArrayList<>();
    for (int i = 0; i < relation.arity(); i++) {
      body.add(substituteTerm(relation.get(i), theta));
    }

    return GdlPool.getRelation(name, body);
  }
Ejemplo n.º 3
0
  private Set<Domain> findAllInstancesOf(GdlVariable var, Gdl gdl, Location loc) {
    if (!domains.containsKey(loc)) domains.put(loc, new Domain(loc));

    Set<Domain> rval = new HashSet<Domain>();

    if (gdl instanceof GdlRelation) {
      GdlRelation relation = (GdlRelation) gdl;
      for (int i = 0; i < relation.arity(); i++) {
        Location parent = new Location();
        parent.name = relation.getName();
        parent.idx = i;
        rval.addAll(findAllInstancesOf(var, relation.get(i), parent));
      }
    } else if (gdl instanceof GdlDistinct) {
      //          GdlDistinct distinct = (GdlDistinct)gdl;
      // Negative context, ignore it for now
    } else if (gdl instanceof GdlNot) {
      //          GdlNot not = (GdlNot)gdl;
      // Negative context, ignore it for now
    } else if (gdl instanceof GdlOr) // TODO: check that this is right, I think it may not be
    {
      GdlOr or = (GdlOr) gdl;
      for (int i = 0; i < or.arity(); i++) rval.addAll(findAllInstancesOf(var, or.get(i), null));
    } else if (gdl instanceof GdlProposition) {
      //          GdlProposition prop = (GdlProposition)gdl;
      // I think these can safely be ignored, they have no body
    } else if (gdl instanceof GdlConstant) {
      //          GdlConstant constant = (GdlConstant)gdl;
      // Just a constant
    } else if (gdl instanceof GdlFunction) {
      GdlFunction func = (GdlFunction) gdl;
      for (int i = 0; i < func.arity(); i++) {
        Location parent = new Location();
        parent.name = func.getName();
        parent.idx = i;
        rval.addAll(findAllInstancesOf(var, func.get(i), parent));
      }
    } else if (gdl instanceof GdlVariable) { // This is the interesting one
      GdlVariable variable = (GdlVariable) gdl;
      if (variable == var) { // Found what we're looking for (base case of recursion)
        if (loc == null) throw new RuntimeException("Parent missing for a variable.");
        rval.add(domains.get(loc));
      }
    } else if (gdl instanceof GdlRule) {
      throw new RuntimeException("Shouldn't nest rules.");
    }

    return rval;
  }
Ejemplo n.º 4
0
 private void findAndInstantiateBaseProps(Gdl gdl) {
   if (gdl instanceof GdlRelation) {
     GdlRelation relation = (GdlRelation) gdl;
     String name = relation.getName().toString();
     if (name.equals("init")) {
       if (relation.arity() != 1)
         throw new RuntimeException("Can't init more than one thing as far as I know.");
       GdlTerm template = relation.get(0);
       if (template instanceof GdlConstant) {
         List<GdlTerm> body = new ArrayList<GdlTerm>();
         body.add(template);
         GdlRelation toAdd = GdlPool.getRelation(baseConstant, body);
         baseRelations.add(toAdd);
         System.err.println("Weird init of constant");
       } else if (template instanceof GdlVariable) {
         System.err.println("Weird init of constant");
         List<GdlTerm> body = new ArrayList<GdlTerm>();
         body.add(universalDom);
         GdlRelation toAdd = GdlPool.getRelation(baseConstant, body);
         baseRelations.add(toAdd);
         System.err.println("Weird init of variable");
       } else if (template instanceof GdlFunction) {
         GdlFunction func = (GdlFunction) template;
         instantiateBaseProps(func.toSentence());
       }
     }
   } else if (gdl instanceof GdlRule) {
     GdlRule rule = (GdlRule) gdl;
     String name = rule.getHead().getName().toString();
     if (name.equals("next")) {
       GdlSentence head = rule.getHead();
       if (head.arity() != 1)
         throw new RuntimeException("Can't next more than one thing as far as I know.");
       if (head.get(0) instanceof GdlVariable) { // weird case where you have rule like (next ?q)
         Location l = new Location();
         l.idx = 0;
         l.name = head.getName();
         Domain dom = domains.get(l);
         for (GdlConstant c : dom.values) {
           List<GdlTerm> body = new ArrayList<GdlTerm>();
           body.add(c);
           baseRelations.add(GdlPool.getRelation(baseConstant, body));
         }
       } else instantiateBasePropsWithRHS(head.get(0).toSentence(), rule.getBody());
     }
   }
 }
Ejemplo n.º 5
0
  private void addRelToMerge(GdlRelation rel, List<Set<GdlConstant>> merge) {
    for (int i = 1; i < rel.arity(); i++) {
      GdlTerm t = rel.get(i);
      if (!(t instanceof GdlFunction))
        throw new RuntimeException("Incorrectly constructed base props");

      if (merge.size() < i) merge.add(new HashSet<GdlConstant>());

      GdlFunction f = (GdlFunction) t;
      Set<GdlConstant> dom = merge.get(i - 1);
      for (GdlTerm t2 : f.getBody()) {
        if (!(t2 instanceof GdlConstant))
          throw new RuntimeException(
              "Incorrectly constructed base props: something other than a constant");
        dom.add((GdlConstant) t2);
      }
    }
  }
Ejemplo n.º 6
0
  private static List<Gdl> runOnce(List<Gdl> description) {
    List<Gdl> newDescription = new ArrayList<Gdl>();

    // First: Clean up all rules with zero-element bodies
    for (Gdl gdl : description) {
      if (gdl instanceof GdlRule) {
        GdlRule rule = (GdlRule) gdl;
        if (rule.getBody().size() == 0) {
          newDescription.add(rule.getHead());
        } else {
          newDescription.add(gdl);
        }
      } else {
        newDescription.add(gdl);
      }
    }

    // TODO: Add (role ?player) where appropriate, i.e. in rules for
    // "legal" or "input" where the first argument is an undefined
    // variable
    // Get rid of "extra parentheses", i.e. zero-arity functions
    description = newDescription;
    newDescription = new ArrayList<Gdl>();
    for (Gdl gdl : description) {
      if (gdl instanceof GdlRelation) {
        newDescription.add(cleanParentheses((GdlRelation) gdl));
      } else if (gdl instanceof GdlRule) {
        newDescription.add(cleanParentheses((GdlRule) gdl));
      } else {
        newDescription.add(gdl);
      }
    }
    // TODO: Get rid of GdlPropositions in the description

    // Get rid of (not (distinct _ _)) literals in rules
    // TODO: Expand to functions
    description = newDescription;
    newDescription = new ArrayList<Gdl>();
    for (Gdl gdl : description) {
      if (gdl instanceof GdlRule) {
        GdlRule cleaned = removeNotDistinctLiterals((GdlRule) gdl);
        if (cleaned != null) newDescription.add(cleaned);
      } else {
        newDescription.add(gdl);
      }
    }

    // Get rid of the old style of "base" sentences (with arity more than 1, not in rules)
    // See e.g. current version of Qyshinsu on the Dresden server
    description = newDescription;
    newDescription = new ArrayList<Gdl>();
    boolean removeBaseSentences = false;
    for (Gdl gdl : description) {
      if (gdl instanceof GdlRelation) {
        GdlRelation relation = (GdlRelation) gdl;
        if (relation.getName() == BASE && relation.arity() != 1) {
          removeBaseSentences = true;
          break;
        }
      }
    }
    // Note that in this case, we have to remove ALL of them or we might
    // misinterpret this as being the new kind of "base" relation
    for (Gdl gdl : description) {
      if (gdl instanceof GdlRelation) {
        GdlRelation relation = (GdlRelation) gdl;
        if (removeBaseSentences && relation.getName() == BASE) {
          // Leave out the relation
        } else {
          newDescription.add(gdl);
        }
      } else {
        newDescription.add(gdl);
      }
    }

    return newDescription;
  }