public App(LogicalForm f, LogicalForm x) : base(null)
{
ISemanticType fType = f.GetSemanticType();
ISemanticType xType = x.GetSemanticType();
if (fType.GetType() != typeof(Arrow))
{
System.Console.WriteLine(
"App failed: function argument not function type");
return;
}
Arrow aType = (Arrow)fType;
if (!aType.GetInputType().Equals(xType))
{
// error
System.Console.WriteLine("App failed: type mismatch");
// throw new InvalidTypeException();
return;
}
this.type = aType.GetOutputType();
this.isFormula = this.type.GetType() == typeof(T);
this.freeVariables = f.MergeVariables(x);
this.f = f;
this.x = x;
}
public FType(ISemanticType basetype, LogicalForm formula)
{
if (!formula.IsFormula() || formula.IsClosed())
{
System.Console.WriteLine("FType failed: not a formula, or not free");
return;
// error
}
HashSet <Variable> .Enumerator vars = formula.GetFreeVariables().GetEnumerator();
vars.MoveNext();
Variable first = vars.Current;
if (vars.MoveNext())
{
System.Console.WriteLine("FType failed: more than one free variable");
return;
// error (more than one free variable)
}
if (!first.GetSemanticType().Equals(basetype))
{
System.Console.WriteLine(first.GetSemanticType());
System.Console.WriteLine(basetype);
System.Console.WriteLine("FType failed: types aren't equal");
return;
// error
}
this.basetype = basetype;
this.formula = formula;
}
static void TestLambda()
{
System.Console.WriteLine("=====================");
System.Console.WriteLine("Testing Lambda:");
Lambda l = new Lambda(
new Variable(new E(), 0),
new App(
new Variable(new Arrow(new E(), new T()), 8),
new Variable(new E(), 0)));
System.Console.WriteLine(l);
LogicalForm noChange = l.Bind(0, new Constant(new E(), 40));
System.Console.WriteLine(noChange);
LogicalForm variableReplace =
l.Bind(8, new Constant(new Arrow(new E(), new T()), 60));
System.Console.WriteLine(variableReplace);
System.Console.WriteLine(l.Apply(new Constant(new E(), 40)));
System.Console.WriteLine("=====================");
}
public Variable(ISemanticType type, int id) : base(type)
{
this.id = id;
this.isFormula = LogicalForm.IsFormulaType(type);
this.freeVariables = new HashSet <Variable>();
this.freeVariables.Add(this);
}
public override LogicalForm Bind(int id, LogicalForm lf)
{
if (id == v.GetID())
{
return(this);
}
return(new Lambda(v, l.Bind(id, lf)));
}
public Lambda(Variable v, LogicalForm l)
: base(new Arrow(v.GetSemanticType(), l.GetSemanticType()))
{
this.v = v;
this.l = l;
this.freeVariables = l.CloneVariables();
freeVariables.Remove(v);
}
// Updates the Model (M) such that
// l has the truth value v in M
private UpdateInfo Make(LogicalForm l, TruthValue.T v)
{
if (l.IsClosed() && l.IsFormula())
{
return(UpdateInfo.NoChange);
}
return(l.Make(this, v));
}
public ToDesirability(LogicalForm sentence) : base(new W())
{
if (sentence.GetType() != typeof(TWG))
{
// error!
}
this.sentence = sentence;
this.isFormula = true;
this.freeVariables = sentence.GetFreeVariables();
}
public Not(LogicalForm sub) : base(sub.GetSemanticType())
{
if (!sub.IsFormula())
{
// error!
return;
}
this.sub = sub;
this.isFormula = true;
this.freeVariables = sub.GetFreeVariables();
}
public override LogicalForm Bind(int id, LogicalForm l)
{
if (this.id == id && l.GetSemanticType().Equals(this.GetSemanticType()))
{
return(l);
}
else
{
return(this);
}
}
public override LogicalForm Bind(int id, LogicalForm l)
{
HashSet <LogicalForm> newSubs = new HashSet <LogicalForm>();
foreach (LogicalForm sub in this.subs)
{
newSubs.Add(sub.Bind(id, l));
}
return(new Or(newSubs));
}
// Super compatible
private HashSet <int> GetDomain(ISemanticType t)
{
Model currentModel = super;
if (t.GetType() == typeof(FType))
{
FType fType = (FType)t;
LogicalForm formula = fType.GetFormula();
int varID = formula.GetFreeVariables().Single <Variable>().GetID();
ISemanticType baseType = fType.GetBaseType();
// populating the set with all semantic values
// (including those in super models)
// possible error: basetype is undefined in M
Dictionary <int, ISemanticValue> .KeyCollection baseSet = model[baseType].Keys;
while (currentModel != null)
{
// possible error: basetype is undefined in M
baseSet.Union <int>(currentModel.model[baseType].Keys);
}
HashSet <int> finalSet = new HashSet <int>();
foreach (int i in baseSet)
{
if (Satisfies(formula.Bind(varID, new Constant(baseType, i))))
{
finalSet.Add(i);
}
}
return(finalSet);
}
HashSet <int> theSet = new HashSet <int>();
foreach (int i in model[t].Keys)
{
theSet.Add(i);
}
while (currentModel != null)
{
// possible error: t is undefined in M
theSet.UnionWith(currentModel.model[t].Keys);
}
return(theSet);
}
public And NegateAndReplaceWith(LogicalForm from, LogicalForm to)
{
HashSet <LogicalForm> newSubs = new HashSet <LogicalForm>();
foreach (LogicalForm sub in this.subs)
{
if (!sub.Equals(from))
{
newSubs.Add(sub.Negate());
}
}
newSubs.Add(to);
return(new And(newSubs));
}
// makes the inference prescribed by r in this model
// returns true if there was a change to the model,
// false otherwise
public bool MakeInference(Rule r)
{
if (!r.IsClosed())
{
return(false);
}
LogicalForm inference = r.GetInference(this);
if (inference != null)
{
sentenceRules.Remove(r);
if (!activeRules.ContainsKey(inference))
{
activeRules[inference] =
Tuple.Create(new HashSet <Rule>(),
new HashSet <Rule>());
}
activeRules[inference].Item2.Add(r);
UpdateInfo info = MakeTrue(inference);
// what was inferred was already true. Boring!
if (info == UpdateInfo.NoChange)
{
return(false);
}
// we've inferred something which turned out
// to be inconsistent. We need to resolve it!
if (info == UpdateInfo.Warning)
{
ResolveInconsistency(inference);
}
// we've either resolved an inconsistency or
// inferred something without a hitch, so the
// model has changed.
return(true);
}
return(false);
}
public static String GetFormName(LogicalForm paramInt)
{
switch (paramInt)
{
case LogicalForm.LogicUnclassified:
return "Not any Normal Form";
case LogicalForm.LogicNnf:
return "Negation Normal Form";
case LogicalForm.LogicCNF:
return "Conjunctive Normal Form (CNF)";
case LogicalForm.LogicDNF:
return "Disjunctive Normal Form (DNF)";
case LogicalForm.LogicCNF | LogicalForm.LogicDNF:
return "Conjunctive and Disjunctive Normal Form (CNF & DNF)";
}
return "Invalid Form passed";
}
public ModelBind(LogicalForm sentence, LogicalForm model)
: base(new TWG())
{
if (!sentence.IsFormula())
{
// error!
}
if (model.GetType() != typeof(Model))
{
// error!
}
this.sentence = sentence;
this.model = model;
this.isFormula = false;
this.freeVariables = sentence.MergeVariables(model);
}
// if there is an inconsistency with l and -l,
// then we need to decide between them.
// l is the new thing.
private Policy ResolveInconsistency(LogicalForm l)
{
LogicalForm notL = l.Negate();
// okay. new plan:
// 1. have two helper methods:
// BestRemoval() and BestInsertion()
// 2. recursively call BestRemoval() and
// BestInsertion() and conjoin sentences
// along best removal path
// 3. (when there's a negation, check to see)
// whether, in the current rule, there's A
// on top or ~A on bottom
// 4. problem for BestInsertion(): have to
// make copy of model to make hypothetical
// inferences
// 5. ResolveInconsistency calls BestRemoval()
// on P and ~P, and then removes whichever
// wins out.
// 6. Question simply becomes what to yield
// as output for BestInsertion() and BestRemoval()
Policy bestL = BestRemoval(l);
Policy bestNotL = BestRemoval(notL);
int comparison = CompareLikelihood(BestRemoval(l), BestRemoval(notL));
if (comparison > 0)
{
// TODO perform the removal strategy encoded by bestL
return(bestL);
}
if (comparison < 0)
{
// TODO perform the removal strategy encoded by bestNotL
return(bestNotL);
}
// TODO pick arbitrary one???
// rn we're conservative - we pick the older one
return(bestNotL);
}
public Rule Bind(int id, LogicalForm replace)
{
HashSet <LogicalForm> newTop = new HashSet <LogicalForm>();
HashSet <LogicalForm>[] newBot = new HashSet <LogicalForm> [bot.Length];
foreach (LogicalForm l in top)
{
newTop.Add(l.Bind(id, replace));
}
for (int i = 0; i < bot.Length; i++)
{
foreach (LogicalForm l in bot[i])
{
newBot[i].Add(l.Bind(id, replace));
}
}
return(new Rule(newTop, newBot));
}
// super compatible
public bool Satisfies(LogicalForm l)
{
if (l.IsClosed() && l.IsFormula())
{
ISemanticValue s = l.Denotation(this);
if (s.GetType() == typeof(TruthValue))
{
TruthValue t = (TruthValue)s;
if (t.IsUnknown() && (super != null))
{
return(super.Satisfies(l));
}
return(t.IsTrue());
}
if (super != null)
{
return(super.Satisfies(l));
}
return(false);
}
return(false);
}
public HashSet <Variable> MergeVariables(LogicalForm l)
{
HashSet <Variable> newVs = new HashSet <Variable>();
if (freeVariables != null)
{
foreach (Variable v in freeVariables)
{
newVs.Add(v);
}
}
if (l.GetFreeVariables() != null)
{
foreach (Variable v in l.GetFreeVariables())
{
newVs.Add(v);
}
}
return(newVs);
}
public abstract LogicalForm Bind(int id, LogicalForm l);
public LogicalForm Apply(LogicalForm x)
{
return(l.Bind(v.GetID(), x));
}
public ToTruth(LogicalForm sentence) : base(new T())
{
this.sentence = sentence;
this.isFormula = true;
this.freeVariables = sentence.GetFreeVariables();
}
public Constant(ISemanticType type, int id) : base(type)
{
this.type = type;
this.id = id;
this.isFormula = LogicalForm.IsFormulaType(type);
}
public override LogicalForm Bind(int id, LogicalForm l)
{
return(this);
}
public override LogicalForm Bind(int id, LogicalForm l)
{
return(new App(f.Bind(id, l), x.Bind(id, l)));
}
private Policy BestRemoval(LogicalForm l)
{
// first, we find what supports l.
if (!activeRules.ContainsKey(l))
{
// this means l was not inferred.
// What should we do here?
return(new Remove(l));
}
foreach (Rule r in activeRules[l].Item2)
{
HashSet <LogicalForm> top = r.GetTop();
HashSet <LogicalForm>[] bot = r.GetBottom();
// all the rules where l is on bottom
// we can either side-step or remove a top one
Policy bestRemoval = null;
Policy bestShift = null;
if (top.Count > 0)
{
bestRemoval = BestRemoval(top.First());
// determine best top to remove
foreach (LogicalForm parent in top)
{
Policy contender = BestRemoval(parent);
if (CompareLikelihood(bestRemoval, contender) < 0)
{
bestRemoval = contender;
}
}
}
// THIS IS ALL THE SIDE-STEP STUFF
for (int i = 0; i < bot.Length; i++)
{
HashSet <LogicalForm> currentTier = bot[i];
foreach (LogicalForm sibling in currentTier)
{
if (!Satisfies(sibling.Negate()))
{
if (bestShift == null)
{
bestShift = BestAddition(sibling);
}
else
{
int comparitor = CompareLikelihood(bestShift, BestAddition(sibling));
if (comparitor < 0)
{
bestShift = BestAddition(sibling);
}
}
}
}
if (bestShift != null)
{
break;
}
}
// bestRemoval = bestRemoval.Concat(new Remove(l));
bestShift = bestRemoval.GetDual().Concat(bestShift);
Policy winner = (CompareLikelihood(bestRemoval, bestShift) > 0) ? bestRemoval : bestShift;
return(winner.Concat(new Remove(l)));
}
return(null);
// TODO collect best results from different rules
}
private Policy BestAddition(LogicalForm l)
{
// TODO make this involve inferences too
return(new Add(l));
}
public override LogicalForm Bind(int id, LogicalForm l)
{
return(new ToTruth(sentence.Bind(id, l)));
}
public Add(LogicalForm l)
{
this.l = l;
}
// Makes s true in M
public UpdateInfo MakeTrue(LogicalForm s)
{
return(Make(s, TruthValue.T.True));
}
