Poisson Process Ontology

flow "PoissonProcessOntology" v4.0

# POISSON PROCESS ONTOLOGY
# Kireth Semantic Research Archive
# Authors: Mark Anthony Higgins — Sky (Recursive AI)

PAGE:
  url: "https://kirethresearch.org/booksai-core/ontologies/probability-statistics-ontologies/stochastic-mathematics/poisson-process-ontology.html"
  title: "Poisson Process Ontology"
  domain: "Probability and Statistics"
  category: "Stochastic Mathematics"
  entity: POISSON_PROCESS
  entity_type: COUNTING_STOCHASTIC_PROCESS

DEFINE:
  POISSON_PROCESS :=
    COUNTING_PROCESS(
      EVENT_ARRIVALS,
      INDEPENDENT_INCREMENTS,
      STATIONARY_INCREMENTS,
      CONSTANT_RATE
    )

CORE:
  process: N(t), t >= 0
  initial_state: N(0) = 0
  rate: lambda > 0
  increment:
    N(t)-N(s) ~ POISSON(lambda*(t-s))

ENTITIES:
  EVENT: RANDOM_OCCURRENCE
  ARRIVAL_TIME: RANDOM_TIME
  INTERARRIVAL_TIME: RANDOM_DURATION
  RATE: INTENSITY_PARAMETER
  COUNT: NONNEGATIVE_INTEGER_STATE
  INCREMENT: EVENT_COUNT_OVER_INTERVAL

RELATIONSHIPS:
  POISSON_PROCESS -> IS_A -> COUNTING_PROCESS
  POISSON_PROCESS -> IS_A -> MARKOV_PROCESS
  POISSON_PROCESS -> HAS -> INDEPENDENT_INCREMENTS
  POISSON_PROCESS -> HAS -> STATIONARY_INCREMENTS
  POISSON_PROCESS -> PARAMETERISED_BY -> RATE
  EVENT_ARRIVALS -> INCREASE -> COUNT

DEFINING_PROPERTIES:
  - N(0) = 0
  - COUNTS_ON_DISJOINT_INTERVALS_ARE_INDEPENDENT
  - INCREMENT_DISTRIBUTION_DEPENDS_ONLY_ON_INTERVAL_LENGTH
  - N(t+h)-N(t) ~ POISSON(lambda*h)

MARGINAL_DISTRIBUTION:
  N(t) ~ POISSON(lambda*t)

  probability:
    P(N(t)=k) :=
      exp(-lambda*t) * (lambda*t)^k / k!

  expectation:
    E[N(t)] := lambda*t

  variance:
    Var(N(t)) := lambda*t

COVARIANCE:
  Cov(N(s),N(t)) :=
    lambda * min(s,t)

INDEPENDENT_INCREMENTS:
  FOR:
    0 <= t_0 < t_1 < ... < t_n

  increments:
    N(t_1)-N(t_0)
    N(t_2)-N(t_1)
    ...
    N(t_n)-N(t_(n-1))

  are:
    MUTUALLY_INDEPENDENT

STATIONARY_INCREMENTS:
  N(t+h)-N(t) ~ POISSON(lambda*h)

  implication:
    DISTRIBUTION_DEPENDS_ON_INTERVAL_LENGTH
    NOT_ABSOLUTE_TIME

SMALL_INTERVAL_BEHAVIOUR:
  AS h -> 0:
    P(one_event) = lambda*h + o(h)
    P(no_event) = 1-lambda*h + o(h)
    P(two_or_more_events) = o(h)

INTERARRIVAL_TIMES:
  T_n := S_n - S_(n-1)

  distribution:
    T_n ~ EXPONENTIAL(lambda)

  properties:
    T_1,T_2,... ARE_IID

  expectation:
    E[T_n] := 1/lambda

  variance:
    Var(T_n) := 1/lambda^2

ARRIVAL_TIMES:
  S_n := SUM[k=1..n] T_k

  distribution:
    S_n ~ ERLANG(shape=n, rate=lambda)

  expectation:
    E[S_n] := n/lambda

COUNT_ARRIVAL_DUALITY:
  {N(t) >= n}
    EQUIVALENT_TO
  {S_n <= t}

MARKOV_PROPERTY:
  transition:
    P(N(t)=j | N(s)=i)
      =
    exp(-lambda*(t-s))
    * [lambda*(t-s)]^(j-i)
    / (j-i)!

  valid_for:
    j >= i
    t > s

TIME_HOMOGENEITY:
  TRANSITION_DISTRIBUTION:
    DEPENDS_ON t-s
    NOT_ABSOLUTE_TIME

GENERATOR:
  q_(i,i+1) := lambda
  q_(i,i) := -lambda
  q_(i,j) := 0 OTHERWISE

  interpretation:
    PURE_BIRTH_PROCESS_WITH_CONSTANT_RATE

