provsql.sql File Reference

ProvSQL PL/pgSQL extension code. More...

Go to the source code of this file.

Types
TYPE	provsql.GATE_WITH_DESC
	Row type for sub_circuit_with_desc results. More...
TYPE	provsql.rv_percentile_state
	Transition state for rv_percentile_impl: the fraction (from the first row) plus the interleaved indicator/value token pairs. More...
TYPE	update_provenance
	Table recording the history of INSERT, UPDATE, DELETE, and UNDO operations. More...

Schemas
namespace	provsql
	provsql schema

Enumerations
ENUM	provsql.PROVENANCE_GATE {   provsql.input , provsql.plus , provsql.times , provsql.monus ,   provsql.project , provsql.zero , provsql.one , provsql.eq ,   provsql.agg , provsql.semimod , provsql.cmp , provsql.delta ,   provsql.value , provsql.mulinput , provsql.update , provsql.rv ,   provsql.arith , provsql.mixture , provsql.assumed , provsql.annotation ,   provsql.conditioned , provsql.mobius , provsql.case , provsql.observe }
	Provenance circuit gate types. More...
ENUM	provsql.QUERY_TYPE_ENUM { provsql.INSERT , provsql.DELETE , provsql.UPDATE , provsql.UNDO }
	Types of update operations tracked for temporal provenance. More...

Functions
VOID	provsql.create_gate (UUID token, PROVENANCE_GATE type, UUID[] children=NULL)
	Create a new gate in the provenance circuit.
PROVENANCE_GATE	provsql.get_gate_type (UUID token)
	Return the gate type of a provenance token.
UUID[]	provsql.get_children (UUID token)
	Return the children of a provenance gate.
VOID	provsql.set_prob (UUID token, DOUBLE PRECISION p)
	Set the probability of an input gate.
DOUBLE PRECISION	provsql.get_prob (UUID token)
	Get the probability associated with an input gate.
VOID	provsql.set_infos (UUID token, INT info1, INT info2=NULL)
	Set additional INTEGER values on provenance circuit gate.
RECORD	provsql.get_infos (UUID token, OUT INT info1, OUT INT info2)
	Get the INTEGER info values associated with a circuit gate.
UUID	provsql.provenance_assume (UUID token, TEXT assumption)
	Wrap token in a fresh gate_assumed carrying assumption as its label, and return the wrapper's UUID.
UUID	provsql.assume_boolean (UUID token)
	Wrap token in a Boolean-assumption marker (compatibility name; see provenance_assume).
UUID	provsql.annotate (UUID token, TEXT extra)
	Wrap token in a fresh transparent gate_annotation carrying extra, and return the wrapper's UUID.
UUID	provsql.strip_annotations (UUID token)
	Peel every transparent gate_annotation wrapper off token, returning the first non-annotation gate underneath.
UUID	provsql.cond (UUID target, UUID evidence)
	Condition a provenance token (a Boolean event) on another.
BOOLEAN	provsql.UUID_op_UUID (UUID left, UUID right)
	Binary | : value-level conditioning, "target | evidence".
UUID	provsql.cond_predicate (UUID target, BOOLEAN predicate)
	Placeholder for "X | (predicate)" on a UUID event.
BOOLEAN	provsql.UUID_op_boolean (UUID left, BOOLEAN right)
UUID	provsql.predicate_cond_predicate (BOOLEAN target, BOOLEAN evidence)
	Placeholder for "(predicate) | (predicate)" on two events.
BOOLEAN	provsql.boolean_op_boolean (BOOLEAN left, BOOLEAN right)
UUID	provsql.regular_indicator (BOOLEAN cond)
	Deterministic indicator gate for an ordinary (regular) comparison.
UUID	provsql.given (UUID evidence)
	Whole-tuple output conditioning directive: "given(evidence)".
UUID	provsql.given (BOOLEAN predicate)
	Prefix unary | : alias for given, "| evidence".
UUID	provsql.provenance_not (UUID event)
	Event negation: "! event" / "provenance_not(event)".
TEXT	provsql.inversion_free_key (TEXT root, TEXT sec, INT factor)
	Prefix unary !
VOID	provsql.set_extra (UUID token, TEXT data)
	Set extra TEXT information on provenance circuit gate.
TEXT	provsql.get_extra (UUID token)
	Get the TEXT-encoded extra data associated with a circuit gate.
BIGINT	provsql.get_nb_gates ()
	Return the total number of materialized gates in the provenance circuit.
TRIGGER	provsql.delete_statement_trigger ()
	Trigger function for DELETE statement provenance tracking.
VOID	provsql.set_table_info (OID relid, TEXT kind, INT2[] block_key=ARRAY[]::INT2[])
	Record per-relation provenance metadata used by the safe-query optimisation.
VOID	provsql.remove_table_info (OID relid)
	Remove per-relation provenance metadata.
RECORD	provsql.get_table_info (OID relid, OUT TEXTkind, INT2[] &block_key)
	Read per-relation provenance metadata.
VOID	provsql.set_ancestors (OID relid, OID[] ancestors=ARRAY[]::OID[])
	Record the base-relation ancestor set of a tracked relation.
VOID	provsql.remove_ancestors (OID relid)
	Clear the ancestor half of a per-relation RECORD (keeps kind/block_key).
OID[]	provsql.get_ancestors (OID relid)
	Read the base-relation ancestor set of a tracked relation.
TRIGGER	provsql.provenance_guard ()
	BEFORE INSERT OR UPDATE OF provsql row trigger installed by add_provenance.
VOID	provsql.add_provenance (REGCLASS _tbl)
	Enable provenance tracking on an existing table.
VOID	provsql.remove_provenance (REGCLASS _tbl)
	Remove provenance tracking from a table.
VOID	provsql.repair_key (REGCLASS _tbl, TEXT key_att)
	Set up provenance for a table with duplicate key values.
event_trigger	provsql.cleanup_table_info ()
	Event trigger that purges per-table provenance metadata when a tracked relation is dropped outside of remove_provenance().
CREATE TABLE IF NOT EXISTS provsql	provsql.provenance_mapping_registry (mapping oid PRIMARY KEY, source oid NOT NULL, attribute name NOT NULL)
	Registry of maintained provenance mappings.
CREATE INDEX IF NOT EXISTS provenance_mapping_registry_source_idx ON provsql	provsql.provenance_mapping_registry (source)
VOID	provsql.create_provenance_mapping (TEXT newtbl, REGCLASS oldtbl, TEXT att, BOOL preserve_case='f', BOOL maintained=false)
	Create a provenance mapping table from an attribute.
UUID	provsql.uuid_ns_provsql ()
	Return the ProvSQL UUID namespace (used for deterministic gate UUIDs).
UUID	provsql.gate_zero ()
	Return the UUID of the semiring zero gate.
UUID	provsql.gate_one ()
	Return the UUID of the semiring one gate.
DOUBLE PRECISION	provsql.epsilon ()
	Return the epsilon threshold used for probability comparisons.
UUID	provsql.provenance_times (UUID[] tokens)
	Create a times (product) gate from multiple provenance tokens.
UUID	provsql.provenance_monus (UUID token1, UUID token2)
	Create a monus (difference) gate from two provenance tokens.
UUID	provsql.provenance_project (UUID token, INT[] positions)
	Create a project gate for where-provenance tracking.
UUID	provsql.provenance_eq (UUID token, INT pos1, INT pos2)
	Create an equijoin gate for where-provenance tracking.
UUID	provsql.provenance_plus (UUID[] tokens)
	Create a plus (sum) gate from an array of provenance tokens.
VOID	provsql.eval_recursive (TEXT body_sql, TEXT work_name, TEXT colnames, TEXT coldef, INT max_iter=1000)
	Driver for provenance over recursive queries (WITH RECURSIVE).
UUID	provsql.provenance_cmp (UUID left_token, OID comparison_op, UUID right_token)
	Create a comparison gate for HAVING clause provenance.
UUID[]	provsql.cmp_surviving_factors (UUID[] tokens, UUID cmp)
	The factors of a row annotation an aggregate comparison does not subsume.
UUID	provsql.provenance_cmp_times (UUID cmp, UUID[] tokens)
	Combine a lifted aggregate comparison with the row annotation it supersedes only part of.
UUID	provsql.provenance_arith (INTEGER op, UUID[] children)
	Create an arithmetic gate over scalar-valued provenance children.
UUID	provsql.provenance_case (UUID[] children)
	Create a guarded-selection gate over scalar (RV) children.
ANYELEMENT	provsql.provenance_evaluate_compiled (UUID token, REGCLASS token2value, TEXT semiring, ANYELEMENT element_one)
	Evaluate provenance using a compiled (built-in) semiring.
ANYELEMENT	provsql.provenance_evaluate (UUID token, REGCLASS token2value, ANYELEMENT element_one, REGTYPE value_type, REGPROC plus_function, REGPROC times_function, REGPROC monus_function, REGPROC delta_function)
	Evaluate provenance over a user-defined semiring (PL/pgSQL version).
ANYELEMENT	provsql.provenance_evaluate (UUID token, REGCLASS token2value, ANYELEMENT element_one, REGPROC plus_function, REGPROC times_function, REGPROC monus_function=NULL, REGPROC delta_function=NULL)
	Evaluate provenance over a user-defined semiring (C version).
SETOF GATE_WITH_DESC	provsql.sub_circuit_with_desc (UUID token, REGCLASS token2desc)
	Return the sub-circuit reachable from a token, with descriptions.
VOID	provsql.identify_token (UUID token, OUT REGCLASS table_name, OUT INTEGER nb_columns)
	Identify which table and how many columns a provenance token belongs to.
