Generated runtime catalog

Source-derived system capabilities, internal IR functions, methods, semantic types, traits, and sandbox groups.

Note

This page is generated from the current RiX implementation by documentation/scripts/generate-reference.js. Do not edit it by hand. Descriptions come from registry documentation strings; the narrative syntax guide and methods guide provide signatures and examples.

At this revision RiX exposes 354 named entries on the default system context and registers 286 internal IR operations. Aliases with different spelling are listed separately because they are separately addressable names.

Public system context

These names are available through the leading-dot system object, such as .Len(value). Uppercase names are also used by explicit system/operator forms where applicable.

Name	Kind	Capability groups	Implementation description
.ABS	function	—	Absolute value
.ADD	function	Arith	Addition or string concatenation
.AFFINEBOXRANGE	function	—	Certify a rational-box range with correlation-preserving affine arithmetic
.ALGEBRA	value	—	Algebra presentation helpers
.ALL	lazy function	—	Every: returns last element if predicate is truthy for ALL elements, null on first failure — callback receives (val, locator, src)
.AND	lazy function	Logic	Logical AND (short-circuits on first falsy, returns deciding value)
.ANY	lazy function	—	Any: returns first item that passed predicate, null if none pass — callback receives (val, locator, src)
.ARRAY	lazy function	—	Create an array/sequence (supports sequence generators)
.ASSET	function	—	Create a portable asset reference
.ASSIGN	lazy function	—	Alias/rebind — lhs shares the same Cell as rhs variable, or gets a fresh Cell for expressions
.ASSIGNCOPY	lazy function	—	Fresh copied-cell assignment (:=) — shallow-copy value + all meta into new binding
.ASSIGNDEEPCOPY	lazy function	—	Fresh deep-copied-cell assignment (::=) — deep-copy value + all meta into new binding
.ASSIGNDEEPUPDATE	lazy function	—	In-place deep value replacement (=) — like ~= but deep-copies rhs value
.ASSIGNUPDATE	lazy function	—	In-place value replacement (~=) — preserves cell identity, ordinary meta; replaces ephemeral; preserves sticky unless rhs overrides
.AUDIO	function	—	Create a portable audio asset
.BIND	lazy function	Output	Capture a live Binding to a RiX variable
.BLOCK	lazy function	—	Sequential block execution, returns last value
.BOXRESUME	function	—	Replay and extend a retained deterministic box subdivision queue
.BOXSUBDIVIDE	function	—	Classify a bounded complete cover with deterministic exact box subdivision
.CALCULUSDERIVATIVECHECK	function	—	Independently recompute and check a primitive Calculus derivative transformation
.CALCULUSDERIVATIVEPROOF	function	—	Build and independently check a first-derivative proof record without trusted leaves
.CALCULUSDERIVATIVESIGN	function	—	Certify a uniform derivative sign for a checked primitive Calculus transformation
.CALCULUSGRAPHREWRITE	function	—	Create and independently check a theorem-named Calculus graph rewrite
.CALCULUSGRAPHREWRITECHECK	function	—	Check a Calculus graph rewrite theorem and retained domain obligations
.CALCULUSGRAPHSIMPLIFICATIONCHECK	function	—	Independently recompute a canonical Calculus graph simplification
.CALCULUSGRAPHSIMPLIFY	function	—	Apply and check the canonical domain-preserving Calculus graph simplifier
.CALCULUSLIPSCHITZRANGE	function	—	Certify a range by midpoint values and bounded first derivatives
.CALCULUSRANGE	function	—	Evaluate a supported immutable Calculus graph over exact rational ranges
.CALCULUSRANGECHECK	function	—	Return the checker record attached to a Calculus graph-range result
.CALCULUSRANGERECOGNIZE	function	—	Recognize an exact polynomial or source-domain-preserving rational graph
.CALCULUSTAYLORRANGE	function	—	Certify a first-order midpoint Taylor range with second-derivative remainder
.CALLOUT	function	—	Create a semantic document callout
.CAPABILITYREGISTER	function	—	Register a package system capability during trusted package startup
.CASE	lazy function	—	Ordered case expression with condition arms, prepared-trial arms, and an optional fallback
.CERTIFIEDAPPROXIMATION	function	—	Construct a certified approximate scalar from an exact candidate and rational enclosure
.CHUNK	lazy function	—	Chunk a collection into subarrays by size or boundary predicate
.CODE	function	—	Create literal inline code
.CODEBLOCK	function	—	Create a literal source-code block
.COMPLEX	value	Exact	Exact complex-number operations
.CONCAT	function	—	Core operation CONCAT
.CONFIG	value	—	Session-scoped RiX configuration, including numeric input and display
.CONTROLPANEL	function	Output, Controls	Group reactive controls in a portable output panel
.CONTROLS	value	—	Reactive control constructors
.CONVERTUNIT	function	Units	Convert a quantity to a compatible display unit
.CORE	function	—	Core capability registration and discovery
.DEBUG	lazy function	—	Debug expression: .Debug(label, expr) — returns expr value, records AST/source
.DEEPMUTABLE	function	—	Recursively set (flag≠_) or remove (flag=_) ._mutable on all nested arrays/maps/tensors. Called via .DeepMutable(value, flag).
.DEFINE	lazy function	—	Define a named function from a name, .Params descriptor, and body
.DEFINEEXACTGENERATOR	function	Exact	Create an algebraic exact generator from low-to-high polynomial coefficients
.DEFINEUNIT	function	Units	Create a linear Unit value from a name and Unit/Quantity definition
.DERIV	function	Symbolic	Differentiate a symbolic spec or spec-backed function exactly
.DIFFERENCE	function	—	Core operation SET_DIFF
.DISJOINT	function	—	Check if two collections are disjoint (1 if true, null otherwise)
.DIV	function	Arith	Division
.DIVMOD	function	Arith	Floor quotient and exact remainder for a positive divisor
.DIVROUND	function	—	Rounded division
.DIVUP	function	—	Ceiling division
.DOCUMENT_TEMPLATE	lazy function	—	Create a Fragment from an @““” document template
.DOUBLEFACTORIAL	function	Arith	Double factorial of a non-negative integer
.DUMP	lazy function	—	Dump expression value: .Dump(label, expr) — returns expr value
.EMPHASIS	function	—	Create semantic inline emphasis
.EQ	function	Logic	Equality check — returns 1 or null
.EQUAL	function	—	Equality check — returns 1 or null
.ERROR	function	—	Emit an error event and abort: .Error(label, dataMap ?= {=})
.EVAL	lazy function	—	Evaluate a deferred AST node or expression: .Eval(ast, bindings ?= _, mode ?= :inherit)
.EXACT	value	Exact	Canonical RiX exact-generator collection
.EXPRESSIONAPPLY	function	—	Construct a mathematical function application
.EXPRESSIONCONSTANT	function	—	Construct a mathematical constant from a supported core scalar provider
.EXPRESSIONCONSTANTINFO	function	—	Inspect core constant denotation and algebraic laws without refinement
.EXPRESSIONDEFINITION	function	—	Inspect a symbol’s immutable definition, or null if it has none
.EXPRESSIONEXPAND	function	—	Expand immutable symbol definitions without changing identities or applying general simplification
.EXPRESSIONFROMSPEC	function	—	Export a symbolic specification through the public Calculus expression schema
.EXPRESSIONHASEXTENDEDCONSTANTS	function	—	Recognize constants requiring provider-aware consumers
.EXPRESSIONHASSCOPEDSYMBOLS	function	—	Recognize expressions requiring identity-aware mathematical consumers
.EXPRESSIONKEY	function	—	Identity-aware structural key, not a proof of mathematical inequality
.EXPRESSIONOPERATION	function	—	Construct a validated mathematical arithmetic node
.EXPRESSIONREAL	function	—	Adapt a certified singleton provider with one bounded initial refinement
.EXPRESSIONREFINE	function	—	Explicitly refine an adapted real constant and check its enclosure
.EXPRESSIONVARIABLE	function	—	Construct a mathematical variable expression without loading a plugin
.EXPRESSIONVARIABLEMATCHES	function	—	Compare variable identities without conflating same-spelled scoped symbols
.EXPRESSIONVARIABLESELECTOR	function	—	Validate an identity-preserving mathematical variable selector
.FACTORIAL	function	Arith	Factorial of a non-negative integer
.FIGURE	function	Output	Wrap output with figure metadata
.FILESTREAM	function	—	UTF-8 file byte stream through an explicitly granted host service
.FILTER	lazy function	Collections, Arrays	Filter a collection with a predicate — callback receives (val, locator, src)
.FIRST	function	Core, Collections, Arrays	First element of a collection
.FORMULASHEET	function	RiXCel	Create a formula-backed sheet from a shaped or rectangular array of deferred RiX formulas
.FRAGMENT	function	Output	Compose portable output values
.GETEL	function	Core, Collections, Arrays	Get element at index (1-based)
.GRAPHICS	value	—	Intrinsic portable 2D scene language
.GREATER	function	—	Greater than — returns 1 or null
.GREATEREQUAL	function	—	Greater than or equal — returns 1 or null
.GRID	function	Output	Create a mathematical layout grid
.GT	function	Logic	Greater than — returns 1 or null
.GTE	function	Logic	Greater than or equal — returns 1 or null
.HEADING	function	Output	Create a portable document heading
.HOST	function	—	Host/plugin capability registration and discovery
.HTTPSTREAM	function	—	UTF-8 HTTP byte stream through an explicitly granted host service
.HULL	function	—	Smallest exact interval containing both rational ranges
.IF	lazy function	Core	Decision conditional: condition ?: truthExpr ?_ nullExpr ?? undecidedExpr
.IMAGE	function	—	Create a portable image asset
.IMMUTABLEVALUE	function	—	Mark a newly constructed structured value immutable and return it
.IMPLICITREGION	function	—	Bound an implicit set by a complete classified box cover without asserting surface topology
.IMPLICITREGIONCHECK	function	—	Replay implicit-region classifications and complete coverage
.IMPLICITREGIONREFINE	function	—	Recheck and refine an implicit region under bounded work limits
.IMPLICITTRACE	function	—	Trace checked local implicit charts with a complete bounded box cover
.IMPLICITTRACECHECK	function	—	Replay all implicit chart, coverage, and topology claims
.IMPLICITTRACEREFINE	function	—	Recheck an implicit trace and refine its original box with bounded options
.IMPORTJS	function	—	Import a local JavaScript module for use from a .js.rix startup file
.INFO	function	—	Emit an info event: .Info(label, level ?= 1, dataMap ?= {=})
.INFOVALUE	lazy function	—	Inspect expression value: .InfoValue(label, depth ?= 1, expr) — returns expr value
.INSPECTSPEC	function	Symbolic	Return the structural inspection map for a symbolic spec
.INTDIV	function	Arith	Integer division (floor)
.INTEGRATE	function	Symbolic	Integrate a supported symbolic spec or spec-backed function exactly
.INTERSECT	function	—	Intersection of two collections (set intersection or interval overlap)
.INTERSECTS	function	—	Check if two collections intersect (1 if true, null otherwise)
.INTERVAL	function	—	Create an interval [lo, hi] or test betweenness like a:b:c
.INTERVALLINEARSOLVE	function	—	Validate an interval linear system by exact preconditioned interval elimination
.INTERVALNEWTONBOX	function	—	Contract a checked nonlinear system with a validated interval Newton operator
.IRANGE	function	Core, Collections, Arrays	Create an integer range [start, end]
.ISEXPRESSION	function	—	Recognize a core mathematical expression
.JACOBIANBOXRANGE	function	—	Certify a scalar range on a rational box using checked Jacobian bounds
.JSCALL	function	—	Call a named export from a local JavaScript module
.KEYOF	function	Core, Maps	Resolve canonical map key string for a value
.KEYS	function	Core, Maps	Get the keys of a map as a set (obj.|)
.KRAWCZYKBOX	function	—	Classify and contract a nonlinear rational box with a checked Krawczyk operator
.KRAWCZYKCHECK	function	—	Independently recompute a checked Krawczyk classification
.LAMBDA	lazy function	—	Create a lambda/anonymous function
.LAST	function	Core, Collections, Arrays	Last element of a collection
.LEN	function	Core, Collections, Arrays	Length of a collection or string
.LESS	function	—	Less than — returns 1 or null
.LESSEQUAL	function	—	Less than or equal — returns 1 or null
.LINEBREAK	function	—	Create an intentional inline line break
.LINK	function	—	Create a portable link
.LINKEDVIEWS	function	—	Compose retained Graphics/snapshot panels with explicit linked semantic IDs
.LIST	function	—	Create an ordered or unordered document list
.LISTITEM	function	—	Create a document list item
.LIVEVIEW	function	Output	Deprecated compatibility wrapper for a reactive output derived from a subscribable source; prefer a named $$ output and final $ read
.LOGICCHECKPROPOSITION	function	—	Recheck an exact arithmetic proposition record
.LOGICCHECKSEQUENT	function	—	Replay every rule and retained budget/countermodel claim in a sequent record
.LOGICEXACTPROPOSITION	function	—	Decide exact rational or interval comparisons without importing assumptions
.LOGICSEQUENT	function	—	Build a bounded classical propositional sequent derivation
.LOGICSEQUENTTREE	function	—	Render a checked sequent as bounded Graphics and an exact text table
.LOOP	lazy function	Core	Loop construct with init, condition, body[, update[, after]]
.LT	function	Logic	Less than — returns 1 or null
.LTE	function	Logic	Less than or equal — returns 1 or null
.MAP	function	Collections, Maps, Arrays	Create a map from .Pair(key, value) entries
.MATH	function	—	Create portable inline TeX math
.MATHBLOCK	function	—	Create a display TeX math block
.MATHBUDGETS	function	—	Inspect default or overridden per-call mathematical budgets
.MATHDECODEJSON	function	—	Load fresh identities and frozen real snapshots without executing code
.MATHDECODEJSONL	function	—	Decode independent bounded JSONL documents without executing code
.MATHENCODEJSON	function	—	Encode an inert document-local mathematical graph
.MATHENCODEJSONL	function	—	Encode independent mathematical documents, one per line
.MATHEVALUATE	function	—	Bounded provider evaluation with explicit unresolved context obligations
.MATHEVALUATECALCULUS	function	—	Evaluate core calculus transformations while retaining domain and branch obligations
.MATHINSTANTIATE	function	—	Instantiate selected local binders while retaining their domains and assumptions
.MATHPOLYNOMIALCOEFFICIENTS	function	—	Compile a selected symbolic identity into bounded ascending rational coefficients
.MATHSUBSTITUTE	function	—	Simultaneous identity-based free substitution retaining context conditions
.MAX	function	—	Maximum over n arguments (ignores nulls)
.MIN	function	—	Minimum over n arguments (ignores nulls)
.MOD	function	Arith	Floor modulo with a positive divisor
.MUL	function	Arith	Multiplication (Product of values)
.MULTI	lazy function	Core	Evaluate multiple expressions, return last
.MULTIVARIATERANGECHECK	function	—	Independently recompute a Jacobian, affine, or Taylor-model enclosure
.MULTIVARIATERANGEREQUEST	function	—	Construct a portable multivariate range request
.NEG	function	—	Negation
.NEQ	function	Logic	Inequality check — returns 1 or null
.NOT	function	Logic	Logical NOT — returns Integer(1) for null input, null otherwise
.NOTATIONPARSER	function	—	Wrap a RiX callable as a registered backtick parser object
.NOTEQUAL	function	—	Inequality check — returns 1 or null
.NUMERALFORMAT	function	—	Bounded exact numeral system NumeralFormat
.NUMERALLOCALE	function	—	Bounded exact numeral system NumeralLocale
.NUMERALPARSE	function	—	Bounded exact numeral system NumeralParse
.NUMERALPLACES	function	—	Bounded exact numeral system NumeralPlaces
.NUMERALSYSTEM	function	—	Bounded exact numeral system NumeralSystem
.OR	lazy function	Logic	Logical OR (short-circuits on first truthy, returns deciding value)
.OUT	function	Output	Declare an output artifact for the active host output sink
.PAIR	function	—	Create a key/value entry for .Map
.PARAGRAPH	function	Output	Create a portable paragraph output node
.PARAMS	function	—	Create a positional parameter descriptor from names
.PIPE	lazy function	—	Pipe a value into a function
.PIPEEXPLICIT	lazy function	—	Explicit pipe operator — placeholders _1, _2, … map tuple elements to specific argument positions
.PLUGIN	function	—	Discover and load host-approved RiX plugins
.PMAP	lazy function	—	Map a function over a collection — callback receives (val, locator, src)
.POLY	function	Symbolic	Compile a symbolic spec or structural arithmetic form into an exact callable; exposes .Parse for backtick polynomial forms
.POW	function	Arith	Exponentiation
.POWPROD	function	—	Exponentiation/product power (currently same implementation as POW)
.PRINT	function	Core, Strings	Print each argument through the replaceable __io__ hook
.PRODUCT	function	—	Core operation SET_PROD
.QUOTE	function	—	Create a document quotation block
.RANDOMSEED	function	Random	Install a fresh default RNG with an explicit seed in the current lexical scope
.RAND_NAME	function	Core, Random	Generate a random name string RAND_NAME(len=10, alphabet=a-zA-Z)
.RANGEABSOLUTEVALUE	function	—	Exact image of range-set absolute value
.RANGEADD	function	—	Exact Cartesian image of range-set addition
.RANGEDIVIDE	function	—	Exact defined image of range-set division
.RANGEEVIDENCE	function	—	Return the checked rangeEvidence metadata attached to a range result
.RANGEINTEGERPOWER	function	—	Exact defined image of a range set raised to an integer power
.RANGEMULTIPLY	function	—	Exact Cartesian image of range-set multiplication
.RANGENEGATE	function	—	Exact image of range-set negation
.RANGEPOLICY	lazy function	—	Evaluate an expression under an inherited range-domain policy
.RANGERECIPROCAL	function	—	Exact defined image of range-set reciprocal
.RANGESUBTRACT	function	—	Exact Cartesian image of range-set subtraction
.RATIONALBOX	function	—	Construct a checked Cartesian box of closed bounded rational intervals
.REACTIVEGRAPH	function	RiXCel	Create a transactional graph of reactive source and computed nodes
.REACTIVESTREAM	function	—	Bounded events from an explicitly passed reactive source
.REALEXPORTJSON	function	—	Export a deterministic real envelope with exact scalar tags
.REALIMPORTINFO	function	—	Inspect imported real evidence without activating a provider
.REALIMPORTJSON	function	—	Load a bounded frozen real envelope without executing recipes
.REALREFINEIMPORTED	function	—	Explicitly refine with an already-installed permitted Numerics provider and replay checker
.REDUCE	lazy function	Collections, Arrays	Reduce a collection with an accumulator function — callback receives (acc, val, locator, src)
.REFINEMENTCHECK	function	—	Validate a numerical provider result against its request and capabilities
.REFINEMENTEFFECTIVELIMITS	function	—	Intersect requester and numerical-provider resource limits
.REFINEMENTREQUEST	function	—	Normalize a shared bounded numerical refinement request
.REFINEMENTSUPPORTS	function	—	Check whether numerical provider capabilities support an operation
.REFINEMENTUNSUPPORTED	function	—	Construct a structured unsupported numerical result
.REGISTERMETHOD	function	Core, Methods	Register a receiver-first extension method on an existing semantic/runtime type
.RENDER	function	—	Render a portable value through an installed target plugin
.RENDERER	value	—	Discover installed output renderers and their target contracts
.RETRY	lazy function	—	Repeat deferred work for expected error tuple values under a bounded retry policy
.REVERSE	function	—	Reverse a collection (returns new copy)
.RIXCELEXPORT	function	RiXCel	Serialize a FormulaSheet to canonical versioned RiXCel JSON
.RIXCELEXPORTCSV	function	RiXCel	Export the computed values of a rank-2 FormulaSheet as CSV
.RIXCELEXPORTTSV	function	RiXCel	Export the computed values of a rank-2 FormulaSheet as TSV
.RIXCELIMPORT	function	RiXCel	Rebuild a FormulaSheet by compiling authoritative source from RiXCel JSON
.RIXCELIMPORTCSV	function	RiXCel	Import CSV values into a rank-2 FormulaSheet; optional header=1 uses the first row as labels
.RIXCELIMPORTTSV	function	RiXCel	Import TSV values into a rank-2 FormulaSheet; optional header=1 uses the first row as labels
.RNG	function	Random	Install a fresh RNG for the current lexical scope and its subscopes
.SAMECELL	lazy function	—	Identity comparison (===) — returns 1 if both sides refer to the same cell, null otherwise
.SAMESYMBOL	function	—	Compare symbol identities independently of mathematical equality
.SAME_CELL	lazy function	—	Identity comparison (===) — returns 1 if both sides refer to the same cell, null otherwise
.SARITH	function	—	Parse structural arithmetic; backticks use this parser by default, with optional Complex/Quaternion/Octonion/Algebra scopes
.SECTION	function	—	Create a structural document section
.SET	lazy function	—	Create a set (unique values)
.SHAPED	value	—	Shaped-storage constructors and explicit generation helpers
.SHEET	function	Output	Create a portable sheet view of indexable data
.SIMPLIFY	function	Symbolic	Compatibility alias for Transform
.SLICE	lazy function	—	Strict slice operator |>/
.SLICECLAMP	lazy function	—	Clamped slice operator |>//
.SLIDE	function	Output	Create a presentation slide
.SLIDES	function	Output	Create a sequential presentation deck
.SNAPSHOTS	function	Output	Materialize [scene, states] tuples into a portable ordered snapshot list
.SORT	lazy function	—	Sort a collection with comparator function (returns new copy)
.SPEC	function	Symbolic	Analyze a pure function and attach/return its symbolic spec
.SPECCABILITY	function	Symbolic	Report whether a pure function can be represented by the exact symbolic subset
.SPECFRACTIONPARTS	function	Symbolic	Split a symbolic top-level fraction into numerator and denominator specs
.SPECFROMEXPRESSION	function	—	Import an expression with explicit identity-ordered inputs for scoped symbols
.SPECROLES	function	Symbolic	Resolve all symbols and input/output roles, with optional role overrides
.SPLIT	lazy function	—	Split a collection by a delimiter or predicate
.STOP	lazy function	—	Conditional abort: .Stop(label, condition, dataMap ?= {=})
.STREAM	function	—	Create a cold, pull-based async stream from a finite collection
.STRONG	function	—	Create semantic inline strong content
.SUB	function	Arith	Subtraction
.SUBSTR	function	Strings	Get substring
.SYMMETRICDIFFERENCE	function	—	Core operation SET_SYMDIFF
.TABLE	function	Output	Create a structured output table
.TAYLORMODELBOXRANGE	function	—	Certify a rational-box range with a multivariate Taylor model and Hessian remainder
.TEMPLATE_TEXT	lazy function	—	Create interpolated text with @expression insertions
.TEST	lazy function	—	Run tests: .Test(label, setup, [tests] | {= tests })
.TESTERROR	lazy function	—	Abort test: .TestError(label, setup, expr) — passes if expr aborts with .Error() or a runtime error
.TESTSTOP	lazy function	—	Abort test: .TestStop(label, setup, expr) — passes if expr aborts via .Stop()
.TEXT	function	Output	Create a portable text output node
.TIMELINE	value	—	Portable exact timeline constructors
.TIMERSTREAM	function	—	Cold monotonic timer stream; optional finite tick count
.TRACE	lazy function	—	Trace execution: .Trace(label, depth, trackedVars?, thunkOrCallable)
.TRAITREGISTER	function	—	Register an immutable semantic trait from a RiX map spec
.TRANSFORM	function	Symbolic	Apply ordered exact symbolic transformations
.TUPLE	lazy function	—	Create a tuple
.TYPEEXPORT	lazy function	—	Export a semantically typed value through its registered type exporter
.TYPEIMPORT	lazy function	—	Import a value from a tagged type export map
.TYPEINSTALL	function	—	Install a registered semantic type into system multifunctions
.TYPEKNOWN	function	—	Return 1 when a semantic type or alias is already registered, otherwise null
.TYPEREGISTER	function	—	Register an immutable semantic type from a RiX map spec
.UISTREAM	function	—	Bounded events from a named host-supplied UI target
.UNDECIDED	function	—	Construct an undecided decision carrying a reason and optional evidence
.UNION	function	—	Join/Union of two collections (set union or interval hull)
.UNITS	value	Units	Canonical RiX unit collection
.UPPER	function	Strings	Convert string to uppercase
.VALIDATEDBOXCHECK	function	—	Independently replay retained linear, interval Newton, and box coverage claims
.VALIDATEDCLAIMEQUAL	function	—	Compare typed retained claims under the shared replay data limits
.VALUES	function	Core, Maps	Get the values of a map as a set (obj|.)
.VIDEO	function	—	Create a portable video asset
.WARN	function	—	Emit a warning event: .Warn(label, dataMap ?= {=})
.WEBSOCKETSTREAM	function	—	Bounded WebSocket messages through an explicitly granted host service
.algebra	function	—	Exact Polynomial and RationalFunction algorithms with checked presentations.
.algebraicreal	function	—	Exact real algebraic roots certified by canonical Polynomial values and Sturm isolating intervals.
.analysis	function	—	Effective scalar and function limits, infinite series, Cauchy criteria, and justified limit exchanges over portable Calculus functions.
.ar	function	—	Exact real algebraic roots certified by canonical Polynomial values and Sturm isolating intervals.
.ball	function	—	Certified real and complex rational balls with precision-negotiated elementary functions.
.bessel	function	—	Clearly named Bessel-function namespace backed by certified universal Numerics algorithms.
.calculus	function	—	Portable abstract functions, obligation-bearing higher differentiation, and provenance-recording evaluation through semantic-ID implementation links.
.canvas	function	—	Serializable Canvas 2D drawing plans for core Graphics scenes.
.cas	function	—	Browser-safe course-level symbolic simplification, polynomial forms, and exact integration with checked replay.
.cauchy	function	—	Rational Cauchy sequences with explicit certified tail bounds and moduli.
.cayley	function	—	Scalar-generic Cayley-Dickson values with certified component enclosures.
.cf	function	—	Finite, lazy, transduced, and certified-extracted simple continued fractions.
.comb	function	Combinatorics	Lazy finite Cartesian products, permutations, combinations, and exact counting.
.combinatorics	function	Combinatorics	Lazy finite Cartesian products, permutations, combinations, and exact counting.
.complex	function	—	Representation-generic certified complex singletons over RiX real backends.
.complexviz	function	—	Certified complex coloring, enclosure-aware surfaces, and Riemann-sphere scenes.
.continuedfraction	function	—	Finite, lazy, transduced, and certified-extracted simple continued fractions.
.csv	function	—	Schema-aware CSV/TSV import and export with exact numeric, sidecar, and streaming-row policies.
.data	function	—	Immutable typed relations with joins, grouping, exact aggregation, missing-data policy, and bounded row sources.
.document	function	—	Portable report templates with citations, assets, numbering policies, and safe target-specific nodes.
.domaincoloring	function	—	Certified complex coloring, enclosure-aware surfaces, and Riemann-sphere scenes.
.draw	function	Draw	Convenient 2D drawing helpers that produce core Graphics nodes.
.exactalgebras	function	Exact	Exact rational quaternion and octonion values.
.f	function	—	Representation-sensitive fractions, fraction intervals, mediants, and exact classroom policies.
.ff	function	—	Form-preserving callable polynomial and rational expressions with explicit transformations and canonical projections.
.float	function	—	Configurable IEEE-754 binary32/binary64 conversion, diagnostics, and optional approximate math.
.frac	function	—	Representation-sensitive fractions, fraction intervals, mediants, and exact classroom policies.
.fracfun	function	—	Form-preserving callable polynomial and rational expressions with explicit transformations and canonical projections.
.fractals	function	—	Pure-RiX iteration, bifurcation, cobweb, and escape-time mathematics with portable Graphics lowering.
.fraction	function	—	Representation-sensitive fractions, fraction intervals, mediants, and exact classroom policies.
.fractionfunction	function	—	Form-preserving callable polynomial and rational expressions with explicit transformations and canonical projections.
.geometry	function	—	Pure-RiX exact geometry, transformations, conics, constraints, and bounded portable Graphics refinement.
.gif	function	—	Deterministic animated GIF rendering from Slides, Timelines, or Snapshots through PNG frames.
.gltf	function	—	Browser-safe glTF 2.0 JSON exporter for retained Scene3D values.
.graph	function	Graph	Exact validated weighted graphs with shortest paths, traversal, components, and topological sorting.
.html	function	—	Standalone semantic HTML renderer for portable RiX output trees.
.latex	function	—	Standalone LaTeX renderer for portable RiX documents and figures.
.linalg	function	—	Pure-RiX exact linear algebra, Rational spectral evidence and finite-support tensors.
.logic	function	—	Portable propositional formulas, bounded truth tables, checked normal forms, scoped natural deduction, and educational tree views.
.markdown	function	—	CommonMark-oriented renderer for portable RiX documents.
.nd	function	—	Pure-RiX exact n-dimensional geometry with affine and Cayley projection records and explicit Scene3D adaptation.
.numerics	function	—	Backend-neutral bounded enclosure and refinement orchestration.
.octonion	function	—	Certified octonion facade with explicit nonassociativity and intrinsic one-variable functions.
.ode	function	—	Portable initial-value problems, vector trajectories, adaptive demonstrations, checked Picard and configurable-order Taylor tubes, and certified event isolation.
.optimize	function	—	Bounded exact LP/MILP, convex quadratic certificates, and global box optimization.
.oracle	function	—	Exact rational-betweenness oracles, certified refinement funnels, and coarse eta-resolution models.
.p	function	—	Semantic callable univariate polynomials with structural and symbolic entry forms.
.pdf	function	—	PDF document and figure renderer orchestrated through LaTeX.
.plot	function	Plot	Pure-RiX exact and numerics-backed 2D plotting that lowers to portable core Graphics scenes.
.png	function	—	PNG snapshot renderer for core Graphics through a host rasterizer.
.poly	function	—	Semantic callable univariate polynomials with structural and symbolic entry forms.
.polynomial	function	—	Semantic callable univariate polynomials with structural and symbolic entry forms.
.prob	function	—	Exact finite probability, certified undergraduate distribution functions, and replayable simulation with explicit approximation policies.
.probability	function	Probability	Exact finite probability, certified undergraduate distribution functions, and replayable simulation with explicit approximation policies.
.quarto	function	—	Quarto Markdown renderer with front matter and portable figure lowering.
.quaternion	function	—	Certified quaternion facade with order-aware arithmetic and intrinsic slice functions.
.radix	function	—	Exact positional expansions, cloneable lazy digit streams, configurable formatting, and bounded period analysis.
.ratfun	function	—	Canonical callable univariate rational functions with exact cancellation and Polynomial interoperability.
.rationalfunction	function	—	Canonical callable univariate rational functions with exact cancellation and Polynomial interoperability.
.rf	function	—	Canonical callable univariate rational functions with exact cancellation and Polynomial interoperability.
.scene3d	function	—	Pure-RiX exact retained 3D scenes, explicit realization and projection, and portable Graphics snapshots.
.solve	function	—	Domain-dispatched exact/certified solution objects for linear, optimization, polynomial, and scalar numerical problems.
.statistics	function	—	Exact descriptive statistics, undergraduate hypothesis tests, confidence objects, linear regression, certified distribution functions, and portable diagnostics.
.stats	function	—	Exact descriptive statistics, undergraduate hypothesis tests, confidence objects, linear regression, certified distribution functions, and portable diagnostics.
.sternbrocot	function	—	Pure RiX Stern-Brocot and Farey records, bounded trees, exact paths, and classroom grids.
.svg	function	—	Portable SVG renderer with outward-safe exact-coordinate lowering.
.symbolic	function	—	Meta-plugin joining representation-sensitive FractionFunction work with portable abstract Calculus expressions.
.terminalascii	function	—	Deterministic terminal rendering with strict ASCII and explicit Unicode/ANSI profiles.
.tikz	function	—	Editable TikZ/PGF source renderer for core Graphics scenes.
.webgl	function	—	Executable WebGL drawing plans for retained Scene3D values.

