Multicomputation

Documentation

Multi Object

Multi is a lazy non-deterministic container with tensor product semantics. It represents expressions with multiple possible values and supports multiway rewriting systems.

Basic Usage

(* Multiple alternatives *)
Multi[{1, 2, 3}]                        (* 3 alternatives *)

(* Tensor product - lazy combination *)
Multi[{1, 2}] + Multi[{10, 20}]         (* 4 combinations: {11, 21, 12, 22} *)

(* Rule-based binding *)
Multi[5, x_ :> {x, x+1, x^2}]           (* 5 → {5, 6, 25} *)

(* Automatic chaining via UpValues *)
f[Multi[{a, b}]]                        (* → Multi with {f[a], f[b]} *)

Constructors

| Syntax | Description | |--------|-------------| | Multi[{a, b, c}] | Alternatives from list | | Multi[expr, rule] | Apply replacement rule to expression | | Multi[expr, {rules...}] | Apply multiple rules | | Multi[assoc] | Create from association (internal) |

---

Properties Reference

Access properties via multi["PropertyName"] or multi["PropertyName", args...].

Core Data Properties

| Property | Description | |----------|-------------| | "Expression" | The underlying expression with placeholders | | "HoldExpression" | Expression wrapped in HoldComplete | | "Data" | Full internal association | | "ValidQ" | Whether the Multi is well-formed | | "Values" | Association mapping positions to alternative values | | "Matches" | Association mapping positions to rule match results | | "Rules" | List of rewrite rules used | | "Keys" | Combined keys from Values and Matches | | "Positions" | Position specifications for all alternatives | | "Placeholders" | Association of placeholder symbols to values | | "Bindings" | Pattern variable bindings from rule matches | | "Size" | Number of alternative positions | | "ValueCount" | Product of alternative counts (total combinations) | | "MatchCount" | Total number of rule matches |

Values & Tuples

| Property | Description | |----------|-------------| | "ListValues" | List of possible values at each position | | "HoldListValues" | Same, wrapped in HoldForm | | "Tuples" | All combinations (Cartesian product) of values | | "Tuples", n | First n tuples | | "HoldTuples" | Tuples with held values | | "MatchBindings" | Pattern bindings for each match |

Evaluation Properties

These evaluate the expression by substituting alternatives:

| Property | Description | |----------|-------------| | "EvaluateList" | List of all evaluated alternatives | | "EvaluateList", n | First n alternatives | | "HoldEvaluateList" | Evaluated alternatives, held | | "EvaluateListOnce" | One step of evaluation per position | | "HoldEvaluateListOnce" | One step, held |

Multi-Returning Evaluation

These return new Multi objects:

| Property | Args | Description | |----------|------|-------------| | "Evaluate" | n | Apply rules n times, return Multi | | "EvaluateOnce" | n, m, k | One-step eval, n iterations, m positions, k tuples | | "HoldEvaluate" | | Evaluate with held results | | "HoldEvaluateOnce" | | One step, held | | "MultiEvaluate" | n | Return list of Multi (one per branch) | | "HoldMultiEvaluate" | n | Same, held | | "MultiEvaluateList" | | Expressions from MultiEvaluate |

List/Multi Hybrid Evaluation

| Property | Description | |----------|-------------| | "MultiList" | Split into list of Multis (one per list element) | | "ListEvaluate" | Evaluate each list element's Multi separately | | "HoldListEvaluate" | Same, held | | "MultiListEvaluate" | Flatten ListEvaluate back to single Multi | | "HoldMultiListEvaluate" | Same, held | | "ListEvaluateWithKeys" | ListEvaluate with position keys |

Transformation Properties

| Property | Args | Description | |----------|------|-------------| | "Apply" | f, pos | Apply function f at position(s) | | "HoldApply" | f, pos | Apply without evaluating argument | | "ListApply" | f | Apply to expression as list | | "DeleteDuplicates" | | Remove duplicate alternatives | | "ReplacePart" | rules | Replace parts of expression | | "RematchRules" | | Re-apply stored rules | | "ModifyData" | f | Transform internal data with function |

Graph Properties