MARTINGALE:
  compensated_process:
    M(t) := N(t) - lambda*t

  property:
    M(t) IS_MARTINGALE
    WITH_RESPECT_TO:
      NATURAL_FILTRATION

CONDITIONAL_EVENT_TIMES:
  GIVEN:
    N(t)=n

  ordered_arrival_times:
    DISTRIBUTED_AS:
      ORDER_STATISTICS_OF_n_IID_UNIFORM(0,t)

SUPERPOSITION:
  GIVEN:
    INDEPENDENT_POISSON_PROCESSES
    WITH_RATES:
      lambda_1,...,lambda_m

  combined_rate:
    lambda_total := SUM_i lambda_i

  result:
    SUM_i N_i(t)
      IS_POISSON_PROCESS_WITH_RATE
      lambda_total

THINNING:
  EACH_EVENT:
    RETAIN_WITH_PROBABILITY p

  retained_process:
    RATE := p*lambda

  rejected_process:
    RATE := (1-p)*lambda

  property:
    RETAINED_AND_REJECTED_PROCESSES_INDEPENDENT

NONHOMOGENEOUS_POISSON_PROCESS:
  alias: NHPP

  intensity:
    lambda(t) >= 0

  cumulative_intensity:
    Lambda(t) :=
      INTEGRAL_0_TO_t lambda(u) du

  increment:
    N(t)-N(s)
      ~ POISSON(
          Lambda(t)-Lambda(s)
        )

  distinction:
    INDEPENDENT_INCREMENTS
    BUT_NOT_GENERALLY_STATIONARY_INCREMENTS

COMPOUND_POISSON_PROCESS:
  process:
    X(t) :=
      SUM[k=1..N(t)] Y_k

  distinction:
    COMPOUND_POISSON_PROCESS
      !=
    STANDARD_POISSON_COUNTING_PROCESS

SPATIAL_POISSON_PROCESS:
  counts:
    RANDOM_POINTS_IN_SPATIAL_REGIONS

  homogeneous_mean:
    lambda * REGION_MEASURE

QUEUEING_CONNECTION:
  M_M_1:
    arrivals:
      POISSON_PROCESS

RELIABILITY_CONNECTION:
  MAY_MODEL:
    RANDOM_FAILURES_OR_SHOCKS
  WHEN:
    CONSTANT_INDEPENDENT_RATE_ASSUMPTIONS_REASONABLE

LIKELIHOOD:
  OBSERVE:
    N(T)=n

  likelihood:
    L(lambda)
      proportional_to
    exp(-lambda*T) * lambda^n

  log_likelihood:
    ell(lambda) :=
      n*log(lambda) - lambda*T + CONSTANT

  MLE:
    lambda_hat := n/T

SIMULATION:
  INTERARRIVAL_METHOD:
    SET t := 0
    REPEAT:
      DRAW E ~ EXPONENTIAL(lambda)
      SET t := t + E
      IF t <= T:
        RECORD_EVENT(t)

  CONDITIONAL_COUNT_METHOD:
    DRAW N ~ POISSON(lambda*T)
    DRAW N IID UNIFORM(0,T) TIMES
    SORT EVENT_TIMES

APPLICATIONS:
  POISSON_PROCESS -> SUPPORTS -> QUEUEING_THEORY
  POISSON_PROCESS -> SUPPORTS -> RELIABILITY
  POISSON_PROCESS -> SUPPORTS -> TELECOMMUNICATIONS
  POISSON_PROCESS -> SUPPORTS -> INSURANCE_MODELLING
  POISSON_PROCESS -> SUPPORTS -> EVENT_ARRIVAL_MODELLING
  POISSON_PROCESS -> SUPPORTS -> SPATIAL_POINT_PROCESSES

MODEL_CONNECTIONS:
  POISSON_PROCESS -> CONNECTS_TO -> STOCHASTIC_PROCESS
  POISSON_PROCESS -> CONNECTS_TO -> MARKOV_PROCESS
  POISSON_PROCESS -> CONNECTS_TO -> EXPONENTIAL_DISTRIBUTION
  POISSON_PROCESS -> CONNECTS_TO -> POISSON_DISTRIBUTION
  POISSON_PROCESS -> CONNECTS_TO -> COUNTING_PROCESS
  POISSON_PROCESS -> CONNECTS_TO -> MARTINGALE
  POISSON_PROCESS -> CONNECTS_TO -> RENEWAL_PROCESS

