!7

srecord DollarVarPattern(S pat) {}
srecord Definition(O lhs, O rhs) {}
srecord Input(S s) {}
srecord Statement(S s) {}

sS defs = [[
A cup of water = A cup with water inside
A cup of Peter = A cup that belongs to Peter
A cup of glass = A cup that consists of glass
A cup of style = A cup that has a lot of style
a $a with $b inside       = [implies] $b is smaller than a $a
a $a that belongs to $b   = [implies] $b is a person
a $a that consists of $b  = [implies] $b is a material
a $a that has a lot of $b = [implies] $b is a property
]];

p-exp {
  new ThoughtSpace ts;
  ts.objects.add(Input("a cup of joe"));
  
  ts.addDefinitions(defs);
  ts.think(false);
  //ts.printDefinitionsForInput();
  
  for (Definition d : ts.definitionsForInput()) {
    print("\nTrying definition " + sfu(d));
    new ThoughtSpace ts2;
    ts2.objects.add(Input((S) d.rhs));
    ts2.addDefinitions(defs);
    ts2.think(false);
    ts2.removeInitialObjects();
    
    //pnlStruct(ts2.literalDefinitions());
    pnlStruct(ts2.statements());
  }
}

sclass ThoughtSpace {
  new LinkedHashSet objects;
  int initialObjects;
  
  void think(bool print) {
    initialObjects = l(objects);
    long startTime = now();
    int n = -1;
    while (l(objects) > n) {
      n = l(objects);
      
      // def + def -> patterned def [emerge pattern]
      L<Definition> defs = instancesOf(Definition, objects);
      for (Definition a : defs)
        for (Definition b : defs)
          if (a.lhs instanceof S && b.lhs instanceof S) {
            S pat = combineToDollarVarPattern((S) a.lhs, (S) b.lhs);
            if (containsDollarVars(pat))
              objects.add(DollarVarPattern(pat));
          }
          
      // pattern + def -> patterned def [generalize]
      for (DollarVarPattern pat : instancesOf(DollarVarPattern, objects)) {
        for (Definition a : defs) if (a.lhs instanceof S) {
          SS match = matchDollarVarsIC(pat.pat, (S) a.lhs);
          if (match != null)
            generalizeDefinition(a, match);
        }
      }
      
      // input + patterned def -> def       [specialize]
      // input + patterned def -> statement [implication]
      for (Input i : instancesOf(Input, objects))
        for (Definition a : defs) if (a.lhs instanceof DollarVarPattern) {
          SS match = matchDollarVarsIC(((DollarVarPattern) a.lhs).pat, i.s);
          new Matches m;
          if (match != null) {
            S rhs = ((DollarVarPattern) a.rhs).pat;
            if (swic_trim(rhs, "[implies]", m))
              objects.add(Statement(transformEachTokenUsingMap(m.rest(), match)));
            else
              specializeDefinition(a, match);
          }
        }
    }
    long time = now()-startTime;
    
    if (print)
      pnlStruct(dropFirst(initialObjects, asList(objects)));
    print("\n" + n2(l(objects)-initialObjects, "rewrite") + " in " + (now()-startTime) + " ms");
  }
  
  void generalizeDefinition(Definition def, SS match) {
    SS rev = reverseCIMap(match);
    S lhs = transformEachTokenUsingMap((S) def.lhs, rev);
    S rhs = transformEachTokenUsingMap((S) def.rhs, rev);
    addIfNotNull(objects, Definition(DollarVarPattern(lhs), DollarVarPattern(rhs)));
  }
  
  void specializeDefinition(Definition def, SS match) {
    S lhs = transformEachTokenUsingMap(((DollarVarPattern) def.lhs).pat, match);
    S rhs = transformEachTokenUsingMap(((DollarVarPattern) def.rhs).pat, match);
    addIfNotNull(objects, Definition(lhs, rhs));
  }
  
  void addDefinitions(S defs) {
    for (S s : tlft(defs)) {
      L<S> l = splitAtJavaToken(s, "=");
      objects.add(Definition(first(l), second(l)));
    }
  }
  
  void printDefinitionsForInput() {
    final Input in = firstInstanceOf(Input, objects);
    if (in != null) {
      L<Definition> definitions = definitionsForInput(in);
      print("Got " + n2(definitions, "definition") + " for input " + quote(in.s) + (empty(definitions) ? "." : ":"));
      printStructLinesIndent(definitions);
    }
  }
  
  Input input() {
    ret firstInstanceOf(Input, objects);
  }
  
  L<Definition> definitionsForInput() { ret definitionsForInput(input()); }
  
  L<Definition> definitionsForInput(final Input in) {
    ret [Definition d : instancesOf(Definition, objects) | eqic_gen(d.lhs, in.s)];
  }
  
  L<Definition> literalDefinitions() {
    ret [Definition d : instancesOf(Definition, objects) | d.lhs instanceof S && d.rhs instanceof S];
  }
  
  L<Statement> statements() {
    ret instancesOf(Statement, objects);
  }
  
  void removeInitialObjects {
    replaceCollection(objects, dropFirst(initialObjects, asList(objects)));
    initialObjects = 0;
  }
}