Built-in receiver methods

Method lookup is case-flexible at the language boundary. The table uses the registry keys and includes shared iterable methods. Read the methods guide for mutability rules, callback shapes, signatures, and examples.

Receiver	Registered methods
Integer	ABS, BITLENGTH, E, NEGATE, TOSTRING
Rational	ABS, APPROXIMATIONERROR, BESTAPPROXIMATION, BESTCONVERGENT, BITLENGTH, CEIL, CONVERGENT, CONVERGENTS, DENOMINATOR, E, FLOOR, NEGATE, NUMERATOR, RECIPROCAL, ROUND, ROUNDTO, TOCONTINUEDFRACTION, TOCONTINUEDFRACTIONAPPROXIMATION, TOCONTINUEDFRACTIONSTRING, TODECIMAL, TODECIMALAPPROXIMATION, TOLOCALESTRING, TOMIXEDSTRING, TOREPEATINGDECIMAL, TOREPEATINGDECIMALINFO, TOSTRING, TRUNC
Rational interval	BITLENGTH, CONTAINS, CONTAINSVALUE, CONTAINSZERO, DENOMINATORINTERVAL, E, END, HIGH, HULL, INTERSECTION, ISASCENDING, LOW, MEDIANT, MIDPOINT, NEGATE, OVERLAPS, RANDOM, RANDOMPARTITION, RECIPROCAL, SHORTESTDECIMAL, SPLIT, START, TOCOMPACTDECIMAL, TOMIXEDSTRING, TORELATIVEDECIMAL, TORELATIVEMIDDECIMAL, TOREPEATINGDECIMAL, TOSTRING, UNION, WIDTH
Array	ALL, ANY, CONCAT, CONCAT!, COUNT, DISTINCT, DISTINCT!, DROPFIRST, DROPLAST, FILTER, FIND, FINDINDEX, FIRST, FLATTEN, FLATTEN!, GET, HASAT, INCLUDES, INDEXOF, INSERT, INSERT!, ISEMPTY, ITERATOR, JOIN, LAST, LASTINDEXOF, LEN, MAP, MOVE, MOVE!, POP!, PUSH, PUSH!, REDUCE, REMOVEAT, REMOVEAT!, REVERSE, REVERSE!, SET, SET!, SHIFT!, SLICE, SORT, SORT!, SWAP, SWAP!, UNSHIFT, UNSHIFT!
Lazy sequence	FIRST, GET, ISEMPTY, ITERATOR, LAST, LEN, MATERIALIZE
Async stream	CHUNK, CHUNKBY, CLOSE, COLLECT, COUNT, DEBOUNCE, DONE, DROP, FILTER, FIND, FIRST, FOREACH, LATEST, MAP, MERGE, REDUCE, STATUS, TAKE, THROTTLE, TIMEOUT, WINDOW
Iterator	DONE, INDEX, NEXT, PEEK, RESET
Map	ALL, ANY, COUNT, DEFAULT, DEFAULT!, ENTRIES, FILTER, GET, HAS, ISEMPTY, ITERATOR, KEEP, KEEP!, KEYS, LEN, MAPVALUES, MERGE, MERGE!, OMIT, OMIT!, REDUCE, REDUCEKEYS, REMOVE, REMOVE!, SET, SET!, UPDATE, UPDATE!, VALUES
Set	ADD, ADD!, ALL, ANY, COUNT, DIFF, DIFF!, DISJOINT, FILTER, HAS, INTERSECT, INTERSECT!, ISEMPTY, ITERATOR, LEN, REDUCE, REMOVE, REMOVE!, SUBSETOF, SUPERSETOF, SYMDIFF, SYMDIFF!, UNION, UNION!, VALUES
String	CONCAT, ENDSWITH, FIRST, GET, INCLUDES, INDEXOF, ISEMPTY, ITERATOR, LAST, LASTINDEXOF, LEN, LOWER, PADLEFT, PADRIGHT, REDUCE, REPEAT, REPLACE, REPLACEALL, SLICE, SPLIT, STARTSWITH, TRIM, TRIMEND, TRIMSTART, UPPER
Tuple	FIRST, GET, ITERATOR, LAST, LEN, REDUCE, SET, SLICE, TOARRAY
Shaped	FILL!, FLATTEN, GET, ITERATOR, MAP, MEAN, PERMUTE, RANK, REDUCE, RESHAPE, SCALARDOMAIN, SET, SET!, SETSCALARDOMAIN!, SHAPE, SIZE, SUM, TRANSPOSE, WITHSCALARDOMAIN
Deferred expression	DESUGAR, EVAL, INSPECT
Structural value	ARGUMENTS, COLLAPSE, HEAD, INSPECT, MAPARGUMENTS, RENDER, SIMPLIFY, SOURCESPAN, TOEXACT
Exact generator	CAYLEY, CONJUGATE, IM, NORMSQUARED, RE
Exact expression	CAYLEY, CONJUGATE, IM, NORMSQUARED, RE
Cayley value	CARTESIAN, CAYLEY, CONJUGATE, DIRECTION, IM, INVERSE, MAGNITUDE, NORMSQUARED, RE

