Examples with Concept com.vaticle.typedb.core.concept.Concept used on opensource projects

Example 21 with Concept

use of com.vaticle.typedb.core.concept.Concept in project grakn by graknlabs.

the class ExplanationTest method applyMapping.

private ConceptMap applyMapping(Map<Retrievable, Set<Retrievable>> mapping, ConceptMap completeMap) {
    Map<Retrievable, Concept> concepts = new HashMap<>();
    mapping.forEach((from, tos) -> {
        assertTrue(completeMap.contains(from));
        Concept concept = completeMap.get(from);
        tos.forEach(mapped -> {
            assertTrue(!concepts.containsKey(mapped) || concepts.get(mapped).equals(concept));
            concepts.put(mapped, concept);
        });
    });
    return new ConceptMap(concepts);
}

Example 22 with Concept

use of com.vaticle.typedb.core.concept.Concept in project grakn by graknlabs.

the class AnswerStateTest method test_root_partially_mapped_to_downstream_and_back.

@Test
public void test_root_partially_mapped_to_downstream_and_back() {
    Map<Identifier.Variable.Retrievable, Identifier.Variable.Retrievable> mapping = new HashMap<>();
    mapping.put(Identifier.Variable.name("a"), Identifier.Variable.name("x"));
    mapping.put(Identifier.Variable.name("b"), Identifier.Variable.name("y"));
    Map<Identifier.Variable.Retrievable, Concept> concepts = new HashMap<>();
    concepts.put(Identifier.Variable.name("a"), new MockConcept(0));
    Set<Identifier.Variable.Retrievable> filter = set(Identifier.Variable.name("a"), Identifier.Variable.name("b"));
    Concludable.Match<?> mapped = InitialImpl.create(filter, new ConceptMap(), null, false).toDownstream().with(new ConceptMap(concepts)).toDownstream(Mapping.of(mapping), null);
    Map<Identifier.Variable.Retrievable, Concept> expectedMapped = new HashMap<>();
    expectedMapped.put(Identifier.Variable.name("x"), new MockConcept(0));
    assertEquals(new ConceptMap(expectedMapped), mapped.conceptMap());
    Map<Identifier.Variable.Retrievable, Concept> downstreamConcepts = new HashMap<>();
    downstreamConcepts.put(Identifier.Variable.name("x"), new MockConcept(0));
    downstreamConcepts.put(Identifier.Variable.name("y"), new MockConcept(1));
    Partial.Compound<?, ?> partial = mapped.toUpstreamLookup(new ConceptMap(downstreamConcepts), false);
    Map<Identifier.Variable.Retrievable, Concept> expectedWithInitial = new HashMap<>();
    expectedWithInitial.put(Identifier.Variable.name("a"), new MockConcept(0));
    expectedWithInitial.put(Identifier.Variable.name("b"), new MockConcept(1));
    assertEquals(new ConceptMap(expectedWithInitial), partial.conceptMap());
}

Example 23 with Concept

use of com.vaticle.typedb.core.concept.Concept in project grakn by graknlabs.

the class Mapping method unTransform.

public ConceptMap unTransform(ConceptMap conceptMap) {
    assert reverseMapping.size() == conceptMap.concepts().size();
    Map<Retrievable, Concept> transformed = new HashMap<>();
    for (Map.Entry<Retrievable, ? extends Concept> entry : conceptMap.concepts().entrySet()) {
        Retrievable id = entry.getKey();
        assert reverseMapping.containsKey(id);
        Concept concept = entry.getValue();
        transformed.put(reverseMapping.get(id), concept);
    }
    // we ignore explainables because they can't be mapped here
    return new ConceptMap(transformed);
}

Example 24 with Concept

use of com.vaticle.typedb.core.concept.Concept in project grakn by graknlabs.

the class UnifyRelationConcludableTest method unUnify_produces_cartesian_named_types_only_for_unbound_vars.

@Test
public void unUnify_produces_cartesian_named_types_only_for_unbound_vars() {
    String conjunction = "{$r ($role: $x) isa $rel;}";
    Set<Concludable> concludables = Concludable.create(resolvedConjunction(conjunction, logicMgr));
    Concludable.Relation queryConcludable = concludables.iterator().next().asRelation();
    Rule rule = createRule("people-are-self-friends", "{ $x isa person; }", " (friend: $x) isa friendship ", logicMgr);
    List<Unifier> unifiers = queryConcludable.unify(rule.conclusion(), conceptMgr).toList();
    assertEquals(1, unifiers.size());
    Unifier unifier = unifiers.get(0);
    // test filter allows a valid answer
    Relation friendship = instanceOf("friendship").asRelation();
    Thing person = instanceOf("person");
    addRolePlayer(friendship, "friend", person);
    Map<Variable, Concept> concepts = map(pair(Variable.anon(0), friendship), pair(Variable.name("x"), person), pair(Variable.label("friendship"), friendship.getType()), pair(Variable.label("friendship:friend"), friendship.getType().getRelates("friend")));
    List<ConceptMap> unified = unifier.unUnify(concepts, new Unifier.Requirements.Instance(map(pair(Variable.name("rel"), friendship.getType())))).toList();
    assertEquals(2, unified.size());
    Set<Map<String, String>> expected = set(new HashMap<String, String>() {

        {
            put("$rel", "friendship");
            put("$role", "friendship:friend");
        }
    }, new HashMap<String, String>() {

        {
            put("$rel", "friendship");
            put("$role", "relation:role");
        }
    });
    Set<Map<String, String>> actual = new HashSet<>();
    iterate(unified).forEachRemaining(answer -> {
        actual.add(new HashMap<String, String>() {

            {
                put("$rel", answer.get("rel").asType().getLabel().name());
                put("$role", answer.get("role").asType().getLabel().scopedName());
            }
        });
    });
    assertEquals(expected, actual);
}

Example 25 with Concept

use of com.vaticle.typedb.core.concept.Concept in project grakn by graknlabs.

the class UnifyRelationConcludableTest method verifyUnificationSucceeds.

private void verifyUnificationSucceeds(String parent, Rule rule) {
    Unifier unifier = uniqueUnifier(parent, rule);
    List<ConceptMap> childAnswers = transaction.query().match(TypeQL.match(rule.getThenPreNormalised())).toList();
    List<ConceptMap> parentAnswers = transaction.query().match(TypeQL.match(TypeQL.parsePattern(parent))).toList();
    assertFalse(childAnswers.isEmpty());
    assertFalse(parentAnswers.isEmpty());
    List<ConceptMap> unifiedAnswers = iterate(childAnswers).flatMap(ans -> {
        Map<Variable, Concept> labelledTypes = addRequiredLabeledTypes(ans, unifier);
        Map<Variable, Concept> requiredRetrievableConcepts = addRequiredRetrievableConcepts(ans, unifier);
        labelledTypes.putAll(requiredRetrievableConcepts);
        // TODO if want to use with iids add instance requirements
        FunctionalIterator<ConceptMap> unified = unifier.unUnify(labelledTypes, new Unifier.Requirements.Instance(map())).map(u -> {
            Map<Variable.Retrievable, Concept> concepts = u.concepts().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
            requiredRetrievableConcepts.forEach(concepts::remove);
            return new ConceptMap(concepts);
        });
        return unified;
    }).toList();
    assertFalse(unifiedAnswers.isEmpty());
    assertTrue(parentAnswers.containsAll(unifiedAnswers));
}