Expresando que un subconjunto específico de X tiene la propiedad de Y en core.logic

Question

Quiero:

1. describir un hecho acerca de un subconjunto de una clase de objetos.
2. Declarar que un objeto tiene una propiedad que consiste en otras propiedades.

tomar las siguientes como ejemplo:

Red robotic birds are only composed of buttons, cheese, and wire. 

quiero expresar que una clase de aves, aves que son de color rojo y robótica, tiene una propiedad. Esta propiedad es que están compuestos solo de botones, queso y alambre. No hay restricciones sobre el tipo de queso o botones. También como resultado, debe ser deducible que no hay pájaros robóticos rojos que están compuestos de papel. Además, estas aves pueden estar compuestas por un subconjunto de botones, queso y alambre.

En clojure/core.logic.prelude, existen relaciones y hechos usando defrel y fact. Sin embargo, no se me ocurre una combinación para explicar este hecho.

Answer 1

En Prolog no hay distinción entre los hechos y los objetivos que existen en miniKanren. Podría abordar esto en el futuro.

Por cierto, no estoy seguro de que esto responda completamente a su pregunta. Sería útil saber qué tipos de consultas desea ejecutar.

Este código es probado (por Clojure 1.3.0-beta1) ya que estoy usando el ^: truco índice de, este código se ejecuta bien en 1.2.0 si cambiarla por ^{: Índice verdadera }:

(ns clojure.core.logic.so 
    (:refer-clojure :exclude [==]) 
    (:use [clojure.core.logic])) 

(defrel property* ^:index p ^:index t) 

(fact property* :bird :red-robotic-bird) 
(fact property* :red :red-robotic-bird) 
(fact property* :robotic :red-robotic-bird) 
(fact property* :tasty :cake) 
(fact property* :red-robotic-bird :macaw) 

(defn property [p t] 
    (conde 
    [(property* p t)] 
    [(fresh [ps] 
     (property* ps t) 
     (property p ps))])) 

(defrel composition* ^:index m ^:index t) 

(fact composition* :buttons :red-robotic-bird) 
(fact composition* :cheese :red-robotic-bird) 
(fact composition* :wire :red-robotic-bird) 
(fact composition* :flour :cake) 

(defn composition [m t] 
    (fresh [p] 
    (composition* m p) 
    (conde 
     [(== p t)] 
     [(property p t)]))) 

Probarlo.

(comment 
    ;; what is a macaw composed of? 
    (run* [q] (composition q :macaw)) 
    ;; (:wire :cheese :buttons) 

    ;; what things include buttons in their composition? 
    (run* [q] (composition :buttons q)) 
    ;; (:red-robotic-bird :macaw) 

    ;; does a macaw include flour in its composition? 
    (run* [q] (composition :flour :macaw)) 
    ;;() 

    ;; is a macaw a bird? 
    (run* [q] (property :bird :macaw)) 
    ;; (_.0) 

    ;; is a cake a bird? 
    (run* [q] (property :bird :cake)) 
    ;;() 

    ;; what are the properties of a macaw? 
    (run* [q] (property q :macaw)) 
    ;; (:red-robotic-bird :robotic :bird :red) 
) 

Answer 2

No estoy del todo seguro si esto es lo que necesita, pero puede expresar fácilmente que una clase tiene un conjunto de propiedades al crear una estructura gráfica de hechos (vea la lista de propiedades a continuación y la regla para encontrar las propiedades un conjunto).

A continuación, para expresar la composición de ese conjunto de propiedades que necesita otro conjunto de datos de composición y regla de que descubra cualquier sub-propiedades de la clase y como resultado de las cosas que puede estar compuesto por.

me he dado un ejemplo de código siguiente, así que ayudan a explicar.

property(bird, red_robotic_bird). 
property(red, red_robotic_bird). 
property(robot, red_robotic_bird). 
property(tasty, cake). 
property(red_robotic_bird, macaw). 

property(Property, Thing) :- 
    property(PropertySet, Thing), 
    property(Property, PropertySet). 


composition(buttons, red_robotic_bird). 
composition(cheese, red_robotic_bird). 
composition(wire, red_robotic_bird). 
composition(flour, cake). 
composition(Material, Thing) :- 
    property(Property, Thing), 
    composition(Material, Property). 

Consultas de ejemplo

?- composition(Material, macaw). 
Material = buttons ; 
Material = cheese ; 
Material = wire ; 
no 

?- composition(buttons, Thing). 
Thing = red_robotic_bird ; 
Thing = macaw ; 
no 

?- composition(flour, macaw). 
no 

?- property(bird, macaw). 
yes 

?- property(bird, cake). 
no 

property(Property, macaw). 
Property = red_robotic_bird ; 
Property = bird ; 
Property = red ; 
Property = robot ; 
no 

normas de Prolog en breve.

Las reglas son esencialmente solo hechos (por ejemplo, animal(cat).) que están condicionados a que otras reglas o hechos sean ciertos. Una regla se compone de una cabeza y un cuerpo (head :- body.). Un cuerpo es una prueba lógica más comúnmente expresada en forma normal conjuntiva (A/\ B/\ C). El operador y en prolog es ,, el operador o es ; (pero su uso no se recomienda en las reglas), y el período (.) indica el final de una regla o hecho.

Tenga en cuenta que si una regla de plazo o hecho en el cuerpo falla, entonces Prolog dar marcha atrás y pedir una respuesta alternativa de una regla o un hecho anterior y vuelva a intentarlo. Considere el ejemplo algo artificial a continuación.

share_same_colour (FruitA, FruitB): - color (Color, FruitA), color (Color, Fruta).

Si ejecutamos la consulta share_same_colour(apple, strawberry)., entonces colour(Colour, apple). puede devolver Color como verde. Sin embargo, no hay fresas verdes, por lo que el prólogo retrocederá y preguntará en qué otros colores entran las manzanas.La siguiente respuesta podría ser roja, sobre la cual la segunda declaración de color tendría éxito y la regla completa sería verdadera.