def __init__(self, chainer):
A = chainer.new_variable()
Rule.__init__(self,
formula=formulas.notFormula,
outputs=[A],
inputs=[chainer.link(types.NotLink, [A])])
def __init__(self, chainer, N, link_type):
atoms = chainer.make_n_variables(N)
Rule.__init__(self,
formula=None,
outputs=atoms,
inputs=[chainer.link(link_type, atoms)])
def __init__(self, chainer):
x = chainer.new_variable()
A = chainer.new_variable()
B = chainer.new_variable()
inputs = [
chainer.link(types.MemberLink, [x, A]),
chainer.link(types.MemberLink, [x, B])
]
outputs = [
chainer.link(types.SubsetLink, [A, B]),
chainer.link(types.SubsetLink, [B, A]),
chainer.link(types.SubsetLink,
[chainer.link(types.NotLink, [A]), B]),
chainer.link(types.SubsetLink,
[chainer.link(types.NotLink, [B]), A]),
chainer.link(types.ExtensionalSimilarityLink, [A, B])
]
Rule.__init__(self,
formula=formulas.extensionalEvaluationFormula,
inputs=inputs,
outputs=outputs)
self.probabilistic_inputs = False
def __init__(self, chainer):
A = chainer.new_variable()
Rule.__init__(self,
formula=formulas.notFormula,
outputs=[A],
inputs=[chainer.link(types.NotLink, [A])])
def __init__(self, chainer, from_type, to_type, formula):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(
self, formula=formula, outputs=[chainer.link(to_type, [A, B])], inputs=[chainer.link(from_type, [A, B])]
)
def __init__(self, chainer, N, link_type):
atoms = chainer.make_n_variables(N)
Rule.__init__(self,
formula=None,
outputs=atoms,
inputs=[chainer.link(link_type, atoms)])
def __init__(self, chainer, N):
atoms = chainer.make_n_variables(N)
self._chainer = chainer
Rule.__init__(self,
formula=formulas.orFormula,
outputs=[chainer.link(types.OrLink, atoms)],
inputs=atoms)
def __init__(self, chainer):
self._chainer = chainer
F = chainer.new_variable()
args = chainer.new_variable()
evallink = chainer.link(types.EvaluationLink, [F, args])
Rule.__init__(self, formula=None, inputs=[], outputs=[evallink])
def __init__(self, chainer):
self._chainer = chainer
F = chainer.new_variable()
args = chainer.new_variable()
evallink = chainer.link(types.EvaluationLink, [F, args])
Rule.__init__(self, formula=None, inputs=[], outputs=[evallink])
def __init__(self, chainer, from_type, to_type, formula):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
formula=formula,
outputs=[chainer.link(to_type, [A, B])],
inputs=[chainer.link(from_type, [A, B])])
def __init__(self, chainer):
Z = chainer.new_variable()
ARG = chainer.new_variable()
self.chainer = chainer
Rule.__init__(self, formula=None, inputs=[chainer.link(types.MemberLink, [ARG, Z])], outputs=[])
self.probabilistic_inputs = False
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
outputs=[chainer.link(link_type, [B, A])],
inputs=[chainer.link(link_type, [A, B]), A, B],
formula=formulas.inversionFormula)
def __init__(self, chainer):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
formula=formulas.orBreakdownFormula,
outputs=[B],
inputs=[A, chainer.link(types.OrLink, [A, B])])
def __init__(self, chainer):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
formula=formulas.orBreakdownFormula,
outputs=[B],
inputs=[A, chainer.link(types.OrLink, [A, B])])
def make_symmetric_rule(lhs, rhs):
rule = Rule(inputs=lhs, outputs=rhs, formula=formulas.identityFormula)
rule.name = 'BooleanTransformationRule'
rules.append(rule)
rule = Rule(inputs=rhs, outputs=lhs, formula=formulas.identityFormula)
rule.name = 'BooleanTransformationRule'
rules.append(rule)
def __init__(self, chainer, N):
atoms = chainer.make_n_variables(N)
self._chainer = chainer
Rule.__init__(self,
formula=formulas.orFormula,
outputs=[chainer.link(types.OrLink, atoms)],
inputs=atoms,
name="OrCreationRule<" + str(N) + ">")
def __init__(self, chainer):
predicate_var = chainer.new_variable()
thing_var = chainer.node(types.VariableNode, "$average_thing")
link = chainer.link(types.EvaluationLink, [predicate_var, thing_var])
outputs = [link]
inputs = [chainer.link(types.AverageLink, [thing_var, link])]
Rule.__init__(self, inputs=inputs, outputs=outputs, formula=formulas.identityFormula)
def __init__(self, chainer, N):
atoms = chainer.make_n_variables(N)
self._chainer = chainer
Rule.__init__(self,
formula=formulas.orFormula,
outputs=[chainer.link(types.OrLink, atoms)],
inputs=atoms,
name = "OrCreationRule<"+str(N)+">")
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
outputs=[B],
inputs=[chainer.link(link_type, [A, B]),
A],
formula=formulas.symmetricModusPonensFormula)
def __init__(self, chainer):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
outputs=[chainer.link(types.SimilarityLink, [A, B])],
inputs=[chainer.link(types.AndLink, [A, B]),
chainer.link(types.OrLink, [A, B])],
formula=formulas.extensionalSimilarityFormula)
def __init__(self, chainer):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
outputs=[chainer.link(types.SimilarityLink, [A, B])],
inputs=[chainer.link(types.AndLink, [A, B]),
chainer.link(types.OrLink, [A, B])],
formula=formulas.extensionalSimilarityFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
name = "InversionRule<%s>"%(get_type_name(link_type),),
outputs=[chainer.link(link_type, [B, A])],
inputs=[chainer.link(link_type, [A, B]), A, B],
formula=formulas.inversionFormula)
def __init__(self, chainer, member_type, output_type, formula):
x = chainer.new_variable()
A = chainer.new_variable()
B = chainer.new_variable()
inputs = [chainer.link(member_type, [x, A]), chainer.link(member_type, [x, B])]
Rule.__init__(self, formula=formula, outputs=[chainer.link(output_type, [A, B])], inputs=inputs)
self.probabilistic_inputs = False
def __init__(self, chainer, link_type):
S = chainer.new_variable()
M = chainer.new_variable()
L = chainer.new_variable()
Rule.__init__(self,
outputs=[chainer.link(link_type, [S, L])],
inputs=[chainer.link(link_type, [S, M]),
chainer.link(link_type, [L, M]), S, M, L],
formula=formulas.inductionFormula)
def __init__(self, chainer, N):
self._chainer = chainer
vars = chainer.make_n_variables(N)
Rule.__init__(self,
name="AndBulkEvaluationRule<%s>"%(N,),
formula=None,
outputs=[chainer.link(types.AndLink, vars)],
inputs=[])
def __init__(self, chainer):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
outputs=[chainer.link(types.InheritanceLink, [A, B])],
inputs=[chainer.link(types.SubsetLink, [A, B]),
chainer.link(types.IntensionalInheritanceLink,
[A, B])],
formula=formulas.inheritanceFormula)
def __init__(self, chainer):
self._chainer = chainer
A = chainer.new_variable()
B = chainer.new_variable()
inhAB = chainer.link(types.InheritanceLink, [A, B])
inhBA = chainer.link(types.InheritanceLink, [B, A])
ontoinhAB = chainer.link(types.OntologicalInheritanceLink, [A, B])
Rule.__init__(self, formula=formulas.ontoInhFormula, inputs=[inhAB, inhBA], outputs=[ontoinhAB])
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
name="ModusPonensRule<%s>"%(get_type_name(link_type),),
outputs=[B],
inputs=[chainer.link(link_type, [A, B]),
A],
formula=formulas.modusPonensFormula)
def __init__(self, chainer):
quantified_var = chainer.new_variable()
expr = chainer.new_variable()
self._chainer = chainer
# output is not produced, it just makes backchaining easier
Rule.__init__(
self, formula=None, inputs=[chainer.link(types.ExistsLink, [quantified_var, expr])], outputs=[expr]
)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
Rule.__init__(self,
formula=formulas.deductionGeometryFormula,
outputs=[chainer.link(link_type, [A, C])],
inputs=[chainer.link(link_type, [A, B]),
chainer.link(link_type, [B, C])])
def __init__(self, chainer):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
outputs=[chainer.link(types.InheritanceLink, [A, B])],
inputs=[chainer.link(types.SubsetLink, [A, B]),
chainer.link(types.IntensionalInheritanceLink,
[A, B])],
formula=formulas.inheritanceFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
name="SymmetricModusPonensRule<%s>"%(get_type_name(link_type),),
outputs=[B],
inputs=[chainer.link(link_type, [A, B]),
A],
formula=formulas.symmetricModusPonensFormula)
def __init__(self, chainer):
self._chainer = chainer
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
formula=None,
outputs=[chainer.link(types.AndLink, [A, B])],
inputs=[])
def __init__(self, chainer, N):
self._chainer = chainer
vars = chainer.make_n_variables(N)
Rule.__init__(self,
name="AndBulkEvaluationRule<%s>" % (N, ),
formula=None,
outputs=[chainer.link(types.AndLink, vars)],
inputs=[])
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
name="AndToSubsetRule1<%s>"%(get_type_name(link_type),),
outputs=[chainer.link(link_type, [A, B])],
inputs=[chainer.link(types.AndLink, [A, B]),
A],
formula=formulas.subsetFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
AB = chainer.link(link_type, [A, B])
BA = chainer.link(link_type, [B, A])
Rule.__init__(self,
outputs=[B],
inputs=[AB, BA, A],
formula=formulas.termProbabilityFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
Rule.__init__(self,
formula=formulas.transitiveSimilarityFormula,
outputs=[chainer.link(link_type, [A, C])],
inputs=[chainer.link(link_type, [A, B]),
chainer.link(link_type, [B, C]),
A, B, C])
def __init__(self, chainer, link_type):
S = chainer.new_variable()
M = chainer.new_variable()
L = chainer.new_variable()
Rule.__init__(self,
name="AbductionRule<%s>"%(get_type_name(link_type),),
outputs=[chainer.link(link_type, [S, L])],
inputs=[chainer.link(link_type, [S, M]),
chainer.link(link_type, [L, M]), S, M, L],
formula=formulas.abductionFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
Rule.__init__(self,
name="DeductionGeometryRule<%s>"%(get_type_name(link_type),),
formula=formulas.deductionGeometryFormula,
outputs=[chainer.link(link_type, [A, C])],
inputs=[chainer.link(link_type, [A, B]),
chainer.link(link_type, [B, C])])
def __init__(self, chainer):
Z = chainer.new_variable()
ARG = chainer.new_variable()
self.chainer = chainer
Rule.__init__(self,
formula=None,
inputs=[chainer.link(types.MemberLink, [ARG, Z])],
outputs=[])
self.probabilistic_inputs = False
def __init__(self, chainer):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
formula=formulas.identityFormula,
outputs=[chainer.link(types.PredictiveAttractionLink,
[A, B])],
inputs=[chainer.link(types.AndLink,
[chainer.link(types.AttractionLink,
[A, B]),
chainer.link(types.BeforeLink,
[A, B])])])
def __init__(self, chainer):
quantified_var = chainer.new_variable()
expr = chainer.new_variable()
self._chainer = chainer
# output is not produced, it just makes backchaining easier
Rule.__init__(
self,
formula=None,
inputs=[chainer.link(types.ExistsLink, [quantified_var, expr])],
outputs=[expr])
def __init__(self, chainer):
predicate_var = chainer.new_variable()
thing_var = chainer.node(types.VariableNode, '$average_thing')
link = chainer.link(types.EvaluationLink, [predicate_var, thing_var])
outputs = [link]
inputs = [chainer.link(types.AverageLink, [thing_var, link])]
Rule.__init__(self,
inputs=inputs,
outputs=outputs,
formula=formulas.identityFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
AB = chainer.link(link_type, [A, B])
BA = chainer.link(link_type, [B, A])
Rule.__init__(self,
name="TermProbabilityRule<%s>"%(get_type_name(link_type),),
outputs=[B],
inputs=[AB, BA, A],
formula=formulas.termProbabilityFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
Rule.__init__(self,
name="TransitiveSimilarityRule<%s>"%(get_type_name(link_type),),
formula=formulas.transitiveSimilarityFormula,
outputs=[chainer.link(link_type, [A, C])],
inputs=[chainer.link(link_type, [A, B]),
chainer.link(link_type, [B, C]),
A, B, C])
def __init__(self, chainer, link_type, N):
vars = chainer.make_n_variables(N)
lhs = chainer.link(types.AndLink, vars[:-1])
rhs = vars[-1]
Rule.__init__(self,
name="AndToSubsetRuleN<%s,%s>"%(get_type_name(link_type),N),
outputs=[chainer.link(link_type, [lhs, rhs])],
inputs=[chainer.link(types.AndLink, vars),
lhs],
formula=formulas.subsetFormula)
def __init__(self, chainer):
A = chainer.new_variable()
B = chainer.new_variable()
Rule.__init__(self,
formula=formulas.identityFormula,
outputs=[chainer.link(types.PredictiveAttractionLink,
[A, B])],
inputs=[chainer.link(types.AndLink,
[chainer.link(types.AttractionLink,
[A, B]),
chainer.link(types.BeforeLink,
[A, B])])])
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
notA = chainer.link(types.NotLink, [A])
Rule.__init__(self,
outputs=[B],
inputs=[chainer.link(link_type, [A, B]),
chainer.link(link_type, [notA, B]),
A],
formula=formulas.preciseModusPonensFormula)
def __init__(self, chainer):
self._chainer = chainer
A = chainer.new_variable()
B = chainer.new_variable()
inhAB = chainer.link(types.InheritanceLink, [A, B])
inhBA = chainer.link(types.InheritanceLink, [B, A])
ontoinhAB = chainer.link(types.OntologicalInheritanceLink, [A, B])
Rule.__init__(self,
formula=formulas.ontoInhFormula,
inputs=[inhAB, inhBA],
outputs=[ontoinhAB])
def __init__(self, chainer, N):
self._chainer = chainer
vars = chainer.make_n_variables(N)
notlink = chainer.link(types.NotLink,
[chainer.link(types.AndLink, vars[0:-1])])
andlink = chainer.link(types.AndLink, [notlink, vars[-1]])
Rule.__init__(self,
name="NegatedAndBulkEvaluationRule<%s>" % (N, ),
formula=None,
outputs=[andlink],
inputs=[])
def __init__(self, chainer):
predA = chainer.new_variable()
predB = chainer.new_variable()
person = chainer.new_variable()
eval1 = chainer.link(types.EvaluationLink, [predA, person])
impl = chainer.link(types.ImplicationLink, [predA, predB])
eval2 = chainer.link(types.EvaluationLink, [predB, person])
Rule.__init__(self,
formula=formulas.evaluationImplicationFormula,
outputs=[eval2],
inputs=[eval1, eval2, predA, predB])
def __init__(self, chainer):
self._chainer = chainer
A = chainer.new_variable()
B = chainer.new_variable()
subset1 = chainer.link(types.SubsetLink, [A, B])
subset2 = chainer.link(types.SubsetLink,
[chainer.link(types.NotLink, [A]), B])
Rule.__init__(self,
formula=formulas.attractionFormula,
outputs=[chainer.link(types.AttractionLink, [A, B])],
inputs=[subset1, subset2])
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
notA = chainer.link(types.NotLink, [A])
Rule.__init__(self,
name="PreciseModusPonensRule<%s>"%(get_type_name(link_type),),
outputs=[B],
inputs=[chainer.link(link_type, [A, B]),
chainer.link(link_type, [notA, B]),
A],
formula=formulas.preciseModusPonensFormula)
def __init__(self, chainer, link_type):
A = chainer.new_variable()
B = chainer.new_variable()
C = chainer.new_variable()
AndAB = chainer.link(types.AndLink, [A, B])
Rule.__init__(self,
name="AndAs1stArgInsideLinkRule<%s>"
%(get_type_name(link_type)),
inputs=[C, chainer.link(link_type, [A, C]),
chainer.link(link_type, [B, C]), A, B],
outputs=[chainer.link(link_type, [AndAB, C]),
AndAB],
formula=formulas.andAs1stArgInsideLinkFormula)
def __init__(self, chainer, member_type, output_type, formula):
x = chainer.new_variable()
A = chainer.new_variable()
B = chainer.new_variable()
inputs = [chainer.link(member_type, [x, A]),
chainer.link(member_type, [x, B])]
Rule.__init__(self,
formula=formula,
outputs=[chainer.link(output_type, [A, B])],
inputs=inputs)
self.probabilistic_inputs = False
def __init__(self, chainer, index, arg_count):
self.index = index
self.chainer = chainer
time = chainer.new_variable()
pred = chainer.new_variable()
all_args = chainer.make_n_variables(arg_count)
list_link = chainer.link(types.ListLink, all_args)
eval_link = chainer.link(types.EvaluationLink, [pred, list_link])
at_time = chainer.link(types.AtTimeLink, [time, eval_link])
self.chainer = chainer
Rule.__init__(self, formula=None, inputs=[at_time], outputs=[])
self.probabilistic_inputs = False
