icl-model-intentionality.txt

//////////// MODELS ASSUMING INTENTIONALITY ////////////////

////// Helper Functions //////
  
var addOp = function(x, y, op){ //add connector between 2 strings
  return "(" + x + op + y + ")"  
} 

var cleanOut = function(arr){ //remove outer brackets
  
   var output = arr
  
   if (arr[0] == "(") {
    
    output.pop() 
    output.shift()
    return output
     
  } else {
    
    return output
  }
}

var splitCause = function(belief){
  
  var beliefMod = belief.replaceAll("(", "")
  var beliefMod = beliefMod.replaceAll(")", "")
  
  return beliefMod.split("|")
  
}

var fullClose = function(arr){ // check if array has equal number of "(" and ")"
  
  var openArr = filter(function(x) { return x == "("; }, arr); 
  var closeArr = filter(function(x) { return x == ")"; }, arr);
  
  if (openArr == null || closeArr == null){
    
    return false
    
  }
  if (openArr.length == closeArr.length && arr[0] == "(" && arr[arr.length-1]==")") {
    
    return true
    
  } else {return false}
}

var getRoot = function(arr, n) { // get position of root connector
  
  var temp = arr.slice(0, arr.length - n)
  
  if(fullClose(temp) || n == 0){
    
    return temp.length // position of operator 
    
  } else {
    getRoot(arr, n-1)
  }
}

var evalOp = function(arg1, arg2, op) { //samples a logical action seq from proposition
  
  var arg1temp = arg1
  var arg2temp = arg2
  
  if (op == "&"){
    
    if(arg1.length == 1 && arg2.length == 1){
      var poss = arg1.concat(arg2)
      return randomSort(poss)
    } else {
      return mixArray(arg1temp,arg2temp)
    }
  } else if (op == "|") {
    
    if(arg1.length == 1 && arg2.length == 1){
      var poss = [arg1.concat(arg2), arg1, arg2] // 1/3 prob each
      var roll = uniformDraw(poss)
      return randomSort(roll)
    } else {
      
      var poss = [mixArray(arg1temp,arg2temp), arg1, arg2]
      return uniformDraw(poss)
    }
  } else {
      return arg1.concat(arg2)
  } 
}


var extract = function(pool, remove){
  filter(function(x) { return x != remove; }, pool); 
}

var drawOther = function(pool, n){ //draw random other causes
  
  if (n > pool.length){
    return drawOther(pool, pool.length)
  } else if(n == 1){
    return uniformDraw(pool)
  } else {
    var arg1 = uniformDraw(pool)
    var poolNew = extract(pool, arg1)
    return addOp(arg1, drawOther(poolNew, n-1), "|")
  }
}

var addBel = function(belief, pool, tau){
 
  if(inside(belief, pool)){
     var ncause = Math.floor(sample(Exponential({a:tau}))) // number of other causes
  //var ncause = Math.floor(sample(Poisson({mu:tau}))) // number of other causes
  var poolOther = extract(pool, belief)
  
  if(ncause == 0){ // if no other causes
    var belFinal = belief
    return belFinal
   } else { 
    var belFinal = addOp(belief, drawOther(poolOther, ncause), "|")
    return belFinal
   }
  }else {
    return belief
  }
 
}
  
var randomSort = function(arr){ //randomly sort array
  
  var getRandomFromBucket = function(bucket) {
   var randomIndex = Math.floor(Math.random()*bucket.length);
   return bucket.splice(randomIndex, 1)[0];
}

return map(function(x){
  return getRandomFromBucket(arr)
}, _.range(arr.length))
  
}


