public static void ParseKeyword(ParserState state, Token firstToken)
{
switch (firstToken.Name)
{
case "initially":
LogicElement le = EntryC1(state);
Initially st = new Initially(le);
state.Expression.Add(st);
break;
case "noninertial":
ParseNoninertial(state, firstToken);
break;
case "by":
Token action = state.TokenList[state.TokenList.Count - 1];
state.TokenList.RemoveAt(state.TokenList.Count - 1);
AgentsList al = GetAgentList(state);
if (al == null)
{
firstToken.ThrowException("Expected ']' at the end of agents list.");
}
Token t = state.PopToken();
if (t == null)
{
firstToken.ThrowException("Expected 'causes' or 'releases'.");
}
LogicElement result = null;
if (t.Name == "releases")
{
Token fT = state.PopToken();
if (fT == null)
{
firstToken.ThrowException("Expected fluent after release.");
}
else if (!state.Fluent.ContainsKey(fT.Name))
{
firstToken.ThrowException("Attempting to use undeclared fluent.");
}
result = state.Fluent[fT.Name];
}
else
if (t.Name == "causes")
{
result = EntryC1(state);
}
else
{
t.ThrowException("Expected 'causes' or 'releases'.");
}
if (t.Name == "releases" && (result is Fluent) == false)
{
t.ThrowException("Expected fluent after release.");
}
LogicElement condition = null;
Token if_token = state.PeepToken();
if (if_token != null && if_token.Name == "if")
{
state.PopToken();
condition = EntryC1(state);
}
if (t.Name == "causes")
{
if (condition == null)
{
state.Expression.Add(new MultiAgentLanguageModels.Expressions.ByCauses(
new MultiAgentLanguageModels.Action(action.Name),
al, result));
}
else
{
state.Expression.Add(new MultiAgentLanguageModels.Expressions.ByCausesIf(
new MultiAgentLanguageModels.Action(action.Name),
al, result, condition));
}
}
if (t.Name == "releases")
{
if (condition == null)
{
state.Expression.Add(new MultiAgentLanguageModels.Expressions.ByReleases(
new MultiAgentLanguageModels.Action(action.Name),
al, (Fluent)result));
state.Expression.Add(new MultiAgentLanguageModels.Expressions.ByCauses(
new MultiAgentLanguageModels.Action(action.Name),
al, new Or(result, new Not(result))));
}
else
{
state.Expression.Add(new MultiAgentLanguageModels.Expressions.ByReleasesIf(
new MultiAgentLanguageModels.Action(action.Name),
al, (Fluent)result, condition));
state.Expression.Add(new MultiAgentLanguageModels.Expressions.ByCausesIf(
new MultiAgentLanguageModels.Action(action.Name),
al, new Or(result, new Not(result)), condition));
}
}
break;
case "causes":
MultiAgentLanguageModels.Action act =
new MultiAgentLanguageModels.Action(state.TokenList[state.TokenList.Count - 1].Name);
state.TokenList.RemoveAt(state.TokenList.Count - 1);
LogicElement effect = EntryC1(state);
Token if_exp = state.PeepToken();
if (if_exp != null && if_exp.Name == "if")
{
state.PopToken();
LogicElement con = EntryC1(state);
state.Expression.Add(new CausesIf(act, effect, con));
}
else
{
state.Expression.Add(new Causes(act, effect));
}
break;
case "releases":
MultiAgentLanguageModels.Action act1 =
new MultiAgentLanguageModels.Action(state.TokenList[state.TokenList.Count - 1].Name);
state.TokenList.RemoveAt(state.TokenList.Count - 1);
Token eff1 = state.PopToken();
if (eff1 == null)
{
firstToken.ThrowException("Expected fluent after release.");
}
else if (!state.Fluent.ContainsKey(eff1.Name))
{
firstToken.ThrowException("Attempting to use undeclared fluent.");
}
Token if_expr = state.PeepToken();
if (if_expr != null && if_expr.Name == "if")
{
state.PopToken();
LogicElement con = EntryC1(state);
state.Expression.Add(new ReleasesIf(act1, state.Fluent[eff1.Name], con));
state.Expression.Add(new CausesIf(act1, new Or(state.Fluent[eff1.Name], new Not(state.Fluent[eff1.Name])), con));
}
else
{
state.Expression.Add(new Releases(act1, state.Fluent[eff1.Name]));
state.Expression.Add(new Causes(act1, new Or(state.Fluent[eff1.Name], new Not(state.Fluent[eff1.Name]))));
}
break;
case "if":
firstToken.ThrowException("Unexpected 'if' token.");
break;
case "impossible":
Token token = state.PopToken();
if (token == null)
{
firstToken.ThrowException("Expected action name.");
}
if (!state.Action.ContainsKey(token.Name))
{
token.ThrowException("Unknown action name.");
}
MultiAgentLanguageModels.Action ac = new MultiAgentLanguageModels.Action(token.Name);
Token key = state.PopToken();
if (key == null)
{
firstToken.ThrowException("Expected 'by' or 'if' token.");
}
AgentsList agentsList = null;
if (key.Name == "by")
{
agentsList = GetAgentList(state);
Token cond_st = state.PeepToken();
if (cond_st == null || cond_st.Name != "if")
{
state.Expression.Add(new ImpossibleBy(ac, agentsList));
}
else
{
state.PopToken();
LogicElement c = EntryC1(state);
state.Expression.Add(new ImpossibleByIf(ac, agentsList, c));
}
}
else if (key.Name == "if")
{
//Token cond_st = state.PopToken();
//if (cond_st == null || cond_st.Name != "if")
//key.ThrowException("Expected if after the list of agents.");
LogicElement c = EntryC1(state);
state.Expression.Add(new ImpossibleIf(ac, c));
}
else
{
firstToken.ThrowException("Expected 'by' or 'if' token.");
}
break;
case "always":
LogicElement cond = EntryC1(state);
state.Expression.Add(new Always(cond));
break;
case "not":
Token act2 = state.TokenList[state.TokenList.Count - 1];
MultiAgentLanguageModels.Action actt = new MultiAgentLanguageModels.Action(act2.Name);
state.TokenList.RemoveAt(state.TokenList.Count - 1);
Token by = state.PopToken();
if (by == null || by.Name != "by")
{
firstToken.ThrowException("Expected 'by' after 'not'.");
}
AgentsList agents = GetAgentList(state);
Token if_st = state.PeepToken();
if (if_st != null && if_st.Name == "if")
{
state.PopToken();
condition = EntryC1(state);
foreach (Agent a in agents)
{
state.Expression.Add(new ImpossibleByIf(actt, new AgentsList()
{
a
}, condition));
Output.Print($"{actt.Name} not by {a.Name} under cond {condition.ToString()}");
}
}
else
{
foreach (Agent a in agents)
{
state.Expression.Add(new ImpossibleBy(actt, new AgentsList()
{
a
}));
}
}
break;
case "after":
LogicElement observable = EntryC1(state);
Token aft = state.PopToken();
if (aft == null || aft.Name != "after")
{
firstToken.ThrowException("Expected 'after' after logic expression.");
}
Instruction instr = GetInstructions(state, aft);
After after_exp = new After(observable, instr);
state.Expression.Add(after_exp);
break;
case "observable":
LogicElement obs = EntryC1(state);
Token after = state.PopToken();
if (after == null || after.Name != "after")
{
firstToken.ThrowException("Expected 'after' after logic expression.");
}
Instruction inst = GetInstructions(state, after);
ObservableAfter obsAfter = new ObservableAfter(obs, inst);
state.Expression.Add(obsAfter);
break;
}
}
private void addClauseButton_Click(object sender, EventArgs e)
{
Actor epsilonActor = new Actor("ϵ");
switch (currentClause)
{
case 0:
{
Initially stmt = ((InitiallyClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
clausesListBox.Items.Add(stmt);
_domain.AddInitiallyClause(stmt);
}
break;
}
case 1:
{
Causes stmt = ((CausesClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
if (stmt.Actors.Contains(epsilonActor))
{
stmt = new Causes(stmt.Action, stmt.Exclusion, availableActors, stmt.Effect, stmt.Condition);
}
clausesListBox.Items.Add(stmt);
_domain.AddCausesClause(stmt);
}
break;
}
case 2:
{
TypicallyCauses stmt = ((TypicallyCausesClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
if (stmt.Actors.Contains(epsilonActor))
{
stmt = new TypicallyCauses(stmt.Action, stmt.Exclusion, availableActors, stmt.Effect, stmt.Condition);
}
clausesListBox.Items.Add(stmt);
_domain.AddTypicallyCausesClause(stmt);
}
break;
}
case 3:
{
Releases stmt = ((ReleasesClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
if (stmt.Actors.Contains(epsilonActor))
{
stmt = new Releases(stmt.Action, stmt.Exclusion, availableActors, stmt.Fluent, stmt.Condition);
}
clausesListBox.Items.Add(stmt);
_domain.AddReleasesClause(stmt);
}
break;
}
case 4:
{
Preserves stmt = ((PreservesClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
if (stmt.Actors.Contains(epsilonActor))
{
stmt = new Preserves(stmt.Action, stmt.Exclusion, availableActors, stmt.Fluent, stmt.Condition);
}
clausesListBox.Items.Add(stmt);
_domain.AddPreservesClause(stmt);
}
break;
}
case 5:
{
Always stmt = ((AlwaysClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
clausesListBox.Items.Add(stmt);
_domain.AddAlwaysClause(stmt);
}
break;
}
case 6:
{
Impossible stmt = ((ImpossibleClauseControl)clauseControls[currentClause]).getClause();
if (stmt != null)
{
if (stmt.Actors.Contains(epsilonActor))
{
stmt = new Impossible(stmt.Action, stmt.Exclusion, availableActors, stmt.Condition);
}
clausesListBox.Items.Add(stmt);
_domain.AddImpossibleClause(stmt);
}
break;
}
}
}
public void AddInitiallyClause(Initially clause)
{
InitiallyClauses.Add(clause);
}
public void DeleteInitiallyClause(Initially clause)
{
InitiallyClauses.Remove(clause);
}
public void Alice()
{
World world = World.Instance;
var hatterActor = new Actor("Hatter");
var drinkAction = new Action("Drink");
var eatAction = new Action("Eat");
var hatterMadFluent = new Fluent("hatterMad");
var cakeExistsFluent = new Fluent("cakeExists");
var elixirExistsFluent = new Fluent("elixirExists");
var fluentList = new List <Fluent> {
hatterMadFluent, cakeExistsFluent, elixirExistsFluent
};
var domain = new Domain();
var initially1 = new Initially(new Conjunction(new Negation(hatterMadFluent), cakeExistsFluent, elixirExistsFluent));
var causes1 = new Causes(drinkAction, false, new List <Actor> {
hatterActor
}, hatterMadFluent, elixirExistsFluent);
var causes2 = new Causes(eatAction, false, new List <Actor> {
hatterActor
}, new Negation(cakeExistsFluent));
var tCauses1 = new TypicallyCauses(eatAction, false, new List <Actor> {
hatterActor
}, new Negation(hatterMadFluent), hatterMadFluent);
var impossible1 = new Impossible(eatAction, false, new List <Actor> {
hatterActor
}, new Negation(cakeExistsFluent));
var releases1 = new Releases(drinkAction, false, new List <Actor> {
hatterActor
}, elixirExistsFluent, elixirExistsFluent);
domain.AddInitiallyClause(initially1);
domain.AddCausesClause(causes1);
domain.AddTypicallyCausesClause(tCauses1);
domain.AddImpossibleClause(impossible1);
domain.AddReleasesClause(releases1);
domain.AddCausesClause(causes2);
world.SetActions(new List <Action> {
drinkAction, eatAction
});
world.SetActors(new List <Actor> {
hatterActor
});
world.SetFluents(fluentList);
world.SetDomain(domain);
Assert.IsTrue(world.Build());
State state0 = new State(fluentList, new List <bool> {
false, true, true
});
State state1 = new State(fluentList, new List <bool> {
true, true, true
});
State state2 = new State(fluentList, new List <bool> {
true, false, true
});
State state3 = new State(fluentList, new List <bool> {
false, false, true
});
State state4 = new State(fluentList, new List <bool> {
true, false, false
});
State state5 = new State(fluentList, new List <bool> {
true, true, false
});
State state6 = new State(fluentList, new List <bool> {
false, true, false
});
State state7 = new State(fluentList, new List <bool> {
false, false, false
});
ISet <State> expectedResN, expectedResAb, actualResN, actualResAb;
// drink; hatter; -hatterMad & cakeExists & elixirExists
expectedResN = new HashSet <State> {
state1, state5
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state0, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state0, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; hatterMad & cakeExists & elixirExists
expectedResN = new HashSet <State> {
state1, state5
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state1, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state1, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; hatterMad & -cakeExists & elixirExists
expectedResN = new HashSet <State> {
state2, state4
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state2, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state2, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; -hatterMad & -cakeExists & elixirExists
expectedResN = new HashSet <State> {
state2, state4
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state3, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state3, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; hatterMad & -cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state4
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state4, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state4, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; hatterMad & cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state5
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state5, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state5, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; -hatterMad & cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state6
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state6, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state6, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// drink; hatter; -hatterMad & -cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state7
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(drinkAction, hatterActor, state7, false);
actualResAb = world.GetStates(drinkAction, hatterActor, state7, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; -hatterMad & cakeExists & elixirExists
expectedResN = new HashSet <State> {
state3
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state0, false);
actualResAb = world.GetStates(eatAction, hatterActor, state0, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; hatterMad & cakeExists & elixirExists
expectedResN = new HashSet <State> {
state3
};
expectedResAb = new HashSet <State> {
state2
};
actualResN = world.GetStates(eatAction, hatterActor, state1, false);
actualResAb = world.GetStates(eatAction, hatterActor, state1, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; hatterMad & -cakeExists & elixirExists
expectedResN = new HashSet <State> {
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state2, false);
actualResAb = world.GetStates(eatAction, hatterActor, state2, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; -hatterMad & -cakeExists & elixirExists
expectedResN = new HashSet <State> {
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state3, false);
actualResAb = world.GetStates(eatAction, hatterActor, state3, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; hatterMad & -cakeExists & -elixirExists
expectedResN = new HashSet <State> {
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state4, false);
actualResAb = world.GetStates(eatAction, hatterActor, state4, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; hatterMad & cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state7
};
expectedResAb = new HashSet <State> {
state4
};
actualResN = world.GetStates(eatAction, hatterActor, state5, false);
actualResAb = world.GetStates(eatAction, hatterActor, state5, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; -hatterMad & cakeExists & -elixirExists
expectedResN = new HashSet <State> {
state7
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state6, false);
actualResAb = world.GetStates(eatAction, hatterActor, state6, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
// eat; hatter; -hatterMad & -cakeExists & -elixirExists
expectedResN = new HashSet <State> {
};
expectedResAb = new HashSet <State> {
};
actualResN = world.GetStates(eatAction, hatterActor, state7, false);
actualResAb = world.GetStates(eatAction, hatterActor, state7, true);
AssertResSetsEqual(expectedResN, actualResN);
AssertResSetsEqual(expectedResAb, actualResAb);
}
