Examples with Atom at.ac.tuwien.kr.alpha.api.programs.atoms.Atom used on opensource projects

Example 6 with Atom

use of at.ac.tuwien.kr.alpha.api.programs.atoms.Atom in project Alpha by alpha-asp.

the class LiteralInstantiationStrategyTest method defaultLazyGroundingNoAssignmentGroundLiteral.

/**
 * Uses {@link DefaultLazyGroundingInstantiationStrategy} to check the truth
 * (i.e. {@link AssignmentStatus}) of the positive ground literal "p(a)".
 *
 * In this case, the instantiation strategy does not have an assignment set (as
 * is the case when {@link NaiveGrounder} is in bootstrap),
 * so we expect the instantiation strategy to determine that p(a) is TRUE.
 * Furthermore, the stale atom set (used by {@link NaiveGrounder} to clean up
 * atoms that should be deleted from working memory) must stay empty.
 */
@Test
public void defaultLazyGroundingNoAssignmentGroundLiteral() {
    Predicate p = Predicates.getPredicate("p", 1);
    BasicAtom pOfA = Atoms.newBasicAtom(p, Terms.newSymbolicConstant("a"));
    WorkingMemory workingMemory = new WorkingMemory();
    LinkedHashSet<Atom> staleSet = new LinkedHashSet<>();
    DefaultLazyGroundingInstantiationStrategy strategy = new DefaultLazyGroundingInstantiationStrategy(workingMemory, new AtomStoreImpl(), Collections.emptyMap(), false);
    strategy.setStaleWorkingMemoryEntries(staleSet);
    strategy.setCurrentAssignment(null);
    AssignmentStatus assignmentStatus = strategy.getTruthForGroundLiteral(Literals.fromAtom(pOfA, true));
    assertEquals(AssignmentStatus.TRUE, assignmentStatus);
    assertTrue(staleSet.isEmpty());
}

Example 7 with Atom

use of at.ac.tuwien.kr.alpha.api.programs.atoms.Atom in project Alpha by alpha-asp.

the class LiteralInstantiationStrategyTest method defaultLazyGroundingCheckTrueGroundLiteral.

/**
 * Uses {@link DefaultLazyGroundingInstantiationStrategy} to check the truth
 * (i.e. {@link AssignmentStatus}) of the positive ground literal "p(a)".
 *
 * In this case, the instantiation strategy has an assignment where the atom
 * "p(a)" is assigned ThriceTruth.TRUE, so we expect the instantiation strategy
 * to determine that p(a) is TRUE. Furthermore, the stale atom set
 * (used by {@link NaiveGrounder} to clean up atoms that should be deleted from
 * working memory) must stay empty.
 */
@Test
public void defaultLazyGroundingCheckTrueGroundLiteral() {
    Predicate p = Predicates.getPredicate("p", 1);
    BasicAtom pOfA = Atoms.newBasicAtom(p, Terms.newSymbolicConstant("a"));
    WorkingMemory workingMemory = new WorkingMemory();
    AtomStore atomStore = new AtomStoreImpl();
    WritableAssignment assignment = new TrailAssignment(atomStore);
    atomStore.putIfAbsent(pOfA);
    assignment.growForMaxAtomId();
    assignment.assign(atomStore.get(pOfA), ThriceTruth.TRUE);
    LinkedHashSet<Atom> staleSet = new LinkedHashSet<>();
    DefaultLazyGroundingInstantiationStrategy strategy = new DefaultLazyGroundingInstantiationStrategy(workingMemory, atomStore, Collections.emptyMap(), false);
    strategy.setStaleWorkingMemoryEntries(staleSet);
    strategy.setCurrentAssignment(assignment);
    AssignmentStatus assignmentStatus = strategy.getTruthForGroundLiteral(Literals.fromAtom(pOfA, true));
    assertEquals(AssignmentStatus.TRUE, assignmentStatus);
    assertTrue(staleSet.isEmpty());
}

Example 8 with Atom

use of at.ac.tuwien.kr.alpha.api.programs.atoms.Atom in project Alpha by alpha-asp.

the class LiteralInstantiationStrategyTest method defaultLazyGroundingCheckUnassignedGroundLiteral.