var mixArray = function(arg1, arg2){ // mix 2 arrays preserving order of individual array
  
var getRandomFromBucket = function(bucket) {
   var randomIndex = Math.floor(Math.random()*bucket.length);
   return bucket.splice(randomIndex, 1)[0];
}

if (arg1.length == 0){
  return arg2
} 
  
if (arg2.length == 0){
  return arg1
}
  
if (typeof(arg1)=="object" && typeof(arg2)=="object") {
  
var fullRange = _.range(arg2.length + arg1.length)

var arg1Order = map(function(){
  getRandomFromBucket(fullRange)}, 
    _.range(arg1.length)) // get random positions (number of draws based on arg2 length)
var arg1Order = sort(arg1Order) // sort random positions

var arg2Order = map(function(){
  getRandomFromBucket(fullRange)}, 
    _.range(arg2.length)) // get random positions (number of draws based on arg2 length)
var arg2Order = sort(arg2Order) // sort random positions

var order = multiJoin(arg1Order, arg2Order)
var value = multiJoin(arg1, arg2)

var order2 = map(function(x){ //get final positions based on default index
  order.indexOf(x)
}, _.range(order.length))
  
var output = indexSub(value, order2)
  return output

} else if(typeof(arg1) == "string" && typeof(arg2) == "object"){
  var ranPos = uniformDraw(_.range(arg2.length+1))
  return insert(arg2, ranPos, arg1)
} else if(typeof(arg2) == "string" && typeof(arg1) == "object") { //if p2 is string
  var ranPos = uniformDraw(_.range(arg1.length+1))
  return insert(arg1, ranPos, arg2)
} else {
  return[arg1, arg2]
}

}

var multiJoin = function(arg1, arg2){ // concatenate 2 objects/strings
  
  if(typeof(arg1)=="object" && typeof(arg2)=="object"){
    
    return arg1.concat(arg2)
    
  } else if(typeof(arg1) == "string" && typeof(arg2) == "object"){
  
  return [arg1].concat(arg2)
    
} else if(typeof(arg2) == "string" && typeof(arg1) == "object") { //if arg2 is string
 
  return arg1.concat(arg2)
  
} else {
  return[arg1, arg2]
}
  
}

var insert = function(target, pos, add){ // insert an element into an array at specified position
  
  if (typeof(target) == "string"){
     var p1 = [target].slice(0, pos)
     var p2 = [target].slice(pos, target.length)
     var output = p1.concat(add)
     return output.concat(p2)
  }else{
    var p1 = target.slice(0, pos)
    var p2 = target.slice(pos, target.length)
    var output = p1.concat(add)
    return output.concat(p2)
  }
}

var inside = function(leftArray, rightArray){ // checks if left inside right

  if(typeof(leftArray) == "string"){
    return any(function(y){y == leftArray}, rightArray)
  } else {
    map(function(x){
    return any(function(y){x==y}, rightArray)
  }, leftArray)
  }
}

var allInside = function(leftArray, rightArray){ //if all of left inside right return true
  
  var result = inside(leftArray, rightArray)
  if(any(function(x){x == false}, result)){
    return false
  }else{
    return true
  }
}

var matchArray = function(x, y){ // checks if 2 arrays are the same
  if (x.length !== y.length){
    return false
  } else {
    var logical = map2(function(a,b){a==b}, x, y)
    if (any(function(z) { return z == false; }, logical)){
      return false
    } else {
      return true
    } 
  }
}

var indexSub = function(input, index){ // indexing

var n = index.length // number of elements to keep

var recurSub = function(input, index, n){

  if (n == 1){ // recursion
    
   return input[ index[0] ] // first element subset
    
  } else{
    
    var firstElement = [ input[index[n-1]] ] //last element subset 
    var nextElement = recurSub(input,index, n - 1) //next element
    
   return firstElement.concat(nextElement) //concatenate 
  }
}

var result = recurSub(input, index, n) // save result
var resultRev = reduce(function(x,acc){
  acc.concat(x)
},[],result)

return resultRev // reverse order of array 

}

var rmse = function(array){
  var array = map(function(x){Math.pow(x, 2)}, array)
  var array = listMean(array)
  var array = Math.pow(array, .5)
  return array
}

var normalize = function(array){
  var arraySum = sum(array)
  return map(function(x){x/arraySum}, array)
}


var sum = function(array){
  reduce(function(x,acc){
  x+acc
}, 0, array)
}

var mean = function(array){
  return sum(array)/array.length
}



//// FUNCTIONS TO PLAN ACTIONS AND ADD NOISE

var planAct = function(belief) { //belief to action
  
  // find root logic
  var belief = cleanOut(belief)
  var opPos = getRoot(belief, belief.length)
  
  if (opPos == belief.length){ //base case
    return belief
  } else {
    
  // eval root logic
  var arg1 = belief.slice(0, opPos)
  var arg2 = belief.slice(opPos+1, belief.length)
  
  return evalOp(planAct(arg1), planAct(arg2), belief[opPos])
  }  
}