Every built-in receiver also supports CheckTraits / CHECKTRAITS.

Semantic types

Type	Native type	Aliases	Default traits
String	string	string	—
Array	array	array	sequence
Tuple	tuple	tuple	sequence
Map	map	map	maplike
Set	set	set	collection
Iterator	iterator	iterator	—
AsyncStream	async_stream	async_stream	—
Function	function	function	—
Multifunction	multifunction	multifunction	—
Null	null	null	—
Hole	hole	hole	—
Undecided	undecided	undecided	decision
Rational	rational	rational	rational, number, ordered, field
Integer	integer	integer	integer, rational, number, ordered
CertifiedApproximation	approximation	approximation, approximate	number, approximate, enclosed, orderInquiry
RationalInterval	interval	Interval, interval	ordered
RationalIntervalSet	intervalSet	RangeSet, rangeSet	collection
Shaped	shaped	—	shaped, indexable, shapeAware, collection
Length	Length	—	—
Point	Point	—	—
Matrix	shaped	—	shaped, indexable, shapeAware, collection
Vector	vector	—	—
Covector	covector	—	—
Tensor	tensor	—	—

Semantic traits

Trait	Implies	Description
number	—	number semantic trait
ring	number	ring semantic trait
field	ring, number	field semantic trait
ordered	number	ordered semantic trait
orderInquiry	number	orderInquiry semantic trait
approximate	number	approximate semantic trait
enclosed	number	enclosed semantic trait
decision	—	decision semantic trait
rational	field, ordered	rational semantic trait
integer	rational	integer semantic trait
indexable	—	indexable semantic trait
shapeAware	—	shapeAware semantic trait
collection	—	collection semantic trait
sequence	collection, indexable	sequence semantic trait
maplike	collection, indexable	maplike semantic trait
shaped	indexable, shapeAware, collection	shaped semantic trait
meters	—	meters semantic trait
cartesian	—	cartesian semantic trait
square	—	square semantic trait
positive	—	positive semantic trait
verify	—	verify semantic trait

