The Spell Primitive Equation System (SPES) v2
The Interactive Version
Spell Forge: SPES V2
This link is an imperfect and minimalist example on this system working in a usable and interactable state.
Abstract
This paper presents a compositional framework for constructing, validating, and analyzing spells as programs - finite sequences of typed operations that transform an initial state of reality into a target state, consuming resources and propagating through defined channels.Rather than labeling spells after the fact (as existing notation systems do), this framework builds spells from seven primitive operations, each defined as a self-contained equation with typed inputs, outputs, internal sub-components, a weighted semantic model, and natural failure modes. A formal type system governs composition validity. A semantic weighting system [0.0, 1.0] quantifies how closely each primitive instance aligns with ideal execution.Primitive ordering is flexible - the canonical pipeline S → H → Σ → Φ → Γ → A → Ξ is the default, but non-standard orderings (anchor-first, source-from-anchor, recursive loops)are valid compositions subject to additional constraints. Ten novel spell compositions stress-test the framework across temporal paradox, self-modifying magic, recursive casting,infrastructure networking, and void-type boundary conditions.
Table of Contents
- Foundational Axioms
- The Semantic Weighting System
- Primitive Ordering and Composition Topology
- The Seven Primitives (Full Specification)
- The Type System
- Multi-Domain Transform Semantics
- Temporal Paradox Handling
- The VALIDATE Algorithm
- Novel Spell Compositions (10 spells)
- Framework Stress Results and Open Questions
1. Foundational Axioms
These five axioms constrain every operation, every composition, every spell. A composition that violates an axiom doesn't produce a "bad spell" - it produces a defined failure state.
Axiom 1 - Closure: Every operation takes a defined input state and produces a defined output state. There is no "undefined." Failure is a state, not an absence of state. If an operation cannot produce its intended output, it produces a failure token F with properties{cause, energy_consumed, residual_state}.
Axiom 2 - Composability: Any two operations whose output type matches the next operation's input type can be chained. Type mismatches are not silent errors - they are either transformation opportunities (with conversion cost) or failure triggers (with defined consequences at the mismatch point).
Axiom 3 - Conservation: No operation creates something from nothing. Every output is a transformation of input plus cost. The equation: input + cost = output + waste + loss.Always. "Temporal displacement" of cost (as in Debt-type spells) does not violate conservation - it defers the balancing, but the ledger must eventually balance. True violation of conservation (producing actual ∅ from non-∅ inputs) is either impossible within the system or requires intervention from outside the system (deity-level action that operates on different axioms).
Axiom 4 - Locality: Every operation has a defined origin point and a defined range of influence. Range is measured in the metric appropriate to the operation's type (spatial distance for energy, relational distance for mind, temporal distance for time effects)."Infinite" is not a valid range - it is an unresolved variable. Extremely large ranges are valid but carry proportional costs.
Axiom 5 - Determinism Within Tolerance: Given identical inputs, conditions, and execution, the same operation produces results within a defined variance band (ε). ε = 0means mechanical precision. Large ε means wild, unpredictable magic. But ε itself is always specifiable and finite. Unknown ε is a sign that the operation's parameters are underspecified, not that the operation is inherently random.
2. The Semantic Weighting System
Overview
Every primitive and every sub-component within a primitive carries a semantic weightw ∈ [0.0, 1.0] that quantifies how closely that instance aligns with the ideal model of its function.
-
w = 1.0: Perfect alignment. The primitive operates exactly as its base equation describes. Inputs are ideal, the mechanism is optimal, and the output is maximally efficient. This is theoretical maximum - rarely achieved in practice.
-
w = 0.5: Functional but degraded. The primitive operates within its definition but with significant deviation from ideal. Outputs are reduced, side effects are increased,and variance (ε) widens.
-
w = 0.0: Complete misalignment. The primitive cannot function as defined. Either the inputs are incompatible, the mechanism is broken, or the context is hostile. The primitive produces a failure token F instead of its intended output.
-
w < 0.0: Does not exist. Semantic weight cannot be negative. A primitive either functions (w > 0) or it doesn't (w = 0). There is no "anti-functioning." (This distinguishes semantic weight from magnitude, which CAN be negative in the case of Inversion-type effects.)
How Semantic Weight Is Calculated
Each primitive's semantic weight is a product of its sub-component weights:
w(Primitive) = Π(w_i) for all sub-components i
This multiplicative model means that a single sub-component at w = 0 drives the entire primitive to w = 0 (total failure from any single critical failure), while moderate degradation across multiple sub-components compounds (0.8 × 0.8 × 0.8 = 0.512 - three"pretty good" sub-components produce a "mediocre" primitive).
Sub-Component Weights
SOURCE sub-component weights:
w(S) = w(R) × w(M_e) × w(κ_match) × w(t_available)
Where:
w(R) = w(T_r_appropriateness) × w(V_r_sufficiency) × w(ρ) × w(σ) × w(A_r_accessibility)
w(T_r_appropriateness): How well does the reservoir type match what's needed?
1.0 = reservoir naturally produces the required payload type
0.5 = reservoir produces a convertible type (conversion loss applies)
0.0 = reservoir produces an incompatible type (no conversion path exists)
w(V_r_sufficiency): Is there enough in the reservoir?
1.0 = V_r >> κ (vast excess - negligible depletion)
0.5 = V_r ≈ κ (just enough - reservoir substantially depleted)
0.0 = V_r < κ (insufficient - partial payload or exhaustion)
w(ρ): Density of resource in reservoir
1.0 = high density (fast extraction, clean payload)
0.5 = moderate density (normal extraction rate)
0.0 = negligible density (nothing to extract from this reservoir)
w(σ): Reservoir stability
1.0 = perfectly stable (caster's own trained reserves)
0.5 = moderately stable (known ley line, established pact)
0.0 = completely unstable (wild magic zone, breaking pact, dying patron)
w(A_r_accessibility): Can the reservoir be accessed?
1.0 = freely accessible, no barrier
0.5 = accessible with cost (spell slot consumed, component required)
0.0 = inaccessible (no key, barrier too strong, access revoked)
w(M_e) = w(I_e_match) × w(F_e) × w(C_e_payable)
w(I_e_match): How well does the extraction mechanism match the reservoir?
1.0 = natural mechanism for this reservoir type
0.5 = functional but inefficient mechanism
0.0 = mechanism incompatible with reservoir
w(F_e) = F_e directly (extraction fidelity IS the semantic weight for this sub-component)
w(C_e_payable): Can the caster pay the extraction cost?
1.0 = trivial cost relative to caster's capacity
0.5 = significant but payable cost
0.0 = cost exceeds caster's capacity to pay
w(κ_match): How well does the requested amount match what's available and needed?
1.0 = exact match between request and downstream requirements
0.5 = overestimate or underestimate (waste or insufficiency downstream)
0.0 = catastrophic mismatch
w(t_available): Is there enough time for the extraction?
1.0 = plenty of time (no time pressure)
0.5 = exactly enough time (tight but functional)
0.0 = insufficient time (extraction cut short)
CHANNEL sub-component weights:
w(H) = w(M_c) × w(B_sufficiency) × w(d_feasibility)
Where:
w(M_c) = w(T_c_match) × w(Ω_impedance) × w(N_c_integrity)
w(T_c_match): How well does the channel medium match the payload type?
Derived from the impedance table: w = 1.0 - Ω(M_c, P.type)
Low impedance = high weight. High impedance = low weight.
w(Ω_impedance) = 1.0 / (1.0 + Ω) - inverse relationship, asymptotic to 0
w(N_c_integrity): Are all channels in the multiplex functional?
1.0 = all channels operational
Degrades proportionally with each failed channel
0.0 = all channels failed
w(B_sufficiency): Can the channel carry the full payload?
1.0 = B >> P.magnitude (vast excess bandwidth)
0.5 = B ≈ P.magnitude (just enough)
0.0 = B << P.magnitude (severe bottleneck)
w(d_feasibility): Is the distance within the channel's effective range?
1.0 = target is adjacent (d ≈ 0)
Decays according to: w = e^(-d / d_max) where d_max is the channel's characteristic range
0.0 = target is beyond effective range
SHAPE sub-component weights:
w(Σ) = w(G_compatibility) × w(T_s_sustainability) × w(D_s_achievability)
Where:
w(G_compatibility): Can the payload type form this geometry?
Derived from Shape Compatibility table
1.0 = type naturally forms this geometry
0.5 = type can be forced into this geometry with extra cost
0.0 = type actively resists this geometry
w(T_s_sustainability): Can the temporal profile be maintained?
1.0 = temporal profile is natural for this effect
0.5 = temporal profile requires active maintenance
0.0 = temporal profile is impossible for this energy/duration
w(D_s_achievability): Can the distribution be achieved?
1.0 = uniform (trivial) or natural for this geometry
0.5 = complex distribution requiring precision
0.0 = distribution violates physics of the payload type
TRANSFORM sub-component weights:
w(Φ) = w(O_validity) × w(λ) × w(precision_achievable)
Where:
w(O_validity): Is this operation meaningful for this target type?
1.0 = operation naturally applies to this target type
0.5 = operation applies with reduced effect
0.0 = category error (e.g., Alter(Mind) on a rock)
w(λ) = λ directly (efficacy IS semantic weight for transformation)
w(precision_achievable): Can the desired precision be achieved with available energy?
1.0 = energy vastly exceeds precision cost
0.5 = energy barely covers precision cost
0.0 = insufficient energy for any meaningful precision
CONDITION sub-component weights:
w(Γ) = Π(w(C_i)) for each condition in C_set
Where:
w(C_i) = w(predicate_evaluable) × w(response_executable)
w(predicate_evaluable): Can this condition's predicate access the data it needs?
1.0 = all required data is available and reliable
0.5 = data is available but uncertain
0.0 = required data is inaccessible
w(response_executable): Can the conditioned response be carried out?
1.0 = response is within the spell's operational capacity
0.5 = response is possible but strained
0.0 = response exceeds the spell's capacity
ANCHOR sub-component weights:
w(A) = w(M_a_suitability) × w(E_a_sustainable) × w(D_a_sufficient)
Where:
w(M_a_suitability): How well does the medium match the change being anchored?
Derived from type compatibility between Δ.type and M_a.type
1.0 = perfect match (fire enchantment on ruby)
0.5 = adequate match (fire enchantment on steel)
0.0 = hostile match (fire enchantment on ice - actively fights the anchor)
w(E_a_sustainable): Can the maintenance energy be supplied for the intended duration?
1.0 = energy supply vastly exceeds total maintenance cost over duration
0.5 = energy supply approximately matches total cost
0.0 = energy supply is insufficient (anchor will starve)
w(D_a_sufficient): Is the anchor durable enough for the context?
1.0 = anchor is far more durable than expected threats
0.5 = anchor can withstand normal conditions but is vulnerable to targeted disruption
0.0 = anchor is too fragile for the context
INTERFACE sub-component weights:
w(Ξ) = w(O_i_appropriate) × w(P_i_functional)
Where:
w(O_i_appropriate): Is the openness level correct for the spell's intended context?
1.0 = openness perfectly matches intended use (combat spell is closed, infrastructure is open)
0.5 = openness is adequate but not optimal
0.0 = openness is catastrophically wrong (combat spell is fully open in hostile environment)
NOTE: this is context-dependent, not absolute. O_i = 0.9 is w = 1.0 for a Thread
and w = 0.0 for a combat evocation.
w(P_i_functional): Are the declared protocols achievable?
1.0 = all protocols are well-defined and operational
0.5 = some protocols are degraded
0.0 = critical protocols are non-functional
Composite Spell Semantic Weight
The overall semantic weight of a spell is:
w(spell) = Π(w(Primitive_i)) for all primitives in the composition
Where the product is taken over the ACTIVE primitives in the spell's
specific composition (not all seven - only those used).
This gives us a single number in [0.0, 1.0] that describes how "well-formed" a spell is.
- w ≈ 1.0: Masterwork casting. Everything is optimally matched. The spell performs at theoretical maximum efficiency.
- w ≈ 0.5: Workable but wasteful. The spell functions but with significant energy loss,wider variance band, and reduced effect.
- w ≈ 0.1: Barely functional. The spell technically executes but the output is so degraded that it may be indistinguishable from failure.
- w = 0.0: Failure. At least one primitive hit w = 0 somewhere, and the spell does not execute as intended. A failure token F is produced.
Relationship to ε (variance band):
ε(spell) = ε_base / w(spell)
As semantic weight decreases, the variance band increases. A well-formed spell (w ≈ 1.0)has tight, predictable output. A poorly formed spell (w ≈ 0.1) has wildly variable output.This is the mechanical basis for "wild magic" - it's not a separate system, it's what happens when w is low across multiple primitives.
3. Primitive Ordering and Composition Topology
The Canonical Pipeline
The standard composition order is:
S → H → Σ → Φ → Γ(woven through) → A → Ξ
This represents the most common and most stable spell architecture: acquire resources,transmit them, shape them, apply them, persist the results, define the interaction surface.
But this is a default, not a requirement. The actual constraint is:
ORDERING RULE: For any edge (A → B) in the composition graph,
A.output.type must be compatible with B.input.type. The ordering
is determined by data flow, not by convention.
Non-Standard Orderings
Anchor-First (A → S → H → Σ → Φ)
The anchor is established BEFORE the spell sources its energy. This is how wards,glyphs, and pre-inscribed magical infrastructure work. The caster first prepares the persistence layer (carves the rune, draws the circle, establishes the ward boundary),then later fills it with energy.
Composition:
A(M_a = prepared_medium, E_a = 0, D_a = structural_only)
→ creates an empty_anchor: a persistence structure with no change to persist.
Then, potentially much later:
S(R, M_e, κ, t) → P
→ H(P, M_c, B, d) → P'
→ Σ(P', G, T_s, D_s) → E
→ Φ(E, X, O, λ) → {X', Δ}
→ Δ binds to the pre-existing empty_anchor
The anchor's E_a begins drawing from its energy supply only when Δ arrives.
This explains several things:
- Why ritual magic takes so long (you're building the anchor infrastructure first)
- Why a glyph can sit dormant for years (anchor exists, but no Δ is bound to it yet - the trigger Condition gates the S → Φ chain)
- Why some magical items require "charging" (the anchor exists in the item's material structure, but the payload must be sourced separately)
- Why ward-breaking involves disrupting the anchor BEFORE the energy discharge (if you destroy the anchor structure, the incoming Δ has nowhere to bind)
Semantic weight modifier for Anchor-First: w(A) is calculated at the time of anchor creation based on M_a and D_a only. w(E_a_sustainable) is deferred until the payload arrives. If the payload's energy requirements exceed what was planned for during anchor construction, the anchor is under-specced and w(A) drops retroactively.
Source-From-Anchor (A → S_from_A → H → Σ → Φ)
The most exotic ordering: the anchor IS the source. The spell draws its energy from the very structure it will persist in. This is auto-cannibalistic magic - the spell consumes its own foundation to execute.
Composition:
A(M_a = pre-existing_enchanted_medium)
- the medium already contains stored magical energy (it's a charged crystal,
an enchanted object, a ley line node).
S(R = A.M_a, M_e = resonant_extraction, κ, t)
- Source draws FROM the anchor medium. The anchor IS the reservoir.
→ H → Σ → Φ → {X', Δ}
→ Δ attempts to bind back to A.M_a
But A.M_a has been depleted by S. The anchor medium is weaker.
binding_strength = original_binding - extraction_damage
If binding_strength > 0: spell persists but anchor is degraded.
The enchanted sword fires its stored spell but is now less magical.
Repeated use depletes the anchor entirely. This is "charges."
If binding_strength ≤ 0: anchor cannot hold Δ. The spell executes
(the Transform happens) but the effect is instantaneous only -
no persistence. The enchanted item is spent.
This is how consumable magical items work. A potion is a Source-From-Anchor composition where the liquid medium IS both the reservoir and the anchor, and drinking it is the Channel. The Transform executes, the anchor (liquid) is consumed, and nothing persists beyond the Transform's natural duration.
Semantic weight modifier for Source-From-Anchor: w(S) and w(A) become interdependent.Drawing from the anchor degrades the anchor, which reduces w(A), which may reduce the spell's overall w below the threshold for the intended Transform. The system naturally limits how much you can draw from the anchor before the spell becomes non-viable.
Anchor-as-initial-Source (requires "seed" energy)
What if the anchor comes FIRST and the Source draws from the anchor,but the anchor requires some initial energy to exist? This creates a bootstrap problem.
Resolution: A "seed" Source - a minimal S_0 that creates the anchor,
which then becomes the reservoir for the main S_1.
S_0(R = caster, κ = minimal_seed) → P_0
→ A(M_a = medium, E_a_initial = P_0) - anchor is established with seed energy
→ S_1(R = A.M_a + ambient_accumulation, κ = main_payload)
→ H → Σ → Φ
→ Δ binds to A
The seed Source is small - just enough to "turn on" the anchor. The anchor
then accumulates energy from its environment over time (if anchored to a
ley line, ambient magical field, or other renewable source). When sufficient
energy has accumulated, the main Source draws from the anchor's accumulated
reserves.
This is how permanent magical infrastructure works. A wizard doesn't power a tower ward from their personal reserves forever. They seed the anchor with enough energy to start it, anchor it to a ley line, and the ley line feeds the anchor indefinitely. The wizard walks away. The ward persists because the anchor's environment is the ongoing Source.
This creates a self-sustaining loop: A feeds S feeds H → Σ → Φ → Δ feeds back to A.The loop is stable as long as the environmental input ≥ the anchor's maintenance cost + the ongoing operational cost. If the environmental input drops (ley line weakens, climate shifts magically), the loop starves and the spell degrades.
Recursive Compositions
A spell can include itself as a sub-component, creating recursion. This is valid but requires a termination condition (Γ with a Termination predicate) or the spell recurses infinitely,consuming resources until Source is exhausted. Infinite recursion without termination is not a paradox - it's a resource exhaustion failure that terminates when V_r hits zero.
RECURSIVE COMPOSITION:
SPELL_A:
S → H → Σ → Φ → Γ(if condition: invoke SPELL_A again) → A → Ξ
Each recursion consumes:
κ_per_recursion from S
W_per_recursion from all primitives
Total cost = Σ(κ_i + W_i) for i = 0 to depth
Maximum recursion depth = V_r / (κ_per_recursion + W_per_recursion)
Termination:
EITHER Γ.termination becomes TRUE (designed termination)
OR V_r < κ_per_recursion (resource exhaustion - forced termination)
OR w(spell) drops below minimum viability threshold per recursion
(degradation termination - each recursion accumulates waste,
reduces fidelity, widens ε, until the spell is too degraded
to execute another cycle)
Branching, Forking, and Merging
Branch: One primitive's output feeds multiple downstream primitives.
S → H → [Σ_1 → Φ_1, Σ_2 → Φ_2, Σ_3 → Φ_3]
The payload P' is split across branches. Total magnitude is conserved:
P'_1.magnitude + P'_2.magnitude + P'_3.magnitude = P'.magnitude
Each branch is an independent sub-composition validated separately.
Fork: One primitive produces multiple typed outputs that follow different paths.
S → H → Σ → Φ(multi-domain) → [Δ_life, Δ_mind, Δ_information]
↓ ↓ ↓
A_1 A_2 A_3
Multi-domain Transform (see Section 6) produces multiple change records,
each requiring its own anchor.
Merge: Multiple upstream paths combine into one downstream primitive.
[S_1, S_2, S_3] → H_merge → Σ → Φ
Multiple Sources feed one Channel. The Channel must handle the combined
payload: B_required = Σ(P_i.magnitude). The merged payload carries all
origin signatures and any taint from all sources.
This is ritual casting with multiple contributors. The merge point is
the Channel - all contributors must use compatible channel types.
A merge with incompatible channel types (one mage chanting, another
gesturing, a third writing) requires a Channel that can accept
multiplexed inputs of different media types.
4. The Seven Primitives (Full Specification)
Primitive 1: SOURCE (S)
Purpose: Acquisition - where does the resource come from, how is it extracted, what is acquired, and what happens to the reservoir?
Equation:
S(R, M_e, κ, t) → {P, δR, W_s}
Inputs:
- R = Reservoir {T_r, V_r, ρ, σ, A_r}
- T_r = Reservoir type (biological, environmental, stored, external_entity, sacrificial, temporal_self, anchor_medium)
- V_r = Volume (total available resource). Finite. Always.
- ρ = Density (concentration of resource within reservoir). Affects extraction rate.
- σ = Stability (reliability of reservoir during/after extraction). [0.0, 1.0]
- A_r = Accessibility (barrier to entry - free, keyed, negotiated, destructive)
- M_e = Mechanism of Extraction {I_e, F_e, C_e}
- I_e = Interface type (metabolic, resonant, contractual, destructive, sympathetic, analytical, temporal)
- F_e = Fidelity (proportion of drawn resource that enters payload). [0.0, 1.0]
- C_e = Cost of extraction (paid regardless of spell success)
- κ = Capacity requested (how much to draw)
- t = Time available for extraction
Outputs:
- P = Payload {magnitude, type, stability, taint, origin_signature}
- P.magnitude = κ × F_e
- P.type = f(T_r, I_e) - determined by reservoir type and extraction mechanism
- P.stability = σ (inherited from reservoir, possibly degraded)
- P.taint = Set
- contaminating types from unstable extraction - P.origin_signature = hash(R, M_e, t_cast) - permanent fingerprint
- δR = Reservoir delta (V_r reduced by κ, σ possibly reduced by extraction stress)
- W_s = Source waste (energy lost in extraction = κ × (1 - F_e))
Semantic Weight:
w(S) = w(T_r_appropriateness) × w(V_r_sufficiency) × w(ρ) × w(σ) × w(A_r)
× w(I_e_match) × w(F_e) × w(C_e_payable) × w(κ_match) × w(t_available)
Failure Modes:
- κ > V_r → Reservoir Exhaustion (partial payload, reservoir damaged)
- A_r = inaccessible → Source Denial (no payload, C_e still paid)
- σ → 0 during extraction → Source Instability (tainted payload)
- F_e → 0 → Extraction Collapse (no payload, reservoir depleted, maximum waste)
Critical Property: P carries its origin forward. Taint transmits at full fidelity through all downstream primitives. The payload REMEMBERS where it came from.
Primitive 2: CHANNEL (H)
Purpose: Conveyance - how does the acquired resource travel from extraction to shaping?
Equation:
H(P, M_c, B, d) → {P', L_h, V_h}
Inputs:
- P = Payload from SOURCE
- M_c = Medium of Conveyance {T_c, N_c, Ω}
- T_c = Channel type(s) (somatic, verbal, material, written, visual, sympathetic, contractual, field)
- N_c = Number of multiplexed channels
- Ω = Impedance function: Ω(T_c, P.type) → [0.0, ∞)
- B = Bandwidth = B_base(T_c) × (1/Ω) × N_c
- d = Distance (measured in appropriate metric for channel type)
Outputs:
- P' = Transmitted Payload
- P'.magnitude = P.magnitude × F_h where F_h = F_e × (1 - (Ω × d / B))
- P'.type = P.type (preserved unless Ω extreme → type-shift possible)
- P'.stability = P.stability × F_h
- P'.taint = P.taint (UNCHANGED - taint transmits perfectly)
- L_h = Channel loss = P.magnitude - P'.magnitude
- V_h = Vulnerability profile (what can interfere with this channel)
Semantic Weight:
w(H) = w(T_c_match) × w(Ω_impedance) × w(N_c_integrity) × w(B_sufficiency) × w(d_feasibility)
Failure Modes:
- P.magnitude > B → Channel Overload (extended cast time, payload bleed, or channel rupture)
- d > effective range → Signal Attenuation (F_h → 0, payload arrives as nothing)
- M_c disrupted → Channel Severance (partial payload in transit, dangerous)
- Ω → ∞ → Type Rejection (total impedance mismatch, nothing transmits)
Critical Property: Taint transmits at full fidelity. The channel doesn't clean contaminated payloads. Channel loss reduces magnitude but not taint concentration.
Primitive 3: SHAPE (Σ)
Purpose: Geometry - what form does the transmitted resource take?
Equation:
Σ(P', G, T_s, D_s) → {E, W_σ}
Inputs:
- P' = Transmitted Payload from CHANNEL
- G = Geometry {dim, topology, origin, extent, boundary}
- dim: 0D (point), 1D (line/ray), 2D (surface), 3D (volume), Relational (graph)
- topology: simply connected, multiply connected, branching, degenerate
- origin: spatial point, relational node, or self-reference
- extent: range from origin in appropriate metric
- boundary: hard, gradient, permeable, reflective, absorptive
- T_s = Temporal Profile {onset, duration, pattern, termination}
- onset: instantaneous, progressive, triggered, delayed
- duration: flash, sustained, permanent, decaying
- pattern: static, pulsing, expanding, contracting, oscillating, iterative
- termination: clean, residual, catastrophic, gradual
- D_s = Distribution function: position_within_G → intensity_at_position
- Types: uniform, concentrated, shell, gradient, discrete, inverse
Outputs:
- E = Effect Field: a function mapping every point within G to an intensity value
- E.magnitude_at_point(x) = (P'.magnitude - W_σ) × D_s(x)
- W_σ = Shaping waste = P'.magnitude × (complexity_G × complexity_T_s × non uniformity_D_s)
Semantic Weight:
w(Σ) = w(G_compatibility) × w(T_s_sustainability) × w(D_s_achievability)
Failure Modes:
- P'.magnitude < W_σ → Shaping Exhaustion (partial/deformed shape or nothing)
- G.extent > payload capacity → Shape Thinning (geometry forms but intensity sub-threshold)
- T_s.duration > anchor capacity → Temporal Collapse (shape flickers and dies)
- Topology incompatible with P'.type → Geometric Rejection (shaping cost explodes or shape distorts)
Primitive 4: TRANSFORM (Φ)
Purpose: The verb - what does the spell DO to reality?
Equation:
Φ(E, X, O, λ) → {X', Δ, W_φ}
Inputs:
- E = Effect Field from SHAPE
- X = Target State {T_x, S_x, R_x, H_x}
- T_x = Target type (matter, energy, mind, life, information, space, time, probability, magic)
- S_x = Current state vector
- R_x = Resistance profile {passive, active, categorical}
- H_x = History (previous transformations)
- O = Operation {mode, domain, intensity, precision}
- mode: create, destroy, alter, move, bind, release, reveal, conceal
- domain: must be compatible with T_x
- intensity: effective_intensity = E.magnitude_at_target × λ
- precision: [low, moderate, high, surgical] - higher precision costs more energy
- λ = Efficacy = λ_base × (1 - R_x.passive) × (1 - R_x.active) × compatibility(O.domain, T_x) × interference(H_x, O)
Outputs:
- X' = Transformed state
- Δ = Change record (what changed, by how much, reversibility, type, taint)
- W_φ = Transform waste = E.magnitude × (1 - efficiency(O.precision))
Semantic Weight:
w(Φ) = w(O_validity) × w(λ) × w(precision_achievable)
Failure Modes:
- λ = 0 → Total Resistance (E consumed, X unchanged)
- O.domain incompatible with T_x → Category Error (energy consumed, nothing happens)
- effective_intensity < threshold → Sub threshold Effect (imperceptible change)
- H_x contains conflicting transform → Transform Collision (overwrite, cancel, or chaotic merge)
- Low precision + high magnitude → Collateral Transformation (area damage)
Critical Property: Transform is the ONLY primitive that modifies reality's base state.Everything else is logistics. A spell with no Transform (or with Φ producing negligible Δ)has done nothing. The minimum viable Transform is Alter(property_of_substrate).
Primitive 5: CONDITION (Γ)
Purpose: Control flow - under what circumstances does each part execute?
Equation:
Γ(Ψ, C_set) → Ψ_conditioned
This is a higher-order function. It takes an operation Ψ (any primitive or composition of primitives) and returns a conditioned version gated by C_set.
Inputs:
- Ψ = Any primitive operation or composition thereof
- C_set = Ordered set of conditions, each being:
- C_i = {type, predicate, response, priority}
- type: prerequisite, trigger, filter, sustain, termination, modification, escalation, failsafe
- predicate: f(world_state, caster_state, target_state, spell_state, time) → {TRUE, FALSE}
- response: what happens on TRUE/FALSE (depends on type)
- priority: resolution order for conflicting conditions
Outputs:
- Ψ_conditioned = Ψ gated by C_set
Semantic Weight:
w(Γ) = Π(w(C_i)) where w(C_i) = w(predicate_evaluable) × w(response_executable)
Failure Modes:
- Predicate references unavailable data → Evaluation Failure (fails open or closed by design)
- Conflicting equal-priority conditions → Condition Deadlock (conservative resolution)
- Empty C_set → Unconditional Execution (valid but dangerous)
- Sustain permanently FALSE → Orphaned Effect (termination sequence)
Critical Property: Condition is woven THROUGH other primitives, not applied after them.A Condition can gate Source, Channel, Shape, Transform, or Anchor independently.
Primitive 6: ANCHOR (A)
Purpose: Persistence - what holds the spell's effects in existence across time?
Equation:
A(Δ, M_a, E_a, D_a) → {Δ_persisted, δ_decay, V_a}
Inputs:
- Δ = Change Record from TRANSFORM (or empty, if Anchor-First ordering)
- M_a = Anchor Medium {type, binding_strength, capacity}
- type: self/concentration, object, location, entity, relationship, phenomenon, information, none
- binding_strength = f(compatibility(Δ.type, M_a.type), E_a, caster_skill)
- capacity: maximum Δ.magnitude the anchor can hold
- E_a = Anchor Energy (ongoing maintenance cost)
- E_a = Δ.magnitude × (1 / binding_strength) × (1 / D_a.structural_integrity)
- Source of E_a: caster, medium degradation, environment, target, self-sustaining loop
- D_a = Durability {structural_integrity, disruption_resistance, restoration_rate}
Outputs:
- Δ_persisted = The change, maintained across time
- δ_decay = Rate of anchor degradation (approaches 0 for well-matched, high-energy anchors)
- V_a = Anchor vulnerability profile (how to disrupt)
Semantic Weight:
w(A) = w(M_a_suitability) × w(E_a_sustainable) × w(D_a_sufficient)
Failure Modes:
- M_a destroyed → Anchor Annihilation (immediate termination sequence)
- E_a exceeds supply → Anchor Starvation (progressive degradation)
- Δ.magnitude > capacity → Anchor Overflow (spell weakened or anchor damaged)
- binding_strength → 0 → Anchor Drift (change migrates, dissipates, or collapses)
Critical Property: Anchor ordering is FLEXIBLE. Anchor can be established before Source(anchor-first), can serve as Source (source-from-anchor), or can be established in the canonical position after Transform. The ordering changes the composition's properties but not its validity.
Primitive 7: INTERFACE (Ξ)
Purpose: Compatibility - how does this spell interact with the magical ecosystem?
Equation:
Ξ(spell_complete, O_i, P_i) → {interaction_result}
Inputs:
- spell_complete = Full spell with accumulated properties
- O_i = Openness [0.0, 1.0] per primitive:{source_openness, channel_openness, shape_openness, transform_openness, condition_openness, anchor_openness}
- P_i = Protocol {incoming_set, outgoing_set, handshake}
- incoming: counterable, dispellable, modifiable, absorbable, stackable, readable
- outgoing: suppressive, enhancing, chaining
- handshake: protocol for resolving spell-to-spell interactions
Outputs:
- interaction_result: determined at runtime when spells interact
Semantic Weight:
w(Ξ) = w(O_i_appropriate) × w(P_i_functional)
Failure Modes:
- O_i too high in hostile context → Interface Exploitation (enemy targets open primitives)
- O_i too low for cooperation → Interface Rigidity (can't be boosted by allies)
- Protocol mismatch → Interaction Failure (traditions can't interoperate)
- Handshake deadlock → Mutual Interference (equal-magnitude opposed spells destabilize)
5. The Type System
Base Types
TYPE HIERARCHY:
Energy (ε)
├── Thermal (ε_t) - heat, fire, cold (negative thermal)
├── Kinetic (ε_k) - force, motion, impact
├── Electrical (ε_e) - lightning, bioelectricity
├── Radiant (ε_r) - light, radiation, divine energy
├── Entropic (ε_n) - decay, necrotic, negative energy
├── Vital (ε_v) - life force, positive energy, healing
├── Gravitational (ε_g) - weight, attraction, spatial warping
└── Arcane (ε_a) - raw magical energy, untyped, universal converter
Matter (μ)
├── Elemental (μ_elem): Solid (μ_s), Liquid (μ_l), Gas (μ_g), Plasma (μ_p)
├── Organic (μ_o)
├── Mineral (μ_m)
└── Exotic (μ_x) - extraplanar, ectoplasm, solidified thought
Mind (ψ)
├── Cognition (ψ_c) - thought, reasoning
├── Emotion (ψ_e) - feelings, moods
├── Memory (ψ_m) - stored experience
├── Will (ψ_w) - volition, resistance
├── Perception (ψ_p) - sensory processing
└── Identity (ψ_i) - selfhood, true name
Space (σ)
├── Distance (σ_d) - separation
├── Direction (σ_dir) - orientation
├── Connectivity (σ_c) - portals, folds, links
├── Volume (σ_v) - bounded regions
└── Boundary (σ_b) - edges, walls, barriers
Time (τ)
├── Flow (τ_f) - rate of passage
├── Sequence (τ_s) - event ordering
├── Duration (τ_d) - interval length
└── Causality (τ_c) - cause-effect chains
Information (ι)
├── Pattern (ι_p) - structure, arrangement
├── Secret (ι_s) - hidden knowledge
├── Name (ι_n) - true names, identifiers
├── History (ι_h) - records of past states
└── Probability (ι_prob) - likelihood, fate, luck
Magic (ω) - NEW in v2
├── Active_Spell (ω_a) - currently executing spell
├── Enchantment (ω_e) - spell anchored to object
├── Ward (ω_w) - spell anchored to location
├── Curse (ω_c) - spell anchored to entity
├── Field (ω_f) - ambient magical conditions
├── Signature (ω_sig) - origin fingerprint of magical effect
└── Structure (ω_str) - the compositional architecture of a spell
Void (∅)
└── (no subtypes) - absence, null, the output of failed operations
Magic (ω) Type - Full Integration
Magic as a base type means spells can target OTHER SPELLS as legitimate targets. This formalizes counter spelling, dispelling, meta-magic, spell analysis, and all forms of magic-targeting-magic.
Channel Impedance for ω:
IMPEDANCE Ω FOR MAGIC (ω) TYPE:
──────────────────────────────────
Medium ω_a ω_e ω_w ω_c ω_f ω_sig ω_str
──────────────────────────────────
Somatic 0.4 0.5 0.6 0.7 0.5 0.8 0.7
Verbal 0.3 0.4 0.3 0.3 0.4 0.5 0.3
Material 0.5 0.2 0.3 0.4 0.6 0.3 0.4
Written/Sigil 0.2 0.1 0.1 0.2 0.3 0.1 0.1
Visual 0.3 0.4 0.3 0.5 0.2 0.6 0.4
Sympathetic 0.2 0.3 0.4 0.1 0.5 0.1 0.2
Contractual 0.3 0.4 0.3 0.1 0.4 0.3 0.3
──────────────────────────────────
Key observations:
- Written/Sigil channels transmit ALL magic subtypes well - this is why
counter spell research, spell analysis, and meta-magic theory are written traditions.
The written word is the best medium for understanding and manipulating magical structure.
- Sympathetic channels excel at targeting Curses (ω_c: 0.1) and Signatures (ω_sig: 0.1)
- to break a curse, you need a connection to the cursed. To trace a signature, you
need a connection to the caster.
- Verbal channels are good generalists for magic targeting - incantations of
counter spelling work across most subtypes.
Conversion Efficiency η for ω:
CONVERSION TO/FROM MAGIC (ω):
──────────────────────────────
FROM ω:
ω → ε_a: 0.7 (magical energy converts to arcane energy efficiently - this is dispelling.
You break down structured magic into raw arcane energy.)
ω → ι: 0.6 (magical structure converts to information - this is spell analysis.
You read the spell's composition.)
ω → ψ: 0.3 (magical effects convert to mental experience - this is magical perception.
Detect Magic translates ω_f into ψ_p.)
ω → all other: 0.1 or less (magic doesn't easily become non-magical things)
TO ω:
ε_a → ω: 0.6 (raw arcane energy can be structured into magical effects - this is
what spell slots ARE. Structured arcane potential.)
ι → ω: 0.5 (information can become magical structure - this is spell research,
learning new spells from theory.)
ψ → ω: 0.4 (mental energy can become magic - this is psionics, sorcerous bloodline
power, raw will made manifest.)
all other → ω: 0.1 or less (non-magical things don't easily become magic)
Transform operations on ω targets:
TRANSFORM MODES FOR MAGIC (ω) TARGETS:
Create(ω): Create new magical effects from raw ε_a. This IS spell casting -
normal spell casting is Create(ω) with the ω immediately applied to
a non-ω target. But Create(ω) that produces a free-standing magical
effect (not applied to anything) is how you make magical items,
wards, and infrastructure.
Destroy(ω): Break down magical effects into constituent energy. This is Dispel Magic.
Produces ε_a + ε_n (the structured magic becomes raw energy plus entropic
waste from the destructuring process).
Alter(ω): Modify an existing magical effect's parameters without destroying it.
This is Meta-magic - changing a spell's Shape, boosting its Transform,
extending its Anchor. Requires the target spell's O_i to be > 0 for
the relevant primitive.
Move(ω): Relocate a magical effect. This is Graft. Change the spell's Anchor
medium without modifying the spell itself.
Bind(ω): Lock a magical effect in place, preventing it from being Altered, Moved,
or Destroyed. Magical locks, unbreakable enchantments. Bind(ω) applied
to a spell sets all its O_i values to 0.0 - fully closed.
Release(ω): Unlock a bound magical effect, restoring its Interface openness.
Break a magical lock. The inverse of Bind(ω).
Reveal(ω): Analyze a magical effect's structure. Detect Magic, Identify, Arcane Sight.
Converts ω_str → ι_p (structure becomes readable pattern). Limited by
the target spell's O_i - a closed spell reveals less.
Conceal(ω): Hide a magical effect from detection. Nondetection, Nystul's Magic Aura.
Converts ω_sig → ι_s (signature becomes secret).
Shape Compatibility Update (with ω and ∅)
SHAPE COMPATIBILITY (complete):
─────────────────────────────────────────────
Type Best Geometries Resists
─────────────────────────────────────────────
ε (energy) 3D volumes, 1D lines, Relational
2D surfaces
μ (matter) 3D volumes, 0D points 1D lines, Relational
ψ (mind) Relational, 0D point 3D volumes
σ (space) 2D surfaces, 3D volumes 0D point
τ (time) 0D point, 1D line, 3D volumes
Relational
ι (info) Relational, 0D point 3D volumes
ω (magic) Relational (spell-to-spell), ALL spatial geometries
0D point (single target (magic is structured, not
spell) spatial - a "30ft antimagic
field" is actually a spatial
Condition on a relational
ω effect)
∅ (void) CANNOT BE SHAPED Everything
─────────────────────────────────────────────
Universal Type Properties
Every typed value carries:
value = {
base_type: T,
magnitude: ℝ⁺,
stability: [0.0, 1.0],
taint: Set<T>,
origin_signature: hash(Source)
}
6. Multi-Domain Transform Semantics (Parallel Forking)
The Problem
Some spells operate on multiple target types simultaneously. Echo Wound affects Life,Information, and Mind. A spell that petrifies affects Matter and Life. A banishment affects Space and the target entity. The single-Transform equation Φ(E, X, O, λ) handles one operation on one domain.
The Solution: Parallel Fork
A multi-domain Transform is syntactic sugar for parallel forking of the Effect Field:
Φ_multi(E, [X_1, X_2, ..., X_n], [O_1, O_2, ..., O_n], [λ_1, λ_2, ..., λ_n])
Is equivalent to:
E → SPLIT → [E_1, E_2, ..., E_n]
where Σ(E_i.magnitude) = E.magnitude (conservation)
and E_i.magnitude is allocated proportionally to O_i.intensity
Φ_1(E_1, X_1, O_1, λ_1) → {X_1', Δ_1, W_φ1}
Φ_2(E_2, X_2, O_2, λ_2) → {X_2', Δ_2, W_φ2}
...
Φ_n(E_n, X_n, O_n, λ_n) → {X_n', Δ_n, W_φn}
Each Δ_i may require its own Anchor (or share an anchor if compatible).
Allocation Strategy
How is E.magnitude split across forks? Three strategies:
Equal: E_i = E / n. Each domain gets the same energy. Simple, wasteful if domains have different requirements.
Proportional: E_i = E × (O_i.intensity / Σ(O_j.intensity)). Energy is allocated proportional to each operation's intensity requirements. More efficient.
Priority: E allocated to O_1 first (up to its full requirement), remainder to O_2,remainder to O_3, etc. First domain gets full power, later domains get leftovers. Used when one effect is primary and others are secondary.
The allocation strategy is a design choice made at spell composition time and affects the spell's behavior. A spell that splits equally across three domains is more balanced but weaker in each. A spell with priority allocation has one strong effect and potentially weak secondary effects.
Inter-Fork Dependencies
Forks can be independent or dependent:
Independent: Each Φ_i executes regardless of others' success. One fork failing doesn't affect the others. Simpler, more robust.
Dependent: Success of Φ_i gates execution of Φ_{i+1}. If the physical wound fails(λ_1 = 0, target immune), the psychic echo also fails because there's no wound to echo. More efficient (don't waste energy on downstream forks if upstream fails) but more fragile (one failure cascades).
Feedback: Output of Φ_i modifies input of Φ_j. The psychic damage from fork 2 reduces the target's Will (R_x.active for fork 3), making the memory-taint more effective. Most powerful, most complex, hardest to validate.
7. Temporal Paradox Handling
The Problem
Debt-type spells borrow from the future. Time magic alters causality. Prophecy-based conditions evaluate future states. All of these involve temporal references that may be paradoxical (the future state being referenced may be changed by the spell itself).
Temporal Reference Types
Every temporal reference in a spell falls into one of three categories:
Retrospective (τ_retro): References the past. Past states are (usually) fixed and stable. σ_temporal = high. Echo Wound uses retrospective references to access historical wound data. Low paradox risk.
Concurrent (τ_conc): References the present moment. Standard spellcasting operates here. No temporal paradox. σ_temporal = maximum.
Prospective (τ_prosp): References the future. Future states are inherently uncertain.σ_temporal = low and inversely proportional to how far forward the reference reaches.Debt uses prospective references. High paradox risk.
The Paradox Index (π)
For any spell with temporal references:
π(spell) = Σ(temporal_reference_i.distance × temporal_reference_i.causal_coupling)
Where:
distance = temporal distance from the present (0 for concurrent, positive for prospective,
negative for retrospective)
causal_coupling = degree to which the spell's effects can alter the referenced temporal state
[0.0, 1.0] where 0.0 = spell cannot affect referenced state, 1.0 = spell directly
determines referenced state
π = 0: No paradox. Standard spellcasting with no temporal references, or retrospective references to events the spell cannot change.
0 < π < 1: Low paradox. The spell references time but the causal coupling is weak.A divination that reads the future but doesn't change it (low causal_coupling). A Debtspell where the collection event is far enough in the future that the caster has manypossible states (low distance × moderate coupling).
1 ≤ π < 10: Moderate paradox. Significant temporal entanglement. A Debt spell due soon from a caster in poor health (moderate distance × high coupling, because the caster's survival IS the condition for the reference). Temporal effects that alter recent causality. The spell functions but with elevated ε (wider variance band) and reduced w(S).stability.
π ≥ 10: Severe paradox. The spell is attempting to reference a temporal state that it directly determines. "I borrow energy from my future self to cast a spell that kills me, preventing my future self from existing to provide the energy." This is a paradox loop. Resolution:
Paradox Resolution Strategies
Strategy 1 - Novikov Self-Consistency: The paradox is impossible. Any spell withπ ≥ threshold_paradox simply fails at Source (the prospective reservoir doesn't exist because it can't exist). w(S) = 0. This is the conservative approach. Magic cannot violate causality.
Strategy 2 - Branching Time-line: The paradox creates a temporal fork. The spell sources from a future that NOW WON'T HAPPEN (because the spell changed the present),but the energy was already extracted from that branch. Conservation is maintained across the multiverse but not within a single time-line. This creates "orphaned energy" - payload with an origin_signature from a time-line that no longer exists. This energy is inherently unstable (σ → 0) and carries heavy taint {τ_c, τ_paradox}.
Strategy 3 - Paradox Tax: The universe resolves paradoxes by applying a "tax" -additional energy is consumed to stabilize the causal inconsistency. The tax scales with π: tax = E_base × (e^π - 1). At low π, the tax is negligible. At high π, the tax exceeds any feasible energy supply, making severe paradoxes effectively impossible through cost rather than prohibition. This is the most flexible approach and the one this framework adopts as default.
TEMPORAL COST MODIFIER:
For any spell with π > 0:
κ_effective = κ_base × (1 + (e^π - 1))
π = 0: κ_effective = κ_base × 1.0 (no extra cost)
π = 0.5: κ_effective = κ_base × 1.65 (65% surcharge)
π = 1.0: κ_effective = κ_base × 2.72 (172% surcharge)
π = 2.0: κ_effective = κ_base × 7.39 (639% surcharge)
π = 5.0: κ_effective = κ_base × 148.4 (effectively impossible for non-deity casters)
π = 10: κ_effective = κ_base × 22026 (requires cosmic-level energy)
This means:
- Simple Debt (borrow from near future, low causal coupling): affordable, practical magic
- Prophetic Conditions (evaluate future states without changing them): affordable
- Temporal editing (change recent causality): very expensive, high-level only
- Time loops (self-referential causality): prohibitively expensive
- Grandfather paradox: effectively impossible (cost exceeds available energy in most settings)
Temporal Taint
Any spell with π > 0 produces payload with τ_c (causality) taint. This taint:
- Is detectable by effects that Reveal(ι_h) or Reveal(ω_sig)
- Increases the ε (variance band) of all downstream primitives
- Cannot be removed by Channel or Shape - it persists through the entire composition
- Resolves (dissolves) when the temporal reference is settled (Debt is paid, prophecy resolves, time-line stabilizes)
- If the reference NEVER settles (orphaned temporal reference), taint is permanent
8. The VALIDATE Algorithm
Purpose
Given a spell composition (a directed graph of primitives), determine whether it is type-valid, axiom-compliant, and semantically viable. Return a validation result with specific error locations if invalid.
Algorithm
VALIDATE(composition) → {valid: bool, w_total: float, errors: list, warnings: list}
PHASE 1: STRUCTURAL VALIDATION
For each node N in composition:
Verify N is one of {S, H, Σ, Φ, Γ, A, Ξ, CONVERSION, SPLIT}
Verify N has all required input parameters specified
Verify N's output is connected to at least one downstream node OR is a terminal node
For each edge (N_a.output → N_b.input):
Verify output port exists on N_a
Verify input port exists on N_b
Check for cycles:
If cycle exists AND cycle does not pass through a Γ with termination condition:
ERROR: "Unbounded recursion at [cycle location]. Add termination condition."
If cycle exists AND cycle passes through Γ with termination condition:
WARNING: "Recursive composition detected. Maximum depth = V_r / cost_per_cycle."
Check Transform presence:
If no Φ node exists in composition:
ERROR: "No Transform primitive. Spell produces no effect on reality."
PHASE 2: TYPE VALIDATION
For each edge (N_a.output → N_b.input):
output_type = N_a.output_type_spec
input_types = N_b.accepted_input_types
IF output_type ∈ input_types:
PASS (compatible)
ELIF conversion_path_exists(output_type, input_types):
best_path = find_minimum_loss_conversion(output_type, input_types)
IF best_path.total_η > 0:
WARNING: "Type conversion needed at [edge]. Path: [best_path].
Efficiency: [total_η]. Energy lost: [loss]."
Insert CONVERSION node on edge
Recalculate downstream magnitudes
ELSE:
ERROR: "No viable conversion path from [output_type] to [input_types] at [edge]."
ELSE:
ERROR: "Type mismatch at [edge]. [output_type] is incompatible with [input_types].
No conversion path exists."
PHASE 3: AXIOM VALIDATION
For each node N:
Axiom 1 (Closure):
Verify N produces defined output for all possible input states
including failure states from upstream nodes.
IF N can receive failure token F and has no handler:
WARNING: "Node [N] has no failure handler. Upstream failure produces undefined state."
Axiom 2 (Composability):
(Covered by Phase 2 type checking)
Axiom 3 (Conservation):
For each node: verify sum(inputs) + sum(costs) = sum(outputs) + sum(waste) + sum(loss)
IF imbalance detected:
ERROR: "Conservation violation at [N]. Input: [X], Output: [Y], Difference: [Z]."
For prospective temporal references:
Verify deferred costs are accounted in paradox tax
IF π > 0 AND no paradox tax applied:
ERROR: "Temporal reference without paradox tax at [N]."
Axiom 4 (Locality):
For each range specification:
IF range = ∞ or range = undefined:
ERROR: "Unbounded range at [N]. Specify finite range."
Axiom 5 (Determinism):
For each node: verify ε is specified
IF ε = undefined or ε = ∞:
WARNING: "Unspecified variance band at [N]. Default ε = ε_base / w(N)."
PHASE 4: SEMANTIC WEIGHT CALCULATION
For each primitive node N:
Calculate w(N) from sub-component weights (as specified in Section 2)
w_total = Π(w(N)) for all primitive nodes
IF w_total = 0:
ERROR: "Spell semantic weight is zero. At least one primitive is completely non-functional.
Zero-weight primitives: [list]."
IF w_total < 0.01:
WARNING: "Spell semantic weight is critically low ([w_total]). Spell will likely fail
or produce wildly unpredictable results. Variance band ε = [calculated]."
IF w_total < 0.1:
WARNING: "Spell semantic weight is low ([w_total]). Significant energy loss and
wide variance band expected."
PHASE 5: RESOURCE FEASIBILITY
Calculate total cost:
κ_total = Σ(κ_i) for all Source nodes
W_total = Σ(W_i) for all waste terms
C_total = Σ(C_i) for all extraction/maintenance costs
tax_total = Σ(paradox_tax_i) for all temporal references
grand_total = κ_total + W_total + C_total + tax_total
IF grand_total > available_resources:
ERROR: "Insufficient resources. Required: [grand_total]. Available: [available].
Deficit: [difference]. Largest cost center: [identified]."
For recursive compositions:
max_depth = available_resources / cost_per_cycle
WARNING: "Recursive spell. Maximum recursion depth: [max_depth] at current resources."
RETURN {
valid: (error_count == 0),
w_total: w_total,
errors: [list of all errors with locations],
warnings: [list of all warnings with locations],
cost_breakdown: {κ, W, C, tax, grand_total},
resource_margin: available - grand_total,
paradox_index: π,
variance_band: ε_base / w_total
}
9. Novel Spell Compositions
Spell 1: DEBT
Concept: Temporal displacement of Source cost. The spell executes now; the cost is deferred to a future extraction event with compound interest.
COMPOSITION: S(temporal_self) → H → Σ → Φ → A(contractual_self) → Ξ
S(
R = {T_r: temporal_self, V_r: PREDICTED(caster_future_reserves),
ρ: high, σ: low(predicted), A_r: contractual(self-acceptance)},
M_e = {I_e: contractual+temporal, F_e: 0.85,
C_e: compound_interest(rate=r, period=t_future - t_cast)},
κ = downstream_requirement,
t = 1 action
)
PARADOX INDEX: π = (t_future - t_cast) × causal_coupling
Where causal_coupling = probability that the spell affects the caster's
future state (low for a fireball aimed at someone else, high for a
self-buff that changes the caster's survival odds).
COLLECTION EVENT at t_future:
Forced S(R=caster_actual, κ=κ_original + C_e(t_future))
If V_r < κ_collection → cascading extraction (life force, linked entities, or secondary debt)
If caster dead → debt anchors to remains/legacy → haunted site
VALIDATE RESULTS:
Type: PASS (ε_a throughout)
Conservation: PASS (deferred, not violated - ledger balances at collection)
Paradox: π typically 0.2-1.5 (affordable tax for reasonable time horizons)
Warning: "Prospective temporal reference. Paradox tax applies."
w(S): low (σ is predicted) → overall w reduced → wider ε
Spell 2: ECHO WOUND
Concept: Damage sourced from a target's own historical injury record.
COMPOSITION: S(history_field) → H(sympathetic+verbal) → Σ(0D_point) →
Φ_multi[life, information, mind] → A(entity_mind for memory_taint) → Ξ
MULTI-DOMAIN TRANSFORM (parallel fork, dependent):
SPLIT(E) → [E_life(60%), E_info(15%), E_mind(25%)]
Φ_1(E_life, target_body, Alter(life), λ_CON) → wound_reopened
Φ_2(E_info, target_history, Alter(information), λ_auto) → history_overwritten
Φ_3(E_mind, target_psyche, Alter(mind, memory), λ_WIS) → pain_re-experienced
Dependency: Φ_2 and Φ_3 gate on Φ_1 (no wound → no info change → no memory)
NATURAL IMMUNITIES (from type checking):
- Undead: T_x ≠ life → Φ_1 category error → cascade failure
- Constructs: T_x ≠ mind → Φ_3 category error → memory fork fails
- Never-wounded: V_r(wound_history) = 0 → Source Denial
- Magically healed: R_x.passive increased → λ reduced
VALIDATE RESULTS:
Type: PASS (ι_h + ε_n → sympathetic channel → 0D shape → multi-fork)
Conservation: PASS
Paradox: π ≈ 0 (retrospective temporal reference - past is stable)
w: moderate (F_e = 0.70 is the bottleneck - historical extraction is imprecise)
Spell 3: THREAD
Concept: Infrastructure spell that creates a persistent low-impedance channel for future spells.
COMPOSITION: S → H(somatic+verbal+written) → Σ(1D_line) → Φ(Alter(σ_c)) → A(location) → Ξ
TRANSFORM: Alter(space, connectivity) - changes the impedance Ω of space along a
1D path. Does not move, create, or destroy - ALTERS A PROPERTY of the substrate.
MINIMUM VIABLE TRANSFORM: This establishes that Alter(property_of_medium) is a valid
Transform. The spell changes space's transmission characteristics without affecting
any entity or object within that space.
INTERFACE (maximally open for infrastructure):
O_i = {source: 0.0, channel: 0.9, shape: 0.8, transform: 0.7, anchor: 0.3}
incoming: [dispellable, readable, modifiable, stackable]
outgoing: [enhancing - reduces Ω for spells routed through]
NETWORK COMPOSITION: Multiple Threads with compatible anchor points form networks.
Thread_1(A→B) + Thread_2(B→C) + Thread_3(C→D) = network(A→B→C→D)
Network impedance = Σ(Ω_thread_i) < Σ(Ω_ambient_i)
VALIDATE RESULTS:
Type: PASS (ε_a + σ_c throughout)
Conservation: PASS
w: high (simple geometry, stable anchor, no resistance from space)
Spell 4: INVERSION
Concept: Read an active spell through its Interface, dynamically construct an equal-and-opposite Transform, apply for destructive interference cancellation.
COMPOSITION: S(caster + target_spell_energy) → H(matched_to_target) →
Σ(matched_to_target) → Φ(anti-Transform) → Ξ(maximally closed)
SOURCE DUAL RESERVOIR: R = [caster_reserves, target_spell.E_remaining]
Draws partially from the target spell itself (reading it siphons energy).
Requires target_spell.O_i.transform > 0 (CLOSED SPELLS RESIST INVERSION).
DYNAMIC TRANSFORM CONSTRUCTION:
O_inversion = negate(target_spell.Φ.O)
Anti-type payload: P.type = -target_spell.E.type (mathematical negation)
OVERSHOOT BEHAVIOR:
If P.magnitude > target_spell.E.magnitude:
excess = P.magnitude - target_spell.E.magnitude
excess manifests as OPPOSITE of target effect (anti-fire = extreme cold)
If P.magnitude < target_spell.E.magnitude:
partial cancellation - target spell weakened but not destroyed
If P.magnitude ≈ target_spell.E.magnitude:
perfect cancellation - both annihilate, releasing energy as W
VALIDATE RESULTS:
Type: PASS (anti-types are valid types with negative sign)
Conservation: PASS (annihilation releases energy as W)
Warning: "Dynamic Transform construction. Validate at runtime, not compile time."
w: depends entirely on reading accuracy (bounded by target_spell.O_i)
Spell 5: GRAFT
Concept: Transplant an existing spell's Anchor from one medium to another.
COMPOSITION: S → H(somatic+verbal+material_bridge) →
Σ(relational_reconnection) → Φ(Move(ω_e/ω_w/ω_c, σ_c)) → Ξ
TRANSFORM: Move(magic + space_connectivity) - the anchor connection is a relationship
between a change record and a medium. Graft MOVES this relationship.
TRANSFER WINDOW: During casting, the target spell's anchor is in transit.
The spell is unmoored. δ_decay spikes. Any disruption during this window
destroys the target spell.
BINDING STRENGTH PARADOX: High binding_strength (good enchantment) = hard to Graft.
Master enchanters building portable enchantments deliberately use moderate
binding_strength - trading stability for transferability.
COMPATIBILITY REQUIREMENT: new_medium must be type-compatible with Δ.type.
Grafting fire enchantment: ruby(1.0) > steel(0.6) > wood(0.2) > ice(0.0)
VALIDATE RESULTS:
Type: PASS (ω + σ_c - magic targeting with spatial reconnection)
Conservation: PASS
Warning: "Transfer window vulnerability. Interruption risk during [cast_time]."
w: varies with binding_strength of target and compatibility of new medium
Spell 6: PARADOX MIRROR (Self-Modifying Magic)
Concept: A spell that uses its own Interface to read its own structure, then modifies its own Transform based on what it observes about itself. Self-referential magic.
COMPOSITION: S → H → Σ → Φ → Ξ(self-reading) → Φ_modified → A
The spell casts normally through S → H → Σ → Φ_initial, producing an initial
effect. Then its OWN Interface reads its own Transform result. Based on the
reading, the spell MODIFIES ITS OWN TRANSFORM and re-executes.
SELF-REFERENCE MECHANISM:
Ξ.O_i.transform must be > 0 (the spell must be open to ITSELF)
The Interface reads Δ_initial (the first Transform's change record).
A Condition evaluates Δ_initial:
IF Δ_initial.magnitude < threshold:
Modify O.intensity upward (boost itself)
IF Δ_initial.magnitude > threshold:
Modify O.intensity downward (throttle itself)
IF Δ_initial.type != intended_type:
Modify O.domain (adapt to what actually happened)
The modified Transform re-executes with updated parameters.
THIS IS A FEEDBACK LOOP, NOT RECURSION:
The spell doesn't invoke itself again. It modifies its own active
Transform within a single casting. The loop is:
Φ → Δ → Ξ_read → Γ_evaluate → Φ_modify → Δ' → (optional: loop again)
TERMINATION: Γ with termination condition:
"Loop terminates when |Δ_n - Δ_{n-1}| < convergence_threshold"
OR "Loop terminates after max_iterations"
OR "Loop terminates when total energy consumed > budget"
PRACTICAL EFFECT: The spell self-calibrates. It fires, observes its own
impact, adjusts, fires again. Like a guided missile that adjusts trajectory.
A healing spell version: Heal → observe healing effectiveness on this
specific patient → adjust healing modality → heal again with better
parameters → converge on optimal treatment.
VALIDATE RESULTS:
Type: PASS (self-reference via ω_str is valid)
Conservation: PASS (each loop iteration costs energy; total cost = iterations × cost_per_loop)
Paradox: π = 0 (self-reference is concurrent, not temporal)
Warning: "Self-modifying composition. Validate termination condition."
Warning: "Maximum iterations: [budget / cost_per_loop]."
w: high for initial cast, degrades per iteration (accumulated waste reduces precision)
Spell 7: CASCADE (Recursive Casting)
Concept: A spell that, upon successful Transform, creates a diminished copy of itself targeting the next entity in a chain. Recursive self-invocation with mandatory diminishment.
COMPOSITION:
S → H → Σ → Φ → Γ(if Φ succeeded AND resources remain: invoke CASCADE again) → A → Ξ
RECURSIVE STRUCTURE:
CASCADE_depth_0:
S(κ = κ_base) → H → Σ → Φ(target_0) → Δ_0
IF Δ_0.magnitude > threshold AND V_r > κ_base × diminishment_factor:
CASCADE_depth_1:
S(κ = κ_base × 0.7) → H → Σ → Φ(target_1) → Δ_1
IF Δ_1.magnitude > threshold AND V_r > ...:
CASCADE_depth_2:
S(κ = κ_base × 0.7²) → ...
MANDATORY DIMINISHMENT: Each recursion reduces κ by diminishment_factor (0.7 default).
This guarantees termination even without explicit conditions because:
At depth d: κ_d = κ_base × diminishment_factor^d
When κ_d < minimum_viable_κ: the spell can't source enough energy for
a viable Transform, and the recursion terminates via Shaping Exhaustion.
Maximum depth ≈ log(κ_base / minimum_viable_κ) / log(1 / diminishment_factor)
For κ_base = 100, minimum = 1, factor = 0.7:
max_depth ≈ log(100) / log(1.43) ≈ 12.9 → 12 bounces
TARGETING RULE: Each recursion must target a DIFFERENT entity (filter condition
prevents re-targeting). This is chain lightning generalized to any Transform type.
A cascade HEAL: heals primary target, then heals nearest wounded ally at 70%,
then next at 49%, etc. A cascade CHARM: charms primary, then attempts charm on
nearest unchamed at 70% efficacy, etc.
VALIDATE RESULTS:
Type: PASS (same type at every recursion depth)
Conservation: PASS (each depth draws from same reservoir, total = geometric series)
Recursion: VALIDATED (diminishment guarantees termination)
w: decreases per depth (accumulated waste, reduced κ)
Total cost: κ_base × (1 + 0.7 + 0.49 + 0.343 + ...) = κ_base × (1 / (1 - 0.7)) = κ_base × 3.33
Spell 8: RETROGRADE (Pure Time Magic)
Concept: A spell that operates entirely in τ (time). It doesn't move matter, create energy, or alter minds. It rewinds a localized region of time by a few seconds.
COMPOSITION: S(ε_a, massive) → H(written_sigil + verbal) → Σ(3D_volume, SMALL) →
Φ(Alter(τ_f + τ_s)) → A(location, brief) → Ξ
SOURCE: ε_a at ENORMOUS κ. Time magic is expensive because:
- ε_a → τ conversion efficiency = 0.3 (from conversion table)
- The type conversion happens implicitly at the Transform boundary
- Effective payload for time manipulation = κ × 0.3
- Plus paradox tax: π = seconds_rewound × causal_coupling
- 6 seconds rewound with moderate coupling (π ≈ 2): κ_effective = κ × 7.39
SHAPE: 3D volume but SMALL - perhaps a 5-foot cube. Time manipulation across
large volumes is prohibitively expensive because:
- Shape cost scales with volume
- Time(τ) resists 3D geometry (from compatibility table)
- w(G_compatibility) is low → shaping waste is high
Making the volume small is a design necessity, not an arbitrary limitation.
TRANSFORM:
Alter(τ_f): local time flow reversed for target duration
Alter(τ_s): local event sequence reversed
Everything within the 5-foot cube experiences the last 6 seconds in reverse.
Broken objects reassemble. Wounds close. Fallen creatures stand.
BUT: only within the cube. The rest of reality has moved forward.
At the boundary: DISCONTINUITY. Inside-time and outside-time are desynchronized
by 6 seconds. This creates a τ_c (causality) disturbance at the boundary that
manifests as intense sensory disorientation for anything crossing the boundary
during the effect.
ANCHOR: Location, brief (the temporal rewind is maintained for only the
duration of the "replay" - 6 seconds of reversed time playing out over
6 seconds of forward time, then the region rejoins normal temporal flow.
The anchor doesn't need to persist beyond this - once the rewind completes,
the new state is the state.
VALIDATE RESULTS:
Type: WARNING - "Type conversion ε_a → τ required. η = 0.3. 70% energy lost in conversion."
Conservation: PASS (energy is consumed in conversion waste, not violated)
Paradox: π ≈ 2.0 (6 seconds × moderate coupling). Tax: ×7.39.
Total cost: (κ / 0.3) × 7.39 = κ × 24.6
- "6 seconds of localized time reversal costs ~25× what an equivalent
energy-domain spell would cost. This is consistent with Time being
the most expensive domain to manipulate."
Warning: "Boundary discontinuity at shape edge. Causality disturbance zone."
w: low (poor type compatibility + high paradox tax + resistant geometry)
Spell 9: RELAY (Thread Network Chaining)
Concept: A spell designed to be routed through an existing Thread network, using the network's reduced impedance to achieve effects at distances that would normally be impossible.
COMPOSITION: S → H(via_Thread_network) → Σ → Φ → A → Ξ
CHANNEL MODIFICATION:
Instead of: H(M_c = standard_channel, Ω = Ω_ambient, d = actual_distance)
Relay uses: H(M_c = Thread_network, Ω = Ω_thread, d = network_path_length)
Where Ω_thread << Ω_ambient (the whole point of Thread infrastructure).
For a Thread network spanning 100 miles with Ω_thread = 0.05:
Standard channel at 100 miles: F_h = e^(-100 × 0.5) ≈ 0 (nothing arrives)
Thread channel at 100 miles: F_h = e^(-100 × 0.05) ≈ 0.007 (still small)
Stacked 5-thread bundle: F_h = e^(-100 × 0.05 / 5) ≈ 0.37 (viable!)
Thread stacking is how magical civilization scales. Individual threads have
limited range. Bundled thread networks carry spells across continents.
REQUIREMENTS:
- Thread network must exist between caster and target
- Relay's Ξ must be compatible with Thread's incoming protocol (it is - Thread
accepts any standard_arcane spell)
- Thread's outgoing (enhancing) applies: Ω reduction benefits the Relay
Relay's Source and Transform are STANDARD - nothing special about the spell
itself. The innovation is entirely in Channel routing.
RELAY + ECHO WOUND EXAMPLE:
A war-mage connected to a thread network spanning the kingdom can cast
Echo Wound on a target 500 miles away - IF they have a sympathetic key
AND the thread network reaches the target's location.
The sympathetic channel (for the wound-history link) is SUPPLEMENTED by
the thread network (for the energy transmission). Multi-channel: the
sympathetic link provides the targeting (low Ω for ψ/ι, high Ω for ε),
while the thread provides the power delivery (low Ω for ε_a).
VALIDATE RESULTS:
Type: PASS (standard spell + Thread as enhanced channel)
Conservation: PASS
w: HIGHER than without Thread (improved channel = higher w(H) = higher w(spell))
Note: "Relay demonstrates that infrastructure investment improves all spells
routed through it. Thread is a force multiplier."
Spell 10: SEVERANCE (Void-Type Boundary Test)
Concept: A spell that attempts to produce ∅ (void) - true absence - at a localized point. Tests the Conservation axiom's boundary.
COMPOSITION: S(ε_a + ε_n, massive) → H(written_sigil) → Σ(0D_point) →
Φ(Destroy(ALL_types_at_point)) → A(none) → Ξ(closed)
THE THEORETICAL PROBLEM:
Conservation says: input + cost = output + waste + loss
Destroy normally converts target into ε_n + ε_a (energy released from destruction)
Severance attempts to Destroy so completely that even the released energy
is destroyed. Destroy(matter) → energy. Destroy(energy) → ???
Under Conservation: Destroy(energy) must produce SOMETHING. Energy cannot
become nothing. The equation demands output + waste ≠ 0.
WHAT ACTUALLY HAPPENS (three possible models):
MODEL A - Conservation Holds Absolutely:
Severance is impossible as specified. Attempting to destroy energy below the
"energy floor" causes the Transform to produce failure token F.
The massive input energy disperses as waste (catastrophic W_φ).
In practice: the spell detonates. All that input energy, shaped to a point,
with nowhere productive to go, releases as omnidirectional energy blast.
"I tried to create nothing and got an explosion instead."
w(Φ) = 0 (category error: Destroy(∅) is undefined)
This is the CONSERVATIVE model and the default in this framework.
MODEL B - Conservation Holds Locally, Breaks Globally:
Severance creates a localized void - a point where the normal conservation
rules are suspended. Energy that enters the void DOES become ∅.
But the void itself is not stable. Reality "heals" the void by rushing
in to fill it (like air filling a vacuum), creating an implosion.
The void exists for an infinitesimal duration, then collapses.
The collapse releases energy equal to what was consumed to create it
(Conservation reasserts at the macro scale).
Net effect: Input energy → momentary void → collapse → energy release
Equivalent to a very expensive way to create a localized implosion.
Conservation is preserved in the total accounting.
MODEL C - Conservation Violable by Deity-Level Action:
Severance works as intended but requires energy from outside the system
(divine intervention, extraplanar source that operates under different
axioms). The void is stable because an external system is absorbing the
conservation debt.
This is the "miracles are real" model. The framework's axioms describe
natural magic. Supernatural agents can violate axioms because they
operate on higher-order axiom sets that subsume ours.
Within the framework: Severance(mortal) = Model A (impossible/explosion).
Severance(divine) = Model C (requires axiom-violating Source).
VALIDATE RESULTS:
Model A (default):
Type: ERROR - "Destroy(∅) is undefined. Cannot produce void output."
Conservation: VIOLATION - "Output = ∅ violates Axiom 3."
Result: INVALID composition. Spell cannot be cast as specified.
Suggestion: "Reduce to Destroy(matter_at_point) for maximum-efficiency
disintegration without attempting void creation."
Model B:
Type: WARNING - "Void creation is transient. Net effect = implosion."
Conservation: PASS (macro-level conservation preserved)
Result: VALID but extremely expensive implosion spell.
w: very low (fighting conservation boundary)
Model C:
Type: PASS (external axiom-set)
Conservation: PASS (external system absorbs debt)
Result: VALID only with deity-level Source. Not mortal-castable.
10. Framework Stress Results and Open Questions
What Held Through All 10 Novel Spells
-
The seven primitives suffice. No new primitives were needed. Every novel spell decomposes into the existing seven, including meta-magical spells that target other spells.
-
The type system catches real constraints. Channel impedance explains component choices. Shape compatibility explains why time magic is expensive. The Magic (ω) type formalizes counter-spelling, dispelling, and meta-magic as type-valid operations.
-
Semantic weighting produces meaningful predictions. Low-w spells have wide variance bands. High-w spells are precise. The multiplicative model means any single critical failure zeros the entire spell.
-
Conservation holds as the fundamental boundary. Severance confirmed that the axiom serves as the framework's hard limit. You can push against it (Debt defers it, Inversion works around it, Retrograde pays enormous premiums) but you can't break it without stepping outside the system entirely.
-
Flexible primitive ordering works. Anchor-first, source-from-anchor, and self-referencing compositions all validate correctly under the ordering rules. The canonical pipeline is a default, not a requirement.
-
The VALIDATE algorithm catches errors at design time. Type mismatches, conservation violations, unbounded recursions, and missing termination conditions are all identified before casting.
Open Questions for Future Work
-
Multi-caster compositions: How do multiple casters' Sources merge? Does each caster contribute their own semantic weight, or is there a group w function? How do conflicting Interface settings resolve when two casters work on the same spell?
-
Spell evolution: Can a persisted spell's composition CHANGE over time without external modification? If a ward's Source environment changes (ley line shifts), does the ward adapt or fail? Is there a natural selection analog for magical effects?
-
Magical ecology: In a world with pervasive magic, spells interact with each other constantly. Is there an equilibrium state? Do magical "ecosystems" form where certain spell types naturally coexist and others naturally conflict?
-
Notation system: The framework now knows WHAT to encode. The next step is building a symbol system that carries structural meaning - where reading a spell's notation tells you its composition, not just its label. The Gorilla of Destiny's polygon-binary system could be repurposed: vertices as primitives, edges as data flows, binary encoding for sub-component parameters.
-
Computational implementation: The VALIDATE algorithm is specified in pseudo-code.A working implementation would allow automated spell design, optimization, and balance testing. This is achievable - the type system is formal enough for a type checker, and the semantic weights are computable.
-
Cross-tradition compatibility: Different magical traditions (arcane, divine, primal,psionic) may use different default Source types, Channel types, and Interface protocols.Can the framework model tradition-specific constraints as configuration rather than separate systems?
Appendix A: Complete Type Tables
A.1 Channel Impedance (Ω) - Full Matrix
ε_t ε_k ε_e ε_r ε_n ε_v ε_g ε_a ψ_c ψ_e ψ_m ψ_w ψ_p ψ_i
Somatic 0.3 0.1 0.4 0.5 0.6 0.3 0.4 0.2 0.4 0.5 0.6 0.3 0.4 0.7
Verbal 0.5 0.6 0.4 0.3 0.4 0.4 0.7 0.2 0.1 0.1 0.3 0.2 0.3 0.2
Material var var var var var var var 0.3 0.7 0.7 0.5 0.7 0.6 0.4
Written 0.4 0.6 0.3 0.4 0.3 0.5 0.5 0.1 0.5 0.5 0.3 0.5 0.5 0.2
Visual 0.6 0.7 0.5 0.1 0.7 0.7 0.5 0.3 0.3 0.4 0.6 0.4 0.1 0.5
Sympathetic 0.8 0.9 0.7 0.7 0.3 0.2 0.8 0.5 0.1 0.1 0.1 0.2 0.3 0.05
Contractual 0.7 0.8 0.7 0.6 0.4 0.3 0.7 0.4 0.2 0.2 0.3 0.1 0.4 0.1
σ_d σ_dir σ_c σ_v σ_b τ_f τ_s τ_d τ_c ι_p ι_s ι_n ι_h ι_prob
Somatic 0.3 0.2 0.4 0.3 0.4 0.8 0.8 0.7 0.9 0.7 0.8 0.7 0.8 0.7
Verbal 0.5 0.4 0.5 0.5 0.5 0.6 0.5 0.6 0.7 0.2 0.3 0.1 0.4 0.4
Material 0.5 0.5 0.4 0.5 0.3 0.7 0.7 0.6 0.7 0.5 0.4 0.3 0.3 0.5
Written 0.2 0.3 0.2 0.3 0.2 0.3 0.3 0.2 0.4 0.1 0.2 0.1 0.1 0.3
Visual 0.1 0.1 0.3 0.2 0.3 0.8 0.8 0.8 0.9 0.3 0.5 0.5 0.6 0.5
Sympathetic 0.6 0.7 0.3 0.7 0.6 0.5 0.5 0.5 0.3 0.1 0.1 0.05 0.1 0.2
Contractual 0.5 0.6 0.4 0.6 0.5 0.4 0.4 0.3 0.2 0.2 0.2 0.1 0.3 0.1
μ_s μ_l μ_g μ_p μ_o μ_m μ_x ω_a ω_e ω_w ω_c ω_f ω_sig ω_str
Somatic 0.9 0.9 0.9 0.8 0.8 0.9 0.7 0.4 0.5 0.6 0.7 0.5 0.8 0.7
Verbal 0.8 0.8 0.8 0.8 0.8 0.9 0.7 0.3 0.4 0.3 0.3 0.4 0.5 0.3
Material var var var var var var var 0.5 0.2 0.3 0.4 0.6 0.3 0.4
Written 0.7 0.8 0.8 0.8 0.8 0.7 0.6 0.2 0.1 0.1 0.2 0.3 0.1 0.1
Visual 0.9 0.9 0.9 0.7 0.9 0.9 0.8 0.3 0.4 0.3 0.5 0.2 0.6 0.4
Sympathetic 0.8 0.9 0.9 0.9 0.7 0.8 0.5 0.2 0.3 0.4 0.1 0.5 0.1 0.2
Contractual 0.9 0.9 0.9 0.9 0.9 0.9 0.8 0.3 0.4 0.3 0.1 0.4 0.3 0.3
A.2 Conversion Efficiency (η) - Full Matrix
(FROM row → TO column)
ε_t ε_k ε_e ε_r ε_n ε_v ε_g ε_a ψ σ τ ι μ ω ∅
ε_t 1.0 0.7 0.5 0.6 0.4 0.1 0.3 0.8 0.0 0.0 0.0 0.0 0.1 0.1 -
ε_k 0.7 1.0 0.4 0.3 0.3 0.1 0.5 0.8 0.0 0.1 0.0 0.0 0.1 0.1 -
ε_e 0.5 0.4 1.0 0.6 0.3 0.1 0.2 0.8 0.1 0.0 0.0 0.0 0.0 0.1 -
ε_r 0.6 0.3 0.6 1.0 0.2 0.3 0.2 0.8 0.1 0.1 0.0 0.1 0.0 0.2 -
ε_n 0.2 0.1 0.1 0.1 1.0 0.0 0.1 0.6 0.2 0.1 0.1 0.1 0.0 0.3 -
ε_v 0.1 0.1 0.1 0.3 0.0 1.0 0.1 0.7 0.3 0.0 0.0 0.1 0.2 0.2 -
ε_g 0.3 0.5 0.2 0.2 0.1 0.1 1.0 0.7 0.0 0.4 0.1 0.0 0.1 0.1 -
ε_a 0.9 0.9 0.9 0.9 0.7 0.7 0.8 1.0 0.5 0.4 0.3 0.5 0.3 0.6 -
ψ 0.0 0.0 0.0 0.1 0.3 0.2 0.0 0.4 1.0 0.1 0.1 0.6 0.0 0.4 -
σ 0.0 0.1 0.0 0.1 0.1 0.0 0.4 0.5 0.1 1.0 0.3 0.2 0.0 0.3 -
τ 0.0 0.0 0.0 0.0 0.2 0.0 0.1 0.3 0.1 0.3 1.0 0.2 0.0 0.2 -
ι 0.0 0.0 0.0 0.1 0.1 0.1 0.0 0.5 0.5 0.2 0.2 1.0 0.0 0.5 -
μ 0.3 0.2 0.1 0.1 0.2 0.3 0.2 0.5 0.0 0.0 0.0 0.0 1.0 0.1 -
ω 0.1 0.1 0.1 0.1 0.2 0.1 0.1 0.7 0.3 0.2 0.1 0.6 0.0 1.0 -
∅ - - - - - - - - - - - - - - -
NOTE: ∅ (void) has no conversion paths. Nothing converts to void (Conservation).
Nothing converts from void (void contains nothing to convert). The ∅ row
and column are all "-" (operation undefined, not zero).
Appendix B: Glossary
- ε (epsilon, lowercase): Variance band. Not to be confused with ε (Energy type).Context disambiguates: ε as a property of a spell = variance. ε with subscript = energy type.
- η (eta): Conversion efficiency [0.0, 1.0]
- κ (kappa): Capacity requested from Source
- λ (lambda): Transform efficacy [0.0, 1.0]
- Ω (Omega): Channel impedance [0.0, ∞)
- π (pi): Paradox index [0, ∞)
- ρ (rho): Reservoir density
- σ (sigma): Stability (reservoir or general)
- τ (tau): Time type
- Φ (Phi): Transform primitive
- Σ (Sigma): Shape primitive
- Γ (Gamma): Condition primitive
- Ξ (Xi): Interface primitive
- Ψ (Psi): Generic operation (input to Condition)
- ω (omega): Magic type
- δ (delta, lowercase): Rate of change (δ_decay, δR)
- Δ (Delta): Change record (Transform output)
- w: Semantic weight [0.0, 1.0]
- F: Failure token (output of failed operations)
- S, H, A: Source, Channel (H for historical reasons - C was taken), Anchor
- P, P': Payload, Transmitted Payload
- E: Effect Field
- X, X': Target State, Transformed State