Skip to content
Rainbow docs menu

Reference · Finite types, distributions and Markov chains

rainbow.math.finite.metric

Finite types, distributions and Markov chainssrc/rainbow/math/finite/metric.clj3 definitions, 11 theorems

Constructive maximum folds and finite sup-distance over exact finite data.

nat/recursive-max

DefinitionSource, line 104

nat/recursive-max :
  (x₁ x₂ : ℕ)
  → ℕ

ℕ = data/Nat

list/nat-map-max

DefinitionSource, line 132

list/nat-map-max.{u} :
  (A : Type u) (mapping : A → ℕ) (x₁ : List A)
  → ℕ

List = data/Listℕ = data/Nat

metric/finite-sup-distance

DefinitionSource, line 155

metric/finite-sup-distance.{u} :
  (A : Type u) (source : Finset A) (left right : A → ℕ)
  → ℕ

Finset = finset-data/Finsetℕ = data/Nat

nat/recursive-max-left-bound

TheoremFor all inputsNo axiomsSource, line 185

nat/recursive-max-left-bound :
  (left right : ℕ)
  → left ≤ nat/recursive-max left right

ℕ = data/Nat≤ = nat/at-most

nat/recursive-max-right-bound

TheoremFor all inputsNo axiomsSource, line 231

nat/recursive-max-right-bound :
  (left right : ℕ)
  → right ≤ nat/recursive-max left right

ℕ = data/Nat≤ = nat/at-most

nat/recursive-max-commutative

TheoremFor all inputsNo axiomsSource, line 279

nat/recursive-max-commutative :
  (left right : ℕ)
  → nat/recursive-max left right = nat/recursive-max right left

= = equality/Eqℕ = data/Nat

nat/recursive-max-is-left-or-right

TheoremFor all inputsNo axiomsSource, line 344

nat/recursive-max-is-left-or-right :
  (left right : ℕ)
  → proposition/disjunction (nat/recursive-max left right = left) (nat/recursive-max left right = right)

= = equality/Eqℕ = data/Nat

nat/recursive-max-least-upper-bound

TheoremFor all inputsNo axiomsSource, line 431

nat/recursive-max-least-upper-bound :
  (left right upper : ℕ)
  (left-bound : left ≤ upper)
  (right-bound : right ≤ upper)
  → nat/recursive-max left right ≤ upper

ℕ = data/Nat≤ = nat/at-most

list/nat-map-max-upper-bound

TheoremFor all inputsNo axiomsSource, line 470

list/nat-map-max-upper-bound.{u} :
  (A : Type u) (mapping : A → ℕ) (source : List A) (value : A)
  (member : list/membership A source value)
  → mapping value ≤ list/nat-map-max A mapping source

List = data/Listℕ = data/Nat≤ = nat/at-most

list/nat-map-max-bounded

TheoremFor all inputsNo axiomsSource, line 548

list/nat-map-max-bounded.{u} :
  (A : Type u) (mapping : A → ℕ) (upper : ℕ) (source : List A)
  (pointwise : ∀ (value : A), ∀ (member : list/membership A source value), mapping value ≤ upper)
  → list/nat-map-max A mapping source ≤ upper

List = data/Listℕ = data/Nat≤ = nat/at-most

list/nat-map-max-congruent

TheoremFor all inputsNo axiomsSource, line 602

list/nat-map-max-congruent.{u} :
  (A : Type u) (left right : A → ℕ)
  (pointwise : ∀ (value : A), left value = right value)
  (source : List A)
  → list/nat-map-max A left source = list/nat-map-max A right source

= = equality/EqList = data/Listℕ = data/Nat

metric/finite-sup-upper-bound

TheoremFor all inputsNo axiomsSource, line 661

metric/finite-sup-upper-bound.{u} :
  (A : Type u) (source : Finset A) (left right : A → ℕ) (state : A)
  (member : state ∈ source)
  → nat/distance (left state) (right state) ≤ metric/finite-sup-distance A source left right

Finset = finset-data/Finsetℕ = data/Nat∈ = finset-data/to-set: membership in a finite set≤ = nat/at-most

metric/finite-sup-symmetric

TheoremFor all inputsNo axiomsSource, line 686

metric/finite-sup-symmetric.{u} :
  (A : Type u) (source : Finset A) (left right : A → ℕ)
  → metric/finite-sup-distance A source left right = metric/finite-sup-distance A source right left

= = equality/EqFinset = finset-data/Finsetℕ = data/Nat

metric/finite-sup-triangle

TheoremFor all inputsNo axiomsSource, line 730

metric/finite-sup-triangle.{u} :
  (A : Type u) (source : Finset A) (left middle right : A → ℕ)
  → metric/finite-sup-distance A source left right ≤ algebra/nat-add (distance₁) (distance)
  where distance := metric/finite-sup-distance A source middle right
  where distance₁ := metric/finite-sup-distance A source left middle

Finset = finset-data/Finsetℕ = data/Nat≤ = nat/at-most