TABLE	provsql.sub_circuit_for_where (UUID token)
	Return the sub-circuit for where-provenance computation.
TABLE	provsql.circuit_subgraph (UUID root, INT max_depth=8)
	BFS expansion of a provenance circuit, capped at max_depth.
jsonb	provsql.simplified_circuit_subgraph (UUID root, INT max_depth=8)
	BFS subgraph of the IN-MEMORY simplified circuit rooted at root.
jsonb	provsql.rv_histogram (UUID token, INT bins=30, UUID prov=gate_one())
	Empirical histogram of a scalar sub-circuit.
jsonb	provsql.rv_analytical_curves (UUID token, INT samples=100, UUID prov=gate_one())
	Sample the closed-form PDF and CDF of a (possibly truncated) scalar distribution.
SETOF float8	provsql.rv_sample (UUID token, INTEGER n, UUID prov=gate_one())
	Draw conditional Monte Carlo samples from a scalar gate.
TABLE	provsql.resolve_input (UUID UUID)
	Resolve an input gate UUID back to its source row.
AGG_TOKEN	provsql.agg_token_in (CSTRING)
	Input function for the AGG_TOKEN type (parses TEXT representation).
CSTRING	provsql.agg_token_out (AGG_TOKEN)
	Output function for the AGG_TOKEN type.
TEXT	provsql.agg_token_cast (AGG_TOKEN)
	Cast an AGG_TOKEN to its TEXT representation.
UUID	provsql.agg_token_uuid (AGG_TOKEN aggtok)
	Extract the UUID from an AGG_TOKEN (implicit cast to UUID).
UUID	provsql.CAST(AGG_TOKEN AS UUID) (AGG_TOKEN)
	Implicit PostgreSQL cast from AGG_TOKEN to UUID (delegates to agg_token_uuid()).
BOOLEAN	provsql.agg_guard_holds (UUID token)
	Deterministic truth of a Boolean guard sub-circuit over aggregate comparisons, evaluated in the actual world (all input tuples present).
NUMERIC	provsql.agg_gate_value (UUID token)
	Deterministic (actual-world) scalar value of an aggregate-carrying gate.
TEXT	provsql.agg_token_value_text (UUID token)
	Recover the "value (*)" display string for an aggregation gate.
NUMERIC	provsql.agg_token_to_numeric (AGG_TOKEN)
	Cast an AGG_TOKEN to NUMERIC (extracts the aggregate value, loses provenance).
DOUBLE PRECISION	provsql.agg_token_to_float8 (AGG_TOKEN)
	Cast an AGG_TOKEN to DOUBLE PRECISION (extracts the aggregate value, loses provenance).
INTEGER	provsql.agg_token_to_int4 (AGG_TOKEN)
	Cast an AGG_TOKEN to INTEGER (extracts the aggregate value, loses provenance).
bigint	provsql.agg_token_to_int8 (AGG_TOKEN)
	Cast an AGG_TOKEN to bigint (extracts the aggregate value, loses provenance).
TEXT	provsql.agg_token_to_text (AGG_TOKEN)
	Cast an AGG_TOKEN to TEXT (extracts the aggregate value, loses provenance).
CREATE	provsql.CAST (AGG_TOKEN AS NUMERIC) WITH FUNCTION agg_token_to_numeric(AGG_TOKEN) AS ASSIGNMENT
	Assignment cast from AGG_TOKEN to NUMERIC (extracts the scalar value, dropping provenance).
NUMERIC	provsql.agg_token_value (AGG_TOKEN)
	Arithmetic on aggregates (AGG_TOKEN) Mirrors the random_variable arithmetic surface: the operators build a gate_arith over the operand provenance UUIDs (via provenance_arith, info1 = PROVSQL_ARITH_*), so the arithmetic is recorded symbolically in the circuit and can be resolved when a comparison (gate_cmp) over the result is evaluated.
AGG_TOKEN	provsql.agg_token_make (UUID tok, NUMERIC val)
	Bundle a provenance gate UUID with a running value into an AGG_TOKEN (inverse of the agg_token_uuid / agg_token_value accessors).
UUID	provsql.agg_value_gate (NUMERIC v)
	Lift a scalar NUMERIC constant into a gate_value leaf and return its UUID, so it can be a child of a gate_arith (the agg-side analogue of as_random for random_variable).
AGG_TOKEN	provsql.agg_arith_make (INT op, UUID[] children, NUMERIC val)
	Mint (or reuse) the gate_arith for an AGG_TOKEN arithmetic result and return the AGG_TOKEN carrying it.
AGG_TOKEN	provsql.agg_token_plus (AGG_TOKEN a, AGG_TOKEN b)
	AGG_TOKEN <op> AGG_TOKEN
AGG_TOKEN	provsql.agg_token_minus (AGG_TOKEN a, AGG_TOKEN b)
	AGG_TOKEN - AGG_TOKEN (gate_arith MINUS).
AGG_TOKEN	provsql.agg_token_times (AGG_TOKEN a, AGG_TOKEN b)
	AGG_TOKEN * AGG_TOKEN (gate_arith TIMES).
AGG_TOKEN	provsql.agg_token_div (AGG_TOKEN a, AGG_TOKEN b)
	AGG_TOKEN / AGG_TOKEN (gate_arith DIV).
AGG_TOKEN	provsql.agg_token_neg (AGG_TOKEN a)
	Unary -AGG_TOKEN (gate_arith NEG).
AGG_TOKEN	provsql.agg_token_plus_numeric (AGG_TOKEN a, NUMERIC b)
	AGG_TOKEN <op> NUMERIC
AGG_TOKEN	provsql.agg_token_minus_numeric (AGG_TOKEN a, NUMERIC b)
	AGG_TOKEN - NUMERIC.
AGG_TOKEN	provsql.agg_token_times_numeric (AGG_TOKEN a, NUMERIC b)
	AGG_TOKEN * NUMERIC.
AGG_TOKEN	provsql.agg_token_div_numeric (AGG_TOKEN a, NUMERIC b)
	AGG_TOKEN / NUMERIC.
AGG_TOKEN	provsql.numeric_plus_agg_token (NUMERIC a, AGG_TOKEN b)
	NUMERIC <op> AGG_TOKEN
AGG_TOKEN	provsql.numeric_minus_agg_token (NUMERIC a, AGG_TOKEN b)
	NUMERIC - AGG_TOKEN.
AGG_TOKEN	provsql.numeric_times_agg_token (NUMERIC a, AGG_TOKEN b)
	NUMERIC * AGG_TOKEN.
AGG_TOKEN	provsql.numeric_div_agg_token (NUMERIC a, AGG_TOKEN b)
	NUMERIC / AGG_TOKEN.
BOOLEAN	provsql.agg_token_op_agg_token (AGG_TOKEN left, AGG_TOKEN right)
	Operator declarations.
BOOLEAN	provsql.agg_token_op_numeric (AGG_TOKEN left, NUMERIC right)
BOOLEAN	provsql.numeric_op_agg_token (NUMERIC left, AGG_TOKEN right)
AGG_TOKEN	provsql.agg_token_cond (AGG_TOKEN a, UUID cond)
	Condition a discrete aggregate's distribution on an event: "SUM(x) | C".
BOOLEAN	provsql.agg_token_op_uuid (AGG_TOKEN left, UUID right)
AGG_TOKEN	provsql.agg_token_cond_predicate (AGG_TOKEN a, BOOLEAN predicate)
	Placeholder for "SUM(x) | (predicate)" on an AGG_TOKEN.
BOOLEAN	provsql.agg_token_op_boolean (AGG_TOKEN left, BOOLEAN right)
AGG_TOKEN	provsql.agg_conditioned_target (AGG_TOKEN a)
	Unpack the target of a conditioned AGG_TOKEN.
BOOLEAN	provsql.agg_token_comp_numeric (AGG_TOKEN a, NUMERIC b)
	Placeholder comparison of AGG_TOKEN with NUMERIC.
BOOLEAN	provsql.numeric_comp_agg_token (NUMERIC a, AGG_TOKEN b)
	Placeholder comparison of NUMERIC with AGG_TOKEN.