var constrainPlan = function(plan){ // adds movement before interaction
  
 return reduce(function(x, acc){
     var revPlan = reduce(function(x, acc){
    return acc.concat(x)
  }, [], plan) 
   
    var last = acc[acc.length-1]
    
    if (inside(revPlan[x], interactPool)){
     var target = revPlan[x].split("interact")[1]
     return acc.concat("move".concat(target)).concat(revPlan[x])
     } else {
      return acc.concat(revPlan[x])
    }
    }, [], _.range(plan.length))
}

var convertPlan = function(plan){ // ensures output is an array
    if(typeof plan === "string"){
    return [plan]
  }else{
    return plan
  }
}

var addGoal = function(array) { // adds moveDoor at the end
  return array.concat("moveDoor")
}

var getNoise = function(pool,eta) { // draws noisy actions
  var n = Math.floor(sample(Exponential({a:eta})))
  if (n == 0){
    return []
  } else {
    map(function(x){
    return uniformDraw(pool)
  }, _.range(n))
  }
}

var drawAct = function(bel, pool, eta){ // draw action from belief
  var idealAction = convertPlan(randomSort(uniformDraw(bel)))
  var noise = getNoise(pool, eta)
  var mixAction =  mixArray(idealAction, noise)
  return addGoal(constrainPlan(mixAction))
}


var randomAct = function(pool,eta) {  // randomly sample action
  var n = Math.floor(sample(Exponential({a:eta})))
  if (n == 0){
    return randomAct(pool, eta)
  } else {
    map(function(x){
    return uniformDraw(pool)
  }, _.range(n))
  }
}

var neccAct = function(belief){ //draw neccessary actions

var beliefMod = belief.split("(").join("!(!").split(")").join("!)!")
var beliefMod = beliefMod.split("!")
var beliefMod = filter(function(x) { return x !== ""; }, beliefMod); 

var actionSeq = planAct(beliefMod)

return actionSeq
  
}

var drawOutcome = function(structure, act){ //simulate outcome
  if(allInside(structure, act)){
      return 1
    } else {
      return 0
    }
}

var addOutcomeNoise = function(outcome, noise){ // add noise to outcome probability
  if(outcome == 1){
    return 1-noise
  }else{
    return noise
  }
}

var moderateNoise = function(noise, otherBool, moderation){
  if(otherBool == 1){
    return noise*moderation
  }else{
    return noise
  }
}
    
var structureMatch = function(structure, observation){ // checks if observed action satisfies world structure requirements
 
  var outcomeSet = map(function(x){drawOutcome(x, observation)}, structure) 

  var outcome = any(function(x) { return x == 1; }, outcomeSet)
  return outcome
  
}

var convertBool = function(bool){ // convert boolean to numbers
  if(bool == true){
    return 1
  }else {
    return 0
  }
}

var knowledgeable = function(structure,random, k){ // draws belief based on knowledgeability of agent
  if (flip(k)){
    return structure
  }else{
    return random
  }
}

var samplePosterior = function(n, posterior, element){
  map(function() { return sample(editor.get(posterior))[element] }, _.range(n))
}

var quantile = function(array, q){
  var pos = Math.floor(q*(array.length-1))
  var sortedArray = sort(array)
  return sortedArray[pos - 1]
}



var interactPool = ["interactBlue", "interactPink", "interactOrange"]

var movePool = ["moveBlue", "movePink", "moveOrange"]

var belPool = ["(interactBlue)", "(interactPink)", "(interactOrange)", 
               "((interactBlue)&(interactPink))","((interactBlue)&(interactOrange))","((interactOrange)&(interactPink))",
              "(((interactBlue)&(interactPink))&(interactOrange))", "(other)"]

var belSet = ["interactBlue", "interactPink", "interactOrange", 
               "interactBlue&interactPink","interactBlue&interactOrange","interactOrange&interactPink",
              "interactBlue&interactPink&interactOrange","other"]

// priors from prolific participants
/*
var belPrior = [.142, .060, .129, 
               .086, .076, .066, 
                .126, .122
               ] 
*/


// priors from nus participants
var belPrior = [.1110, .0897, .1167,
               .1153, .1292, .1287,
               .1616, .1473]


var causeLambda = 2 // fixed

var eta = 1
var k = .7
var n = .02
var m = 4 //moderation
var nsim = 1000