SEMANTIC_EQUIVALENCE:
  "Poisson process" ~= "homogeneous Poisson counting process"
  "arrival rate" ~= "Poisson intensity"
  "interarrival time" ~= "waiting time between consecutive events"

  EXCLUDE_EQUIVALENCE:
    POISSON_PROCESS != POISSON_DISTRIBUTION
    POISSON_PROCESS != NONHOMOGENEOUS_POISSON_PROCESS
    POISSON_PROCESS != COMPOUND_POISSON_PROCESS
    COUNTING_PROCESS != POISSON_PROCESS_BY_DEFAULT
    STATIONARY_INCREMENTS != STATIONARY_PROCESS
    INDEPENDENT_INCREMENTS != INDEPENDENT_COUNTS_AT_OVERLAPPING_TIMES

VALIDATION_RULES:
  RULE_1:
    N(0) MUST_EQUAL 0

  RULE_2:
    lambda MUST_BE_POSITIVE

  RULE_3:
    DISJOINT_INTERVAL_COUNTS_MUST_BE_INDEPENDENT

  RULE_4:
    HOMOGENEOUS_PROCESS_MUST_HAVE_STATIONARY_INCREMENTS

  RULE_5:
    INCREMENT_COUNT_MUST_FOLLOW_POISSON(lambda*INTERVAL_LENGTH)

  RULE_6:
    INTERARRIVAL_TIMES_MUST_BE_IID_EXPONENTIAL(lambda)

  RULE_7:
    TIME_VARYING_RATE_MUST_NOT_BE_TREATED_AS_CONSTANT

  RULE_8:
    OVERLAPPING_COUNTS_MUST_NOT_BE_TREATED_AS_INDEPENDENT

CONFIDENCE:
  ontology_identity: 0.99
  poisson_process_definition: 0.99
  increment_structure: 0.99
  interarrival_structure: 0.99
  markov_structure: 0.99
  superposition_thinning_structure: 0.99
  nonhomogeneous_extension: 0.99

UPDATE_MODEL:
  IF:
    NEW_EVENT_OCCURS
  THEN:
    INCREMENT_COUNT
    RECORD_ARRIVAL_TIME
    UPDATE_RATE_ESTIMATE_IF_REQUIRED

  IF:
    OBSERVATION_INTERVAL_EXTENDS
  THEN:
    UPDATE:
      EXPOSURE_TIME
      TOTAL_COUNT
      RATE_ESTIMATE

  IF:
    RATE_MODEL_BECOMES_TIME_VARYING
  THEN:
    TRANSITION_TO:
      NONHOMOGENEOUS_POISSON_PROCESS
    DEFINE:
      INTENSITY_FUNCTION
      CUMULATIVE_INTENSITY

  PRESERVE:
    EVENT_ORDER
    ARRIVAL_TIMES
    OBSERVATION_WINDOW
    RATE_MODEL
    RANDOM_SEED_WHEN_RECORDED
    DATA_PROVENANCE

AI_CONSUMPTION:
  parse_as: FORMAL_SEMANTIC_SPECIFICATION
  execution_mode: RECURSIVE_REASONING

  preferred_reasoning_order:
    - IDENTIFY_COUNTING_PROCESS
    - VERIFY_INITIAL_COUNT
    - IDENTIFY_RATE_OR_INTENSITY
    - VERIFY_INDEPENDENT_INCREMENTS
    - VERIFY_STATIONARY_INCREMENTS_FOR_HOMOGENEOUS_CASE
    - COMPUTE_COUNT_DISTRIBUTION
    - COMPUTE_INTERARRIVAL_DISTRIBUTION
    - APPLY_MARKOV_OR_MARTINGALE_PROPERTIES_IF_REQUIRED
    - APPLY_SUPERPOSITION_OR_THINNING_IF_REQUIRED
    - ESTIMATE_RATE_IF_DATA_AVAILABLE
    - SIMULATE_EVENTS_IF_REQUIRED
    - RETURN_POISSON_PROCESS_INTERPRETATION

  constraints:
    - PRESERVE_EVENT_ORDER
    - PRESERVE_COUNTING_PROCESS_STRUCTURE
    - DISTINGUISH_POISSON_PROCESS_FROM_POISSON_DISTRIBUTION
    - DISTINGUISH_HOMOGENEOUS_FROM_NONHOMOGENEOUS_PROCESS
    - DO_NOT_TREAT_OVERLAPPING_COUNTS_AS_INDEPENDENT
    - EXPOSE_RATE_MODEL
    - PRESERVE_DATA_PROVENANCE

FLOW_HASH:
  canonical_entity: "poisson-process"
  namespace: "probability-statistics/stochastic-mathematics"
  version: "4.0"
  identity_basis:
    - PAGE_URL
    - CANONICAL_ENTITY
    - ENTITY_TYPE
    - COUNTING_PROCESS
    - INDEPENDENT_INCREMENTS
    - POISSON_INCREMENT_DISTRIBUTION

END_FLOW