Generate visualizations of multiway evolution:

| Property | Args | Description | |----------|------|-------------| | "Graph" | n, opts | Evolution graph for n steps | | "HoldGraph" | n, opts | Evolution graph with held expressions | | "CausalGraph" | n, opts | Causal relationships between events | | "BranchialGraph" | n, opts | Connections between concurrent states | | "TokenEventGraph" | n, opts | Token-event relationships | | "EvolutionCausalGraph" | n, opts | Combined evolution + causal | | "CausalBranchialGraph" | n, opts | Combined causal + branchial | | "CausalStatesGraph" | n, opts | Causal graph of states |

Event & Edge Properties

| Property | Description | |----------|-------------| | "Events" | Tagged events from evaluation | | "HoldEvents" | Events with held expressions | | "Edges" | Directed edges for graph construction | | "HoldEdges" | Edges with held expressions | | "Branches" | Output states from each event | | "HoldBranches" | Branches with held expressions | | "BranchPairs" | Pairs of concurrent branches | | "HoldBranchPairs" | Branch pairs, held | | "FoliationSlices" | Layer-by-layer evolution with counts (docs) | | "HoldFoliationSlices" | FoliationSlices with held expressions |

---

Examples

Tensor Product (Lazy Cartesian Product)

m = Multi[{1, 2, 3}] + Multi[{10, 20}];
m["Expression"]      (* $MultiPlaceholder$1 + $MultiPlaceholder$2 *)
m["Tuples"]          (* {{1,10}, {1,20}, {2,10}, {2,20}, {3,10}, {3,20}} *)
m["EvaluateList"]    (* {11, 21, 12, 22, 13, 23} *)

Rule-Based Binding

(* Each x produces variable alternatives based on value *)
m = Multi[{1, 2, 3}, x_ :> Range[x]];
m["EvaluateList"]    (* 1×2×3 = 6 combinations *)

(* Conditional branching *)
m = Multi[Range[5], {
  x_ /; EvenQ[x] :> {x, x/2},
  x_ /; OddQ[x] :> {x, 3x + 1}
}];
m["EvaluateList"]    (* 2^5 = 32 combinations *)

Multiway Evolution Graph

m = Multi[1, x_ :> {x + 1, x * 2}];
m["Graph", 4]        (* Visualize 4 steps of evolution *)

Subset Sum Algorithm

(* Each element: include (element) or exclude (0) *)
subsetSums[nums_] := Total[Multi[{0, #}] & /@ nums]

ss = subsetSums[{3, 7, 1, 8, 4}];
Pick[ss["Tuples"], ss["EvaluateList"], 12]  (* Subsets summing to 12 *)

---

MultiwaySystem

MultiwaySystem wraps Multi for string rewriting with RF-compatible properties. See docs/MultiwaySystemRF.md.

(* Object API *)
ms = MultiwaySystem[{"A" -> "AA", "B" -> "AB"}, "ABA"];
ms["AllStatesList", 3]
ms["StatesGraph", 5]

(* Standalone API (RF-compatible, auto-enables DeduplicateSlices) *)
MultiwaySystem[{"A" -> "AA", "B" -> "AB"}, "ABA", 3, "AllStatesList"]
MultiwaySystem[{"A" -> "AA", "B" -> "AB"}, "ABA", 3]  (* defaults to AllStatesList *)

(* With deduplication via object API *)
ms = MultiwaySystem[{"A" -> "AA", "B" -> "AB"}, "ABA", "DeduplicateSlices" -> True];
ms["StatesCountsList", 5]

---

Automatic Chaining

Multi has UpValues that propagate through expressions:

m = Multi[{1, 2, 3}];
m + 10                 (* → Multi, evaluates to {11, 12, 13} *)
Sin[m]                 (* → Multi, evaluates to Sin values *)
f[g[m]]                (* → Multi, expression f[g[$placeholder]] *)

(* Rule-based Multi chains too *)
m2 = Multi[5, x_ :> {x, x+1}] * 10;
m2["EvaluateList"]     (* {50, 60} *)

No explicit ["EvaluateList"] needed for intermediate steps—just use Multi in expressions naturally.