var epistemicModel = function(){
  
///// INFERENCE STEPS

  var structureFull = sample(Categorical({ps: belPrior, vs:belPool}))
  var structureFull = addBel(structureFull, belPool, causeLambda)
  
  var structureRandom = sample(Categorical({ps: belPrior, vs:belPool}))
  var structureRandom = addBel(structureRandom, belPool, causeLambda)
  
  var belief = knowledgeable(structureFull, structureRandom, k)
  var structureWorld = splitCause(structureFull) // removes brackets
  var structureBelief = splitCause(belief)
  
  var trackHyp = inside(belSet, structureWorld)
  
  var blueOnly = convertBool(trackHyp[0])
  var pinkOnly = convertBool(trackHyp[1])
  var orangeOnly = convertBool(trackHyp[2])
  var blueAndPink = convertBool(trackHyp[3])
  var blueAndOrange = convertBool(trackHyp[4])
  var orangeAndPink = convertBool(trackHyp[5])
  var bluePinkOrange = convertBool(trackHyp[6])
  var other = convertBool(trackHyp[7])

// observed sequence

 // two-event
var observation = [ "moveBlue", "interactBlue" , "movePink", "interactPink", "moveDoor"]

var structureWorldReq = map(function(x){x.split("&")}, structureWorld)
var structureBeliefReq = map(function(x){x.split("&")}, structureBelief)

var action = drawAct(structureBeliefReq, interactPool, eta) //draw action based on belief

var outcomeSet1 = map(function(x){drawOutcome(x, action)}, structureWorldReq) // draw outcome based on W and A

//as long as 1 cause is consistent with observation
var otherBool = any(function(x) { return x == "other"; }, structureWorldReq)
var n = moderateNoise(n, otherBool, m)
var outcome1Prob = any(function(x) { return x == 1; }, outcomeSet1)
var outcome1Prob = addOutcomeNoise(outcome1Prob, n)
var outcome1 = flip(outcome1Prob)


condition(outcome1==1)  // condition on outcome
condition(matchArray(action, observation))
  

return {
    blueOnly:blueOnly,
    pinkOnly:pinkOnly,
    orangeOnly:orangeOnly,
    blueAndPink:blueAndPink,
    blueAndOrange:blueAndOrange ,
    orangeAndPink:orangeAndPink,
    bluePinkOrange:bluePinkOrange,
    other:other,
    structureFull:structureFull,
    length: structureWorld.length
       }

}



var epistemicPosterior = Infer({method: 'MCMC', samples:50000,burn:50000, callbacks: [editor.MCMCProgress()]}, epistemicModel)

editor.put("epistemicPosterior",epistemicPosterior) //save posterior


var structurePosterior = samplePosterior(nsim, "epistemicPosterior", "structureFull")

var structurePosteriorSet = map(function(x){
    var temp = splitCause(x)
    return map(function(y){y.split("&")}, temp)
  }, structurePosterior)


var instrumentalModel = function(){
  
  var structureCandidate = samplePosterior(1, "epistemicPosterior", "structureFull")[0] //draw candidate belief

  var actSim = neccAct(structureCandidate) // draw action based on candidate belief
  
  var structureSet = splitCause(structureCandidate)
  
  var trackHyp = inside(belSet, structureSet)
  
  var blueOnly = convertBool(trackHyp[0])
  var pinkOnly = convertBool(trackHyp[1])
  var orangeOnly = convertBool(trackHyp[2])
  var blueAndPink = convertBool(trackHyp[3])
  var blueAndOrange = convertBool(trackHyp[4])
  var orangeAndPink = convertBool(trackHyp[5])
  var bluePinkOrange = convertBool(trackHyp[6])
  var other = convertBool(trackHyp[7])
  
  var outcomeSim = map(function(x){structureMatch(x, actSim)}, structurePosteriorSet)
  var outcomeProb = mean(outcomeSim)
  var outcomeSimSample = flip(outcomeProb) // draw outcome 
 
  condition(outcomeSimSample == true) 
  
  return{
    blueOnly:blueOnly,
    pinkOnly:pinkOnly,
    orangeOnly:orangeOnly,
    blueAndPink:blueAndPink,
    blueAndOrange:blueAndOrange ,
    orangeAndPink:orangeAndPink,
    bluePinkOrange:bluePinkOrange,
    other:other,
    structureCandidate: structureCandidate,
    length: structureSet.length
  }
  
}

var instrumentalPosterior = Infer({method: 'MCMC', samples:2000,burn:1000, callbacks: [editor.MCMCProgress()]}, instrumentalModel)

editor.put("instrumentalPosterior",instrumentalPosterior) //save posterior