Enum TimeKind 

pub enum TimeKind {
    Euclidean(EuclideanTime),
    Entropic(EntropicTime),
    Discrete(DiscreteTime),
    Lorentzian(LorentzianTime),
}

An enumeration of supported time models for unified, heterogeneous temporal reasoning.

TimeKind provides a polymorphic abstraction over multiple time semantics used in both physical and symbolic systems. It allows causal models, simulations, or reasoning engines to switch between continuous, discrete, and qualitative time representations in a unified way.

This is especially useful in hybrid environments where:

• Time may be physical in one subsystem and symbolic in another
• Models must support both discrete and continuous timelines
• Simulation layers require flexible temporal modes

Use Cases

• Dynamic systems with configurable time semantics
• Spacetime graphs mixing physics and logic
• Abstract symbolic timelines
• Causal models across domains (AI, physics, engineering)

Variants

• Lorentzian(LorentzianTime)

  • Real-valued time coordinate used in special/general relativity
  • Metric signature: (-+++), t ∈ ℝ
  • Appears in causal structure and physical propagation

• Euclidean(EuclideanTime)

  • Imaginary time (Wick-rotated), used in quantum/statistical physics
  • Metric signature: (++++)
  • Common in quantum field theory (QFT), path integrals, and lattice simulations

• Discrete(DiscreteTime)

  • Integer-valued ticks or steps (e.g., for simulation time, state machines)
  • Unitless or context-dependent
  • Used in agent-based models, control systems, and RL environments

Example

use deep_causality::*;

let lorentz = TimeKind::Lorentzian(LorentzianTime::new(1, TimeScale::Second, 3.14));
let discrete = TimeKind::Discrete(DiscreteTime::new(2, TimeScale::Second, 42));

println!("L: {}, ID: {}", lorentz, lorentz.id());
println!("D: {}, ID: {}", discrete, discrete.id());

Trait Compatibility

• Implements Identifiable based on the inner ID
• Implements Display for readable output
• Can be extended to support Temporal<f64> and Temporal<u64>

See also

• LorentzianTime, EuclideanTime, DiscreteTime, SymbolicTime
• SpaceKind for spatial equivalents
• SpacetimeInterval for reasoning over separation or causality

Design Note

For models that need a single time field but must support multiple representations of time (e.g., symbolic vs physical), TimeKind provides a principled and type-safe solution.

Variants

Euclidean(EuclideanTime)

Imaginary-time axis for quantum/statistical models via Wick rotation.

Entropic(EntropicTime)

Entropic time for emergent causal models via entropy.

Discrete(DiscreteTime)

Discrete tick-based time (steps, iterations, simulation frames).

Lorentzian(LorentzianTime)

Real-valued coordinate time in Lorentzian (causal, relativistic) geometry.

Trait Implementations

impl Clone for TimeKind

fn clone(&self) -> TimeKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TimeKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for TimeKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<DiscreteTime> for TimeKind

fn from(t: DiscreteTime) -> Self

Converts to this type from the input type.

impl From<EntropicTime> for TimeKind

fn from(t: EntropicTime) -> Self

Converts to this type from the input type.

impl From<EuclideanTime> for TimeKind

fn from(t: EuclideanTime) -> Self

Converts to this type from the input type.

impl From<LorentzianTime> for TimeKind

fn from(t: LorentzianTime) -> Self

Converts to this type from the input type.

impl Identifiable for TimeKind

fn id(&self) -> u64

impl PartialEq for TimeKind

fn eq(&self, other: &TimeKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ScalarProjector for TimeKind

type Scalar = f64

The scalar value extracted from the input (must implement ScalarValue)

fn project(&self) -> Self::Scalar

Extracts a scalar from self.

impl Temporal<f64> for TimeKind

fn time_scale(&self) -> TimeScale

Returns the unit scale of time (e.g. TimeScale::Milliseconds).

fn time_unit(&self) -> f64

Returns a reference to the numeric time unit (e.g. 0, 100, 32768).

impl Copy for TimeKind

impl StructuralPartialEq for TimeKind