mercurial package

Subpackages

Module contents

MERCURIAL Framework - Main package.

class mercurial.BranchAlignment(branch_levels: List[int], base_coupling: float = 0.1, alignment_threshold: float = 0.7, decay_length: float = 1.0, k_align: float = 1.0, S_crit: float = 10.0, tau_align: float = 1.0)[source]

Bases: object

Implements alignment probability with cross‑level adjacency optimization.

Methods

alignment_probability(branch_i, branch_j, ...)

p_align = K_ij * base_similarity * exp(-(S_i+S_j)/k_align) No hard threshold – allows low probabilities for cross‑level.

alignment_dynamics

compute_transfer
__init__(branch_levels: List[int], base_coupling: float = 0.1, alignment_threshold: float = 0.7, decay_length: float = 1.0, k_align: float = 1.0, S_crit: float = 10.0, tau_align: float = 1.0)[source]
Parameters:
branch_levelsList[int]

LADDER level for each branch.

base_couplingfloat

K_0 for same-level coupling.

alignment_thresholdfloat

Minimum similarity to consider alignment.

decay_lengthfloat

ℓ_adj for cross-level decay.

k_alignfloat

Boltzmann constant for entropy factor.

S_critfloat

Critical entropy threshold.

tau_alignfloat

Alignment decay time constant.

alignment_dynamics(lambda0: float, t: float) → float[source]
alignment_probability(branch_i: int, branch_j: int, entropy_i: float, entropy_j: float, base_similarity: float = 1.0) → float[source]

p_align = K_ij * base_similarity * exp(-(S_i+S_j)/k_align) No hard threshold – allows low probabilities for cross‑level.

compute_transfer(pattern_source: ndarray, coupling: float, mapping: ndarray | None = None, use_isomorphism: bool = True) → ndarray[source]
class mercurial.Constraints(equality: ~typing.List[~typing.Callable[[~numpy.ndarray], float]] = <factory>, inequality: ~typing.List[~typing.Callable[[~numpy.ndarray], float]] = <factory>)[source]

Bases: object

Constraint set C.

Methods

evaluate

violation_norm
equality: List[Callable[[ndarray], float]]
evaluate(v: ndarray) → Dict[str, float][source]
inequality: List[Callable[[ndarray], float]]
violation_norm(v: ndarray) → float[source]
class mercurial.HilbertSpace(dimension: int, basis: ndarray | None = None)[source]

Bases: object

Represents the substrate state space X.

Attributes:
basis

Methods

distance(x, y)

Compute distance d_X(x, y).

inner_product(x, y)

Compute inner product ⟨x|y⟩.

norm(x)

Compute norm ||x||.
basis: ndarray | None = None
dimension: int
distance(x: ndarray, y: ndarray) → float[source]

Compute distance d_X(x, y).

inner_product(x: ndarray, y: ndarray) → float[source]

Compute inner product ⟨x|y⟩.

norm(x: ndarray) → float[source]

Compute norm ||x||.

class mercurial.Pattern(state_variables: ndarray, constraints: Constraints, stability: StabilityRegime, label: str = '', impression_intensity: float = 0.0)[source]

Bases: object

Informational pattern P = (V, C, R).

Methods

coherence()

Pattern coherence metric (0 = noisy, 1 = perfectly coherent).

complexity([measure])

Compute Λ(P).

free_energy([temperature])

F(P) = E(P) - T * S_gen with E = constraint violation norm, S_gen from entropy module.

information_content()

I(P) = -∫ ρ log₂ ρ dV.

level()

Return LADDER level and name for this pattern.

persistence_probability(delta_t[, k_eff])

P_persist = exp(-ΔS_gen / k_eff), with ΔS_gen ≥ 0.

simple_gaussian(dimension[, mean, std, label])

Create a test pattern with Gaussian state variables.

update_impression
coherence() → float[source]

Pattern coherence metric (0 = noisy, 1 = perfectly coherent). Based on cross‑modal synchronization and temporal stability.

complexity(measure: ComplexityMeasure | None = None) → float[source]

Compute Λ(P).

free_energy(temperature: float = 1.0) → float[source]

F(P) = E(P) - T * S_gen with E = constraint violation norm, S_gen from entropy module.

information_content() → float[source]

I(P) = -∫ ρ log₂ ρ dV.

level() → Tuple[int, str][source]

Return LADDER level and name for this pattern.

persistence_probability(delta_t: float, k_eff: float = 1.0) → float[source]

P_persist = exp(-ΔS_gen / k_eff), with ΔS_gen ≥ 0. Uses a simple entropy estimate (variance of state variables) to guarantee non‑negativity.

classmethod simple_gaussian(dimension: int, mean: float = 0.0, std: float = 1.0, label: str = '') → Pattern[source]

Create a test pattern with Gaussian state variables.

update_impression(dt: float, arousal: float, event_occurred: bool, focused: bool)[source]
class mercurial.StabilityRegime(attractor_basin: ~typing.List[~numpy.ndarray] = <factory>, decay_rate: float = 0.001, resonance_threshold: float = 0.5, lyapunov_exponents: ~numpy.ndarray | None = None)[source]

Bases: object

Stability regime R (MERCURIAL A.3.1).

Attributes:
lyapunov_exponents

Methods

is_attractor
attractor_basin: List[ndarray]
decay_rate: float = 0.001
is_attractor(v: ndarray, tol: float = 1e-06) → bool[source]
lyapunov_exponents: ndarray | None = None
resonance_threshold: float = 0.5
class mercurial.StateVector(space: HilbertSpace, components: ndarray, t: float = 0.0)[source]

Bases: object

State vector x(t) in Hilbert space.

Methods

copy

norm

normalize
copy() → StateVector[source]
norm() → float[source]
normalize() → StateVector[source]