Kurze Version: Ich interessiere mich für einen Clojure-Code, mit dem ich die Transformationen von x (z. B. Permutationen, Rotationen) angeben kann, unter denen der Wert einer Funktion f (x) unveränderlich ist, sodass ich effizient eine Folge von erzeugen kann x, die r = f (x) erfüllen. Gibt es eine Entwicklung in der Computeralgebra für Clojure? Für (ein triviales) Beispiel

(defn #^{:domain #{3 4 7} 
         :range #{0,1,2}
         :invariance-group :full} 
          f [x]  (- x x))

Ich könnte aufrufen (preimage f # {0}) und es würde effizient # {3 4 7} zurückgeben. Natürlich würde es auch in der Lage sein, die Codomäne korrekt zu kommentieren. Irgendwelche Vorschläge

Längere Version: Ich habe ein spezifisches Problem, das mich interessiert, mehr über die Entwicklung der Computeralgebra für Clojure zu erfahren. Kann mich jemand auf ein solches Projekt hinweisen? Mein spezielles Problem besteht darin, alle Wortkombinationen zu finden, die F (x) = r erfüllen, wobei F eine Rangfolgefunktion und r eine positive ganze Zahl ist. In meinem speziellen Fall kann f als Summe @ berechnet werde

F (x) = f (x [0]) + f (x [1]) + ... f (x [N-1])

Außerdem habe ich eine Menge von disjunkten Mengen S = {s_i}, so dass f (a) = f (b) für a, b in s, s in S. Also eine Strategie, um alle x so zu erzeugen, dass F (x) = r sollte sich auf diese Faktorisierung von F und die Invarianz von f unter jedem s_i stützen. Mit Worten, ich berechne alle Permutationen von Sites, die Elemente von S enthalten, die sich zu r summieren, und setze sie mit allen Kombinationen der Elemente in jedem s_i zusammen. Dies geschieht im Folgenden recht schlampig:

(use 'clojure.contrib.combinatorics)
(use 'clojure.contrib.seq-utils)


(defn expand-counter [c]
 (flatten (for [m c] (let [x (m 0) y (m 1)] (repeat y x)))))

(defn partition-by-rank-sum [A N f r]
  (let [M (group-by f A)
    image-A (set (keys M))
    ;integer-partition computes restricted integer partitions,
    ;returning a multiset as key value pairs
    rank-partitions (integer-partition r (disj image-A 0))
    ]
    (apply concat (for [part rank-partitions]
        (let [k (- N (reduce + (vals part)))
          rank-map (if (pos? k) (assoc part 0 k) part) 
          all-buckets (lex-permutations (expand-counter rank-map))
          ]
          (apply concat (for [bucket all-buckets]
        (let [val-bucket (map M bucket)
              filled-buckets (apply cartesian-product val-bucket)]
          (map vec filled-buckets)))))))))

Dies erledigt den Job, aber das zugrunde liegende Bild fehlt. Wenn zum Beispiel die assoziative Operation ein Produkt anstelle einer Summe wäre, müsste ich Teile umschreiben.