Script capability groups

Imported scripts can add or withhold named groups. Permission-like names are interpreted separately from callable names by the host policy.

Group	Members
Output	OUT, BIND, LIVEVIEW, TEXT, PARAGRAPH, HEADING, FRAGMENT, SNAPSHOTS, TABLE, GRID, SHEET, CONTROLPANEL, FIGURE, SLIDE, SLIDES, Algebra, Timeline
Controls	CONTROLPANEL, Controls
Graphics	Graphics, LinkedViews
Radix	NumeralSystem, NumeralParse, NumeralFormat, NumeralPlaces, NumeralLocale
Geometry	ImplicitRegion, ImplicitRegionCheck, ImplicitRegionRefine, ImplicitTrace, ImplicitTraceCheck, ImplicitTraceRefine
Draw	draw
Plot	plot
Core	LEN, FIRST, LAST, GETEL, IRANGE, IF, LOOP, MULTI, RAND_NAME, PRINT, Shaped, KEYOF, KEYS, VALUES, REGISTERMETHOD, CertifiedApproximation, Undecided, RefinementRequest, RefinementEffectiveLimits, RefinementSupports, RefinementCheck, RefinementUnsupported, TypeKnown, ImmutableValue
Methods	REGISTERMETHOD
Numerics	IntervalLinearSolve, IntervalNewtonBox, BoxSubdivide, BoxResume, ValidatedBoxCheck, ValidatedClaimEqual, RationalBox, KrawczykBox, KrawczykCheck
Arith	ADD, SUB, MUL, DIV, INTDIV, DIVMOD, MOD, POW, FACTORIAL, DOUBLEFACTORIAL, RANGE_POLICY, RANGE_EVIDENCE, RANGE_ADD, RANGE_SUBTRACT, RANGE_MULTIPLY, RANGE_DIVIDE, RANGE_NEGATE, RANGE_ABSOLUTE_VALUE, RANGE_RECIPROCAL, RANGE_INTEGER_POWER, CALCULUS_RANGE, CALCULUS_RANGE_CHECK, CALCULUS_RANGE_RECOGNIZE, CALCULUS_GRAPH_SIMPLIFY, CALCULUS_GRAPH_SIMPLIFICATION_CHECK, CALCULUS_DERIVATIVE_CHECK, CALCULUS_DERIVATIVE_SIGN, CALCULUS_LIPSCHITZ_RANGE, CALCULUS_TAYLOR_RANGE
Logic	EQ, NEQ, LT, GT, LTE, GTE, AND, OR, NOT, GUARD_RETURN, LogicSequent, LogicCheckSequent, LogicSequentTree, LogicExactProposition, LogicCheckProposition
Collections	LEN, FIRST, LAST, GETEL, IRANGE, MAP, FILTER, REDUCE, Shaped, Stream
Async	Stream, Retry, TimerStream, ReactiveStream, UIStream
Background	BACKGROUND
Maps	MAP, KEYOF, KEYS, VALUES
Arrays	LEN, FIRST, LAST, GETEL, IRANGE, MAP, FILTER, REDUCE, Shaped
Strings	UPPER, SUBSTR, PRINT
Imports	IMPORTS
Plugins	PLUGINS
Net	NET, HttpStream, WebSocketStream
Files	FILES, FileStream
Units	UNITS, Units, CONVERTUNIT, ConvertUnit, DEFINEUNIT, DefineUnit
Exact	EXACT, Exact, COMPLEX, Complex, DEFINEEXACTGENERATOR, DefineExactGenerator, exactalgebras
Symbolic	POLY, DERIV, INTEGRATE, TRANSFORM, SIMPLIFY, SPEC, SPECCABILITY, INSPECTSPEC, SPECROLES, SPECFRACTIONPARTS, SArith, ExpressionVariable, ExpressionConstant, ExpressionOperation, ExpressionApply, IsExpression, ExpressionKey, ExpressionHasScopedSymbols, SameSymbol, SYMBOL_RETRIEVE, SYMBOL_DEFINE, ExpressionDefinition, ExpressionExpand, ExpressionVariableSelector, ExpressionVariableMatches
MathematicalContexts	MATH_CONTEXT, BOUND_SYMBOL
MathematicalProof	CALCULUS_DERIVATIVE_PROOF
MathematicalSerialization	RealImportJSON, RealExportJSON, RealImportInfo, RealRefineImported, MathEncodeJSON, MathDecodeJSON, MathEncodeJSONL, MathDecodeJSONL
MathematicalLocalization	MathSubstitute, MathEvaluate, MathInstantiate, MathBudgets, MathEvaluateCalculus, MathPolynomialCoefficients
SymbolicConstants	ExpressionConstantInfo, ExpressionHasExtendedConstants, ExpressionReal, ExpressionRefine
Notation	SArith, Poly, NotationParser
Random	RNG, RANDOMSEED, RandomSeed, RAND_NAME
Probability	probability
Graph	graph
Combinatorics	combinatorics, comb
RiXCel	FORMULASHEET, REACTIVEGRAPH, RIXCELEXPORT, RIXCELIMPORT, RIXCELIMPORTCSV, RIXCELIMPORTTSV, RIXCELEXPORTCSV, RIXCELEXPORTTSV

