public static void AddDoorModel(Model m)
{
// ACTION RULES
m.Add(new ActionRule(Expression.VERUM,
new Phrase(Expression.WOULD,
new Phrase(Expression.AT, Expression.SELF, new Phrase(Expression.THE, Expression.DOOR))),
new Phrase(Expression.AT, Expression.SELF, new Phrase(Expression.THE, Expression.DOOR))));
m.Add(new ActionRule(Expression.VERUM,
new Phrase(Expression.WOULD, new Phrase(Expression.AT, Expression.SELF, Expression.BOB)),
new Phrase(Expression.AT, Expression.SELF, Expression.BOB)));
m.Add(new ActionRule(Expression.VERUM,
new Phrase(Expression.WOULD, new Phrase(Expression.AT, Expression.SELF, Expression.EVAN)),
new Phrase(Expression.AT, Expression.SELF, Expression.EVAN)));
m.Add(new ActionRule(Expression.VERUM,
new Phrase(Expression.WOULD, new Phrase(Expression.AT, Expression.SELF, new Phrase(Expression.THE, Expression.DOOR))),
new Phrase(Expression.AT, Expression.SELF, new Phrase(Expression.THE, Expression.DOOR))));
m.Add(new ActionRule(Expression.VERUM,
new Phrase(Expression.WOULD, new Phrase(Expression.AT, Expression.SELF, new Phrase(Expression.THE, Expression.COW))),
new Phrase(Expression.AT, Expression.SELF, new Phrase(Expression.THE, Expression.COW))));
// SUBSTITUTION RULES
// open(x) |- not(closed(x))
m.Add(new SubstitutionRule(
new List <IPattern>[] { DefaultModel.BuildList(new ExpressionPattern(
Expression.OPEN,
new MetaVariable(SemanticType.INDIVIDUAL, 0))) },
new List <IPattern>[] { DefaultModel.BuildList(new ExpressionPattern(
Expression.NOT,
new ExpressionPattern(Expression.CLOSED, new MetaVariable(SemanticType.INDIVIDUAL, 0)))) }));
// COMMON KNOWLEDGE
m.Add(new Phrase(Expression.NOT, new Phrase(Expression.IDENTITY, Expression.BOB, Expression.EVAN)));
}
void Start()
{
base.Start();
this.name = new Phrase(Expression.THE, new Phrase(Expression.POSSESS, new Phrase(Expression.THE, Expression.LOG), 1));
CustomModels.AddWoodcutterModel(this.model);
// ACTION RULES
this.model.Add(new ActionRule(
new Phrase(Expression.AT, Expression.SELF, new Phrase(Expression.THE, Expression.TREE)),
new Phrase(Expression.WOULD, new Phrase(Expression.EXISTS, new Phrase(Expression.THE, Expression.LOG))),
new Phrase(Expression.EXISTS, new Phrase(Expression.THE, Expression.LOG))));
// Substitution Rules
// x has the crown |- x is king
this.model.Add(new SubstitutionRule(
new List <IPattern>[] { DefaultModel.BuildList(new ExpressionPattern(Expression.POSSESS, new MetaVariable(SemanticType.INDIVIDUAL, 0), new Phrase(Expression.THE, Expression.CROWN))) },
new List <IPattern>[] { DefaultModel.BuildList(new ExpressionPattern(Expression.KING, new MetaVariable(SemanticType.INDIVIDUAL, 0))) }));
// particular beliefs
// self-knowledge
}
public static Model Make()
{
Model m = new SimpleModel();
MetaVariable xt0 = new MetaVariable(SemanticType.TRUTH_VALUE, 0);
MetaVariable xt1 = new MetaVariable(SemanticType.TRUTH_VALUE, 1);
MetaVariable xi0 = new MetaVariable(SemanticType.INDIVIDUAL, 0);
MetaVariable xi1 = new MetaVariable(SemanticType.INDIVIDUAL, 1);
MetaVariable xi2 = new MetaVariable(SemanticType.INDIVIDUAL, 2);
MetaVariable xp0 = new MetaVariable(SemanticType.PREDICATE, 0);
MetaVariable xp1 = new MetaVariable(SemanticType.PREDICATE, 1);
MetaVariable xr20 = new MetaVariable(SemanticType.RELATION_2, 0);
MetaVariable xitr0 = new MetaVariable(SemanticType.INDIVIDUAL_TRUTH_RELATION, 0);
MetaVariable xtf10 = new MetaVariable(SemanticType.TRUTH_FUNCTION_1, 0);
MetaVariable xqp0 = new MetaVariable(SemanticType.QUANTIFIER_PHRASE, 0);
Expression not = Expression.NOT;
// COMMON-KNOWLEDGE
// m.Add(new Phrase(Expression.AT, Expression.SELF, Expression.SELF));
// m.Add(new Phrase(Expression.COLOR, new Phrase(Expression.NOMINALIZE, Expression.BLACK)));
// m.Add(new Phrase(Expression.COLOR, new Phrase(Expression.NOMINALIZE, Expression.RED)));
// m.Add(new Phrase(Expression.COLOR, new Phrase(Expression.NOMINALIZE, Expression.GREEN)));
// m.Add(new Phrase(Expression.COLOR, new Phrase(Expression.NOMINALIZE, Expression.BLUE)));
// m.Add(new Phrase(Expression.COLOR, new Phrase(Expression.NOMINALIZE, Expression.CYAN)));
// m.Add(new Phrase(Expression.COLOR, new Phrase(Expression.NOMINALIZE, Expression.MAGENTA)));
// m.Add(new Phrase(Expression.COLOR, new Phrase(Expression.NOMINALIZE, Expression.YELLOW)));
// m.Add(new Phrase(Expression.COLOR, new Phrase(Expression.NOMINALIZE, Expression.WHITE)));
// SELF-KNOWLEDGE
m.Add(new Phrase(Expression.PERSON, Expression.SELF));
m.Add(new Phrase(Expression.ACTIVE, Expression.SELF));
// // ACTION RULES
// m.Add(new ActionRule(
// Expression.VERUM,
// new ExpressionPattern(Expression.WOULD,
// new ExpressionPattern(Expression.AT, Expression.SELF, xi0)),
// new ExpressionPattern(Expression.AT, Expression.SELF, xi0)));
// m.Add(new ActionRule(
// new ExpressionPattern(Expression.AT, Expression.SELF, xi0),
// new ExpressionPattern(Expression.WOULD,
// new ExpressionPattern(Expression.BELIEVE, xi0, xt0)),
// new ExpressionPattern(Expression.BELIEVE, xi0, xt0)));
// m.Add(new ActionRule(
// new ExpressionPattern(Expression.AT, Expression.SELF, xi0),
// new ExpressionPattern(Expression.WOULD,
// new ExpressionPattern(Expression.INTEND, xi0, xt0)),
// new ExpressionPattern(Expression.INTEND, xi0, xt0)));
// m.Add(new ActionRule(
// new ExpressionPattern(Expression.POSSESS, Expression.SELF, xi0),
// new ExpressionPattern(Expression.WOULD,
// new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.POSSESS, Expression.SELF, xi0))),
// new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.POSSESS, Expression.SELF, xi0))));
// SUBSTITUTION RULES
// |- verum
m.Add(new SubstitutionRule(
new List <IPattern>[] {},
new List <IPattern>[] { BuildList(Expression.VERUM) }));
// falsum |-
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(Expression.FALSUM) },
new List <IPattern>[] {}));
// // S |- believes(self, S)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(xt0)},
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.BELIEVE, Expression.SELF, xt0))},
// false));
// // believes(x, ~S) |- ~believes(x, S)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.BELIEVE, xi0, new ExpressionPattern(not, xt0)))},
// new List<IPattern>[]{BuildList(new ExpressionPattern(not, new ExpressionPattern(Expression.BELIEVE, xi0, xt0)))},
// false));
// better(A, B) |- prefers(self, A, B)
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.BETTER, xt0, xt1)) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.PREFER, Expression.SELF, xt0, xt1)) },
false));
// ~better(A, B) |- ~prefers(self, A, B)
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.BETTER, xt0, xt1))) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.PREFER, Expression.SELF, xt0, xt1))) },
false));
// S |- T(S)
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(xt0) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.TRUE, xt0)) },
false));
// ~S |- ~T(S)
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.NOT, xt0)) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.TRUE, xt0))) },
false));
// S |- ~~S
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(xt0) },
new List <IPattern>[] { BuildList(new ExpressionPattern(not, new ExpressionPattern(not, xt0))) },
false));
// // GEACH RULES
// // t -> t
// // !F(x) |- G(!, F, x)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(xtf10, new ExpressionPattern(xp0, xi0)))},
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.GEACH_TF1, xtf10, xp0, xi0))},
// false));
// // t, t -> t
// // C(F(x), H(x)) |- G(C, F, H, x)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(xtf10, new ExpressionPattern(xp0, xi0)))},
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.GEACH_TF1, xtf10, xp0, xi0))},
// false));
// // |- F(the(F))
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{},
// new List<IPattern>[]{BuildList(new ExpressionPattern(xp0, new ExpressionPattern(Expression.THE, xp0)))}));
// // reflexivity for at
// // |- at(x, x)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{},
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.AT, xi0, xi0))}));
// reflexivity for identity
// |- x = x
m.Add(new SubstitutionRule(
new List <IPattern>[] {},
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.IDENTITY, xi0, xi0)) }));
// @NOTE this is redundant once substitution of identicals is figured out.
// symmetry for identity
// x = y |- y = x
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.IDENTITY, xi0, xi1)) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.IDENTITY, xi1, xi0)) }));
// // CAUSING LOOPS
// // substitution of identiticals
// // x = y, F(x) |- F(y)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{
// BuildList(new ExpressionPattern(Expression.IDENTITY, xi0, xi1),
// new ExpressionPattern(xp0, xi0))},
// new List<IPattern>[]{BuildList(new ExpressionPattern(xp0, xi1))}));
// F(x), G(x) |- some(F, G)
// not transposable to save time
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(xp0, xi0), new ExpressionPattern(xp1, xi0)) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.SOME, xp0, xp1)) },
false));
// // uniqueness of king
// // king(i), king(j) |- i = j
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{
// BuildList(
// new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.IDENTITY, xi0, xi1)))},
// new List<IPattern>[]{
// BuildList(
// new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.KING, xi0)),
// new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.KING, xi1)))},
// false));
MetaVariable xt2 = new MetaVariable(SemanticType.TRUTH_VALUE, 2);
// A, B |- A & B
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(xt0, xt1) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.AND, xt0, xt1)) }));
// // A & B |- A
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.AND, xt0, xt1))},
// new List<IPattern>[]{BuildList(xt0)}));
// // A & B |- B
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.AND, xt0, xt1))},
// new List<IPattern>[]{BuildList(xt1)}));
// // A v B |- A, B
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.OR, xt0, xt1))},
// new List<IPattern>[]{BuildList(xt0, xt1)}));
// A |- A v B
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(xt0) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.OR, xt0, xt1)) }));
// B |- A v B
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(xt1) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.OR, xt0, xt1)) }));
// reflexivity of as_good_as
m.Add(new SubstitutionRule(
new List <IPattern>[] {},
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.AS_GOOD_AS, xt0, xt0)) }));
m.Add(new SubstitutionRule(
new List <IPattern>[] {},
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.INDIFFERENT, xi0, xt0, xt0)) }));
// symmetry of as_good_as
// as_good_as(A, B) |- as_good_as(B, A)
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.AS_GOOD_AS, xt0, xt1)) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.AS_GOOD_AS, xt1, xt0)) }));
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.INDIFFERENT, xi0, xt0, xt1)) },
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.INDIFFERENT, xi0, xt1, xt0)) }));
// better(A, B) |- ~better(B, A)
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.BETTER, xt0, xt1)) },
new List <IPattern>[] { BuildList(
new ExpressionPattern(Expression.NOT,
new ExpressionPattern(Expression.BETTER, xt1, xt0))) }));
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.PREFER, xi0, xt0, xt1)) },
new List <IPattern>[] { BuildList(
new ExpressionPattern(Expression.NOT,
new ExpressionPattern(Expression.PREFER, xi0, xt1, xt0))) }));
// as_good_as(A, B) |- ~better(A, B)
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.AS_GOOD_AS, xt0, xt1)) },
new List <IPattern>[] { BuildList(
new ExpressionPattern(Expression.NOT,
new ExpressionPattern(Expression.BETTER, xt0, xt1))) }));
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.INDIFFERENT, xi0, xt0, xt1)) },
new List <IPattern>[] { BuildList(
new ExpressionPattern(Expression.NOT,
new ExpressionPattern(Expression.PREFER, xi0, xt0, xt1))) }));
// // A, B |- equivalent(A, B)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(xt0, xt1)},
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.EQUIVALENT, xt0, xt1))},
// false));
// // ~A, ~B |- equivalent(A, B)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(not, xt0), new ExpressionPattern(not, xt1))},
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.EQUIVALENT, xt0, xt1))},
// false));
// // A, ~B |- ~equivalent(A, B)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(xt0, new ExpressionPattern(not, xt1))},
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.EQUIVALENT, xt0, xt1)))},
// false));
// // ~A, B |- ~equivalent(A, B)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(not, xt0), xt1)},
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.EQUIVALENT, xt0, xt1)))},
// false));
// // NATURAL ARITHEMTIC
// // numeric conversion
// MetaVariable xii0 = new MetaVariable(SemanticType.INDIVIDUAL_FUNCTION_1, 0);
// // x = succ(0) |- x = 1
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.IDENTITY, xi0,
// new ExpressionPattern(Expression.SUCC, Expression.ZERO)))},
// new List<IPattern>[]{
// BuildList(new ExpressionPattern(Expression.IDENTITY, xi0, Expression.ONE))}, false));
// // x = succ(1) |- x = 2
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.IDENTITY, xi0,
// new ExpressionPattern(Expression.SUCC, Expression.ONE)))},
// new List<IPattern>[]{
// BuildList(new ExpressionPattern(Expression.IDENTITY, xi0, Expression.TWO))}, false));
// // x = succ(2) |- x = 3
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.IDENTITY, xi0,
// new ExpressionPattern(Expression.SUCC, Expression.TWO)))},
// new List<IPattern>[]{
// BuildList(new ExpressionPattern(Expression.IDENTITY, xi0, Expression.THREE))}, false));
// // x = succ(3) |- x = 4
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.IDENTITY, xi0,
// new ExpressionPattern(Expression.SUCC, Expression.THREE)))},
// new List<IPattern>[]{
// BuildList(new ExpressionPattern(Expression.IDENTITY, xi0, Expression.FOUR))}, false));
// // x = succ(4) |- x = 5
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.IDENTITY, xi0,
// new ExpressionPattern(Expression.SUCC, Expression.FOUR)))},
// new List<IPattern>[]{
// BuildList(new ExpressionPattern(Expression.IDENTITY, xi0, Expression.FIVE))}, false));
// |- succ(x) != 0
m.Add(new SubstitutionRule(
new List <IPattern>[] {},
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.NOT,
new ExpressionPattern(Expression.IDENTITY,
new ExpressionPattern(Expression.SUCC, xi0), Expression.ZERO)))
}, false));
// x = y |- succ(x) = succ(y)
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.IDENTITY, xi0, xi1)) },
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.IDENTITY, new ExpressionPattern(Expression.SUCC, xi0),
new ExpressionPattern(Expression.SUCC, xi1)))
}, false));
// x != y |- succ(x) != succ(y)
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.IDENTITY, xi0, xi1))) },
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.NOT,
new ExpressionPattern(Expression.IDENTITY, new ExpressionPattern(Expression.SUCC, xi0),
new ExpressionPattern(Expression.SUCC, xi1))))
}, false));
// x = y |- x = y + 0
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.IDENTITY, xi0, xi1)) },
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.IDENTITY, xi0,
new ExpressionPattern(Expression.PLUS, xi1, Expression.ZERO)))
}, false));
// x != y |- x != y + 0
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.IDENTITY, xi0, xi1))) },
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.IDENTITY, xi0,
new ExpressionPattern(Expression.PLUS, xi1, Expression.ZERO))))
}, false));
// x = y + z |- succ(x) = y + succ(z)
m.Add(new SubstitutionRule(
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.IDENTITY, xi0,
new ExpressionPattern(Expression.PLUS, xi1, xi2)))
},
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.IDENTITY,
new ExpressionPattern(Expression.SUCC, xi0),
new ExpressionPattern(Expression.PLUS, xi1, new ExpressionPattern(Expression.SUCC, xi2))))
}, false));
// x != y + z |- succ(x) != y + succ(z)
m.Add(new SubstitutionRule(
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.IDENTITY, xi0,
new ExpressionPattern(Expression.PLUS, xi1, xi2))))
},
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.IDENTITY,
new ExpressionPattern(Expression.SUCC, xi0),
new ExpressionPattern(Expression.PLUS, xi1, new ExpressionPattern(Expression.SUCC, xi2)))))
}, false)) ;
// // perceptual inference
// // perceive(self, S) | veridical(self, S) |- S
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{
// BuildList(new ExpressionPattern(Expression.PERCEIVE, Expression.SELF, xt0)),
// BuildList(new ExpressionPattern(Expression.VERIDICAL, Expression.SELF, xt0))},
// new List<IPattern>[]{BuildList(xt0)}));
// // able(x, S), make(x, S) |- S
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{
// BuildList(
// new ExpressionPattern(Expression.ABLE, xi0, xt0),
// new ExpressionPattern(Expression.MAKE, xi0, xt0))},
// new List<IPattern>[]{BuildList(xt0)}));
// make(x, S) |- S
m.Add(new SubstitutionRule(
new List <IPattern>[] { BuildList(new ExpressionPattern(Expression.MAKE, Expression.SELF, xt0)) },
new List <IPattern>[] { BuildList(xt0) }));
// you're able to give your stuff to other people
m.Add(new SubstitutionRule(
new List <IPattern>[] { DefaultModel.BuildList(
new ExpressionPattern(Expression.PERSON, xi1),
new ExpressionPattern(Expression.POSSESS, xi0, xi2)) },
new List <IPattern>[] {
DefaultModel.BuildList(
new ExpressionPattern(Expression.ABLE, xi0,
new ExpressionPattern(Expression.POSSESS, xi1, xi2)))
}));
// TRUST
// renege
// bound(x, A), ~A |- ~trustworthy(x)
m.Add(new SubstitutionRule(
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.BOUND, xi0, xt0), new ExpressionPattern(Expression.NOT, xt0))
},
new List <IPattern>[] {
BuildList(new ExpressionPattern(Expression.NOT, new ExpressionPattern(Expression.TRUSTWORTHY, xi0)))
},
false));
// // testimonial inference
// // express(x, S) | sincere(x, S) |- believe(x, S)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{
// BuildList(new ExpressionPattern(Expression.EXPRESS, xi0, xt0)),
// BuildList(new ExpressionPattern(Expression.SINCERE, xi0, xt0))
// },
// new List<IPattern>[]{
// BuildList(new ExpressionPattern(Expression.BELIEVE, xi0, xt0))
// }));
// // believe(x, S) | correct(x, S) |- S
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{
// BuildList(new ExpressionPattern(Expression.BELIEVE, xi0, xt0)),
// BuildList(new ExpressionPattern(Expression.CORRECT, xi0, xt0))
// },
// new List<IPattern>[]{
// BuildList(xt0)
// }));
// // F(x) |- exists(x)
// m.Add(new SubstitutionRule(
// new List<IPattern>[]{BuildList(new ExpressionPattern(xp0, xi0))},
// new List<IPattern>[]{BuildList(new ExpressionPattern(Expression.EXISTS, xi0))}, false));
return(m);
}
