def create_si_contra():
#define the initial atomic name in the WCS: one for each observed card
#these atoms have value None
D = basicLogic.atom('D')
K = basicLogic.atom('K')
three = basicLogic.atom('3')
seven = basicLogic.atom('7')
#this is the atom which means NOT (D)
Dprime = basicLogic.atom("D'")
#create an epistemic state containing the known facts and conditionals
basePointContra = epistemicState.epistemicState('WST')
#the set of conditionals with the contraposition rule
delta_contra = ["( 3 | D )", " ( D' | 7 ) "]
#the set of conditionals as a set of <basicLogic> clauses
deltaAsLogic = scpNotationParser.stringListToBasicLogic(delta_contra)
#the set of facts known, this prevents negative heads in rules
S_contra = ["( ( D ) <- ( ! D' ) )"]
#the set of known facts as <basicLogic>
SAsLogic = scpNotationParser.stringListToBasicLogic(S_contra)
#the set of abducibles, any subset of which might be an explanation
abducibs = [
'( D <- T )', '( D <- F )', '( K <- T )', '( K <- F )', '( 3 <- T )',
'( 3 <- F )', '( 7 <- T )', '( 7 <- F )'
]
abducibs = ['( D <- T )', '( K <- T )', '( 3 <- T )', '( 7 <- T )']
#transform the set of abducibles to a set of <basicLogic> clauses
logAbducibs = scpNotationParser.stringListToBasicLogic(abducibs)
#set the structural variables of the only epistemic state in the intial state point
basePointContra['S'] = SAsLogic
basePointContra['Delta'] = deltaAsLogic
basePointContra['V'] = [D, K, three, seven, Dprime]
basePointContra['R'] = {'abducibles': logAbducibs}
return [basePointContra]
def example_birds():
W = no.stringListToBasicLogic(['( bird <- T )'])
V = no.stringListToBasicLogic(['bird', 'flies', 'penguin'])
dParts = no.stringListToBasicLogic(
['( bird <- T )', '( flies <- T ) ', '( flies <- T )'])
default1 = basicLogic.operator_tritonic_defaultRule(
dParts[0], [dParts[1]], dParts[2])
dParts2 = no.stringListToBasicLogic(
['( cold <- T )', '( flies <- F ) ', '( flies <- F )'])
default2 = basicLogic.operator_tritonic_defaultRule(
dParts2[0], [dParts2[1]], dParts2[2])
D = [default1, default2]
basePoint = epistemicState.epistemicState('Bird Example')
basePoint['D'] = D
basePoint['W'] = W
basePoint['V'] = V
ctm_flight = CTM.CTM()
ctm_flight.si = [basePoint]
#ctm_flight.appendm(TH)
ctm_flight.appendm(DEFAULT)
print(ctm_flight)
print(ctm_flight.evaluate())
def example_nixon():
DEFAULT = cop.m_default()
W = no.stringListToBasicLogic(['( quaker <- T )', ' ( republican <- T ) '])
#W = no.stringListToBasicLogic([' bird ', ' penguin '])
V = no.stringListToBasicLogic(['quaker', 'republican', 'pacifist'])
#dParts = no.stringListToBasicLogic(['( bird <- T )', '( penguin <- F ) ', '( flies <- T )'])
dParts = no.stringListToBasicLogic(
['( quaker <- T )', '( pacifist <- T ) ', '( pacifist <- T )'])
default1 = basicLogic.operator_tritonic_defaultRule(
dParts[0], [dParts[1]], dParts[2])
dParts2 = no.stringListToBasicLogic(
['( republican <- T )', '( pacifist <- F ) ', '( pacifist <- F )'])
default2 = basicLogic.operator_tritonic_defaultRule(
dParts2[0], [dParts2[1]], dParts2[2])
D = [default1, default2]
basePoint = epistemicState.epistemicState('Bird Example')
basePoint['D'] = D
basePoint['W'] = W
basePoint['V'] = V
ctm_flight = CTM.CTM()
ctm_flight.si = [basePoint]
ctm_flight.appendm(DEFAULT)
print(ctm_flight)
print(ctm_flight.evaluate())
def abducibleSuppression():
print("===========================================================")
print("=================ABDUCIBLE SUPPRESSION=====================")
print("===========================================================")
basePoint1 = epistemicState.epistemicState('el')
delta1 = ["( l | e )"]
S1 = ["( e <- T )"]
delta1AsLogic = scpNotationParser.stringListToBasicLogic(delta1)
S1AsLogic = scpNotationParser.stringListToBasicLogic(S1)
basePoint1['S'] = S1AsLogic
basePoint1['Delta'] = delta1AsLogic
basePoint1['V'] = [e, l]
#The elo case expressed as the addition of information to the el case
basePoint2 = copy.deepcopy(basePoint1)
basePoint2.setName('elo')
#The possible starting states for the SCP
extraConditional = ["( l | o )"]
extraConditionalAsLogic = scpNotationParser.stringListToBasicLogic(
extraConditional)
basePoint2['Delta'] = basePoint2['Delta'] + extraConditionalAsLogic
basePoint2['V'] = basePoint2['V'] + [o]
#abducibs = [ '( l <- T )', '( l <- F )','( o <- T )', '( o <- F )']
abducibs = ['( o <- T )', '( o <- F )']
logAbducibs = scpNotationParser.stringListToBasicLogic(abducibs)
basePoint1['R'] = {'abducibles': logAbducibs}
basePoint2['R'] = {'abducibles': logAbducibs}
#Create the first state point
statePoints = [basePoint1, basePoint2]
s_i = statePoints
f = f_suppression_studyLate
#The desired output of the external evaluation function
gamma = {
'el': 'She will study late in the library',
'elo': 'We are uncertain if she will study late in the library'
}
#test ctm
c = CTM.CTM()
c.setSi(s_i)
c.appendm(ADDAB)
c.appendm(ABDUCIBLES)
c.appendm(WC)
c.appendm(SEMANTIC)
predictions = f(c)
print('predictions: ', predictions)
print("Lenient Interp")
print(
StatePointOperations.predictionsModelsGamma_lenient(
predictions, gamma))
print("Strict Interp")
print(
StatePointOperations.predictionsModelsGamma_strict(predictions, gamma))
print("f(pi) models gamma_noSup? : ",
(StatePointOperations.predictionsModelsGamma_lenient(
predictions, gamma)))
def createBasePoint_el():
basePoint_el = epistemicState.epistemicState('el')
delta1 = ["( l | e )"]
S1 = ["( e <- T )"]
delta1AsLogic = scpNotationParser.stringListToBasicLogic(delta1)
S1AsLogic = scpNotationParser.stringListToBasicLogic(S1)
basePoint_el['S'] = S1AsLogic
basePoint_el['Delta'] = delta1AsLogic
basePoint_el['V'] = [e, l]
return basePoint_el
def scpSearch():
print(
"=======================BEGINNING SEARCH==============================="
)
basePoint_el = createBasePoint_el()
basePoint_elo = createBasePoint_elo()
#abducibs = [ '( l <- T )', '( l <- F )','( o <- T )', '( o <- F )']
abducibs = ['( o <- T )', '( o <- F )']
logAbducibs = scpNotationParser.stringListToBasicLogic(abducibs)
basePoint_el['R'] = {'delete': ["o", "e"]}
basePoint_elo['R'] = {'delete': ["o", "e"]}
basePoint_el['R']['abducibles'] = logAbducibs
basePoint_elo['R']['abducibles'] = logAbducibs
#Create the first state point
statePoints = [basePoint_el, basePoint_elo]
s_i = statePoints
#The set of possible states
M = [ADDAB, SEMANTIC, WC]
#The external evaluation function
f = f_suppression_studyLate
#The desired output of the external evaluation function
gamma = {
'el': 'She will study late in the library',
'elo': 'We are uncertain if she will study late in the library'
}
#The SCP task which states what is required from a solution SCP or realised SCP
task = SCP_Task.SCP_Task(s_i, M, f, gamma)
searchResult = task.deNoveSearch()
print("\nSEARCH RESULTS:")
print(strSCPLi(searchResult))
def example_suppression():
W = no.stringListToBasicLogic(['( e <- T )'])
#W = no.stringListToBasicLogic([' bird ', ' penguin '])
V = no.stringListToBasicLogic(['e', 'l', 'o'])
#dParts = no.stringListToBasicLogic(['( bird <- T )', '( penguin <- F ) ', '( flies <- T )'])
dParts1 = no.stringListToBasicLogic(['( e <- T )', '( ab1 <- F ) ', '( l <- T )'])
default1 = basicLogic.operator_tritonic_defaultRule(dParts1[0],[dParts1[1]],dParts1[2])
dParts2 = no.stringListToBasicLogic(['( o <- T )', '( ab2 <- F ) ', '( l <- T )'])
default2 = basicLogic.operator_tritonic_defaultRule(dParts2[0],[dParts2[1]],dParts2[2])
dParts3 = no.stringListToBasicLogic(['( o <- F )', '( ab1 <- T ) ', '( ab1 <- T )'])
default3 = basicLogic.operator_tritonic_defaultRule(dParts3[0],[dParts3[1]],dParts3[2])
dParts4 = no.stringListToBasicLogic(['( e <- F )', '( ab2 <- T ) ', '( ab2 <- T )'])
default4 = basicLogic.operator_tritonic_defaultRule(dParts4[0],[dParts4[1]],dParts4[2])
D=[default1,default2,default3,default4]
basePoint = epistemicState.epistemicState('Bird Example')
basePoint['D']=D
basePoint['W']=W
basePoint['V']=V
ctm_flight = CTM.CTM()
ctm_flight.si=[basePoint]
#ctm_flight.appendm(TH)
ctm_flight.appendm(DEFAULT)
print (ctm_flight)
print (ctm_flight.evaluate())
def createBasePoint_elo():
#The elo case expressed as the addition of information to the el case
basePoint_el = copy.deepcopy(createBasePoint_el())
basePoint_elo = copy.deepcopy(basePoint_el)
basePoint_elo.setName('elo')
#The possible starting states for the SCP
extraConditional = ["( l | o )"]
extraConditionalAsLogic = scpNotationParser.stringListToBasicLogic(
extraConditional)
basePoint_elo['Delta'] = basePoint_elo['Delta'] + extraConditionalAsLogic
basePoint_elo['V'] = basePoint_elo['V'] + [o]
basePoint_elo['R'] = {'delete': ["o", "e"]}
basePoint_elo['R'] = {'delete': ["o", "e"]}
return basePoint_elo
def abducibleSuppression():
print("===========================================================")
print("=================ABDUCIBLE SUPPRESSION=====================")
print("===========================================================")
basePoint_el = createBasePoint_el()
basePoint_elo = createBasePoint_elo()
statePoints = [basePoint_el, basePoint_elo]
#abducibs = [ '( l <- T )', '( l <- F )','( o <- T )', '( o <- F )']
abducibs = ['( o <- T )', '( o <- F )']
logAbducibs = scpNotationParser.stringListToBasicLogic(abducibs)
basePoint_el['R'] = {'abducibles': logAbducibs}
basePoint_elo['R'] = {'abducibles': logAbducibs}
#Create the first state point
statePoints = [basePoint_el, basePoint_elo]
s_i = statePoints
f = f_suppression_studyLate
#The desired output of the external evaluation function
gamma = {
'el': 'She will study late in the library',
'elo': 'We are uncertain if she will study late in the library'
}
#test ctm
c = CTM.CTM()
c.setSi(s_i)
c.appendm(ADDAB)
c.appendm(ABDUCIBLES)
c.appendm(WC)
c.appendm(SEMANTIC)
predictions = f(c)
print('predictions: ', predictions)
print("Lenient Interp")
print(
StatePointOperations.predictionsModelsGamma_lenient(
predictions, gamma))
print("Strict Interp")
print(
StatePointOperations.predictionsModelsGamma_strict(predictions, gamma))
print("f(pi) models gamma_noSup? : ",
(StatePointOperations.predictionsModelsGamma_lenient(
predictions, gamma)))
print("response(p_bar):", responses[-1])
print("------------------------------")
return responses
# THE SET OF COGNITIVE OPERATIONS APPROPRIATE TO THE SUPPRESSION TASK
ADDAB = CognitiveOperation.m_addAB()
WC = CognitiveOperation.m_wc()
SEMANTIC = CognitiveOperation.m_semantic()
ABDUCIBLES = CognitiveOperation.m_addAbducibles(maxLength=4)
DELETE = CognitiveOperation.m_deleteo()
basePoint1 = epistemicState.epistemicState('el')
delta1 = ["( l | e )"]
S1 = ["( e <- T )"]
delta1AsLogic = scpNotationParser.stringListToBasicLogic(delta1)
S1AsLogic = scpNotationParser.stringListToBasicLogic(S1)
basePoint1['S'] = S1AsLogic
basePoint1['Delta'] = delta1AsLogic
basePoint1['V'] = [e, l]
#The elo case expressed as the addition of information to the el case
basePoint2 = copy.deepcopy(basePoint1)
basePoint2.setName('elo')
#The possible starting states for the SCP
extraConditional = ["( l | o )"]
extraConditionalAsLogic = scpNotationParser.stringListToBasicLogic(
extraConditional)
basePoint2['Delta'] = basePoint2['Delta'] + extraConditionalAsLogic
basePoint2['V'] = basePoint2['V'] + [o]
basePoint1['R'] = {'delete': ["o", "e"]}
def f_turn(pi, observation):
finalStructures = pi.evaluate()
finalStates = StatePointOperations.flattenStatePoint(finalStructures)
if not isinstance(finalStates, list):
finalStates = [finalStates]
conditional = scpNotationParser.stringListToBasicLogic(
["( ( 3 | D ) or ( D' | 7 ) )"])
# we are willing to turn the card if either the (3 | D) or the contrapositive case ( D' | 7 ) holds
obs = scpNotationParser.stringListToBasicLogic(
['( {} <- T )'.format(observation)])
responses = []
for epi in finalStates:
#print ("\n")
#print (epi)
basicLogic.setkbfromv(obs, epi['V'])
#the conditional must be verified or falsified
#the observation must be True
allObsTrue = True
for o in obs:
if o.evaluate() != True:
allObsTrue = False
#allCondApplicable = True
if allObsTrue:
responses.append('observations hold')
else:
responses.append('observations do not')
#now we need to find the minimal set of abducibles to turn the cards
turnResponses = []
#WE PREFER MINIMAL EXPLANATIONS
for i in range(0, len(responses)):
if responses[i] == 'observations hold':
turnResponses.append(finalStates[i])
minimalSubset = []
for epi in turnResponses:
#print ("epi is ", epi)
#print (epi['R']['abducibles'])
#print ("and then here")
x = [
StatePointOperations.properSubset(ot['R']['abducibles'],
epi['R']['abducibles'])
for ot in turnResponses
]
#another least model is a subset of this one
if True in x:
pass
else:
minimalSubsetAsVariables = epi['V']
minimalSubsetAsList = StatePointOperations.VtoTupleList(
minimalSubsetAsVariables, ignoreNone=True)
if minimalSubsetAsList not in minimalSubset:
minimalSubset.append(minimalSubsetAsVariables)
turns = []
for mini in minimalSubset:
allCondApplicable = True
#this is done later
basicLogic.setkbfromv(conditional, mini)
#print ("mini is : ", mini)
for cond in conditional:
#print (cond, "Evaluates to ", cond.evaluate())
if cond.evaluate() == None:
#print ("evaluation was ", cond.evaluate())
allCondApplicable = False
#print ("cond is ",cond)
if allCondApplicable:
turns.append('Turn Card')
#print ("1")
else:
turns.append('Do Not Turn')
#print("2")
return turns