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

clojure-core.logic

Question

Quiero:

1. Describe un hecho sobre un subconjunto de una clase de objetos.
2. Declare que un objeto tiene una propiedad que consiste en otras propiedades.

Tomemos como ejemplo lo siguiente:

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

Quiero expresar que una clase de aves, aves que son rojas y robóticas, tienen una propiedad. Esta propiedad es que están compuestas solamente de botones, queso y alambre. No hay restricciones en el tipo de queso de alambre 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 los botones de elementos, queso y alambre.

En clojure / core.logic.prelude, hay relaciones y hechos que utilizan defrel y fact . Sin embargo, no puedo encontrar una combinación para explicar este hecho.

Answer 1

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

Por cierto, no estoy seguro de que esto responda completamente a tu pregunta; sería útil escuchar qué tipo de consultas deseas realizar.

Este es un código probado (para Clojure 1.3.0-beta1) ya que estoy usando el truco ^: index , este código funcionará bien en 1.2.0 si lo cambias por ^ {: index true} :

(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)])))

Probando

(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 está completamente seguro de si esto es lo que necesita, pero puede expresar fácilmente que una clase tiene un conjunto de propiedades mediante la creación de una estructura gráfica de hechos (consulte la lista de hechos de propiedades a continuación y la regla para encontrar las propiedades dentro de un conjunto).

Luego, para expresar la composición de ese conjunto de propiedades, necesita otro conjunto de hechos de composición y reglas que descubran las subpropiedades de la clase y, como resultado, de qué cosas pueden componerse.

He dado un ejemplo de código a continuación también para ayudar 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

Las reglas del prólogo en breve.

Las reglas son esencialmente 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 conjuntiva normal (A / / B / / C). El operador y en el prólogo es, el operador o es ; (pero su uso está desaconsejado en las reglas), y el período ( . ) denota el final de una regla o hecho.

Tenga en cuenta que si una regla o hecho posterior en el cuerpo falla, entonces el prólogo retrocederá y solicitará una respuesta alternativa de una regla o hecho anterior y luego volverá a intentarlo. Considere el ejemplo un tanto artificioso a continuación.

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

Si ejecutamos la consulta share_same_colour(apple, strawberry). luego colour(Colour, apple). podría devolver el color como verde. Sin embargo, no hay fresas verdes, así que el prólogo retrocederá y preguntará 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 toda la regla sería verdadera.