cargo
Rust package manager (36 subcommands).
louisville-quantum-gravity
Louisville/Liouville quantum gravity measure for KPZ stationary measures. Open boundary conditions, phase diagrams, and analytic continuation for infinite-dimensional measures.
Full skill instructions
Status: ✅ Production Ready Trit: +1 (PLUS - generative/measures) Color: #9370DB (Medium Purple) Principle: Stationary measures for KPZ via quantum gravity Frame: Derivative measures, open boundary conditions, phase diagrams
Louisville/Liouville Quantum Gravity (LQG) provides the stationary measures for the KPZ equation. This skill covers:
The KPZ equation with open boundary conditions:
∂h/∂t = ν∂²h/∂x² + (λ/2)(∂h/∂x)² + √D ξ(x,t)
Boundary conditions:
∂h/∂x|_{x=0} = U (left boundary slope)
∂h/∂x|_{x=L} = V (right boundary slope)
The height h(x,t) is too rough for direct analysis:
Solution: Work with increments or derivatives where measures are well-defined.
For increments ∂h/∂x, the stationary measure has the form:
μ_stationary ∝ exp(-∫ V(∂h/∂x) dx) × Louisville-QG-correction
Where:
V = potential depending on slope
LQG correction = quantum gravity measure (Gaussian free field + exponential)
# Louisville quantum gravity measure on the line
struct LouisvilleMeasure
γ::Float64 # Coupling constant
Q::Float64 # Background charge (Q = 2/γ + γ/2)
gff::GaussianFreeField
end
function sample(lqg::LouisvilleMeasure, domain)
# Sample GFF
φ = sample(lqg.gff, domain)
# Exponential to get LQG area measure
μ = exp(lqg.γ * φ - (lqg.γ^2/2) * 𝔼[φ²])
return μ
end
The parameters U, V (boundary slopes) create a phase diagram:
V
↑
│ MAXIMAL CURRENT
│ (fan phase)
----┼---------→
│
│ LOW DENSITY HIGH DENSITY
│ (shock left) (shock right)
└───────────────────────→ U
# Height function long-time limit depends on phase
function long_time_limit(h, U, V)
if in_maximal_current_phase(U, V)
# Height grows linearly in t
return (:linear, slope = 1/4)
elseif in_low_density_phase(U, V)
return (:linear, slope = U^2/4)
else
return (:linear, slope = V^2/4)
end
end
The stationary measure has a two-layer structure:
Layer 1: Uncolored paths (non-crossing)
Layer 2: Coloring (Pitman transform)
Joint measure: μ = μ_uncolored × μ_color|uncolored
# Matrix product representation of stationary measure
function matrix_product_ansatz(n_sites)
# Boundary vectors
⟨W| = left_boundary_vector(U)
|V⟩ = right_boundary_vector(V)
# Transfer matrices
D = creation_operator()
E = annihilation_operator()
# Stationary weight
weight(config) = ⟨W| * prod(D if c == 1 else E for c in config) * |V⟩
return StatMeasure(weight)
end
Geometric LPP replicates KPZ stationary structure in discrete setting:
struct GeometricLPP
n::Int # Grid size
weights::Matrix{Float64} # Exponential(1) weights
end
function passage_time(lpp::GeometricLPP, start, finish)
# G(m,n) = max over up-right paths of ∑ weights
return dynamic_programming_max_path(lpp.weights, start, finish)
end
# Stationary measure on LPP
function stationary_lpp(n, boundary_params)
# Two-layer structure matches KPZ
lpp = GeometricLPP(n, rand(Exponential(1), n, n))
return sample_with_boundary(lpp, boundary_params)
end
Problem: Extending finite-dimensional formulas to infinite dimensions.
# Finite dimensional: well-defined
μ_n(h₁, ..., hₙ) = exp(-S(h)) / Z_n
# Infinite dimensional: requires care
μ_∞(h(x)) = "limit" of μ_n # Needs regularization
# Techniques:
# 1. Cylinder set extension
# 2. Prokhorov tightness
# 3. Kolmogorov consistency
function analytic_continuation(finite_measure, regularization)
# Step 1: Verify Kolmogorov consistency
@assert kolmogorov_consistent(finite_measure)
# Step 2: Check tightness
@assert prokhorov_tight(finite_measure)
# Step 3: Extend via inverse limit
return inverse_limit(finite_measure)
end
The Fokker-Planck equation for KPZ has Louisville stationary measure:
using FokkerPlanck, LouisvilleQG
# Fokker-Planck with Louisville stationary
fp = FokkerPlanckKPZ(
boundary_U = U,
boundary_V = V,
temperature = T
)
# Verify Louisville is stationary
lqg = LouisvilleMeasure(γ = sqrt(T))
@test is_stationary(lqg, fp)
# Convergence rate
τ_mix = mixing_time(fp, lqg)
Louisville measure is the equilibrium of KPZ Langevin dynamics:
using Langevin, LouisvilleQG
# KPZ as Langevin SDE
kpz_langevin = LangevinKPZ(
drift = kpz_drift,
diffusion = sqrt(2*T),
boundary = (U, V)
)
# Equilibrium = Louisville
@test equilibrium(kpz_langevin) ≈ LouisvilleMeasure(sqrt(T))
| Trit | Skill | Role |
|---|---|---|
| -1 | yang-baxter-integrability | Structure |
| 0 | kpz-universality | Dynamics |
| +1 | louisville-quantum-gravity | Measures |
Conservation: (-1) + (0) + (+1) = 0 ✓
# Sample Louisville measure
just lqg-sample gamma=0.5 domain=circle
# Compute stationary measure for KPZ
just lqg-stationary U=0.3 V=0.5
# Phase diagram
just lqg-phase-diagram
# Verify analytic continuation
just lqg-verify-continuation n_max=100
# louisville-quantum-gravity.yaml
measure:
gamma: 0.5 # LQG coupling
Q: 2.5 # Background charge
boundary:
U: 0.3 # Left slope
V: 0.5 # Right slope
regularization:
method: cylinder_sets
tightness_check: true
Skill Name: louisville-quantum-gravity Type: Probability Measures Trit: +1 (PLUS) Key Property: Stationary measures for KPZ Status: ✅ Production Ready
Trit: +1 (PLUS)
Home: Measures
Poly Op: ⊗
Kan Role: Lan_K
Color: #9370DB
μ: Configurations → ℝ₊
Louisville measure is covariant under conformal maps (quantum gravity).
(-1) + (0) + (+1) ≡ 0 (mod 3)
The measure settles. The boundary shapes the bulk. Quantum gravity meets KPZ.
Every use of this skill is an opportunity for worlding:
Add Interaction Exemplars here as the skill is used.
Rust package manager (36 subcommands).
Translate Figma nodes into production-ready code with 1:1 visual fidelity using the Figma MCP workflow (design context, screenshots, assets, and project-convention translation). Trigger when the user provides Figma URLs or node IDs, or asks to implement designs or components that must match Figma...
**Status**: 🌳 Production Ready (upstream in StringZilla v3+) **Type**: High-Performance String Operations / SIMD-Accelerated Text Processing **Principle**: Zero-copy views, SIMD/SWAR acceleration, deterministic hashing **Frame**: Cross-language interoperability (C, C++, Python, Rust, Go, Swift, ...
Conformal Geometric Algebra (CGA) for circles, spheres, and Möbius transformations
Verifies code implements exactly what documentation specifies for blockchain audits. Use when comparing code against whitepapers, finding gaps between specs and implementation, or performing compliance checks for protocol implementations.
Systems programming and performance optimization using Zig. Provides low-level abstractions, memory-safe compiled code, and performance benchmarking. Use for system-level operations, optimization, and interoperability with C/POSIX APIs.
Topological soliton detection and agency bridge with anyonic fusion algebra for concept composition
PayPal MCP server integration for invoices, payments, subscriptions, disputes, and transaction reporting via @paypal/mcp.
Unison language - content-addressed functional programming with abilities for effects, distributed computing, and structural types. Use for pure functional code, effect management, distributed systems, and refactoring-safe codebases.
Google Tasks management via TasksACSet. Transforms task operations into GF(3)-typed Interactions, routes to triadic queues, detects saturation for task-zero-as-condensed-state.
World C Skill
Syrup binary serialization for OCapN/CapTP wire format. Canonical encoding for capability messages.
Generate, edit, and beat-sync AI video with leading models in one workspace.
The world's fastest calendar for remote work
Transform Your Design with AI Designer by ImgCreator.ai
Revolutionizing Video Production with AI-Powered Creativity
Extend an image past the frame and let AI fill the new aspect ratio.
Discover your celebrity doppelgänger with StarByFace!
ChainClarity explains 700+ crypto whitepapers in plain English, with layered summaries, comparisons, research tools, alerts, and a $4.99 Pro plan.
Opus.ai: Revolutionize Your Web Experience