Statistics
Symbolic probability distributions, joint laws, and random-variable algebra. A
distribution node names a parametrised family; a random variable node names
a draw from a distribution. Distinct draws are not independent unless they share
an explicit independent-product law. The complete distribution registry
lists every accepted family, its ordered parameters, support, and closed-form
operations. The canonical names for the gamma and beta families are
gamma_distribution and beta_distribution.
distribution#
api::probability::Session method
pub fn distribution(
&self,
name: &str,
parameters: &[Expression],
) -> Result<Expression, ApiError>Build a distribution node from a family name and its ordered parameter list
(e.g. distribution("normal", [mean, standard_deviation])). An unknown name
raises an invalid-option error. A parameter count that does not match the
family's arity raises a collection-shape error; it does not create an
undefined mathematical value.
random_variable#
api::probability::Session method
pub fn random_variable(
&self,
name: &str,
distribution: &Expression,
) -> Result<Expression, ApiError>Build a random variable named name drawn from distribution. Each call creates
a distinct coordinate identity, even when its display name is reused.
multivariate_normal#
api::probability::Session method
pub fn multivariate_normal(
&self,
mean: &[Expression],
covariance: &Matrix,
) -> Result<Expression, ApiError>Construct an ordinary multivariate normal law from an ordered real mean vector and a symmetric positive-definite covariance matrix.
multinomial_distribution#
api::probability::Session method
pub fn multinomial_distribution(
&self,
trial_count: &Expression,
probabilities: &[Expression],
) -> Result<Expression, ApiError>Construct a multinomial law from a nonnegative integer trial count and ordered category probabilities summing exactly to one.
dirichlet#
api::probability::Session method
pub fn dirichlet(
&self,
parameters: &[Expression],
) -> Result<Expression, ApiError>Construct a Dirichlet law. Its density is relative to intrinsic simplex measure, not ambient Euclidean Lebesgue measure.
independent_product#
api::probability::Session method
pub fn independent_product(
&self,
factors: &[Expression],
) -> Result<Expression, ApiError>Construct the joint product law that explicitly certifies independence.
discrete_markov_chain#
api::probability::Session method
pub fn discrete_markov_chain(
&self,
name: &str,
states: &[Expression],
transition_matrix: &Matrix,
initial_probabilities: &[Expression],
) -> Result<Expression, ApiError>Construct a finite-state time-homogeneous Markov chain with ordered distinct state labels, an exact row-stochastic transition matrix, and an exact initial row law.
transition_probability#
api::probability::Session method
pub fn transition_probability(
&self,
process: &Expression,
from_state: &Expression,
to_state: &Expression,
start_index: &Expression,
end_index: &Expression,
) -> Result<Expression, ApiError>Return the exact finite-horizon transition probability for a finite Markov chain. The horizon must be a proved nonnegative integer.
stationary_distributions#
api::probability::Session method
pub fn stationary_distributions(
&self,
process: &Expression,
) -> Result<Matrix, ApiError>Return one row for every extreme stationary law. All stationary laws are the convex combinations of these rows in the process state order.
hitting_probability#
api::probability::Session method
pub fn hitting_probability(
&self,
process: &Expression,
start_state: &Expression,
target_states: &[Expression],
) -> Result<Expression, ApiError>Return the exact probability that the chain ever reaches one of the target
states from start_state.
expected_hitting_time#
api::probability::Session method
pub fn expected_hitting_time(
&self,
process: &Expression,
start_state: &Expression,
target_states: &[Expression],
) -> Result<Expression, ApiError>Return the exact expected time to reach a target state set. The result is positive infinity when the target is not reached almost surely.
affine_process_transformation#
api::probability::Session method
pub fn affine_process_transformation(
&self,
name: &str,
source: &Expression,
multiplier: &Expression,
offset: &Expression,
) -> Result<Expression, ApiError>Construct the pointwise affine image offset + multiplier * source of a certified Gaussian process.
independent_gaussian_process_sum#
api::probability::Session method
pub fn independent_gaussian_process_sum(
&self,
name: &str,
first_source: &Expression,
second_source: &Expression,
) -> Result<Expression, ApiError>Construct the pointwise sum of two explicitly independent Gaussian processes on the same index domain.
finite_dimensional_random_vector#
api::probability::Session method
pub fn finite_dimensional_random_vector(
&self,
process: &Expression,
indices: &[Expression],
coordinate_names: &[String],
) -> Result<Expression, ApiError>Construct the ordered random-vector handle for a finite process slice, using the shared joint-law and conditioning operations.
conditional_process_slice_distribution#
api::probability::Session method
pub fn conditional_process_slice_distribution(
&self,
process: &Expression,
selected_indices: &[Expression],
conditioning_indices: &[Expression],
conditioning_values: &[Expression],
) -> Result<Expression, ApiError>Condition an ordered finite process slice on another ordered slice at explicit values through the shared continuous conditional-law engine. The operation declines or remains unevaluated when the conditioning marginal has no certified density.
independent_process_product#
api::probability::Session method
pub fn independent_process_product(
&self,
first_process: &Expression,
first_indices: &[Expression],
second_process: &Expression,
second_indices: &[Expression],
) -> Result<Expression, ApiError>Construct the explicit block-independent joint law of two finite process slices.
product_copula#
api::probability::Session method
pub fn product_copula(
&self,
marginals: &[Expression],
) -> Result<Expression, ApiError>Construct the product copula of at least two continuous marginals with exact CDF and density descriptors. The result is the certified independent product law.
gaussian_copula#
api::probability::Session method
pub fn gaussian_copula(
&self,
marginals: &[Expression],
correlation: &Matrix,
) -> Result<Expression, ApiError>Construct a Gaussian copula from continuous marginals and a symmetric positive-semidefinite unit-diagonal correlation matrix. Its density remains unevaluated unless the system gains an exact normal-quantile representation.
archimedean_copula#
api::probability::Session method
pub fn archimedean_copula(
&self,
family: &str,
marginals: &[Expression],
parameter: &Expression,
) -> Result<Expression, ApiError>Construct a Clayton, Frank, or Gumbel copula from continuous marginals. The parameter domain is checked exactly; arbitrary generator expressions are not accepted as copulas.
estimate_archimedean_copula_parameter#
api::probability::Session method
pub fn estimate_archimedean_copula_parameter(
&self,
family: &str,
observations: &Matrix,
) -> Result<Expression, ApiError>Estimate a Clayton or Gumbel parameter by exactly inverting bivariate Kendall's tau. Observations must have exactly two columns and every pairwise order must be exact and strict, so ties and undecidable comparisons decline.
estimate_archimedean_copula_parameter_numeric#
api::probability::Session method
pub fn estimate_archimedean_copula_parameter_numeric(
&self,
family: &str,
observations: &Matrix,
parameter: &Expression,
lower: &Expression,
upper: &Expression,
options: NumericOptions,
) -> Result<NumericRootFindingResult, ApiError>Explicitly request bracketed numerical Frank-parameter estimation. A result is returned only when the requested bracket and every needed numerical kernel can be certified; otherwise its typed decline explains why.
quantile_numeric#
api::probability::Session method
pub fn quantile_numeric(
&self,
distribution: &Expression,
probability: &Expression,
quantile_variable: &Expression,
lower: &Expression,
upper: &Expression,
options: NumericOptions,
) -> Result<NumericRootFindingResult, ApiError>Explicitly invert a scalar continuous CDF on an exact rational bracket. Symbolic probability operations never invoke this numerical operation implicitly.
order_statistic#
api::probability::Session method
pub fn order_statistic(
&self,
base_law: &Expression,
sample_size: &Expression,
rank: &Expression,
) -> Result<Expression, ApiError>Construct the rank order statistic of an i.i.d. sample from a scalar law. Both sample size and rank must be positive exact integers, and rank cannot exceed sample size.
minimum#
api::probability::Session method
pub fn minimum(
&self,
base_law: &Expression,
sample_size: &Expression,
) -> Result<Expression, ApiError>Construct the smallest member of an i.i.d. sample from a scalar law.
maximum#
api::probability::Session method
pub fn maximum(
&self,
base_law: &Expression,
sample_size: &Expression,
) -> Result<Expression, ApiError>Construct the largest member of an i.i.d. sample from a scalar law.
random_vector#
api::probability::Session method
pub fn random_vector(
&self,
coordinate_names: &[String],
joint_distribution: &Expression,
) -> Result<Expression, ApiError>Construct an ordered vector of fresh coordinate handles for a joint law.
joint_distribution#
api::probability::Session method
pub fn joint_distribution(
&self,
random_vector: &Expression,
) -> Result<Expression, ApiError>Return a random vector's joint law.
component#
api::probability::Session method
pub fn component(
&self,
random_vector: &Expression,
position: usize,
) -> Result<Expression, ApiError>Select one coordinate by zero-based position.
marginal#
api::probability::Session method
pub fn marginal(
&self,
joint_distribution: &Expression,
positions: &[usize],
) -> Result<Expression, ApiError>Return the distinct ordered coordinate projection of a joint law.
permute#
api::probability::Session method
pub fn permute(
&self,
joint_distribution: &Expression,
permutation: &[usize],
) -> Result<Expression, ApiError>Reorder every coordinate by a permutation.
joint_density#
api::probability::Session method
pub fn joint_density(
&self,
joint_distribution: &Expression,
points: &[Expression],
) -> Result<Expression, ApiError>Evaluate an ordinary joint density at an ordered point. Laws without an ordinary density retain an unevaluated query.
intrinsic_simplex_density#
api::probability::Session method
pub fn intrinsic_simplex_density(
&self,
joint_distribution: &Expression,
points: &[Expression],
) -> Result<Expression, ApiError>Evaluate a Dirichlet density relative to its intrinsic simplex measure.
joint_probability_mass_function#
api::probability::Session method
pub fn joint_probability_mass_function(
&self,
joint_distribution: &Expression,
points: &[Expression],
) -> Result<Expression, ApiError>Evaluate a joint point mass at an ordered point.
joint_cumulative_distribution#
api::probability::Session method
pub fn joint_cumulative_distribution(
&self,
joint_distribution: &Expression,
points: &[Expression],
) -> Result<Expression, ApiError>Evaluate the lower-orthant cumulative distribution at an ordered point.
joint_rectangle_probability#
api::probability::Session method
pub fn joint_rectangle_probability(
&self,
joint_distribution: &Expression,
lower_bounds: &[Expression],
upper_bounds: &[Expression],
) -> Result<Expression, ApiError>Evaluate the ordered rectangle probability (lower, upper].
joint_support#
api::probability::Session method
pub fn joint_support(
&self,
joint_distribution: &Expression,
) -> Result<Expression, ApiError>Return the exact support of a joint law when available.
joint_raw_moment#
api::probability::Session method
pub fn joint_raw_moment(
&self,
joint_distribution: &Expression,
orders: &[Expression],
) -> Result<Expression, ApiError>Return an exact multi-index raw moment when known.
joint_mean#
api::probability::Session method
pub fn joint_mean(
&self,
joint_distribution: &Expression,
) -> Result<Vec<Expression>, ApiError>Return the ordered exact mean entries of a joint law.
joint_covariance_matrix#
api::probability::Session method
pub fn joint_covariance_matrix(
&self,
joint_distribution: &Expression,
) -> Result<Matrix, ApiError>Return the exact covariance matrix of a joint law.
joint_correlation_matrix#
api::probability::Session method
pub fn joint_correlation_matrix(
&self,
joint_distribution: &Expression,
) -> Result<Matrix, ApiError>Return the correlation matrix when coordinate variances are proved positive.
density#
api::probability::Session method
pub fn density(
&self,
random_variable: &Expression,
point: &Expression,
) -> Result<Expression, ApiError>Probability density (continuous families) or probability mass (discrete
families) of random_variable evaluated at point. Falls back to an
unevaluated structural form when no closed form exists.
cumulative_distribution#
api::probability::Session method
pub fn cumulative_distribution(
&self,
random_variable: &Expression,
point: &Expression,
) -> Result<Expression, ApiError>Cumulative distribution function of random_variable evaluated at point.
expectation#
api::probability::Session method
pub fn expectation(
&self,
target: &Expression,
random_variables: &[Expression],
) -> Result<Expression, ApiError>Expectation of target over the listed independent random variables. Linearity
and the constant-factor lift are applied; bare and power-of-random-variable
leaves consume the distribution's mean and raw moments.
variance#
api::probability::Session method
pub fn variance(
&self,
target: &Expression,
random_variables: &[Expression],
) -> Result<Expression, ApiError>Variance of target over the listed independent random variables.
covariance#
api::probability::Session method
pub fn covariance(
&self,
left: &Expression,
right: &Expression,
random_variables: &[Expression],
) -> Result<Expression, ApiError>Covariance of left and right over the listed independent random variables;
zero for independent operands.
probability#
api::probability::Session method
pub fn probability(
&self,
predicate: &Expression,
random_variables: &[Expression],
) -> Result<Expression, ApiError>Probability that predicate (a tail comparison such as X > t) holds over the
listed independent random variables.
moment#
api::probability::Session method
pub fn moment(
&self,
random_variable: &Expression,
order: &Expression,
) -> Result<Expression, ApiError>The order-th raw moment E[X^order] of random_variable.
cumulant#
api::probability::Session method
pub fn cumulant(
&self,
random_variable: &Expression,
order: &Expression,
) -> Result<Expression, ApiError>The order-th cumulant of random_variable.
moment_generating_function#
api::probability::Session method
pub fn moment_generating_function<'a, VariableType>(
&self,
random_variable: &Expression,
auxiliary_variable: VariableType,
) -> Result<Expression, ApiError>
where
VariableType: Into<VariableLike<'a>>,Closed-form moment generating function M_X(t) of random_variable in the
named auxiliary variable, when elementary; otherwise an unevaluated structural
form.
characteristic_function#
api::probability::Session method
pub fn characteristic_function<'a, VariableType>(
&self,
random_variable: &Expression,
auxiliary_variable: VariableType,
) -> Result<Expression, ApiError>
where
VariableType: Into<VariableLike<'a>>,Closed-form characteristic function of random_variable in the named
auxiliary variable, when elementary; otherwise an unevaluated structural form.
Example#
Build a random variable and read its density, mean, and variance.
use symi::api::prelude::*;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let session = Session::new();
let standard_normal =
session.distribution("normal", &[session.integer(0), session.integer(1)])?;
let measurement = session.random_variable("X", &standard_normal)?;
println!("{}", session.density(&measurement, &session.symbol("t"))?);
println!("{}", session.expectation(&measurement, &[measurement.clone()])?);
println!("{}", session.variance(&measurement, &[measurement.clone()])?);
Ok(())
}Additional API#
affine_transformation#
api::probability::Session method
pub fn affine_transformation(
&self,
source: &Expression,
scale: &Expression,
shift: &Expression,
) -> Result<Expression, ApiError>Construct the exact affine pushforward scale * source + shift.
affine_vector_transformation#
api::probability::Session method
pub fn affine_vector_transformation(
&self,
source: &Expression,
matrix: &Matrix,
shift: &[Expression],
) -> Result<Expression, ApiError>Construct the exact affine pushforward matrix * source + shift of a random vector.
bernoulli_process#
api::probability::Session method
pub fn bernoulli_process(
&self,
name: &str,
success_probability: &Expression,
) -> Result<Expression, ApiError>Construct an i.i.d. Bernoulli process with a proved unit-interval probability.
brownian_bridge#
api::probability::Session method
pub fn brownian_bridge(
&self,
name: &str,
horizon: &Expression,
) -> Result<Expression, ApiError>Construct a standard zero-endpoint Brownian bridge on a proved-positive horizon.
conditional_covariance#
api::probability::Session method
pub fn conditional_covariance(
&self,
left: &Expression,
right: &Expression,
condition: &Expression,
random_vector: &Expression,
) -> Result<Expression, ApiError>Return the exact covariance of two targets conditional on a positive-mass discrete event.
conditional_covariance_given#
api::probability::Session method
pub fn conditional_covariance_given(
&self,
left_position: usize,
right_position: usize,
random_vector: &Expression,
selected_positions: &[usize],
conditioning_positions: &[usize],
conditioning_values: &[Expression],
) -> Result<Expression, ApiError>Return an exact conditional covariance for two selected coordinates when their density-conditioned law has certified second moments.
conditional_density_distribution#
api::probability::Session method
pub fn conditional_density_distribution(
&self,
random_vector: &Expression,
selected_positions: &[usize],
conditioning_positions: &[usize],
conditioning_values: &[Expression],
) -> Result<Expression, ApiError>Construct a density-based conditional law for selected continuous coordinates at explicit coordinate values.
conditional_distribution#
api::probability::Session method
pub fn conditional_distribution(
&self,
random_vector: &Expression,
condition: &Expression,
) -> Result<Expression, ApiError>Restrict a finite discrete joint law to an event with proved positive mass.
conditional_expectation#
api::probability::Session method
pub fn conditional_expectation(
&self,
target: &Expression,
condition: &Expression,
random_vector: &Expression,
) -> Result<Expression, ApiError>Return the exact expectation of a target conditional on a positive-mass discrete event.
conditional_expectation_given#
api::probability::Session method
pub fn conditional_expectation_given(
&self,
target_position: usize,
random_vector: &Expression,
selected_positions: &[usize],
conditioning_positions: &[usize],
conditioning_values: &[Expression],
) -> Result<Expression, ApiError>Return an exact conditional expectation for one selected coordinate when its density-conditioned law has a certified moment.
conditional_moment#
api::probability::Session method
pub fn conditional_moment(
&self,
target: &Expression,
order: &Expression,
condition: &Expression,
random_vector: &Expression,
) -> Result<Expression, ApiError>Return the exact raw moment of a target conditional on a positive-mass discrete event.
conditional_probability#
api::probability::Session method
pub fn conditional_probability(
&self,
event: &Expression,
condition: &Expression,
random_vector: &Expression,
) -> Result<Expression, ApiError>Return the exact probability of an event conditional on a positive-mass discrete event.
conditional_variance#
api::probability::Session method
pub fn conditional_variance(
&self,
target: &Expression,
condition: &Expression,
random_vector: &Expression,
) -> Result<Expression, ApiError>Return the exact variance of a target conditional on a positive-mass discrete event.
conditional_variance_given#
api::probability::Session method
pub fn conditional_variance_given(
&self,
target_position: usize,
random_vector: &Expression,
selected_positions: &[usize],
conditioning_positions: &[usize],
conditioning_values: &[Expression],
) -> Result<Expression, ApiError>Return an exact conditional variance for one selected coordinate when its density-conditioned law has a certified second moment.
correlation#
api::probability::Session method
pub fn correlation(
&self,
left: &Expression,
right: &Expression,
) -> Result<Expression, ApiError>Return the correlation of two components belonging to one explicit joint space.
finite_dimensional_law#
api::probability::Session method
pub fn finite_dimensional_law(
&self,
process: &Expression,
indices: &[Expression],
) -> Result<Expression, ApiError>Return the exact finite-dimensional law for ordered process indices.
finite_membership_event#
api::probability::Session method
pub fn finite_membership_event(
&self,
element: &Expression,
members: &[Expression],
) -> Result<Expression, ApiError>Construct the Boolean event that an expression belongs to a finite list of values.
gaussian_process#
api::probability::Session method
pub fn gaussian_process(
&self,
name: &str,
mean_index: &Expression,
mean: &Expression,
first_covariance_index: &Expression,
second_covariance_index: &Expression,
covariance: &Expression,
certificate: GaussianKernelCertificate,
) -> Result<Expression, ApiError>Construct a real-valued Gaussian process from hygienic mean and covariance templates.
group_multinomial_categories#
api::probability::Session method
pub fn group_multinomial_categories(
&self,
joint_distribution: &Expression,
category_groups: &[&[usize]],
) -> Result<Expression, ApiError>Combine disjoint multinomial category groups into their exact aggregate law.
iid_discrete_process#
api::probability::Session method
pub fn iid_discrete_process(
&self,
name: &str,
marginal_law: &Expression,
) -> Result<Expression, ApiError>Construct an i.i.d. discrete sequence with one fresh process identity.
increment_covariance#
api::probability::Session method
pub fn increment_covariance(
&self,
process: &Expression,
first_start: &Expression,
first_end: &Expression,
second_start: &Expression,
second_end: &Expression,
) -> Result<Expression, ApiError>Return the exact covariance of two supported process increments.
increment_distribution#
api::probability::Session method
pub fn increment_distribution(
&self,
process: &Expression,
start: &Expression,
end: &Expression,
) -> Result<Expression, ApiError>Return the exact law of a supported process increment over a proved ordered interval.
increments_are_independent#
api::probability::Session method
pub fn increments_are_independent(
&self,
process: &Expression,
first_start: &Expression,
first_end: &Expression,
second_start: &Expression,
second_end: &Expression,
) -> Result<TruthValue, ApiError>Decide whether two supported Wiener increments are independent.
independent_convolution#
api::probability::Session method
pub fn independent_convolution(
&self,
first_law: &Expression,
second_law: &Expression,
) -> Result<Expression, ApiError>Construct the law of the sum of two independently constructed scalar laws.
independent_discrete_process#
api::probability::Session method
pub fn independent_discrete_process(
&self,
name: &str,
marginal_law: &Expression,
) -> Result<Expression, ApiError>Construct a discrete independent-sequence process with a fresh process identity.
is_independent#
api::probability::Session method
pub fn is_independent(
&self,
joint_distribution: &Expression,
left_positions: &[usize],
right_positions: &[usize],
) -> Result<TruthValue, ApiError>Decide whether two disjoint coordinate sets are independent in one explicit joint law.
joint_characteristic_function#
api::probability::Session method
pub fn joint_characteristic_function(
&self,
joint_distribution: &Expression,
frequencies: &[Expression],
) -> Result<Expression, ApiError>Return the exact Gaussian characteristic function at an ordered real frequency vector.
poisson_counting_process#
api::probability::Session method
pub fn poisson_counting_process(
&self,
name: &str,
rate: &Expression,
) -> Result<Expression, ApiError>Construct a homogeneous Poisson counting process with a proved positive real rate.
api::probability#
api module
pub mod probability;Distribution and statistics operations of the native API.
process_covariance#
api::probability::Session method
pub fn process_covariance(
&self,
left_process_value: &Expression,
right_process_value: &Expression,
) -> Result<Expression, ApiError>Return the exact covariance of two coordinates from the same stochastic process.
process_mean#
api::probability::Session method
pub fn process_mean(
&self,
process_value: &Expression,
) -> Result<Expression, ApiError>Return the exact mean of one indexed stochastic-process coordinate.
process_probability_mass#
api::probability::Session method
pub fn process_probability_mass(
&self,
process: &Expression,
indices: &[Expression],
points: &[Expression],
) -> Result<Expression, ApiError>Return the exact point-event probability for an ordered finite process slice.
process_value#
api::probability::Session method
pub fn process_value(
&self,
process: &Expression,
index: &Expression,
) -> Result<Expression, ApiError>Construct the scalar coordinate at a proved index in the process descriptor's domain.
process_variance#
api::probability::Session method
pub fn process_variance(
&self,
process_value: &Expression,
) -> Result<Expression, ApiError>Return the exact variance of one indexed stochastic-process coordinate.
random_walk#
api::probability::Session method
pub fn random_walk(
&self,
name: &str,
initial_value: &Expression,
increment_law: &Expression,
) -> Result<Expression, ApiError>Construct a random walk from its exact initial value and common increment law.
semidefinite_gaussian_rank#
api::probability::Session method
pub fn semidefinite_gaussian_rank(
&self,
joint_distribution: &Expression,
) -> Result<usize, ApiError>Return the covariance rank of a semidefinite Gaussian finite-dimensional law.
transformed_distribution#
api::probability::Session method
pub fn transformed_distribution(
&self,
source: &Expression,
mapping: &Expression,
) -> Result<Expression, ApiError>Construct an exact scalar pushforward with its source and mapping retained.
wiener_process#
api::probability::Session method
pub fn wiener_process(
&self,
name: &str,
initial_value: &Expression,
drift: &Expression,
scale: &Expression,
) -> Result<Expression, ApiError>Construct a Wiener process with exact initial value, drift, and nonnegative scale.
GaussianKernelCertificate#
Type
pub enum GaussianKernelCertificateThe globally valid kernel theorem selected for a Gaussian-process descriptor.
GaussianKernelCertificate.Candidate#
api::probability::GaussianKernelCertificate variant
Candidate,Retain a symmetric user proposal without asserting global positive semidefiniteness.
GaussianKernelCertificate.Constant#
api::probability::GaussianKernelCertificate variant
Constant,Certify a nonnegative constant covariance kernel.