BOOLEAN	provsql.agg_token_lt_numeric (AGG_TOKEN left, NUMERIC right)
	SQL operator AGG_TOKEN < NUMERIC (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.numeric_lt_agg_token (NUMERIC left, AGG_TOKEN right)
	SQL operator NUMERIC < AGG_TOKEN (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.agg_token_le_numeric (AGG_TOKEN left, NUMERIC right)
	SQL operator AGG_TOKEN <= NUMERIC (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.numeric_le_agg_token (NUMERIC left, AGG_TOKEN right)
	SQL operator NUMERIC <= AGG_TOKEN (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.agg_token_eq_numeric (AGG_TOKEN left, NUMERIC right)
	SQL operator AGG_TOKEN = NUMERIC (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.numeric_eq_agg_token (NUMERIC left, AGG_TOKEN right)
	SQL operator NUMERIC = AGG_TOKEN (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.agg_token_ne_numeric (AGG_TOKEN left, NUMERIC right)
	SQL operator AGG_TOKEN <> NUMERIC (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.numeric_ne_agg_token (NUMERIC left, AGG_TOKEN right)
	SQL operator NUMERIC <> AGG_TOKEN (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.agg_token_ge_numeric (AGG_TOKEN left, NUMERIC right)
	SQL operator AGG_TOKEN >= NUMERIC (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.numeric_ge_agg_token (NUMERIC left, AGG_TOKEN right)
	SQL operator NUMERIC >= AGG_TOKEN (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.agg_token_gt_numeric (AGG_TOKEN left, NUMERIC right)
	SQL operator AGG_TOKEN > NUMERIC (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.numeric_gt_agg_token (NUMERIC left, AGG_TOKEN right)
	SQL operator NUMERIC > AGG_TOKEN (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.agg_token_comp_agg_token (AGG_TOKEN a, AGG_TOKEN b)
	Placeholder comparison of two AGG_TOKEN values (the diagonal).
BOOLEAN	provsql.agg_token_lt_agg_token (AGG_TOKEN left, AGG_TOKEN right)
	SQL operator AGG_TOKEN < AGG_TOKEN (placeholder rewritten at plan time).
BOOLEAN	provsql.agg_token_le_agg_token (AGG_TOKEN left, AGG_TOKEN right)
	SQL operator AGG_TOKEN <= AGG_TOKEN (placeholder rewritten at plan time).
BOOLEAN	provsql.agg_token_gt_agg_token (AGG_TOKEN left, AGG_TOKEN right)
	SQL operator AGG_TOKEN > AGG_TOKEN (placeholder rewritten at plan time).
BOOLEAN	provsql.agg_token_ge_agg_token (AGG_TOKEN left, AGG_TOKEN right)
	SQL operator AGG_TOKEN >= AGG_TOKEN (placeholder rewritten at plan time).
BOOLEAN	provsql.agg_token_eq_agg_token (AGG_TOKEN left, AGG_TOKEN right)
	SQL operator AGG_TOKEN = AGG_TOKEN (placeholder rewritten at plan time).
BOOLEAN	provsql.agg_token_ne_agg_token (AGG_TOKEN left, AGG_TOKEN right)
	SQL operator AGG_TOKEN <> AGG_TOKEN (placeholder rewritten at plan time).
BOOLEAN	provsql.agg_token_comp_text (AGG_TOKEN a, TEXT b)
	Placeholder comparison of AGG_TOKEN with TEXT.
BOOLEAN	provsql.text_comp_agg_token (TEXT a, AGG_TOKEN b)
	Placeholder comparison of TEXT with AGG_TOKEN.
BOOLEAN	provsql.agg_token_eq_text (AGG_TOKEN left, TEXT right)
	SQL operator AGG_TOKEN = TEXT (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.text_eq_agg_token (TEXT left, AGG_TOKEN right)
	SQL operator TEXT = AGG_TOKEN (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.agg_token_ne_text (AGG_TOKEN left, TEXT right)
	SQL operator AGG_TOKEN <> TEXT (placeholder rewritten by ProvSQL at plan time).
BOOLEAN	provsql.text_ne_agg_token (TEXT left, AGG_TOKEN right)
	SQL operator TEXT <> AGG_TOKEN (placeholder rewritten by ProvSQL at plan time).
random_variable	provsql.random_variable_in (CSTRING)
	Input function for the random_variable type.
CSTRING	provsql.random_variable_out (random_variable)
	Output function for the random_variable type.
random_variable	provsql.random_variable_make (UUID tok)
	Build a random_variable from a UUID (internal).
CREATE	provsql.CAST (random_variable AS UUID) WITHOUT FUNCTION AS ASSIGNMENT
	Binary-coercible cast random_variable -> UUID.
CREATE	provsql.CAST (UUID AS random_variable) WITHOUT FUNCTION
random_variable	provsql.agg_token_to_random_variable (AGG_TOKEN a)
	Coerce an AGG_TOKEN to a random_variable (its circuit token).
random_variable	provsql.CAST(AGG_TOKEN AS RANDOM_VARIABLE) (AGG_TOKEN)
BOOL	provsql.is_finite_float8 (DOUBLE PRECISION x)
	Internal: true iff x is a finite (non-NaN, non-±∞) float8.
random_variable	provsql.rv_parametric2 (TEXT family, UUID p1_tok, DOUBLE PRECISION p1_lit, UUID p2_tok, DOUBLE PRECISION p2_lit)
	Internal: build a two-parameter latent gate_rv.
random_variable	provsql.rv_parametric1 (TEXT family, UUID p_tok)
	Internal: build a one-parameter latent gate_rv (rate/scale).
random_variable	provsql.normal (random_variable mu, DOUBLE PRECISION sigma)
	normal(mu, sigma)
random_variable	provsql.normal (DOUBLE PRECISION mu, random_variable sigma)
random_variable	provsql.normal (random_variable mu, random_variable sigma)
random_variable	provsql.logistic (random_variable mu, DOUBLE PRECISION s)
	logistic(mu, s)
random_variable	provsql.logistic (DOUBLE PRECISION mu, random_variable s)
random_variable	provsql.logistic (random_variable mu, random_variable s)
random_variable	provsql.uniform (random_variable a, DOUBLE PRECISION b)
	uniform(a, b)
random_variable	provsql.uniform (DOUBLE PRECISION a, random_variable b)
random_variable	provsql.uniform (random_variable a, random_variable b)
random_variable	provsql.exponential (random_variable lambda)
	exponential(lambda)
random_variable	provsql.gamma (random_variable k, DOUBLE PRECISION lambda)
	gamma(k, lambda)
random_variable	provsql.gamma (DOUBLE PRECISION k, random_variable lambda)
random_variable	provsql.gamma (random_variable k, random_variable lambda)
random_variable	provsql.lognormal (random_variable mu, DOUBLE PRECISION sigma)
	lognormal(mu, sigma)
random_variable	provsql.lognormal (DOUBLE PRECISION mu, random_variable sigma)
random_variable	provsql.lognormal (random_variable mu, random_variable sigma)
random_variable	provsql.weibull (random_variable k, DOUBLE PRECISION lambda)
	weibull(k, lambda)
random_variable	provsql.weibull (DOUBLE PRECISION k, random_variable lambda)
random_variable	provsql.weibull (random_variable k, random_variable lambda)
random_variable	provsql.pareto (random_variable xm, DOUBLE PRECISION alpha)
	pareto(xm, alpha)
random_variable	provsql.pareto (DOUBLE PRECISION xm, random_variable alpha)
random_variable	provsql.pareto (random_variable xm, random_variable alpha)
random_variable	provsql.beta (random_variable alpha, DOUBLE PRECISION beta)
	beta(alpha, beta)
random_variable	provsql.beta (DOUBLE PRECISION alpha, random_variable beta)
random_variable	provsql.beta (random_variable alpha, random_variable beta)
random_variable	provsql.inverse_gamma (random_variable alpha, DOUBLE PRECISION beta)
	inverse_gamma(alpha, beta)
random_variable	provsql.inverse_gamma (DOUBLE PRECISION alpha, random_variable beta)
random_variable	provsql.inverse_gamma (random_variable alpha, random_variable beta)
random_variable	provsql.inverse_gaussian (random_variable mu, DOUBLE PRECISION lambda)
	inverse_gaussian(mu, lambda)
random_variable	provsql.inverse_gaussian (DOUBLE PRECISION mu, random_variable lambda)
random_variable	provsql.inverse_gaussian (random_variable mu, random_variable lambda)
random_variable	provsql.normal (DOUBLE PRECISION mu, DOUBLE PRECISION sigma)
	Construct a normal-distribution random variable.
random_variable	provsql.logistic (DOUBLE PRECISION mu, DOUBLE PRECISION s)
	Construct a logistic-distribution random variable Logistic(μ, s).
random_variable	provsql.uniform (DOUBLE PRECISION a, DOUBLE PRECISION b)
	Construct a uniform-distribution random variable on [a, b].
random_variable	provsql.exponential (DOUBLE PRECISION lambda)
	Construct an exponential-distribution random variable with rate λ
random_variable	provsql.erlang (INTEGER k, DOUBLE PRECISION lambda)
	Construct an Erlang-distribution random variable, sum of k i.i.d.
random_variable	provsql.gamma (DOUBLE PRECISION k, DOUBLE PRECISION lambda)
	Construct a gamma-distribution random variable with shape k (any positive real) and rate lambda.
random_variable	provsql.chi_squared (DOUBLE PRECISION k)
	Construct a chi-squared random variable with k degrees of freedom: syntactic sugar for gamma(k/2, 1/2).
random_variable	provsql.lognormal (DOUBLE PRECISION mu, DOUBLE PRECISION sigma)
	Construct a log-normal random variable: exp of a Normal(mu, sigma), parameterised by the underlying normal (so its median is exp(mu) and its mean exp(mu + sigma^2/2)).
random_variable	provsql.weibull (DOUBLE PRECISION k, DOUBLE PRECISION lambda)
	Construct a Weibull random variable with shape k and scale lambda.
random_variable	provsql.pareto (DOUBLE PRECISION xm, DOUBLE PRECISION alpha)
	Construct a Pareto random variable with scale (minimum) xm and shape alpha.
random_variable	provsql.inverse_gamma (DOUBLE PRECISION alpha, DOUBLE PRECISION beta)
	Construct an inverse-gamma random variable with shape alpha and scale beta.
random_variable	provsql.inverse_gaussian (DOUBLE PRECISION mu, DOUBLE PRECISION lambda)
	Construct an inverse-Gaussian (Wald) random variable with mean mu and shape lambda.
random_variable	provsql.wald (DOUBLE PRECISION mu, DOUBLE PRECISION lambda)
	Wald distribution: alias for inverse_gaussian.
random_variable	provsql.categorical_from_log_pmf (DOUBLE_PRECISION[] outcomes, DOUBLE_PRECISION[] log_pmf)
	Build a discrete (categorical) random variable from outcomes and UNNORMALISED log-masses.
random_variable	provsql.poisson (DOUBLE PRECISION lambda)
	Construct a Poisson random variable with mean lambda, as a truncated categorical.
random_variable	provsql.poisson (random_variable lambda)
	Poisson with a LATENT rate: poisson(random_variable).
random_variable	provsql.beta (DOUBLE PRECISION alpha, DOUBLE PRECISION beta)
	Construct a Beta(α, β) random variable on the unit interval.
random_variable	provsql.binomial (INTEGER n, DOUBLE PRECISION p)
	Construct a Binomial(n, p) random variable (number of successes in n independent trials), as a categorical.
random_variable	provsql.binomial (INTEGER n, random_variable p)
	Binomial with a fixed trial count and a LATENT success probability: binomial(INTEGER, random_variable).
random_variable	provsql.geometric (DOUBLE PRECISION p)
	Construct a Geometric(p) random variable – the number of TRIALS up to and including the first success (support starting at 1; subtract 1 for the failures convention).
random_variable	provsql.geometric (random_variable p)
	Geometric with a LATENT success probability: geometric(random_variable).
random_variable	provsql.hypergeometric (INTEGER pop_n, INTEGER k_marked, INTEGER n)
	Construct a Hypergeometric(N, K, n) random variable: the number of marked items among n draws WITHOUT replacement from a population of pop_n items of which k_marked are marked.
random_variable	provsql.negative_binomial (DOUBLE PRECISION r, DOUBLE PRECISION p)
	Construct a negative-binomial random variable: the number of FAILURES before the r-th success (support starting at 0), with real r > 0 allowed (the Polya / overdispersed-count parameterisation, the Poisson-Gamma mixture).
random_variable	provsql.negative_binomial (DOUBLE PRECISION r, random_variable p)
random_variable	provsql.negative_binomial (random_variable r, DOUBLE PRECISION p)
random_variable	provsql.negative_binomial (random_variable r, random_variable p)
TABLE	provsql.rv_families ()
	Catalog of the registered continuous-distribution families.
random_variable	provsql.mixture (UUID p, random_variable x, random_variable y)
	Construct a probabilistic-mixture random variable.
random_variable	provsql.mixture (DOUBLE PRECISION p_value, random_variable x, random_variable y)
	Ad-hoc mixture constructor that mints a fresh anonymous gate_input Bernoulli with probability p_value.
random_variable	provsql.categorical (DOUBLE_PRECISION[] probs, DOUBLE_PRECISION[] outcomes)
	Categorical-RV constructor over explicit (probabilities, values) arrays.
random_variable	provsql.gmm (DOUBLE_PRECISION[] weights, DOUBLE_PRECISION[] means, DOUBLE_PRECISION[] stddevs)
	Gaussian-mixture-model (GMM) constructor.
random_variable	provsql.empirical_samples (DOUBLE_PRECISION[] samples)
	Empirical-samples constructor: the ecdf of a sample bundle as a random_variable.
random_variable	provsql.empirical_cdf (DOUBLE_PRECISION[] grid, DOUBLE_PRECISION[] cdf)
	Empirical-CDF constructor: a piecewise-linear CDF table as a random_variable.
random_variable	provsql.as_random (DOUBLE PRECISION c)
	Lift a deterministic constant into a random_variable.
CREATE	provsql.CAST (DOUBLE PRECISION AS random_variable) WITH FUNCTION as_random(DOUBLE PRECISION) AS IMPLICIT
	Implicit cast DOUBLE PRECISION -> random_variable (lifts a scalar literal to a constant RV).
random_variable	provsql.as_random (INTEGER c)
	as_random for INTEGER (delegates to the float8 form).
random_variable	provsql.as_random (NUMERIC c)
	as_random for NUMERIC (delegates to the float8 form).
random_variable	provsql.CAST(INTEGER AS RANDOM_VARIABLE) (INTEGER)
	Implicit cast INTEGER -> random_variable.
random_variable	provsql.CAST(NUMERIC AS RANDOM_VARIABLE) (NUMERIC)
	Implicit cast NUMERIC -> random_variable.
UUID	provsql.provenance_delta (UUID token)
	Create a δ-semiring gate wrapping a provenance token.
AGG_TOKEN	provsql.provenance_aggregate (INTEGER aggfnoid, INTEGER aggtype, ANYELEMENT val, UUID[] tokens, BOOLEAN is_scalar=false)
	Build an aggregate provenance gate from grouped tokens.
UUID	provsql.provenance_semimod (ANYELEMENT val, UUID token)
	Create a semimodule scalar multiplication gate.
DOUBLE PRECISION	provsql.probability_evaluate (UUID token, TEXT method=NULL, TEXT arguments=NULL)
	Compute the probability of a provenance token.
DOUBLE PRECISION	provsql.probability (UUID token, TEXT method=NULL, TEXT arguments=NULL)
	Short alias of probability_evaluate.
DOUBLE PRECISION	provsql.probability (BOOLEAN predicate, TEXT method=NULL, TEXT arguments=NULL)
	Probability of a Boolean event over random variables.
VOID	provsql.probability_bounds (UUID token, OUT DOUBLE PRECISION lower, OUT DOUBLE PRECISION upper)
	Cheap certified probability interval of a DNF-shaped circuit.
DOUBLE PRECISION	provsql.expected (ANYELEMENT input, UUID prov=gate_one(), TEXT method=NULL, TEXT arguments=NULL)
	Compute the expected value of a probabilistic scalar.
DOUBLE PRECISION	provsql.rv_moment (UUID token, INTEGER k, BOOLEAN central, UUID prov=gate_one())
	Internal: shared C entry point for variance / moment / central_moment.
DOUBLE PRECISION	provsql.agg_avg_moment_exact (UUID token, INTEGER k)
	Exact E[AVG^k | COUNT >= 1] over independent rows (the joint (sum, count) fold); NULL when the shape is out of scope (shared leaves, compound contributors), signalling agg_raw_moment's avg arm to fall back to the Monte-Carlo scalar path.
DOUBLE PRECISION	provsql.agg_collapsed_moment (UUID token, INTEGER k)
	Collapsed (Rao-Blackwellised) raw moment E[C^k] of a correlated COUNT / SUM whose per-row selection events are coupled through a single shared continuous latent: 1-D quadrature over the latent, closed-form per-row CDF given it (O(G·n), exact up to the grid).
DOUBLE_PRECISION[]	provsql.agg_collapsed_moments (UUID token)
	Both collapsed raw moments {E[C], E[C^2]} of a correlated COUNT / SUM from a single circuit load and plan build; NULL when the shared-latent pattern does not match.
UUID	provsql.agg_defined_event (UUID token)
	Boolean event "this aggregate-carrying gate's value is defined (non-NULL) in the world".
DOUBLE PRECISION	provsql.agg_raw_moment (AGG_TOKEN token, INTEGER k, UUID prov=gate_one(), TEXT method=NULL, TEXT arguments=NULL)
	Compute the raw moment E[X^k | prov] of an AGG_TOKEN aggregate.
DOUBLE PRECISION	provsql.variance (ANYELEMENT input, UUID prov=gate_one(), TEXT method=NULL, TEXT arguments=NULL)
	Compute the variance Var[X | prov] of a probabilistic scalar.
DOUBLE PRECISION	provsql.moment (ANYELEMENT input, INTEGER k, UUID prov=gate_one(), TEXT method=NULL, TEXT arguments=NULL)
	Compute the raw moment E[X^k | prov] of a probabilistic scalar.
DOUBLE PRECISION	provsql.rv_quantile (UUID token, DOUBLE PRECISION p, UUID prov=gate_one())
	Internal: rv-side quantile computation.
DOUBLE PRECISION	provsql.quantile (ANYELEMENT input, DOUBLE PRECISION p, UUID prov=gate_one(), TEXT method=NULL, TEXT arguments=NULL)
	Compute the p-quantile (inverse CDF) of a probabilistic scalar.
VOID	provsql.rv_support (UUID token, UUID prov=gate_one(), float8 &lo, float8 &hi)
	Internal: rv-side support computation.
VOID	provsql.support (ANYELEMENT input, UUID prov=gate_one(), TEXT method=NULL, TEXT arguments=NULL, float8 &lo, float8 &hi)
	Compute the support interval [lo, hi] of a probabilistic (or deterministic) scalar.
DOUBLE PRECISION	provsql.central_moment (ANYELEMENT input, INTEGER k, UUID prov=gate_one(), TEXT method=NULL, TEXT arguments=NULL)
	Compute the central moment E[(X - E[X|prov])^k | prov].
DOUBLE PRECISION	provsql.rv_covariance (UUID x, UUID y, UUID prov)
	C entry point behind covariance (UUID-level binding).
DOUBLE PRECISION	provsql.covariance (random_variable x, random_variable y, UUID prov=gate_one())
	Covariance Cov(X, Y) = E[XY] − E[X]·E[Y] of two random variables.
DOUBLE PRECISION	provsql.stddev (random_variable x, UUID prov=gate_one())
	Standard deviation σ(X) = √Var(X) of a random variable.
DOUBLE PRECISION	provsql.rv_correlation (UUID x, UUID y, UUID prov)
	C entry point behind correlation (UUID-level binding).
DOUBLE PRECISION	provsql.correlation (random_variable x, random_variable y, UUID prov=gate_one())
	Pearson correlation ρ(X, Y) = Cov(X, Y) / (σ(X)·σ(Y)).
DOUBLE PRECISION	provsql.rv_entropy (UUID token, UUID prov)
	C entry point behind entropy (UUID-level binding).
DOUBLE PRECISION	provsql.entropy (random_variable x, UUID prov=gate_one())
	Entropy H(X) of a random variable, in nats.
DOUBLE PRECISION	provsql.rv_kl (UUID p, UUID q)
	C entry point behind kl (UUID-level binding).
DOUBLE PRECISION	provsql.kl (random_variable p, random_variable q)
	Kullback-Leibler divergence KL(P || Q), in nats.
DOUBLE PRECISION	provsql.rv_mutual_information (UUID x, UUID y)
	C entry point behind mutual_information (UUID-level binding).
DOUBLE PRECISION	provsql.mutual_information (random_variable x, random_variable y)
	Mutual information I(X; Y), in nats.
DOUBLE PRECISION	provsql.shapley (UUID token, UUID variable, TEXT method=NULL, TEXT arguments=NULL, BOOLEAN banzhaf='f')
	Compute the Shapley value of an input variable.
SETOF RECORD	provsql.shapley_all_vars (UUID token, TEXT method=NULL, TEXT arguments=NULL, BOOLEAN banzhaf='f', OUT UUID variable, OUT DOUBLE PRECISIONvalue)
	Compute Shapley values for all input variables at once.
DOUBLE PRECISION	provsql.banzhaf (UUID token, UUID variable, TEXT method=NULL, TEXT arguments=NULL)
	Compute the Banzhaf power index of an input variable.
SETOF RECORD	provsql.banzhaf_all_vars (UUID token, TEXT method=NULL, TEXT arguments=NULL, OUT UUID variable, OUT DOUBLE PRECISIONvalue)
	Compute Banzhaf power indices for all input variables at once.
DOUBLE PRECISION	provsql.reachability_evaluate (INT[] sources, INT[] destinations, UUID[] tokens, DOUBLE_PRECISION[] probabilities, INT source, INT target, BOOLEAN directed)
	Exact reachability probability over bounded-treewidth data (columnar form).
VOID	provsql.reachability_compile_stats (INT[] sources, INT[] destinations, UUID[] tokens, DOUBLE_PRECISION[] probabilities, INT source, INT target, BOOLEAN directed, OUT DOUBLE PRECISIONprobability, OUT INT data_treewidth, OUT BIGINT nb_bags, OUT BIGINT max_states, OUT BIGINT nb_gates, OUT BIGINT nb_variables)
	Reachability probability plus compilation statistics (columnar form).
VOID	provsql.ucq_joint_compile_stats (INT[] disjunct_nvars, INT[] atom_disjunct, INT[] atom_rel, INT[] atom_vars, INT[] atom_arity, INT[] fact_rel, INT[] fact_elems, INT[] fact_arity, UUID[] fact_tokens, DOUBLE_PRECISION[] fact_probs, OUT DOUBLE PRECISIONprobability, OUT INT joint_treewidth, OUT INT data_treewidth_lb, OUT INT circuit_treewidth_lb, OUT BIGINT n_bags, OUT BIGINT max_states, OUT BIGINT dd_size, OUT INT n_enumerating)
	Boolean UCQ probability plus compilation statistics (columnar form, internal).
VOID	provsql.ucq_joint_compile_stats (JSONB query, INT[] fact_rel, INT[] fact_elems, INT[] fact_arity, UUID[] fact_tokens, DOUBLE_PRECISION[] fact_probs, OUT DOUBLE PRECISIONprobability, OUT INT joint_treewidth, OUT INT data_treewidth_lb, OUT INT circuit_treewidth_lb, OUT BIGINT n_bags, OUT BIGINT max_states, OUT BIGINT dd_size, OUT INT n_enumerating)
	Boolean UCQ probability plus statistics from a JSON specification.
VOID	provsql.ucq_joint_compile_stats_tracked (INT[] disjunct_nvars, INT[] atom_disjunct, INT[] atom_rel, INT[] atom_vars, INT[] atom_arity, INT[] fact_rel, INT[] fact_elems, INT[] fact_arity, UUID[] fact_tokens, OUT DOUBLE PRECISIONprobability, OUT INT joint_treewidth, OUT INT data_treewidth_lb, OUT INT circuit_treewidth_lb, OUT BIGINT n_bags, OUT BIGINT max_states, OUT BIGINT dd_size, OUT INT n_enumerating)
	Correlated Boolean UCQ probability plus compilation statistics (columnar form, internal).
VOID	provsql.ucq_joint_compile_stats_tracked (JSONB query, INT[] fact_rel, INT[] fact_elems, INT[] fact_arity, UUID[] fact_tokens, OUT DOUBLE PRECISIONprobability, OUT INT joint_treewidth, OUT INT data_treewidth_lb, OUT INT circuit_treewidth_lb, OUT BIGINT n_bags, OUT BIGINT max_states, OUT BIGINT dd_size, OUT INT n_enumerating)
	Correlated Boolean UCQ probability plus statistics from a JSON spec.
UUID	provsql.ucq_joint_materialize_tracked (INT[] disjunct_nvars, INT[] atom_disjunct, INT[] atom_rel, INT[] atom_vars, INT[] atom_arity, INT[] fact_rel, INT[] fact_elems, INT[] fact_arity, UUID[] fact_tokens)
	Compile a correlated UCQ and materialise its certified d-D, returning the root provenance token (columnar form, internal).
UUID	provsql.ucq_joint_materialize_tracked (JSONB query, INT[] fact_rel, INT[] fact_elems, INT[] fact_arity, UUID[] fact_tokens)
	Compile a correlated UCQ and materialise its certified d-D from a JSON spec, returning the root provenance token.
UUID	provsql.ucq_joint_provenance (JSONB descriptor, UUID fallback=NULL)
	Compile a UCQ over named relations into a materialised certified d-D, gathering the facts from the store – the descriptor-driven engine.
UUID	provsql.ucq_mobius_materialize_tracked (INT[] disjunct_nvars, INT[] atom_disjunct, INT[] atom_rel, INT[] atom_vars, INT[] atom_arity, INT[] fact_rel, INT[] fact_elems, INT[] fact_arity, UUID[] fact_tokens, UUID lineage=NULL)
	=========================================================================== Safe-UCQ Möbius-inversion route (mobius_evaluate.cpp).
VOID	provsql.ucq_mobius_compile_stats (INT[] disjunct_nvars, INT[] atom_disjunct, INT[] atom_rel, INT[] atom_vars, INT[] atom_arity, INT[] fact_rel, INT[] fact_elems, INT[] fact_arity, UUID[] fact_tokens, OUT DOUBLE PRECISIONprobability, OUT INT n_components, OUT INT n_cnf_conjuncts, OUT INT lattice_size, OUT INT n_nonzero, OUT INT n_cancelled, OUT BOOLEAN cancelled_hard, OUT BIGINT dd_size, OUT BIGINT memo_hits)
	Compile the Möbius circuit and return the lattice statistics plus the probability (the demonstrability surface).
UUID	provsql.mobius_or_null (UUID tok)
	Pass a token through iff it is a gate_mobius, else return NULL.
UUID	provsql.ucq_mobius_provenance (JSONB descriptor, UUID fallback=NULL)
	Möbius-route provenance from a descriptor (the planner-substituted entry point, and the manual one).
RECORD	provsql.mobius_compile_stats (JSONB descriptor, OUT DOUBLE PRECISIONprobability, OUT INT n_components, OUT INT n_cnf_conjuncts, OUT INT lattice_size, OUT INT n_nonzero, OUT INT n_cancelled, OUT BOOLEAN cancelled_hard, OUT BIGINT dd_size, OUT BIGINT memo_hits)
	Möbius lattice statistics + probability from a descriptor: the demonstrability SRF.
VOID	provsql.ucq_joint_gather (JSONB descriptor, INT[] &disjunct_nvars, INT[] &atom_disjunct, INT[] &atom_rel, INT[] &atom_vars, INT[] &atom_arity, INT[] &fact_rel, INT[] &fact_elems, INT[] &fact_arity, UUID[] &fact_tokens, TEXT[] &val_by_id)
	Internal gather for the per-answer joint route: parse descriptor into the columnar UCQ arrays and gather every fact (relation index, dense element ids, provenance token) with the value dictionary.
UUID	provsql.ucq_joint_provenance_answer (JSONB descriptor, INT[] head_vars, TEXT[] head_vals, UUID fallback=NULL)
	Per-answer joint-width provenance via the TOP-DOWN single DP (planner-substituted, C).
UUID	provsql.ucq_mobius_provenance_answer (JSONB descriptor, INT[] head_vars, TEXT[] head_vals, UUID fallback=NULL)
	Per-answer safe-UCQ Möbius provenance (planner-substituted): one head-pinned Möbius circuit per output group.
SETOF RECORD	provsql.reachability_materialize (INT[] sources, INT[] destinations, UUID[] tokens, DOUBLE_PRECISION[] probabilities, UUID[] block_keys, INT[] block_indices, INT[] source_vertices, UUID[] source_tokens, DOUBLE_PRECISION[] source_probabilities, BOOLEAN directed, OUT INT vertex, OUT UUID token)
	Compile and materialise the reachability provenance of every vertex (columnar form, internal).
SETOF RECORD	provsql.reachability_materialize_hops (INT[] sources, INT[] destinations, UUID[] tokens, DOUBLE_PRECISION[] probabilities, UUID[] block_keys, INT[] block_indices, INT[] source_vertices, UUID[] source_tokens, DOUBLE_PRECISION[] source_probabilities, BOOLEAN directed, INT hop_bound, INT hop_seed, OUT INT vertex, OUT INT hops, OUT UUID token)
	Bounded-hop variant of reachability_materialize() (internal).
SETOF RECORD	provsql.reachability_materialize_any (INT[] sources, INT[] destinations, UUID[] tokens, DOUBLE_PRECISION[] probabilities, UUID[] block_keys, INT[] block_indices, INT[] source_vertices, UUID[] source_tokens, DOUBLE_PRECISION[] source_probabilities, BOOLEAN directed, INT[] group_ids, INT[] member_vertices, OUT INT group_id, OUT UUID token)
	Per-group "some member reachable" compilation (columnar form, internal).
UUID	provsql.reachability_materialize_cover (INT[] sources, INT[] destinations, UUID[] tokens, DOUBLE_PRECISION[] probabilities, UUID[] block_keys, INT[] block_indices, INT[] source_vertices, UUID[] source_tokens, DOUBLE_PRECISION[] source_probabilities, BOOLEAN directed, INT[] member_vertices)
	Compile and materialise the "every member vertex reachable" (k-terminal / coverage) circuit (columnar form, internal).
VOID	provsql.plant_reach_any_groups (TEXT work_name, TEXT node_attribute, REGCLASS member_rel, TEXT member_attribute, TEXT group_attribute, REGCLASS edge_rel, TEXT source_attribute, TEXT destination_attribute, TEXT source_value, BOOLEAN directed, TEXT edge_quals=NULL, REGCLASS source_rel=NULL, TEXT source_rel_attribute=NULL, TEXT edge_sql=NULL, TEXT member_quals=NULL)
	Plant certified any-member-reachable gates for a grouped reachability aggregation (internal).
VOID	provsql.plant_reach_cover (TEXT work_name, TEXT node_attribute, REGCLASS edge_rel, TEXT source_attribute, TEXT destination_attribute, TEXT source_value, BOOLEAN directed, TEXT[] node_values, TEXT edge_quals=NULL, REGCLASS source_rel=NULL, TEXT source_rel_attribute=NULL, TEXT edge_sql=NULL)
	Plant the certified all-members-reachable gate for a reachability self-join conjunction (internal).
UUID[]	provsql.token_conjunctive_leaves (UUID token)
	Input leaves of a conjunction-shaped provenance token (internal).
VOID	provsql.gather_reachability_edges (REGCLASS rel, TEXT source_attribute, TEXT destination_attribute, TEXT[] extra_vertices, TEXT edge_quals=NULL, TEXT rel_sql=NULL, INT[] &sources, INT[] &destinations, UUID[] &tokens, DOUBLE_PRECISION[] &probabilities, UUID[] &block_keys, INT[] &block_indices, INT[] &extra_ids, TEXT[] &vertices)
	Gather the edges of a tracked relation in the columnar form expected by reachability_evaluate (internal).
VOID	provsql.gather_reachability_sources (REGCLASS rel, TEXT source_attribute, TEXT[] &source_values, UUID[] &source_tokens, DOUBLE_PRECISION[] &source_probabilities)
	Gather a source relation's vertices, tokens and probabilities (internal).
VOID	provsql.eval_reachability (REGCLASS edge_rel, TEXT source_attribute, TEXT destination_attribute, TEXT source_value, BOOLEAN directed, TEXT work_name, TEXT colnames, TEXT coldef, TEXT coltype, TEXT body_sql, TEXT edge_quals=NULL, REGCLASS source_rel=NULL, TEXT source_rel_attribute=NULL, TEXT edge_sql=NULL, INT hop_bound=NULL, INT hop_seed=NULL, INT hops_position=NULL)
	Fixpoint driver for the recursive reachability shape: decomposition-aligned compilation with fallback to eval_recursive.
TEXT	provsql.view_circuit (UUID token, REGCLASS token2desc, INT dbg=0)
	Return a DOT or TEXT visualization of the provenance circuit.
TEXT	provsql.compile_to_ddnnf_dot (UUID token, TEXT compiler='')
	Return a DOT visualisation of the d-DNNF compiled from the provenance circuit.
TEXT	provsql.compile_to_ddnnf (UUID token, TEXT compiler='')
	Return the compiled d-DNNF of a provenance circuit in the c2d / d4 ".nnf" TEXT interchange format.
jsonb	provsql.ddnnf_stats (UUID token, TEXT compiler='')
	Structural statistics of the d-DNNF a compiler produces for a provenance circuit.
TEXT	provsql.tseytin_cnf (UUID token, BOOLEAN weighted=TRUE, BOOLEAN mapping=TRUE)
	Return the DIMACS CNF (Tseytin transformation) of the provenance circuit.
jsonb	provsql.tseytin_cnf_mapping_json (UUID token)
	Map each DIMACS variable of tseytin_cnf back to its provenance input.
TABLE	provsql.tseytin_cnf_mapping (UUID token)
TEXT	provsql.tree_decomposition_dot (UUID token)
	Return a DOT visualisation of the tree decomposition of the provenance circuit.
BOOLEAN	provsql.tool_available (TEXT name)
	Report whether an external tool is on the backend's resolved PATH.
CREATE TABLE IF NOT EXISTS	provsql.tool_overrides (name TEXT PRIMARY KEY, removed BOOLEAN NOT NULL DEFAULT false, kind TEXT, executable TEXT, operations TEXT[], input_formats TEXT[], output_format TEXT, parser TEXT, preference INT, enabled BOOLEAN, dependencies TEXT[], argtpl TEXT, argtpl_circuit TEXT, endpoint TEXT)
	Persistent overrides overlaid on the compiled-in tool seed.
TABLE	provsql.tool_registry_list ()
	Set-returning listing backing the provsql.tools view.
VOID	provsql.register_tool (TEXT name, TEXT executable=NULL, TEXT kind='cli', TEXT[] operations=NULL, TEXT[] input_formats=NULL, TEXT output_format=NULL, TEXT parser=NULL, TEXT argtpl=NULL, TEXT argtpl_circuit=NULL, INT preference=0, BOOLEAN enabled=true, TEXT endpoint=NULL)
	Register a tool, or replace the RECORD with the same logical name.
VOID	provsql.unregister_tool (TEXT name)
	Unregister a tool; errors on an unknown tool name.
VOID	provsql.set_tool_enabled (TEXT name, BOOLEAN enabled)
	Enable/disable a tool; errors on an unknown tool name.
VOID	provsql.set_tool_preference (TEXT name, INT preference)
	Set a tool's preference; errors on an unknown tool name.
TEXT	provsql.to_provxml (UUID token, REGCLASS token2desc=NULL)
	Return an XML representation of the provenance circuit.
UUID	provsql.provenance ()
	Return the provenance token of the current query result tuple.
TEXT	provsql.where_provenance (UUID token)
	Compute where-provenance for a result tuple.
VOID	provsql.reset_constants_cache ()
	Reset the internal cache of OID constants used by the query rewriter.
VARCHAR	provsql.sr_formula (ANYELEMENT token, REGCLASS token2value=NULL)
	Evaluate provenance as a symbolic formula (e.g., "a ⊗ b ⊕ c").
INT	provsql.sr_counting (ANYELEMENT token, REGCLASS token2value)
	Evaluate provenance over the counting semiring (ℕ).
VARCHAR	provsql.sr_why (ANYELEMENT token, REGCLASS token2value)
	Evaluate provenance as why-provenance (set of witness sets).
VARCHAR	provsql.sr_how (ANYELEMENT token, REGCLASS token2value)
	Evaluate provenance as how-provenance (canonical polynomial provenance ℕ[X], universal commutative-semiring provenance).
VARCHAR	provsql.sr_which (ANYELEMENT token, REGCLASS token2value)
	Evaluate provenance as which-provenance (lineage: a single set of contributing labels).
VARCHAR	provsql.sr_boolexpr (ANYELEMENT token, REGCLASS token2value=NULL)
	Evaluate provenance as a Boolean expression.
BOOLEAN	provsql.sr_boolean (ANYELEMENT token, REGCLASS token2value)
	Evaluate provenance over the Boolean semiring (true/false).
BOOLEAN	provsql.true_nonzero (UUID token)
	Structural universal-zero test (C backend of nonzero's default mode).
BOOLEAN	provsql.nonzero (UUID token, TEXT semiring=NULL, REGCLASS mapping=NULL)
	Test whether a provenance annotation is nonzero.
BOOLEAN	provsql.present (UUID token)
	Presence in the vanilla SQL answer on this instance.
FLOAT	provsql.sr_tropical (ANYELEMENT token, REGCLASS token2value, BOOLEAN nonnegative=false)
	Evaluate provenance over the tropical (min-plus) m-semiring.
FLOAT	provsql.sr_viterbi (ANYELEMENT token, REGCLASS token2value)
	Evaluate provenance over the Viterbi (max-times) m-semiring.
FLOAT	provsql.sr_lukasiewicz (ANYELEMENT token, REGCLASS token2value)
	Evaluate provenance over the Łukasiewicz fuzzy m-semiring.
ANYENUM	provsql.sr_minmax (UUID token, REGCLASS token2value, ANYENUM element_one)
	Evaluate provenance over the min-max m-semiring on a user ENUM.
ANYENUM	provsql.sr_maxmin (UUID token, REGCLASS token2value, ANYENUM element_one)
	Evaluate provenance over the max-min m-semiring on a user ENUM.
ANYELEMENT	provsql.choose_function (ANYELEMENT state, ANYELEMENT data)
	Transition function for the choose aggregate (keeps first non-NULL value).
VOID	provsql.choose (ANYELEMENT)
	Aggregate that returns an arbitrary non-NULL value from a group.
VOID	provsql.explode_table (TEXT _tbl, TEXT AGG_TOKEN)
	Explodes a table column containing aggregated provenance into multiple rows.
TEXT	provsql.setup_search_path ()
	Append provsql to this database's default search_path, if missing.
TRIGGER	insert_statement_trigger ()
	Trigger function for INSERT statement provenance tracking.
TRIGGER	update_statement_trigger ()
	Trigger function for UPDATE statement provenance tracking.
TSTZMULTIRANGE	sr_temporal (ANYELEMENT token, REGCLASS token2value)
	Evaluate provenance over the temporal (interval-union) m-semiring.
nummultirange	sr_interval_num (ANYELEMENT token, REGCLASS token2value)
	Evaluate provenance over the interval-union m-semiring with a NUMERIC multirange carrier.
int4multirange	sr_interval_int (ANYELEMENT token, REGCLASS token2value)
	Evaluate provenance over the interval-union m-semiring with an int4 multirange carrier.
TSTZMULTIRANGE	union_tstzintervals (UUID token, REGCLASS token2value)
	Evaluate temporal provenance as a TIMESTAMP multirange.
SETOF RECORD	timetravel (TEXT tablename, TIMESTAMPTZ at_time)
	Query a table as it was at a specific point in time.
SETOF RECORD	timeslice (TEXT tablename, TIMESTAMPTZ from_time, TIMESTAMPTZ to_time)
	Query a table for rows valid during a time interval.
SETOF RECORD	history (TEXT tablename, TEXT[] col_names, TEXT[] col_values)
	Query the full temporal history of specific rows.
TSTZMULTIRANGE	get_valid_time (UUID token, TEXT tablename)
	Get the valid time range for a specific tuple.
UUID	undo (UUID c)
	Undo a previously recorded update operation.
UUID	replace_the_circuit (UUID x, UUID c, UUID u)
	Recursively rewrite a circuit to undo a specific operation.
Order statistics over random_variable
Same-row greatest / least over random_variable arguments: the order-statistic counterpart of the element-wise "+ - * /" operators. They lower to a single gate_arith with the MAX / MIN opcode over the argument circuits, the same n-ary shape the max / min aggregates build. Evaluation is Monte-Carlo-correct out of the box (std::max / std::min over the jointly-sampled children, so shared base RVs stay coupled); closed forms for i.i.d. families come from the analytic order-statistic pass. PostgreSQL's built-in GREATEST / LEAST are dedicated syntax (a MinMaxExpr requiring a btree comparison), not overloadable functions, so the surface is the schema-qualified provsql.greatest(...) / provsql.least(...). NULL arguments are ignored, matching the built-in (an all-NULL / empty call returns NULL).
CREATE OR REPLACE FUNCTION	provsql.greatest (VARIADIC args random_variable[]) RETURNS random_variable AS CREATE OR REPLACE FUNCTION "least"(VARIADIC args random_variable[]) RETURNS random_variable AS random_variable rv_case(UUID[] children)
	"greatest" / "least" are col_name keywords, so the CREATE FUNCTION name must be quoted; callers reach them qualified as provsql.greatest(...).
AGG_TOKEN	provsql.agg_case (UUID[] children)
	Build an AGG_TOKEN from a guarded-selection gate_case.
Aggregates over random_variable
An overload of the standard sum aggregate that takes a random_variable per row and returns the random_variable representing the (provenance-weighted) sum. Lives in the provsql schema so a sum(random_variable) call resolves to it without colliding with the built-in NUMERIC sum overloads in pg_catalog. Direct calls outside a provenance-tracked query treat each row's contribution unconditionally (no per-row Boolean selector). When the planner hook sees a provsql.sum Aggref over a provenance-tracked query, it wraps the per-row argument x in provsql.mixture(prov_token, x, provsql.as_random(0)) so the aggregate's effective semantics become \(\mathrm{SUM}(x) = \sum_i \mathbf{1}\{\varphi_i\} \cdot X_i\), the natural extension of semimodule-provenance to RV-valued M. The internal state is the array of UUIDs of the per-row mixtures. The final function builds a single gate_arith PLUS over them (or returns as_random(0) for an empty group, the additive identity). Sharing on provenance_arith's v5 hash means two sum invocations over the same set of rows collide on the same gate.
random_variable	provsql.rv_aggregate_semimod (UUID prov, random_variable rv)
	Per-row helper: wrap an RV in mixture(prov, rv, as_random(0)).
random_variable	provsql.rv_aggregate_semimod (UUID prov, random_variable rv, DOUBLE PRECISION identity)
	Identity-parameterised per-row wrap for an RV-returning aggregate.
random_variable	provsql.rv_aggregate_indicator (UUID prov)
	Per-row denominator wrap for avg(random_variable): the provenance indicator \(\mathbf{1}\{\varphi\}\).
random_variable	provsql.rv_aggregate_indicator (UUID prov, random_variable rv)
	Value-aware presence indicator: NULL when the row's aggregated value is NULL.
UUID[]	provsql.sum_rv_sfunc (UUID[] state, random_variable rv)
	State-transition function for sum(random_variable).
random_variable	provsql.sum_rv_ffunc (UUID[] state)
	Final function for sum(random_variable): build a gate_arith PLUS root.
VOID	provsql.sum (random_variable)
random_variable	provsql.rv_sum_or_null_ffunc (UUID[] state)
	Numerator final function for the avg rewrite: sum, NULL on an empty group.
VOID	provsql.rv_sum_or_null (random_variable)
random_variable	provsql.avg_rv_ffunc (UUID[] state)
	Final function for avg(random_variable).
VOID	provsql.avg (random_variable)
random_variable	provsql.product_rv_ffunc (UUID[] state)
	Final function for product(random_variable): fold a gate_arith TIMES root over the per-row contributions.
VOID	provsql.product (random_variable)
random_variable	provsql.extremum_rv_ffunc (UUID[] state, INTEGER op, DOUBLE PRECISION identity)
	Final function for max(random_variable) / min(random_variable): fold a gate_arith MAX / MIN root over the per-row contributions.
random_variable	provsql.max_rv_ffunc (UUID[] state)
random_variable	provsql.min_rv_ffunc (UUID[] state)
VOID	provsql.max (random_variable)
VOID	provsql.min (random_variable)
UUID[]	provsql.rv_stat1_sfunc (UUID[] state, random_variable x)
	SQL-standard statistic aggregates over random_variable rows: covar_pop / covar_samp / corr (two-argument), stddev_pop / stddev_samp (one-argument), and the ordered-set percentile_cont.
UUID[]	provsql.rv_stat2_sfunc (UUID[] state, random_variable x, random_variable y)
	State transition for the two-argument RV statistic aggregates (covar_pop / covar_samp / corr): append the certain indicator and the row's RV pair as a triple.
UUID[]	provsql.rv_stat1_impl_sfunc (UUID[] state, random_variable ind, random_variable x)
	Indicator-carrying state transition for the one-argument rv_*_impl statistic aggregates: the planner-hook rewrite passes the row's provenance indicator rv_aggregate_indicator(prov) as ind.
UUID[]	provsql.rv_stat2_impl_sfunc (UUID[] state, random_variable ind, random_variable x, random_variable y)
	Indicator-carrying state transition for the two-argument rv_*_impl statistic aggregates.
VOID	provsql.rv_stat_sum_tokens (UUID[] state, INTEGER stride, OUT UUID n_tok, OUT UUID sx_tok, OUT UUID sxx_tok, OUT UUID sy_tok, OUT UUID sxy_tok, OUT UUID syy_tok)
	Mint the indicator-weighted power-sum gates shared by the covariance / stddev final functions.
UUID	provsql.rv_stat_var_pop_token (UUID n_tok, UUID s_tok, UUID ss_tok)
	Population-variance gate \(SXX/N - (SX/N)^2\) from the power-sum tokens.
UUID	provsql.rv_stat_var_samp_token (UUID n_tok, UUID s_tok, UUID ss_tok)
	Sample-variance gate \((SXX - SX^2/N) / (N - 1)\) from the power-sum tokens (NaN in a world with \(N \le 1\), the undefined-world convention).
UUID	provsql.rv_stat_sqrt_token (UUID v_tok)
	\(\sqrt{\max(v, 0)}\) gate over a variance token: the max-clamp removes the tiny negative values float error can produce (variance is mathematically non-negative), so the POW domain guard never fires.
UUID	provsql.rv_stat_covar_pop_token (UUID n_tok, UUID sx_tok, UUID sy_tok, UUID sxy_tok)
	Population-covariance gate \(SXY/N - (SX/N)(SY/N)\) from the power-sum tokens.
random_variable	provsql.covar_pop_rv_ffunc (UUID[] state)
	Final function for covar_pop(random_variable, random_variable).
random_variable	provsql.covar_samp_rv_ffunc (UUID[] state)
	Final function for covar_samp(random_variable, random_variable): \((SXY - SX\,SY/N) / (N-1)\).
random_variable	provsql.corr_rv_ffunc (UUID[] state)
	Final function for corr(random_variable, random_variable): \(\mathrm{covar\_pop} / \sqrt{\max(v_x v_y, 0)}\) (a zero-variance world divides to \(\pm\infty\) / NaN, the undefined-world convention, matching SQL's NULL for a zero-stddev input).
random_variable	provsql.stddev_pop_rv_ffunc (UUID[] state)
	Final function for stddev_pop(random_variable).
random_variable	provsql.stddev_samp_rv_ffunc (UUID[] state)
	Final function for stddev_samp(random_variable).
VOID	provsql.covar_pop (random_variable, random_variable)
VOID	provsql.covar_samp (random_variable, random_variable)
VOID	provsql.corr (random_variable, random_variable)
VOID	provsql.stddev_pop (random_variable)
VOID	provsql.stddev_samp (random_variable)
VOID	provsql.rv_covar_pop_impl (random_variable, random_variable, random_variable)
	The indicator-carrying rewrite targets (planner hook only; never called directly by users).
VOID	provsql.rv_covar_samp_impl (random_variable, random_variable, random_variable)
VOID	provsql.rv_corr_impl (random_variable, random_variable, random_variable)
VOID	provsql.rv_stddev_pop_impl (random_variable, random_variable)
VOID	provsql.rv_stddev_samp_impl (random_variable, random_variable)
random_variable	provsql.rv_percentile_make (DOUBLE PRECISION fraction, UUID[] pairs)
	Mint the PROVSQL_ARITH_PERCENTILE gate: the continuous percentile (SQL percentile_cont) over a group of RV rows.
UUID[]	provsql.percentile_cont_rv_sfunc (UUID[] state, random_variable x)
	State transition for the public ordered-set percentile_cont(float8) WITHIN GROUP (ORDER BY random_variable): append the certain indicator and the row's RV.
random_variable	provsql.percentile_cont_rv_ffunc (UUID[] state, DOUBLE PRECISION fraction)
	Final function for the public ordered-set percentile_cont: receives the direct fraction argument after the state.
VOID	provsql.percentile_cont (DOUBLE PRECISION ORDER BY random_variable)
rv_percentile_state	provsql.rv_percentile_impl_sfunc (rv_percentile_state state, DOUBLE PRECISION fraction, random_variable ind, random_variable x)
	State transition for rv_percentile_impl, the planner-hook rewrite target of a provenance-tracked percentile_cont: stashes the (group-constant) fraction and appends the indicator/value pair.
random_variable	provsql.rv_percentile_impl_ffunc (rv_percentile_state state)
	Final function for rv_percentile_impl.
VOID	provsql.rv_percentile_impl (DOUBLE PRECISION, random_variable, random_variable)

Variables
DROP EVENT TRIGGER IF EXISTS	provsql.provsql_cleanup_table_info
CREATE OR REPLACE VIEW tools AS SELECT	provsql.name
	Read-only view of the registered tools.
CREATE OR REPLACE VIEW tools AS SELECT	provsql.kind
CREATE OR REPLACE VIEW tools AS SELECT	provsql.executable
CREATE OR REPLACE VIEW tools AS SELECT	provsql.operations
CREATE OR REPLACE VIEW tools AS SELECT	provsql.input_formats
CREATE OR REPLACE VIEW tools AS SELECT	provsql.output_format
CREATE OR REPLACE VIEW tools AS SELECT	provsql.parser
CREATE OR REPLACE VIEW tools AS SELECT	provsql.preference
CREATE OR REPLACE VIEW tools AS SELECT	provsql.enabled
CREATE OR REPLACE VIEW tools AS SELECT	provsql.argtpl
CREATE OR REPLACE VIEW tools AS SELECT	provsql.argtpl_circuit
CREATE OR REPLACE VIEW tools AS SELECT	provsql.endpoint
CREATE VIEW provsql time_validity_view AS SELECT valid_time AS	value
	The base validity mapping is a plain view over the data-modification log: update_provenance is append-only and never has its provsql rewritten, so a view stays correct (unlike a tracked table's mapping, which must be a maintained mapping table ///< see create_provenance_mapping(maintained)).
CREATE VIEW provsql time_validity_view AS SELECT valid_time AS provsql AS provenance FROM provsql	update_provenance

Arithmetic and comparison on random_variable
Each binary operator below is declared on (random_variable, random_variable) only; mixed shapes such as rv + 2 or 2.5 > rv resolve through the implicit casts from INTEGER / NUMERIC / double precision to random_variable declared above. This avoids the resolution ambiguity that would arise if both (rv, NUMERIC) and (rv, rv) overloads were declared while implicit casts also existed. Arithmetic operators build a gate_arith via provenance_arith and return a new random_variable wrapping its UUID. Comparison operators are placeholders that return BOOLEAN and raise if executed – the BOOLEAN return type is required so that PostgreSQL accepts WHERE rv > 2 at parse-analyze. The planner hook intercepts every such OpExpr (matched by opfuncid against constants_t::OID_FUNCTION_RV_CMP) and rewrites it into a provenance_cmp call whose UUID is conjoined into the tuple's provsql column via provenance_times. Code that needs a gate_cmp UUID directly (without going through the planner hook) uses the rv_cmp_* family below, which call provenance_cmp with the matching float8-comparator OID.
CREATE OPERATOR CLASS random_variable_ops DEFAULT FOR TYPE random_variable USING btree AS OPERATOR<, OPERATOR 2<=, OPERATOR 3=, OPERATOR 4 >	provsql.OPERATOR
random_variable	provsql.random_variable_plus (random_variable a, random_variable b)
	random_variable + random_variable (gate_arith PLUS).
random_variable	provsql.random_variable_minus (random_variable a, random_variable b)
	random_variable - random_variable (gate_arith MINUS).
random_variable	provsql.random_variable_times (random_variable a, random_variable b)
	random_variable * random_variable (gate_arith TIMES).
random_variable	provsql.random_variable_div (random_variable a, random_variable b)
	random_variable / random_variable (gate_arith DIV).
random_variable	provsql.random_variable_neg (random_variable a)
	Unary -random_variable (gate_arith NEG).
random_variable	provsql.random_variable_pow (random_variable a, random_variable b)
	random_variable ^ random_variable (gate_arith POW).
random_variable	provsql.ln (random_variable a)
	Natural logarithm of a random_variable (gate_arith LN).
random_variable	provsql.exp (random_variable a)
	e^x for a random_variable (gate_arith EXP).
random_variable	provsql.pow (random_variable a, random_variable b)
	pow / power spellings of the ^ operator, mirroring PostgreSQL's NUMERIC surface.
random_variable	provsql.power (random_variable a, random_variable b)
random_variable	provsql.sqrt (random_variable a)
	Square root of a random_variable: sugar for x ^ 0.5 (no gate or opcode of its own).
oid	provsql.random_variable_cmp_oid (TEXT sym)
	Internal helper: float8-comparator OID for a given symbol.
BOOLEAN	provsql.random_variable_cmp_placeholder (random_variable a, random_variable b)
	Placeholder body shared by every random_variable_* comparison procedure.
BOOLEAN	provsql.random_variable_lt (random_variable a, random_variable b)
BOOLEAN	provsql.random_variable_le (random_variable a, random_variable b)
BOOLEAN	provsql.random_variable_eq (random_variable a, random_variable b)
BOOLEAN	provsql.random_variable_ne (random_variable a, random_variable b)
BOOLEAN	provsql.random_variable_ge (random_variable a, random_variable b)
BOOLEAN	provsql.random_variable_gt (random_variable a, random_variable b)
UUID	provsql.rv_cmp_lt (random_variable a, random_variable b)
	Build a gate_cmp for a < b and return its UUID.
UUID	provsql.rv_cmp_le (random_variable a, random_variable b)
	Build a gate_cmp for a ≤ b and return its UUID.
UUID	provsql.rv_cmp_eq (random_variable a, random_variable b)
	Build a gate_cmp for a = b and return its UUID.
UUID	provsql.rv_cmp_ne (random_variable a, random_variable b)
	Build a gate_cmp for a <> b and return its UUID.
UUID	provsql.rv_cmp_ge (random_variable a, random_variable b)
	Build a gate_cmp for a ≥ b and return its UUID.
UUID	provsql.rv_cmp_gt (random_variable a, random_variable b)
	Build a gate_cmp for a > b and return its UUID.
BOOLEAN	provsql.random_variable_op_random_variable (random_variable left, random_variable right)
	Prefix unary minus on random_variable.
BOOLEAN	provsql.random_variable_lt_random_variable (random_variable left, random_variable right)
BOOLEAN	provsql.random_variable_le_random_variable (random_variable left, random_variable right)
BOOLEAN	provsql.random_variable_eq_random_variable (random_variable left, random_variable right)
BOOLEAN	provsql.random_variable_ne_random_variable (random_variable left, random_variable right)
BOOLEAN	provsql.random_variable_ge_random_variable (random_variable left, random_variable right)
BOOLEAN	provsql.random_variable_gt_random_variable (random_variable left, random_variable right)
INTEGER	provsql.random_variable_btree_cmp (random_variable a, random_variable b)
	btree comparison support for random_variable – always an error.
random_variable	provsql.random_variable_cond (random_variable rv, UUID cond)
	Condition a random variable on an event: "X | C".
BOOLEAN	provsql.random_variable_op_uuid (random_variable left, UUID right)
random_variable	provsql.random_variable_cond_predicate (random_variable rv, BOOLEAN predicate)
	Placeholder for "X | (predicate)" – conditioning a random variable on a Boolean comparison written naturally.
BOOLEAN	provsql.random_variable_op_boolean (random_variable left, BOOLEAN right)
UUID	provsql.rv_conditioned_target (UUID token)
	Unpack the target of a random-variable conditioning gate.
UUID	provsql.rv_conditioned_prov (UUID token, UUID prov)
	Combine a conditioning gate's event with an explicit prov.
UUID	provsql.evidence_as_observation (UUID ev)
	Internal: rewrite a point-equality conditioning event into an observation.
UUID	provsql.observe (random_variable x, DOUBLE PRECISION datum)
	Internal: bind an observed datum to a random-variable leaf – the likelihood-weighting evidence behind "X | (Y = d)".
UUID	provsql.and_agg_sfunc (UUID state, UUID ev)
	Conjunction state function for and_agg (evidence gate_times).
VOID	provsql.and_agg (UUID)
	Conjoin per-row evidence tokens into one evidence circuit.
DOUBLE PRECISION	provsql.evidence (UUID evidence)
	Marginal likelihood P(data) of an evidence circuit.
UUID[]	provsql.observe_atoms (UUID evidence)
	The observe atoms of an evidence circuit.
TABLE	provsql.shapley_observe (UUID target, UUID evidence, TEXT payoff='expected')
	Shapley attribution of each observation to a posterior moment.

Detailed Description

ProvSQL PL/pgSQL extension code.

This file contains the PL/pgSQL code of the ProvSQL extension. This extension requires the standard UUID-ossp extension.

Definition in file provsql.sql.