/**
 * Uses {@link DefaultLazyGroundingInstantiationStrategy} to check the truth
 * (i.e. {@link AssignmentStatus}) of the positive ground literal "p(a)".
 *
 * In this case, the instantiation strategy has an empty assignment,
 * so we expect the instantiation strategy to determine that p(a) is UNASSIGNED.
 * Since UNASSIGNED and FALSE atoms are (potentially) stale in working memory,
 * we expect the atom "p(a)" to be added to the stale set by the instantiation
 * strategy.
 */
@Test
public void defaultLazyGroundingCheckUnassignedGroundLiteral() {
    Predicate p = Predicates.getPredicate("p", 1);
    BasicAtom pOfA = Atoms.newBasicAtom(p, Terms.newSymbolicConstant("a"));
    WorkingMemory workingMemory = new WorkingMemory();
    AtomStore atomStore = new AtomStoreImpl();
    WritableAssignment assignment = new TrailAssignment(atomStore);
    LinkedHashSet<Atom> staleSet = new LinkedHashSet<>();
    DefaultLazyGroundingInstantiationStrategy strategy = new DefaultLazyGroundingInstantiationStrategy(workingMemory, atomStore, Collections.emptyMap(), false);
    strategy.setStaleWorkingMemoryEntries(staleSet);
    strategy.setCurrentAssignment(assignment);
    AssignmentStatus assignmentStatus = strategy.getTruthForGroundLiteral(Literals.fromAtom(pOfA, true));
    assertEquals(AssignmentStatus.UNASSIGNED, assignmentStatus);
    assertEquals(1, staleSet.size());
    assertTrue(staleSet.contains(pOfA));
}

Example 9 with Atom

use of at.ac.tuwien.kr.alpha.api.programs.atoms.Atom in project Alpha by alpha-asp.

the class AnalyzeUnjustifiedTest method justifyLargerRules.

@Test
public void justifyLargerRules() {
    String program = "p(X) :- q(X,Y), r(Y), not s(X,Y)." + "{ q(1,X)} :- dom(X)." + "dom(1..3)." + "{r(X)} :- p(X)." + "{r(2)}." + "{s(1,2)}." + ":- not p(1).";
    CompiledProgram internalProgram = parseAndPreprocess.apply(program);
    AtomStore atomStore = new AtomStoreImpl();
    NaiveGrounder grounder = new NaiveGrounder(internalProgram, atomStore, true);
    grounder.getNoGoods(null);
    TrailAssignment assignment = new TrailAssignment(atomStore);
    Atom p1 = parser.parse("p(1).").getFacts().get(0);
    Atom r2 = parser.parse("r(2).").getFacts().get(0);
    Atom s12 = parser.parse("s(1,2).").getFacts().get(0);
    Atom q11 = parser.parse("q(1,1).").getFacts().get(0);
    Atom q12 = parser.parse("q(1,2).").getFacts().get(0);
    Atom q13 = parser.parse("q(1,3).").getFacts().get(0);
    int p1Id = atomStore.get(p1);
    int r2Id = atomStore.get(r2);
    int s12Id = atomStore.get(s12);
    int q11Id = atomStore.get(q11);
    int q12Id = atomStore.get(q12);
    int q13Id = atomStore.get(q13);
    assignment.growForMaxAtomId();
    assignment.assign(p1Id, ThriceTruth.MBT);
    assignment.assign(r2Id, ThriceTruth.TRUE);
    assignment.assign(s12Id, ThriceTruth.TRUE);
    assignment.assign(q11Id, ThriceTruth.TRUE);
    assignment.assign(q12Id, ThriceTruth.TRUE);
    assignment.assign(q13Id, ThriceTruth.FALSE);
    Set<Literal> reasons = grounder.justifyAtom(p1Id, assignment);
    assertFalse(reasons.isEmpty());
}

Example 10 with Atom

use of at.ac.tuwien.kr.alpha.api.programs.atoms.Atom in project Alpha by alpha-asp.

the class UnificationTest method unificationWithFunctionTerms.

@Test
public void unificationWithFunctionTerms() {
    Atom left = partsParser.parseLiteral("a(b, f(X, 13), g(Z), d)").getAtom();
    Atom right = partsParser.parseLiteral("a(b, A, g(e), d)").getAtom();
    Unifier unifier = Unification.unifyAtoms(left, right);
    assertNotNull(unifier);
    assertEquals(3, unifier.getMappedVariables().size());
    assertEquals(left.substitute(unifier).toString(), right.substitute(unifier).toString());
}