Default script policy includes all functions and the IMPORTS permission. Recognized permission names are IMPORTS, NET, FILES, PLUGINS, BACKGROUND. The default loop limit is 10,000 iterations and the default constructor capture mode is deep_copy.

Internal IR registry

This is the evaluator dispatch surface, not a promise that every name should be called directly from RiX source. Syntax normally lowers to these functions.

IR function	Dispatch	Implementation description
ABS	eager, effectful/unspecified, multifunction	Absolute value
ACTIVE_BASE_LITERAL	eager, effectful/unspecified	Parse a strict numeral using the session’s active input base
ADD	eager, effectful/unspecified, multifunction	Addition or string concatenation
AFFINE_BOX_RANGE	eager, pure	Certify a rational-box range with correlation-preserving affine arithmetic
AND	lazy, pure	Logical AND (short-circuits on first falsy, returns deciding value)
ARRAY	lazy, pure	Create an array/sequence (supports sequence generators)
ARRAY_CAPTURE	lazy, pure	Create an array/sequence with constructor capture controls
ASSERT_GT	eager, pure	Assert a > b (:>:)
ASSERT_GTE	eager, pure	Assert a >= b (:>=:)
ASSERT_LT	eager, pure	Assert a < b (:<:)
ASSERT_LTE	eager, pure	Assert a <= b (:<=:)
ASSET	eager, pure	Create a portable asset reference
ASSIGN	lazy, effectful/unspecified	Alias/rebind — lhs shares the same Cell as rhs variable, or gets a fresh Cell for expressions
ASSIGN_COPY	lazy, effectful/unspecified	Fresh copied-cell assignment (:=) — shallow-copy value + all meta into new binding
ASSIGN_DEEP_COPY	lazy, effectful/unspecified	Fresh deep-copied-cell assignment (::=) — deep-copy value + all meta into new binding
ASSIGN_DEEP_UPDATE	lazy, effectful/unspecified	In-place deep value replacement (=) — like ~= but deep-copies rhs value
ASSIGN_EXPR	lazy, effectful/unspecified	Assignment expression (lvalue = expr)
ASSIGN_UPDATE	lazy, effectful/unspecified	In-place value replacement (~=) — preserves cell identity, ordinary meta; replaces ephemeral; preserves sticky unless rhs overrides
AUDIO	eager, pure	Create a portable audio asset
BIND	lazy, effectful/unspecified	Capture a live Binding to a RiX variable
BINOP	eager, pure	Fallback for unrecognized binary operators
BLOCK	lazy, effectful/unspecified	Sequential block execution, returns last value
BOUND_SYMBOL	lazy, effectful/unspecified	—
BOX_RESUME	eager, pure	Replay and extend a retained deterministic box subdivision queue
BOX_SUBDIVIDE	eager, pure	Classify a bounded complete cover with deterministic exact box subdivision
BRACKET_GET	lazy, effectful/unspecified	Shaped-aware bracket indexing and slicing
BRACKET_SET	lazy, effectful/unspecified	Shaped-aware bracket assignment
BREAK	lazy, effectful/unspecified	Structured break block that exits the nearest matching breakable construct
CALCULUS_DERIVATIVE_CHECK	eager, pure	Independently recompute and check a primitive Calculus derivative transformation
CALCULUS_DERIVATIVE_PROOF	eager, pure	Build and independently check a first-derivative proof record without trusted leaves
CALCULUS_DERIVATIVE_SIGN	eager, pure	Certify a uniform derivative sign for a checked primitive Calculus transformation
CALCULUS_GRAPH_REWRITE	eager, pure	Create and independently check a theorem-named Calculus graph rewrite
CALCULUS_GRAPH_REWRITE_CHECK	eager, pure	Check a Calculus graph rewrite theorem and retained domain obligations
CALCULUS_GRAPH_SIMPLIFICATION_CHECK	eager, pure	Independently recompute a canonical Calculus graph simplification
CALCULUS_GRAPH_SIMPLIFY	eager, pure	Apply and check the canonical domain-preserving Calculus graph simplifier
CALCULUS_LIPSCHITZ_RANGE	eager, pure	Certify a range by midpoint values and bounded first derivatives
CALCULUS_RANGE	eager, pure	Evaluate a supported immutable Calculus graph over exact rational ranges
CALCULUS_RANGE_CHECK	eager, pure	Return the checker record attached to a Calculus graph-range result
CALCULUS_RANGE_RECOGNIZE	eager, pure	Recognize an exact polynomial or source-domain-preserving rational graph
CALCULUS_TAYLOR_RANGE	eager, pure	Certify a first-order midpoint Taylor range with second-derivative remainder
CALL	lazy, effectful/unspecified	Call a user-defined or built-in function
CALLOUT	eager, pure	Create a semantic document callout
CALL_EXPR	lazy, effectful/unspecified	Call an expression that evaluates to a function
CALL_METHOD	lazy, effectful/unspecified	Resolve and invoke a receiver-first method call
CAPABILITY_REGISTER	eager, effectful/unspecified	Register a package system capability during trusted package startup
CASE	lazy, effectful/unspecified	Ordered case expression with condition arms, prepared-trial arms, and an optional fallback
CERTIFIED_APPROXIMATION	eager, pure	Construct a certified approximate scalar from an exact candidate and rational enclosure
CERTIFY_FORMAT	lazy, effectful/unspecified	Convert an exact number to a bounded certified representation
CODE	eager, pure	Create literal inline code
CODEBLOCK	eager, pure	Create a literal source-code block
COMPARE	eager, pure, multifunction	Compare two values; returns -1, 0, or 1
CONCAT	eager, pure	—
CONTROLPANEL	eager, pure	Group reactive controls in a portable output panel
CONVERTUNIT	eager, pure	Convert a quantity to a compatible display unit
CUSTOM_OPERATOR	eager, effectful/unspecified	Dispatch a statically declared custom operator to a function or plugin method
DEFINEBASE	lazy, effectful/unspecified	Define a custom uppercase base prefix (0A = …), one-time global definition
DEFINEEXACTGENERATOR	eager, pure	Create an algebraic exact generator from low-to-high polynomial coefficients
DEFINEUNIT	eager, pure	Create a linear Unit value from a name and Unit/Quantity definition
DERIVATIVE	eager, pure	Postfix exact symbolic derivative
DESTRUCTURE_ASSIGN	lazy, effectful/unspecified	General lhs destructuring assignment
DISJOINT	eager, pure	Check if two collections are disjoint (1 if true, null otherwise)
DIV	eager, effectful/unspecified, multifunction	Division
DIVIDE	eager, pure	Return n lazy equally spaced points including interval endpoints
DIVMOD	eager, pure	Floor quotient and exact remainder for a positive divisor
DIVROUND	eager, pure	Rounded division
DIVUP	eager, pure	Ceiling division
DOCUMENT_TEMPLATE	lazy, effectful/unspecified	Create a Fragment from an @““” document template
DOUBLE_FACTORIAL	eager, pure	Double factorial of a non-negative integer
EMBEDDED	eager, effectful/unspecified	Dispatch a backtick body to a registered .Name.Parse parser
EMPHASIS	eager, pure	Create semantic inline emphasis
EQ	eager, effectful/unspecified, multifunction	Equality check — returns 1 or null
EVAL	lazy, effectful/unspecified	Evaluate a deferred AST node or expression: .Eval(ast, bindings ?= _, mode ?= :inherit)
FACTORIAL	eager, pure	Factorial of a non-negative integer
FIGURE	eager, pure	Wrap output with figure metadata
FORMULASHEET	eager, effectful/unspecified	Create a formula-backed sheet from a shaped or rectangular array of deferred RiX formulas
FRAGMENT	eager, pure	Compose portable output values
FROMBASE	lazy, effectful/unspecified	Parse base string to number: str <_ baseSpec
FUNCDEF	lazy, effectful/unspecified	Define a named function
GENERATOR	eager, effectful/unspecified	Internal array-generator marker
GLOBAL	lazy, effectful/unspecified	Assign a value to a variable in the global scope
GRID	eager, pure	Create a mathematical layout grid
GT	eager, effectful/unspecified, multifunction	Greater than — returns 1 or null
GTE	eager, effectful/unspecified, multifunction	Greater than or equal — returns 1 or null
GUARD_RETURN	lazy, effectful/unspecified	Return from the active function on a null or undecided decision
HALO	eager, pure	Construct a halo neighborhood for bounded-refinement comparison
HEADING	eager, pure	Create a portable document heading
HOLE	eager, pure	Internal hole/undefined sentinel — represents an explicitly omitted value
HOLE_COALESCE	lazy, effectful/unspecified	Hole-coalescing: x ?| y returns x if x is not a hole, else y
HULL	eager, pure	Smallest exact interval containing both rational ranges
IMAGE	eager, pure	Create a portable image asset
IMMUTABLE_VALUE	eager, effectful/unspecified	Mark a newly constructed structured value immutable and return it
IMPLICIT_REGION	eager, pure	Bound an implicit set by a complete classified box cover without asserting surface topology
IMPLICIT_REGION_CHECK	eager, pure	Replay implicit-region classifications and complete coverage
IMPLICIT_REGION_REFINE	eager, pure	Recheck and refine an implicit region under bounded work limits
IMPLICIT_TRACE	eager, pure	Trace checked local implicit charts with a complete bounded box cover
IMPLICIT_TRACE_CHECK	eager, pure	Replay all implicit chart, coverage, and topology claims
IMPLICIT_TRACE_REFINE	eager, pure	Recheck an implicit trace and refine its original box with bounded options
IMPORT_JS	eager, effectful/unspecified	Import a local JavaScript module for use from a .js.rix startup file
INDEX_GET	eager, effectful/unspecified	Index into collection (1-based for sequences; string or value keys for maps) — obj[i]
INDEX_SET	lazy, effectful/unspecified	Set index in collection (requires ._mutable meta flag) — obj[i] = val
INFSEQ	eager, pure	Lazy unbounded exact arithmetic sequence
INTDIV	eager, pure, multifunction	Integer division (floor)
INTEGRAL	eager, pure	Prefix exact symbolic integral
INTERSECT	eager, pure	Intersection of two collections (set intersection or interval overlap)
INTERSECTS	eager, pure	Check if two collections intersect (1 if true, null otherwise)
INTERVAL	eager, pure	Create an interval [lo, hi] or test betweenness like a:b:c
INTERVAL_LINEAR_SOLVE	eager, pure	Validate an interval linear system by exact preconditioned interval elimination
INTERVAL_NEWTON_BOX	eager, pure	Contract a checked nonlinear system with a validated interval Newton operator
JACOBIAN_BOX_RANGE	eager, pure	Certify a scalar range on a rational box using checked Jacobian bounds
JS_CALL	eager, effectful/unspecified	Call a named export from a local JavaScript module
KEYOF	eager, pure	Resolve canonical map key string for a value
KEYS	eager, pure	Get the keys of a map as a set (obj.|)
KRAWCZYK_BOX	eager, pure	Classify and contract a nonlinear rational box with a checked Krawczyk operator
KRAWCZYK_CHECK	eager, pure	Independently recompute a checked Krawczyk classification
KWARG	eager, pure	Keyword argument wrapper
LAMBDA	lazy, effectful/unspecified	Create a lambda/anonymous function
LINEBREAK	eager, pure	Create an intentional inline line break
LINK	eager, pure	Create a portable link
LINKED_VIEWS	eager, pure	Compose retained Graphics/snapshot panels with explicit linked semantic IDs
LIST	eager, pure	Create an ordered or unordered document list
LISTITEM	eager, pure	Create a document list item
LITERAL	eager, pure	Parse a number literal string into a ratmath type
LIVEVIEW	eager, effectful/unspecified	Deprecated compatibility wrapper for a reactive output derived from a subscribable source; prefer a named $$ output and final $ read
LOGIC_CHECK_PROPOSITION	eager, pure	Recheck an exact arithmetic proposition record
LOGIC_CHECK_SEQUENT	eager, pure	Replay every rule and retained budget/countermodel claim in a sequent record
LOGIC_EXACT_PROPOSITION	eager, pure	Decide exact rational or interval comparisons without importing assumptions
LOGIC_SEQUENT	eager, pure	Build a bounded classical propositional sequent derivation
LOGIC_SEQUENT_TREE	eager, pure	Render a checked sequent as bounded Graphics and an exact text table
LOOP	lazy, effectful/unspecified	Loop construct with init, condition, body[, update[, after]]
LT	eager, effectful/unspecified, multifunction	Less than — returns 1 or null
LTE	eager, effectful/unspecified, multifunction	Less than or equal — returns 1 or null
MAP_OBJ	lazy, pure	Create a map/object
MATH	eager, pure	Create portable inline TeX math
MATHBLOCK	eager, pure	Create a display TeX math block
MATHUNIT	eager, pure	Resolve exact-generator sugar through the active Exact RiX collection
MATH_CONTEXT	lazy, effectful/unspecified	—
MAX	eager, pure, multifunction	Maximum over n arguments (ignores nulls)
MEDIANTS	eager, pure	Return nested levels of exact mediants
MEDIANT_PARTITION	eager, pure	Partition an interval using exact mediant boundaries
MEMBER	eager, effectful/unspecified	Check membership (1 if present, null otherwise)
META_ALL	eager, effectful/unspecified	Get all meta properties as a map (read-only copy) — obj..
META_GET	eager, effectful/unspecified	Get meta property (returns null if absent) — obj.name
META_MERGE	lazy, effectful/unspecified	Bulk merge map into object meta properties (null values = delete) — obj .= map
META_SET	lazy, effectful/unspecified	Set meta property (null deletes; respects immutable/frozen) — obj.name = val
METHOD_LIFT	eager, effectful/unspecified	Create a receiver-first callable from prefix ..Method syntax
MIN	eager, pure, multifunction	Minimum over n arguments (ignores nulls)
MOD	eager, pure, multifunction	Floor modulo with a positive divisor
MUL	eager, effectful/unspecified, multifunction	Multiplication (Product of values)
MULTIFUNCDEF	lazy, effectful/unspecified	Append or prepend a multifunction variant
MULTIFUNCTION	lazy, effectful/unspecified	Create an ordered multifunction literal, flattening nested multifunctions
MULTIVARIATE_RANGE_CHECK	eager, pure	Independently recompute a Jacobian, affine, or Taylor-model enclosure
MULTIVARIATE_RANGE_REQUEST	eager, pure	Construct a portable multivariate range request
MUTCOPY	eager, effectful/unspecified	Clone a map and apply mutations (obj{= +a=3, -.b })
MUTINPLACE	eager, effectful/unspecified	Mutate a map in-place (obj{! +a=3, -.b })
NARY_CONCAT	eager, pure	N-ary concatenation fold
NARY_INTERSECT	eager, pure	N-ary intersection/overlap fold for sets or intervals
NARY_UNION	eager, pure	N-ary true union fold for sets or rational interval sets
NEG	eager, effectful/unspecified, multifunction	Negation
NEQ	eager, effectful/unspecified, multifunction	Inequality check — returns 1 or null
NOP	eager, pure	No operation
NOT	eager, pure	Logical NOT — returns Integer(1) for null input, null otherwise
NOT_MEMBER	eager, effectful/unspecified	Check non-membership (1 if not present, null otherwise)
NULL	eager, pure	Null value
NUMERAL_FORMAT	eager, pure	Bounded exact numeral system NumeralFormat
NUMERAL_LOCALE	eager, pure	Bounded exact numeral system NumeralLocale
NUMERAL_PARSE	eager, pure	Bounded exact numeral system NumeralParse
NUMERAL_PLACES	eager, pure	Bounded exact numeral system NumeralPlaces
NUMERAL_SYSTEM	eager, pure	Bounded exact numeral system NumeralSystem
NUM_DISPLAY	eager, effectful/unspecified	Set the session’s comma-separated number display profile
NUM_INPUT	eager, effectful/unspecified	Set the session’s strict # numeral input base
OR	lazy, pure	Logical OR (short-circuits on first truthy, returns deciding value)
OUT	eager, effectful/unspecified	Declare an output artifact for the active host output sink
OUTER_ASSIGN	lazy, effectful/unspecified	Assign a value to an existing outer scope variable
OUTER_RETRIEVE	eager, effectful/unspecified	Look up a variable strictly in the outer scope chains
OUTER_UPDATE	lazy, effectful/unspecified	In-place value replacement on an outer scope variable (~= / = with @)
PALL	lazy, effectful/unspecified	Every: returns last element if predicate is truthy for ALL elements, null on first failure — callback receives (val, locator, src)
PANY	lazy, effectful/unspecified	Any: returns first item that passed predicate, null if none pass — callback receives (val, locator, src)
PARAGRAPH	eager, pure	Create a portable paragraph output node
PARENT_SELF	eager, effectful/unspecified	Resolve the parent multifunction inside a variant body
PARTITION	eager, pure	Partition an interval into n equal touching subintervals
PCHUNK	lazy, effectful/unspecified	Chunk a collection into subarrays by size or boundary predicate
PEXPECT	lazy, effectful/unspecified	Recover expected {: :error, … } values or skip when the handler returns null
PFILTER	lazy, effectful/unspecified	Filter a collection with a predicate — callback receives (val, locator, src)
PFOREACH	lazy, effectful/unspecified	Drain a source through a callback, ignore callback results, and return null
PIPE	lazy, effectful/unspecified	Pipe a value into a function
PIPE_EXPLICIT	lazy, effectful/unspecified	Explicit pipe operator — placeholders _1, _2, … map tuple elements to specific argument positions
PLACEHOLDER	eager, pure	Numbered placeholder for partial application and explicit pipes
PLUGIN_IMPORT	eager, effectful/unspecified	Import selected plugin exports as bare callables in the current lexical scope
PMAP	lazy, effectful/unspecified	Map a function over a collection — callback receives (val, locator, src)
POW	eager, effectful/unspecified, multifunction	Exponentiation
POWPROD	eager, pure, multifunction	Exponentiation/product power (currently same implementation as POW)
PREDUCE	lazy, effectful/unspecified	Reduce a collection with an accumulator function — callback receives (acc, val, locator, src)
PREP_TRIAL	lazy, effectful/unspecified	Evaluate a candidate through ordered soft/strict prep gates, returning null on soft failure
PREP_TRIAL_CASE	lazy, effectful/unspecified	Evaluate a prepared-trial case arm while preserving its no-match status
PREVERSE	eager, pure	Reverse a collection (returns new copy)
PSLICE_CLAMP	lazy, effectful/unspecified	Clamped slice operator |>//
PSLICE_STRICT	lazy, effectful/unspecified	Strict slice operator |>/
PSORT	lazy, effectful/unspecified	Sort a collection with comparator function (returns new copy)
PSPLIT	lazy, effectful/unspecified	Split a collection by a delimiter or predicate
QUOTE	eager, pure	Create a document quotation block
RANDOM	eager, effectful/unspecified	Sample exact rational points from an interval
RANDOM_PARTITION	eager, effectful/unspecified	Partition an interval at distinct random rational points
RANGE_ABSOLUTE_VALUE	eager, pure	Exact image of range-set absolute value
RANGE_ADD	eager, pure	Exact Cartesian image of range-set addition
RANGE_DIVIDE	eager, pure	Exact defined image of range-set division
RANGE_EVIDENCE	eager, pure	Return the checked rangeEvidence metadata attached to a range result
RANGE_INTEGER_POWER	eager, pure	Exact defined image of a range set raised to an integer power
RANGE_MULTIPLY	eager, pure	Exact Cartesian image of range-set multiplication
RANGE_NEGATE	eager, pure	Exact image of range-set negation
RANGE_POLICY	lazy, effectful/unspecified	Evaluate an expression under an inherited range-domain policy
RANGE_RECIPROCAL	eager, pure	Exact defined image of range-set reciprocal
RANGE_SUBTRACT	eager, pure	Exact Cartesian image of range-set subtraction
RATIONAL_BOX	eager, pure	Construct a checked Cartesian box of closed bounded rational intervals
REACTIVEGRAPH	eager, effectful/unspecified	Create a transactional graph of reactive source and computed nodes
REACTIVE_DECLARE	lazy, effectful/unspecified	Declare a new reactive cell from a deferred definition
REACTIVE_INDEX_NODE	lazy, effectful/unspecified	Retrieve a FormulaSheet cell identity without dereferencing it
REACTIVE_INDEX_READ	lazy, effectful/unspecified	Read a FormulaSheet cell and record a dependency
REACTIVE_INDEX_UPDATE	lazy, effectful/unspecified	Replace a FormulaSheet cell’s deferred formula
REACTIVE_NODE	eager, effectful/unspecified	Retrieve a reactive cell identity without dereferencing it
REACTIVE_READ	eager, effectful/unspecified	Read a reactive cell value and record a dependency
REACTIVE_TRANSACTION	lazy, effectful/unspecified	Stage reactive declarations and updates and commit one atomic graph epoch
REACTIVE_UPDATE	lazy, effectful/unspecified	Replace a reactive cell definition while preserving its identity
REFINEMENT_CHECK	eager, pure	Validate a numerical provider result against its request and capabilities
REFINEMENT_EFFECTIVE_LIMITS	eager, pure	Intersect requester and numerical-provider resource limits
REFINEMENT_REQUEST	eager, pure	Normalize a shared bounded numerical refinement request
REFINEMENT_SUPPORTS	eager, pure	Check whether numerical provider capabilities support an operation
REFINEMENT_UNSUPPORTED	eager, pure	Construct a structured unsupported numerical result
REGEX	eager, effectful/unspecified	Create a regex matching function
RETRIEVE	eager, effectful/unspecified	Look up a variable in the current scope chain
RIXCELEXPORT	eager, effectful/unspecified	Serialize a FormulaSheet to canonical versioned RiXCel JSON
RIXCELEXPORTCSV	eager, effectful/unspecified	Export the computed values of a rank-2 FormulaSheet as CSV
RIXCELEXPORTTSV	eager, effectful/unspecified	Export the computed values of a rank-2 FormulaSheet as TSV
RIXCELIMPORT	eager, effectful/unspecified	Rebuild a FormulaSheet by compiling authoritative source from RiXCel JSON
RIXCELIMPORTCSV	eager, effectful/unspecified	Import CSV values into a rank-2 FormulaSheet; optional header=1 uses the first row as labels
RIXCELIMPORTTSV	eager, effectful/unspecified	Import TSV values into a rank-2 FormulaSheet; optional header=1 uses the first row as labels
SAME_CELL	lazy, effectful/unspecified	Identity comparison (===) — returns 1 if both sides refer to the same cell, null otherwise
SARITH_FUNCTION_BODY	eager, effectful/unspecified	Resolve a structural-arithmetic function template against its arguments
SECTION	eager, pure	Create a structural document section
SELF	eager, effectful/unspecified	Resolve the current callable object inside a function body
SEMANTIC_CONVERT_SOFT	lazy, effectful/unspecified	Convert a value to a semantic type, returning null on failure
SEMANTIC_CONVERT_STRICT	lazy, effectful/unspecified	Convert a value to a semantic type, throwing on failure
SEMANTIC_HAS	lazy, effectful/unspecified	Check semantic type/trait membership against __type, _type, and __traits
SEQ	lazy, effectful/unspecified	Expression sequence: evaluate arguments left-to-right in the current scope and return the last value
SET	lazy, pure	Create a set (unique values)
SET_DIFF	eager, pure	—
SET_PROD	eager, pure	—
SET_SYMDIFF	eager, pure	—
SHAPED_LITERAL	lazy, pure	Shaped literal with explicit shape
SHAPED_TRANSPOSE	eager, pure	Transpose a rank-2 Shaped or Matrix view
SHEET	eager, pure	Create a portable sheet view of indexable data
SLIDE	eager, pure	Create a presentation slide
SLIDES	eager, pure	Create a sequential presentation deck
SNAPSHOTS	eager, pure	Materialize [scene, states] tuples into a portable ordered snapshot list
STEP	eager, pure	Lazy exact stepped range over a rational interval
STRING	eager, pure	Create a string value
STRONG	eager, pure	Create semantic inline strong content
SUB	eager, effectful/unspecified, multifunction	Subtraction
SYMBOL_DEFINE	lazy, effectful/unspecified	—
SYMBOL_RETRIEVE	lazy, effectful/unspecified	—
SYSREF	eager, pure	Reference to a system function
SYSTEM	lazy, effectful/unspecified	Mathematical system container, currently evaluates as a block
SYSTEM_SPEC	lazy, pure	Create a first-class symbolic system specification
TABLE	eager, pure	Create a structured output table
TAIL_SELF	lazy, effectful/unspecified	Tail-position self call that reuses the current function frame
TAYLOR_MODEL_BOX_RANGE	eager, pure	Certify a rational-box range with a multivariate Taylor model and Hessian remainder
TEMPLATE_TEXT	lazy, effectful/unspecified	Create interpolated text with @expression insertions
TERNARY	lazy, effectful/unspecified	Decision conditional: condition ?: truthExpr ?_ nullExpr ?? undecidedExpr
TEXT	eager, pure	Create a portable text output node
TOBASE	lazy, effectful/unspecified	Format number to base string: expr _> baseSpec
TOBASE_EXACT	lazy, effectful/unspecified	Format a number as lossless RiX source, or fail
TRAIT_REGISTER	eager, effectful/unspecified	Register an immutable semantic trait from a RiX map spec
TUPLE	lazy, pure	Create a tuple
TYPE_EXPORT	lazy, effectful/unspecified	Export a semantically typed value through its registered type exporter
TYPE_IMPORT	lazy, effectful/unspecified	Import a value from a tagged type export map
TYPE_INSTALL	eager, effectful/unspecified	Install a registered semantic type into system multifunctions
TYPE_KNOWN	eager, effectful/unspecified	Return 1 when a semantic type or alias is already registered, otherwise null
TYPE_REGISTER	eager, effectful/unspecified	Register an immutable semantic type from a RiX map spec
UNDECIDED	eager, pure	Return the singleton undecided decision value
UNDECIDED_DIAGNOSTIC	eager, pure	Construct an undecided decision carrying a reason and optional evidence
UNION	eager, pure	Join/Union of two collections (set union or interval hull)
UNIT	eager, pure	Resolve scientific unit sugar through the active Units RiX collection
VALIDATED_BOX_CHECK	eager, pure	Independently replay retained linear, interval Newton, and box coverage claims
VALIDATED_CLAIM_EQUAL	eager, pure	Compare typed retained claims under the shared replay data limits
VALUES	eager, pure	Get the values of a map as a set (obj|.)
VALUE_OUTFIT	lazy, effectful/unspecified	Apply semantic/value outfitting metadata to a value
VIDEO	eager, pure	Create a portable video asset