Documentation

Studies.Luce1959

Luce (1959): Individual choice behavior #

This file formalizes Luce's theory of choice built on his choice axiom. Wherever discrimination is imperfect, the axiom makes choice from a finite set of alternatives the conditional probability of a ratio scale on them. The first chapter derives this scale and the semiorder of just noticeable differences it induces. The second applies it to psychophysics, deriving the logistic and power laws of discrimination, its incompatibility with Thurstone's discriminal processes, a response-bias account of signal detection that is exactly a logistic observer, and the probabilities of rankings. The third couples preference among gambles with the subjective likelihood of events and shows that imperfect discrimination among pure alternatives confines the events to at most three classes. The fourth builds learning models on response strengths and derives the asymptotic behavior of the beta model.

Implementation notes #

TODO #

References #

§1.C–§1.E: The choice axiom and its ratio scale (pp. 5–24) #

Axiom 1 (p. 6) has two parts. Under imperfect discrimination, choice from nested sets composes multiplicatively, and an alternative never chosen over another may be deleted. On a set with imperfect discrimination throughout, the axiom yields a ratio scale unique up to its unit (Theorem 3, p. 23).

Pairwise choice under a ratio scale #

Under a ratio scale v the probability of choosing x over y is v x / (v x + v y). The lemmas assume positivity only at the alternatives involved, so they apply to scales defined on a local set.

noncomputable def Luce1959.pairwiseProb {A : Type u_1} (v : A → ℝ) (x y : A) :
ℝ

Under the ratio scale v, x is chosen over y with probability v x / (v x + v y).

Equations
Instances For
    theorem Luce1959.pairwiseProb_complement {A : Type u_1} {v : A → ℝ} {x y : A} (hx : 0 < v x) (hy : 0 < v y) :
    pairwiseProb v x y + pairwiseProb v y x = 1
    theorem Luce1959.pairwiseProb_ge_half_iff {A : Type u_1} {v : A → ℝ} {x y : A} (hx : 0 < v x) (hy : 0 < v y) :
    1 / 2 ≤ pairwiseProb v x y ↔ v y ≤ v x
    theorem Luce1959.pairwiseProb_eq_half_iff {A : Type u_1} {v : A → ℝ} {x y : A} (hx : 0 < v x) (hy : 0 < v y) :
    pairwiseProb v x y = 1 / 2 ↔ v x = v y
    theorem Luce1959.pairwiseProb_mono_iff {A : Type u_1} {v : A → ℝ} {x y z : A} (hx : 0 < v x) (hy : 0 < v y) (hz : 0 < v z) :
    pairwiseProb v y z ≤ pairwiseProb v x z ↔ v y ≤ v x
    theorem Luce1959.pairwiseProb_sst {A : Type u_1} {v : A → ℝ} {x y z : A} (hx : 0 < v x) (hy : 0 < v y) (hz : 0 < v z) (hxy : 1 / 2 ≤ pairwiseProb v x y) (hyz : 1 / 2 ≤ pairwiseProb v y z) :
    max (pairwiseProb v x y) (pairwiseProb v y z) ≤ pairwiseProb v x z

    A positive ratio scale is strongly stochastically transitive, P(x, z) ≥ max (P(x, y), P(y, z)) when P(x, y) ≥ 1/2 and P(y, z) ≥ 1/2 (Definition 2, p. 25).

    theorem Luce1959.pairwiseProb_eq_pairwiseProb_iff {A : Type u_1} {v : A → ℝ} {x y x' y' : A} (hx : 0 < v x) (hy : 0 < v y) (hx' : 0 < v x') (hy' : 0 < v y') :
    pairwiseProb v x y = pairwiseProb v x' y' ↔ v x * v y' = v x' * v y
    theorem Luce1959.pairwiseProb_eq_sigmoid {A : Type u_1} {v : A → ℝ} {x y : A} (hx : 0 < v x) (hy : 0 < v y) :
    pairwiseProb v x y = (Real.log (v x) - Real.log (v y)).sigmoid

    Pairwise choice is the sigmoid of the difference of the log scale values (§2.A.2).

    theorem Luce1959.pairwiseProb_exp {A : Type u_1} (u : A → ℝ) (x y : A) :
    pairwiseProb (fun (a : A) => Real.exp (u a)) x y = (u x - u y).sigmoid

    The ratio rule and conditional probability #

    A positive scale v gives each alternative a of a finite set T the choice probability v a / ∑ b ∈ T, v b (Theorem 3, p. 23). Luce remarks that under the choice axiom P_S "acts like a conditional probability relative to P_T" (p. 24), and for the ratio rule this holds literally.

    theorem Luce1959.withDensity_ofReal_finset {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {v : A → ℝ} (hv : ∀ (a : A), 0 ≤ v a) (E : Finset A) :
    (MeasureTheory.Measure.count.withDensity fun (b : A) => ENNReal.ofReal (v b)) ↑E = ENNReal.ofReal (∑ b ∈ E, v b)
    noncomputable def Luce1959.ratioProb {A : Type u_1} [DecidableEq A] (v : A → ℝ) (T : Finset A) (a : A) :
    ℝ

    The ratio rule gives a the probability v a / ∑ b ∈ T, v b of being chosen from T, and 0 if a ∉ T.

    Equations
    Instances For
      theorem Luce1959.ratioProb_eq_div {A : Type u_1} [DecidableEq A] (v : A → ℝ) (T : Finset A) (a : A) (ha : a ∈ T) :
      ratioProb v T a = v a / ∑ b ∈ T, v b
      theorem Luce1959.ratioProb_sum_eq_one {A : Type u_1} [DecidableEq A] (v : A → ℝ) (T : Finset A) (hT : ∑ b ∈ T, v b ≠ 0) :
      ∑ a ∈ T, ratioProb v T a = 1
      theorem Luce1959.ratioProb_ratio {A : Type u_1} [DecidableEq A] (v : A → ℝ) (T : Finset A) (a₁ a₂ : A) (h₁ : a₁ ∈ T) (h₂ : a₂ ∈ T) :
      ratioProb v T a₁ * v a₂ = ratioProb v T a₂ * v a₁

      Within a set the odds of two alternatives are the ratio of their scale values (Lemma 3, p. 9).

      theorem Luce1959.ratioProb_univ {A : Type u_1} [DecidableEq A] [Fintype A] (v : A → ℝ) :
      ratioProb v Finset.univ = (∑ j : A, v j)⁻¹ • v
      theorem Luce1959.ratioProb_smul {A : Type u_1} [DecidableEq A] {c : ℝ} (hc : c ≠ 0) (v : A → ℝ) (T : Finset A) :
      ratioProb (c • v) T = ratioProb v T

      The ratio rule does not depend on the unit of the scale (Theorem 3, p. 23).

      theorem Luce1959.ratioProb_pair {A : Type u_1} [DecidableEq A] (v : A → ℝ) {x y : A} (hne : x ≠ y) :
      ratioProb v {x, y} x = pairwiseProb v x y
      theorem Luce1959.ratioProb_eq_one_div_sum {A : Type u_1} [DecidableEq A] {v : A → ℝ} {T : Finset A} {x : A} (hv : ∀ a ∈ T, 0 < v a) (hx : x ∈ T) :
      ratioProb v T x = 1 / ∑ y ∈ T, pairwiseProb v y x / pairwiseProb v x y

      Under a positive ratio scale choice from T is determined by pairwise choice, P_T(x) = 1 / ∑ y ∈ T, P(y, x) / P(x, y) (Theorem 1, p. 16).

      theorem Luce1959.ratioProb_eq_cond {A : Type u_1} [DecidableEq A] [MeasurableSpace A] [MeasurableSingletonClass A] {v : A → ℝ} (hv : ∀ (a : A), 0 ≤ v a) (T : Finset A) (a : A) :
      ratioProb v T a = (MeasureTheory.Measure.count.withDensity fun (b : A) => ENNReal.ofReal (v b))[{a} | ↑T].toReal

      For a nonnegative scale v, choosing a from T by the ratio rule is conditioning on T the measure with point masses v (p. 24).

      Systems of choice probabilities and the forms of the choice axiom #

      For each finite set T the choice probabilities P_T "form an ordinary probability measure on the subsets of T" (p. 5). Part i of Axiom 1 makes choice from a subset the conditional probability given it, and a ratio scale is a measure from which every P_T is obtained by conditioning.

      theorem Luce1959.restrict_eq_smul_of_cond_eq {A : Type u_1} [MeasurableSpace A] {μ ν : MeasureTheory.Measure A} {T : Set A} (hμ₀ : μ T ≠ 0) (hμ : μ T ≠ ⊤) (h : μ[|T] = ν[|T]) :
      μ.restrict T = (μ T / ν T) • ν.restrict T

      Two measures that give the same choice from T by conditioning agree on T up to a constant multiple (Theorem 3, p. 23).

      structure Luce1959.ChoiceFn (A : Type u_1) [MeasurableSpace A] [MeasurableSingletonClass A] :
      Type u_1

      A system of choice probabilities assigns to every finite set T a measure P_T concentrated on T, the distribution of the alternative chosen from T, which is a probability measure when T is nonempty (pp. 4–5).

      • prob : Finset A → MeasureTheory.Measure A

        The measure P_T of the alternative chosen from T.

      • isProbabilityMeasure_prob (T : Finset A) : T.Nonempty → MeasureTheory.IsProbabilityMeasure (self.prob T)

        P_T is a probability measure when T is nonempty (probability axioms (i) and (ii)).

      • prob_compl (T : Finset A) : (self.prob T) (↑T)ᶜ = 0

        The alternative chosen from T lies in T.

      Instances For
        instance Luce1959.ChoiceFn.isFiniteMeasure_prob {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) (T : Finset A) :
        MeasureTheory.IsFiniteMeasure (cf.prob T)
        theorem Luce1959.ChoiceFn.prob_coe {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) {T : Finset A} (hT : T.Nonempty) :
        (cf.prob T) ↑T = 1
        theorem Luce1959.ChoiceFn.sum_prob_real {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) {T : Finset A} (hT : T.Nonempty) :
        ∑ a ∈ T, (cf.prob T).real {a} = 1
        def Luce1959.ChoiceFn.HasRatioScale {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) :

        A system has a ratio scale if a measure μ with positive finite point masses gives every P_T by conditioning on T (Theorem 3, p. 23).

        Equations
        • cf.HasRatioScale = ∃ (μ : MeasureTheory.Measure A), (∀ (a : A), μ {a} ≠ 0) ∧ (∀ (a : A), μ {a} ≠ ⊤) ∧ ∀ (T : Finset A), T.Nonempty → cf.prob T = μ[|↑T]
        Instances For
          def Luce1959.ChoiceFn.HasProductRule {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) :

          A system satisfies the product rule if P_T(R) = P_S(R) P_T(S) whenever R ⊆ S ⊆ T, which is part i of Axiom 1 without its hypothesis of imperfect discrimination (p. 6).

          Equations
          Instances For
            theorem Luce1959.ChoiceFn.HasRatioScale.hasProductRule {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} (h : cf.HasRatioScale) :

            A ratio scale satisfies the product rule, since conditioning on T and then on S ⊆ T is conditioning on S.

            noncomputable def Luce1959.ChoiceFn.binary {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) [DecidableEq A] (x y : A) :
            ℝ

            Binary choice P(x, y) is the probability P_{x,y}(x) of choosing x from {x, y} (p. 5).

            Equations
            Instances For
              theorem Luce1959.ChoiceFn.binary_nonneg {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) [DecidableEq A] (x y : A) :
              0 ≤ cf.binary x y
              theorem Luce1959.ChoiceFn.binary_le_one {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) [DecidableEq A] (x y : A) :
              cf.binary x y ≤ 1
              theorem Luce1959.ChoiceFn.binary_complement {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) [DecidableEq A] {x y : A} (hxy : x ≠ y) :
              cf.binary x y + cf.binary y x = 1
              theorem Luce1959.ChoiceFn.binary_self {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) [DecidableEq A] (x : A) :
              cf.binary x x = 1

              Choice from the singleton {x} gives P(x, x) = 1, where Luce sets P(x, x) = 1/2 by convention (p. 5).

              def Luce1959.ChoiceFn.HasPairwiseIIA {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) [DecidableEq A] :

              A system satisfies the constant-ratio rule if every set containing a and b gives them the odds of the pair, P_T(a) P(b, a) = P_T(b) P(a, b) (Lemma 3, p. 9).

              Equations
              Instances For
                def Luce1959.ChoiceFn.BinaryRatioScaleOn {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) [DecidableEq A] (S : Set A) (v : A → ℝ) :

                A function v, positive on S, is a binary ratio scale on S if choice between distinct elements of S follows P(x, y) = v x / (v x + v y).

                Equations
                Instances For
                  def Luce1959.ChoiceFn.ImperfectOn {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) [DecidableEq A] (T : Finset A) :

                  Discrimination is imperfect throughout T if 0 < P(x, y) < 1 for all distinct x and y in T (p. 6).

                  Equations
                  Instances For
                    structure Luce1959.ChoiceFn.HasChoiceAxiom {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] (cf : ChoiceFn A) [DecidableEq A] :

                    A system satisfies Axiom 1 (p. 6) if P_T(R) = P_S(R) P_T(S) for R ⊆ S ⊆ T whenever discrimination is imperfect throughout T, and P_T(S) = P_{T - {x}}(S - {x}) for S ⊆ T whenever P(x, y) = 0 for some x and y in T.

                    • product_rule (T : Finset A) : cf.ImperfectOn T → ∀ (R S : Finset A), R ⊆ S → S ⊆ T → (cf.prob T) ↑R = (cf.prob S) ↑R * (cf.prob T) ↑S
                    • deletion (T : Finset A) (x : A) : x ∈ T → ∀ y ∈ T, cf.binary x y = 0 → ∀ S ⊆ T, (cf.prob T) ↑S = (cf.prob (T.erase x)) ↑(S.erase x)
                    Instances For
                      theorem Luce1959.ChoiceFn.HasRatioScale.hasPairwiseIIA {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] (h : cf.HasRatioScale) :

                      A ratio scale satisfies the constant-ratio rule.

                      theorem Luce1959.ChoiceFn.HasRatioScale.binaryRatioScaleOn {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] (h : cf.HasRatioScale) :
                      ∃ (v : A → ℝ), ∀ (S : Set A), cf.BinaryRatioScaleOn S v

                      A ratio scale is a binary ratio scale on every set, with v a = μ {a}.

                      theorem Luce1959.ChoiceFn.HasRatioScale.hasChoiceAxiom {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] (h : cf.HasRatioScale) :

                      A ratio scale satisfies Axiom 1, part ii vacuously since no discrimination is perfect.

                      theorem Luce1959.ChoiceFn.HasPairwiseIIA.hasRatioScale {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] [Inhabited A] (hIIA : cf.HasPairwiseIIA) (hpos : ∀ (T : Finset A), ∀ a ∈ T, 0 < (cf.prob T).real {a}) :

                      When every probability of choice is positive, the constant-ratio rule gives the ratio scale v x = P(x, x₀) / P(x₀, x) for a fixed alternative x₀ (p. 24).

                      theorem Luce1959.ChoiceFn.hasRatioScale_iff_hasPairwiseIIA {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] [Inhabited A] (hpos : ∀ (T : Finset A), ∀ a ∈ T, 0 < (cf.prob T).real {a}) :

                      The ratio form and the constant-ratio rule are equivalent when every probability of choice is positive.

                      theorem Luce1959.ChoiceFn.HasChoiceAxiom.prob_singleton_eq_zero {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] (h : cf.HasChoiceAxiom) {T : Finset A} {x y : A} (hx : x ∈ T) (hy : y ∈ T) (h0 : cf.binary x y = 0) :
                      (cf.prob T) {x} = 0

                      Under Axiom 1 an alternative never chosen over another is never chosen at all (Lemma 1, p. 6).

                      theorem Luce1959.ChoiceFn.HasChoiceAxiom.prob_singleton_ne_zero {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] (h : cf.HasChoiceAxiom) {T : Finset A} (himp : cf.ImperfectOn T) {x : A} (hx : x ∈ T) :
                      (cf.prob T) {x} ≠ 0

                      Under Axiom 1 and imperfect discrimination throughout T, every alternative in T is chosen from T with positive probability.

                      theorem Luce1959.ChoiceFn.HasChoiceAxiom.prob_eq_cond {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] (h : cf.HasChoiceAxiom) {T S : Finset A} (himp : cf.ImperfectOn T) (hST : S ⊆ T) (hS : S.Nonempty) :
                      cf.prob S = (cf.prob T)[|↑S]

                      Under Axiom 1 and imperfect discrimination throughout T, choice from a nonempty S ⊆ T is choice from T conditioned on S (p. 24).

                      theorem Luce1959.ChoiceFn.HasChoiceAxiom.ratioScaleOn {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] (h : cf.HasChoiceAxiom) {T : Finset A} (himp : cf.ImperfectOn T) :
                      (∀ x ∈ T, (cf.prob T) {x} ≠ 0) ∧ ∀ S ⊆ T, S.Nonempty → cf.prob S = (cf.prob T)[|↑S]

                      Under Axiom 1 and imperfect discrimination throughout T, P_T has positive point masses and gives choice from every nonempty S ⊆ T by conditioning (Theorem 3, p. 23).

                      theorem Luce1959.ChoiceFn.HasChoiceAxiom.binaryRatioScaleOn_prob {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] (h : cf.HasChoiceAxiom) {T : Finset A} (himp : cf.ImperfectOn T) :
                      cf.BinaryRatioScaleOn ↑T fun (a : A) => (cf.prob T).real {a}

                      Under Axiom 1 and imperfect discrimination throughout T, v a = P_T(a) is a binary ratio scale on T (Theorem 3, p. 23).

                      theorem Luce1959.ChoiceFn.HasChoiceAxiom.binaryRatioScaleOn {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] (h : cf.HasChoiceAxiom) {T : Finset A} (himp : cf.ImperfectOn T) :
                      ∃ (v : A → ℝ), cf.BinaryRatioScaleOn (↑T) v
                      theorem Luce1959.ChoiceFn.HasChoiceAxiom.binary_mul_cycle {A : Type u_1} [MeasurableSpace A] [MeasurableSingletonClass A] {cf : ChoiceFn A} [DecidableEq A] (h : cf.HasChoiceAxiom) {x y z : A} (hxy : x ≠ y) (hyz : y ≠ z) (hxz : x ≠ z) (himp : cf.ImperfectOn {x, y, z}) :
                      cf.binary x y * cf.binary y z * cf.binary z x = cf.binary x z * cf.binary z y * cf.binary y x

                      Under Axiom 1 and imperfect discrimination on {x, y, z}, a stochastic intransitivity is exactly as probable as its reverse, P(x, y) P(y, z) P(z, x) = P(x, z) P(z, y) P(y, x) (Theorem 2, p. 16).

                      §1.G: Just noticeable differences and the trace (pp. 34–37) #

                      A cutoff π ∈ (1/2, 1) defines the relations L(π), at least one π-jnd larger, and I(π), at most one π-jnd apart (Definition 3, p. 34). Under a ratio scale they form a semiorder (Theorem 5), and the trace, which orders alternatives by how well they fare against every other, is the weak order of the scale (Theorem 6).

                      def Luce1959.jndL {A : Type u_1} (v : A → ℝ) (thr : ℝ) (x y : A) :

                      x L(π) y holds when P(x, y) > π, so that x is at least one π-jnd larger than y (Definition 3, p. 34).

                      Equations
                      Instances For
                        def Luce1959.jndI {A : Type u_1} (v : A → ℝ) (thr : ℝ) (x y : A) :

                        x I(π) y holds when 1 - π ≤ P(x, y) ≤ π, so that x and y are at most one π-jnd apart (Definition 3, p. 34).

                        Equations
                        Instances For
                          theorem Luce1959.jndL_iff {A : Type u_1} {v : A → ℝ} {thr : ℝ} {x y : A} (hx : 0 < v x) (hy : 0 < v y) (hthr : thr < 1) :
                          jndL v thr x y ↔ thr / (1 - thr) * v y < v x

                          Under a positive ratio scale x L(π) y holds exactly when v x > π / (1 - π) · v y (proof of Theorem 5, p. 35).

                          theorem Luce1959.jndI_iff {A : Type u_1} {v : A → ℝ} {thr : ℝ} {x y : A} (hx : 0 < v x) (hy : 0 < v y) :
                          jndI v thr x y ↔ ¬jndL v thr x y ∧ ¬jndL v thr y x

                          x I(π) y holds exactly when neither alternative is one π-jnd larger than the other.

                          theorem Luce1959.jnd_trichotomy {A : Type u_1} {v : A → ℝ} {thr : ℝ} {x y : A} (hv : ∀ (a : A), 0 < v a) (hthr₀ : 1 / 2 < thr) (hthr₁ : thr < 1) :
                          jndL v thr x y ∧ ¬jndL v thr y x ∧ ¬jndI v thr x y ∨ jndL v thr y x ∧ ¬jndL v thr x y ∧ ¬jndI v thr x y ∨ jndI v thr x y ∧ ¬jndL v thr x y ∧ ¬jndL v thr y x

                          Exactly one of x L y, y L x and x I y holds, which is the first semiorder axiom (Theorem 5, p. 35).

                          theorem Luce1959.jndI_refl {A : Type u_1} {v : A → ℝ} {thr : ℝ} {x : A} (hv : ∀ (a : A), 0 < v a) (hthr₀ : 1 / 2 < thr) (hthr₁ : thr < 1) :
                          jndI v thr x x

                          Every alternative bears I to itself, which is the second semiorder axiom (Theorem 5, p. 35).

                          theorem Luce1959.jndL_interval {A : Type u_1} {v : A → ℝ} {thr : ℝ} {x y z w : A} (hv : ∀ (a : A), 0 < v a) (hthr₁ : thr < 1) (hxy : jndL v thr x y) (hyz : jndI v thr y z) (hzw : jndL v thr z w) :
                          jndL v thr x w

                          x L y, y I z and z L w imply x L w, which is the third semiorder axiom (Theorem 5, p. 35).

                          theorem Luce1959.jndL_no_sandwich {A : Type u_1} {v : A → ℝ} {thr : ℝ} {x y z w : A} (hv : ∀ (a : A), 0 < v a) (hthr₀ : 1 / 2 < thr) (hthr₁ : thr < 1) (hxy : jndL v thr x y) (hyz : jndL v thr y z) :
                          ¬(jndI v thr x w ∧ jndI v thr w z)

                          x L y and y L z exclude x I w together with w I z, which is the fourth semiorder axiom (Theorem 5, p. 35).

                          def Luce1959.traceGe {A : Type u_1} (v : A → ℝ) (x y : A) :

                          In the trace x ≥ y holds when P(x, z) ≥ P(y, z) for every z (Definition 4, p. 37).

                          Equations
                          Instances For
                            theorem Luce1959.traceGe_iff {A : Type u_1} {v : A → ℝ} {x y : A} (hv : ∀ (a : A), 0 < v a) :
                            traceGe v x y ↔ v y ≤ v x

                            Under a positive ratio scale the trace is the order of the scale (proof of Theorem 6, p. 37).

                            theorem Luce1959.theorem6 {A : Type u_1} {v : A → ℝ} (hv : ∀ (a : A), 0 < v a) :
                            Std.Total (traceGe v) ∧ IsTrans A (traceGe v)

                            Under a positive ratio scale the trace is a weak order (Theorem 6, p. 37).

                            theorem Luce1959.traceGe_iff_pairwiseProb {A : Type u_1} {v : A → ℝ} {x y : A} (hv : ∀ (a : A), 0 < v a) :
                            traceGe v x y ↔ 1 / 2 ≤ pairwiseProb v x y

                            Under a positive ratio scale x ≥ y in the trace exactly when P(x, y) ≥ 1/2 (corollary to Theorem 6, p. 37).

                            §2.A.3: Uniqueness of the logistic curve (pp. 41–42) #

                            If pairwise choice depends only on differences of a scale u that takes every real value, the ratio scale is exponential in u and pairwise choice is logistic. Luce reproduces Adams and Messick's proof, which reduces the claim to Cauchy's functional equation.

                            theorem Luce1959.logistic_unique {X : Type u_1} {v u : X → ℝ} {g F : ℝ → ℝ} (hu : Function.Surjective u) (hg_pos : ∀ (r : ℝ), 0 < g r) (hg : StrictMono g) (hv : ∀ (x : X), v x = g (u x)) (hF : ∀ (x y : X), v x / (v x + v y) = F (u x - u y)) :
                            ∃ (k : ℝ), 0 < k ∧ (∀ (x : X), v x = g 0 * Real.exp (k * u x)) ∧ ∀ (x y : X), v x / (v x + v y) = (k * (u x - u y)).sigmoid

                            If v = g ∘ u for a positive strictly increasing g, u takes every real value, and pairwise choice is a function of u x - u y, then v x = g 0 · exp (k · u x) for some k > 0 and pairwise choice is the sigmoid of k (u x - u y) (§2.A.3, pp. 41–42). Luce derives the form v = g ∘ u from the monotonicity of pairwise choice.

                            §2.B: The power law (pp. 42–44) #

                            On prothetic continua Luce assumes the linear generalization of Weber's law, under which P(x, y) = π exactly when x = (1 + c(π)) y + d(π), and finds the power scale A (x + C)^B (p. 43). He checks by substitution that the power scale solves the equation and cites Luce and Edwards for uniqueness, which follows here from the uniqueness of the logistic curve in the coordinate log (x + C).

                            noncomputable def Luce1959.powerScale (A C B x : ℝ) :
                            ℝ

                            The power scale is v(x) = A (x + C)^B (p. 43).

                            Equations
                            Instances For
                              theorem Luce1959.pairwiseProb_powerScale {A C B x y : ℝ} (hA : 0 < A) (hx : 0 < x + C) (hy : 0 < y + C) :
                              pairwiseProb (powerScale A C B) x y = 1 / (1 + ((y + C) / (x + C)) ^ B)

                              On the power scale P(x, y) = 1 / (1 + ((y + C) / (x + C))^B) (p. 44).

                              theorem Luce1959.pairwiseProb_powerScale_eq_iff {A C B x y p : ℝ} (hA : 0 < A) (hB : 0 < B) (hp₀ : 0 < p) (hp₁ : p < 1) (hx : 0 < x + C) (hy : 0 < y + C) :
                              pairwiseProb (powerScale A C B) x y = p ↔ x + C = (p / (1 - p)) ^ (1 / B) * (y + C)

                              On the power scale P(x, y) = π exactly when x + C = (π / (1 - π))^(1/B) (y + C).

                              theorem Luce1959.powerScale_weber {A C B p c : ℝ} (hA : 0 < A) (hB : 0 < B) (hp₀ : 1 / 2 < p) (hp₁ : p < 1) (hc : 1 + c = (p / (1 - p)) ^ (1 / B)) :
                              (∀ (x y : ℝ), 0 < x + C → 0 < y + C → (pairwiseProb (powerScale A C B) x y = p ↔ x = (1 + c) * y + c * C)) ∧ B = (Real.log p - Real.log (1 - p)) / Real.log (1 + c)

                              With 1 + c = (π / (1 - π))^(1/B), the power scale satisfies the linear generalization of Weber's law, P(x, y) = π exactly when x = (1 + c) y + c C, and B = (log π - log (1 - π)) / log (1 + c) (p. 43).

                              theorem Luce1959.powerScale_unique {C : ℝ} {v F : ℝ → ℝ} (hv_pos : ∀ (x : ℝ), 0 < x + C → 0 < v x) (hv : StrictMonoOn v (Set.Ioi (-C))) (hF : ∀ (x y : ℝ), 0 < x + C → 0 < y + C → pairwiseProb v x y = F ((x + C) / (y + C))) :
                              ∃ (B : ℝ), 0 < B ∧ ∀ (x : ℝ), 0 < x + C → v x = powerScale (v (1 - C)) C B x

                              A scale that is positive and strictly increasing above -C and makes pairwise choice a function of (x + C) / (y + C) is a power scale, the uniqueness that Luce attributes to Luce and Edwards (p. 43).

                              theorem Luce1959.jndL_powerScale_iff {A C B x y thr : ℝ} (hA : 0 < A) (hB : 0 < B) (hthr₀ : 0 < thr) (hthr₁ : thr < 1) (hx : 0 < x + C) (hy : 0 < y + C) :
                              jndL (powerScale A C B) thr x y ↔ (thr / (1 - thr)) ^ (1 / B) * (y + C) < x + C

                              On the power scale x L(π) y holds exactly when x + C > (π / (1 - π))^(1/B) (y + C), which is the linear generalization of Weber's law as an inequality.

                              §2.C: Interaction of continua (pp. 47–51) #

                              With an intensity x and a second variable ξ, Weber's law on each continuum makes the scale a power function of each variable with the other held fixed, and Luce assumes that the two surfaces coincide (p. 49). He reaches the form (8) by differentiating twice. Since the equation is affine in log x and log ξ, two of its values suffice here, with no assumption of differentiability.

                              theorem Luce1959.interaction_form {Aξ Bξ Ax Bx : ℝ → ℝ} (hA : ∀ (ξ : ℝ), 0 < ξ → 0 < Aξ ξ) (hA' : ∀ (x : ℝ), 0 < x → 0 < Ax x) (h : ∀ (x ξ : ℝ), 0 < x → 0 < ξ → Aξ ξ * x ^ Bξ ξ = Ax x * ξ ^ Bx x) :
                              ∃ (K : ℝ) (b : ℝ) (b' : ℝ) (c : ℝ), 0 < K ∧ ∀ (x ξ : ℝ), 0 < x → 0 < ξ → Aξ ξ * x ^ Bξ ξ = K * ξ ^ b' * x ^ (b + c * Real.log ξ)

                              If A(ξ) x^B(ξ) = A*(x) ξ^B*(x) for all positive x and ξ, then A(ξ) x^B(ξ) = K ξ^B* x^(B + C log ξ) for constants K > 0, B, B* and C (equation (8), p. 50).

                              theorem Luce1959.pairwiseProb_interaction {x y K b b' c ξ : ℝ} (hK : 0 < K) (hξ : 0 < ξ) (hx : 0 < x) (hy : 0 < y) :
                              pairwiseProb (fun (x : ℝ) => K * ξ ^ b' * x ^ (b + c * Real.log ξ)) x y = 1 / (1 + (y / x) ^ (b + c * Real.log ξ))

                              At a fixed ξ the scale of equation (8) is the power scale in x with exponent B + C log ξ, so P(x, y; ξ) = 1 / (1 + (y / x)^(B + C log ξ)) (p. 50).

                              §2.D: Discriminal processes (pp. 54–58) #

                              In Thurstone's model each stimulus a produces a discriminal process U ω a, and the stimulus whose process is the largest is judged the largest. Choice from T is then the random utility model on the processes of T (ProbabilityTheory.choiceProb), Luce's integral (9) when the processes are independent. Judging the smallest is judging the largest of the processes -U ω a, his (10). With three stimuli the probabilities that x is judged the largest and the smallest differ by P(x, y) + P(x, z) - 1, and Theorem 7 (p. 57) shows that the two judgments cannot both satisfy Axiom 1.

                              noncomputable def Luce1959.ChoiceFn.ofRandomUtility {A : Type u_1} {Ω : Type u_2} [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace Ω] {U : Ω → A → ℝ} (P : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure P] (hU : Measurable U) (hties : ∀ (j k : A), j ≠ k → P {ω : Ω | U ω j = U ω k} = 0) :

                              The system of choice probabilities of discriminal processes U ω a whose ties have probability zero. Choice from T is the random utility model on the processes of T, so P_T(a) is the probability that the process of a is the largest of them, equation (9) for independent processes (p. 56).

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For
                                theorem Luce1959.ChoiceFn.ofRandomUtility_prob_singleton {A : Type u_1} {Ω : Type u_2} [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace Ω] {U : Ω → A → ℝ} {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] (hU : Measurable U) (hties : ∀ (j k : A), j ≠ k → P {ω : Ω | U ω j = U ω k} = 0) {T : Finset A} {a : A} (ha : a ∈ T) :
                                ((ofRandomUtility P hU hties).prob T) {a} = P {ω : Ω | ∀ j ∈ T, j ≠ a → U ω j < U ω a}

                                The probability that a is judged the largest from T is the probability that its process exceeds the others of T.

                                theorem Luce1959.ChoiceFn.binary_ofRandomUtility {A : Type u_1} {Ω : Type u_2} [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace Ω] {U : Ω → A → ℝ} {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] (hU : Measurable U) (hties : ∀ (j k : A), j ≠ k → P {ω : Ω | U ω j = U ω k} = 0) [DecidableEq A] {x y : A} (hxy : x ≠ y) :
                                (ofRandomUtility P hU hties).binary x y = P.real {ω : Ω | U ω y < U ω x}
                                theorem Luce1959.ChoiceFn.theorem7 {A : Type u_1} {Ω : Type u_2} [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace Ω] {U : Ω → A → ℝ} {P : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure P] (hU : Measurable U) (hties : ∀ (j k : A), j ≠ k → P {ω : Ω | U ω j = U ω k} = 0) [DecidableEq A] {x y z : A} (hxy : x ≠ y) (hxz : x ≠ z) (hyz : y ≠ z) (himp : (ofRandomUtility P hU hties).ImperfectOn {x, y, z}) (hne : (ofRandomUtility P hU hties).binary x y + (ofRandomUtility P hU hties).binary x z ≠ 1) :

                                Theorem 7 (p. 57). Let discriminal processes U with null ties make P_T(a) the probability that a is judged the largest and P*_T(a) the probability that it is judged the smallest, the largest of the processes -U. If discrimination is imperfect on {x, y, z} (i) and P(x, y) + P(x, z) ≠ 1 (ii), then P and P* do not both satisfy Axiom 1 (iii). Luce's hypothesis (iv), P*(x, y) = P(y, x), holds in every such model. He takes the processes independent with densities, which makes ties null (Measure.pi_setOf_apply_eq_apply), and the stimuli to be x, y and z alone, so that Axiom 1 concerns only {x, y, z} and its subsets.

                                §2.E: Signal detectability theory (pp. 58–64) #

                                In the Yes-No experiment Luce applies the choice axiom to the two responses, with a signal parameter α and a response bias v among the scale values (p. 60). He contrasts the response bias with the criterion of signal detectability theory, yet the resulting model is exactly a logistic observer with a criterion. The two-alternative forced choice is the Yes-No model with α² in place of α (p. 62), since the subject makes "in effect, two Yes-No decisions", so it doubles the logistic sensitivity, while the normal model multiplies its sensitivity by √2.

                                noncomputable def Luce1959.yesNoProb (α v : ℝ) :
                                Bool → ℝ

                                yesNoProb α v b is the probability of affirming the signal in the axiom-1 Yes-No model with signal parameter α and response bias v, on signal trials (b = true) and noise trials (b = false) (p. 61).

                                Equations
                                Instances For
                                  noncomputable def Luce1959.forcedChoiceProb (α v : ℝ) :
                                  Bool → ℝ

                                  forcedChoiceProb α v b is the probability of choosing the first interval in the axiom-1 two-alternative forced choice, when the signal is in the first interval (b = true) or the second (b = false) (p. 62).

                                  Equations
                                  Instances For
                                    theorem Luce1959.yesNoProb_roc {α v : ℝ} (hα : 0 < α) (hv : 0 < v) :
                                    yesNoProb α v true = α * yesNoProb α v false / ((α - 1) * yesNoProb α v false + 1)

                                    In the axiom-1 Yes-No model the hit rate is α F / ((α - 1) F + 1) at the false-alarm rate F, which is its receiver operating characteristic (p. 61).

                                    theorem Luce1959.forcedChoiceProb_eq_yesNoProb {α v : ℝ} (hα : 0 < α) :
                                    forcedChoiceProb α v = yesNoProb (α ^ 2) (α * v)

                                    The forced choice is the Yes-No model with signal parameter α² and response bias α v (p. 62).

                                    theorem Luce1959.forcedChoiceProb_roc {α v : ℝ} (hα : 0 < α) (hv : 0 < v) :
                                    forcedChoiceProb α v true = α ^ 2 * forcedChoiceProb α v false / ((α ^ 2 - 1) * forcedChoiceProb α v false + 1)

                                    The axiom-1 forced choice has the receiver operating characteristic of the Yes-No model with α² in place of α (p. 62).

                                    theorem Luce1959.yesNoProb_eq_logistic {α v : ℝ} (hα : 0 < α) (hv : 0 < v) (b : Bool) :
                                    yesNoProb α v b = ((SignalDetection.locationExperiment ProbabilityTheory.logisticMeasure (Real.log α)) b).real (Set.Ioi (Real.log v - Real.log α / 2))

                                    The axiom-1 Yes-No observer responds as the logistic observer at sensitivity log α and criterion log v - log α / 2.

                                    theorem Luce1959.forcedChoiceProb_eq_logistic {α v : ℝ} (hα : 0 < α) (hv : 0 < v) (b : Bool) :
                                    forcedChoiceProb α v b = ((SignalDetection.locationExperiment ProbabilityTheory.logisticMeasure (2 * Real.log α)) b).real (Set.Ioi (Real.log v))

                                    The axiom-1 forced choice responds as the logistic observer at sensitivity 2 log α and criterion log v.

                                    §2.F: Rank orderings (pp. 68–74) #

                                    The ranking postulate (p. 72) ranks first an alternative chosen from the whole set and then ranks the rest by the same rule, so under a ratio scale the probability of a ranking is a product of choices from shrinking sets.

                                    noncomputable def Luce1959.rankProb {A : Type u_1} [DecidableEq A] (v : A → ℝ) :
                                    List A → ℝ

                                    Under the ranking postulate with ratio scale v, a ranking has the probability that its first alternative is chosen from the whole ranking by the ratio rule, times the probability of the rest (p. 72).

                                    Equations
                                    Instances For
                                      noncomputable def Luce1959.allRankings {A : Type u_1} [DecidableEq A] (T : Finset A) :
                                      Finset (List A)

                                      The rankings of T are the lists without repetition whose elements are those of T.

                                      Equations
                                      Instances For
                                        theorem Luce1959.mem_allRankings_iff {A : Type u_1} [DecidableEq A] {T : Finset A} {r : List A} :
                                        r ∈ allRankings T ↔ r.toFinset = T ∧ r.Nodup
                                        noncomputable def Luce1959.rankMeasure {A : Type u_1} [DecidableEq A] (v : A → ℝ) (T : Finset A) :
                                        MeasureTheory.Measure (List A)

                                        The distribution of the rankings of T under the ranking postulate puts the mass rankProb v r on each ranking r of T.

                                        Equations
                                        Instances For
                                          theorem Luce1959.rankMeasure_apply {A : Type u_1} [DecidableEq A] (v : A → ℝ) (T : Finset A) (s : Set (List A)) [DecidablePred fun (x : List A) => x ∈ s] :
                                          (rankMeasure v T) s = ∑ r ∈ allRankings T with r ∈ s, ENNReal.ofReal (rankProb v r)
                                          theorem Luce1959.isProbabilityMeasure_rankMeasure {A : Type u_1} [DecidableEq A] {v : A → ℝ} {T : Finset A} (hv : ∀ a ∈ T, 0 < v a) :
                                          MeasureTheory.IsProbabilityMeasure (rankMeasure v T)

                                          Under a positive scale the rankings of T form a probability distribution.

                                          theorem Luce1959.theorem9 {A : Type u_1} [DecidableEq A] {v : A → ℝ} {x y : A} (hxy : x ≠ y) {T : Finset A} (hx : x ∈ T) (hy : y ∈ T) (hv : ∀ a ∈ T, 0 < v a) :
                                          (rankMeasure v T) {r : List A | [x, y].Sublist r} = ENNReal.ofReal (pairwiseProb v x y)

                                          Under the ranking postulate and a positive ratio scale, a ranking of T places x above y with probability P(x, y) (Theorem 9, p. 72).

                                          theorem Luce1959.theorem8 {x y z : ℝ} (hx : 0 < x) (hy : 0 < y) (hz : 0 < z) :
                                          x / (x + y + z) * (y / (y + z)) = x * y / (x * y + x * z + y * z) * (x / (x + y)) ↔ x / (x + y) = y / (y + z)

                                          Let P* choose the worst alternative under Axiom 1 with P*(x, y) = P(y, x), and so with the reciprocal scale. Ranking {x, y, z} from the top, P_T(x) P(y, z), and from the bottom, P*_T(z) P(x, y), give x > y > z the same probability exactly when P(x, y) = P(y, z) (Theorem 8, p. 69).

                                          §3.B–D: Decomposable preference structures (pp. 78–90) #

                                          A gamble aρb has the outcome a if the event ρ occurs and b otherwise. A decomposable preference structure couples preference among gambles and pure alternatives with the subjective likelihood of events through the decomposition axiom (p. 78). If some pure alternatives are discriminated imperfectly, the events fall into at most three classes of equal likelihood (Theorem 10, p. 80).

                                          structure Luce1959.Gamble (A : Type u_3) (E : Type u_4) :
                                          Type (max u_3 u_4)

                                          The gamble aρb has the outcome win if event occurs and lose otherwise (p. 78).

                                          • win : A

                                            The outcome if the event occurs.

                                          • event : E

                                            The event.

                                          • lose : A

                                            The outcome if the event does not occur.

                                          Instances For
                                            def Luce1959.instDecidableEqGamble.decEq {A✝ : Type u_3} {E✝ : Type u_4} [DecidableEq A✝] [DecidableEq E✝] (x✝ x✝¹ : Gamble A✝ E✝) :
                                            Decidable (x✝ = x✝¹)
                                            Equations
                                            • One or more equations did not get rendered due to their size.
                                            Instances For
                                              @[instance_reducible]
                                              instance Luce1959.instDecidableEqGamble {A✝ : Type u_3} {E✝ : Type u_4} [DecidableEq A✝] [DecidableEq E✝] :
                                              DecidableEq (Gamble A✝ E✝)
                                              Equations
                                              @[instance_reducible]
                                              instance Luce1959.instMeasurableSpaceGamble {A : Type u_1} {E : Type u_2} :
                                              MeasurableSpace (Gamble A E)
                                              Equations
                                              instance Luce1959.instDiscreteMeasurableSpaceGamble {A : Type u_1} {E : Type u_2} :
                                              DiscreteMeasurableSpace (Gamble A E)
                                              @[reducible, inline]
                                              abbrev Luce1959.Alternative (A : Type u_3) (E : Type u_4) :
                                              Type (max (max u_4 u_3) u_3)

                                              The alternatives S(A, E) = (A × E × A) ∪ A are the gambles and the pure alternatives (p. 78).

                                              Equations
                                              Instances For
                                                structure Luce1959.DecomposablePreference (A : Type u_3) (E : Type u_4) [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] :
                                                Type (max u_3 u_4)

                                                A decomposable preference structure couples choice P among the alternatives with choice Q among events by subjective likelihood, each satisfying Axiom 1, through Axiom 2 (Definition 5, p. 78).

                                                • Choice among gambles and pure alternatives by preference.

                                                • Q : ChoiceFn E

                                                  Choice among events by subjective likelihood.

                                                • axiom2 (a b : A) : a ≠ b → ∀ (ρ σ : E), self.P.binary (Sum.inl { win := a, event := ρ, lose := b }) (Sum.inl { win := a, event := σ, lose := b }) = self.P.binary (Sum.inr a) (Sum.inr b) * self.Q.binary ρ σ + self.P.binary (Sum.inr b) (Sum.inr a) * self.Q.binary σ ρ

                                                  Axiom 2, P(aρb, aσb) = P(a, b) Q(ρ, σ) + P(b, a) Q(σ, ρ) for a ≠ b (p. 78).

                                                • axiom1P : self.P.HasChoiceAxiom

                                                  P satisfies Axiom 1.

                                                • axiom1Q : self.Q.HasChoiceAxiom

                                                  Q satisfies Axiom 1.

                                                Instances For
                                                  theorem Luce1959.axiom2_unguarded_false {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] [Nontrivial E] [Inhabited A] (P : ChoiceFn (Alternative A E)) (Q : ChoiceFn E) (h : ∀ (a b : A) (ρ σ : E), P.binary (Sum.inl { win := a, event := ρ, lose := b }) (Sum.inl { win := a, event := σ, lose := b }) = P.binary (Sum.inr a) (Sum.inr b) * Q.binary ρ σ + P.binary (Sum.inr b) (Sum.inr a) * Q.binary σ ρ) :
                                                  False

                                                  Without its guard a ≠ b, Axiom 2 would force P(aρa, aσa) = P(aσa, aρa) = 1, since P(a, a) = 1.

                                                  noncomputable def Luce1959.DecomposablePreference.alt {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] (dp : DecomposablePreference A E) (a b : A) :
                                                  ℝ

                                                  dp.alt a b is the choice probability P(a, b) between pure alternatives.

                                                  Equations
                                                  Instances For
                                                    noncomputable def Luce1959.DecomposablePreference.gam {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] (dp : DecomposablePreference A E) (g h : Gamble A E) :
                                                    ℝ

                                                    dp.gam g h is the choice probability P(g, h) between gambles.

                                                    Equations
                                                    Instances For
                                                      theorem Luce1959.DecomposablePreference.gam_of_alt_eq_one {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} {a b : A} (hab : a ≠ b) (h1 : dp.alt a b = 1) (ρ σ : E) :
                                                      dp.gam { win := a, event := ρ, lose := b } { win := a, event := σ, lose := b } = dp.Q.binary ρ σ

                                                      If P(a, b) = 1 then P(aρb, aσb) = Q(ρ, σ), a step in the proofs of Theorems 13 and 14 (pp. 87, 89).

                                                      def Luce1959.DecomposablePreference.EventPref {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] (dp : DecomposablePreference A E) (ρ σ : E) :

                                                      ρ ≿ σ holds when Q(ρ, σ) ≥ 1/2, so that ρ is deemed at least as likely as σ (Definition 6, p. 79).

                                                      Equations
                                                      Instances For
                                                        def Luce1959.DecomposablePreference.EventIndiff {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] (dp : DecomposablePreference A E) (ρ σ : E) :

                                                        Events ρ and σ are equi-likely, ρ ∼ σ, when ρ ≿ σ and σ ≿ ρ.

                                                        Equations
                                                        Instances For
                                                          theorem Luce1959.DecomposablePreference.eventIndiff_refl {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] (dp : DecomposablePreference A E) (ρ : E) :
                                                          dp.EventIndiff ρ ρ
                                                          theorem Luce1959.DecomposablePreference.EventIndiff.symm {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} {ρ σ : E} (h : dp.EventIndiff ρ σ) :
                                                          dp.EventIndiff σ ρ
                                                          theorem Luce1959.DecomposablePreference.eventIndiff_iff_eq_half {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} {ρ σ : E} (hne : ρ ≠ σ) :
                                                          dp.EventIndiff ρ σ ↔ dp.Q.binary ρ σ = 1 / 2
                                                          theorem Luce1959.DecomposablePreference.ne_of_not_eventIndiff {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} {ρ σ : E} (h : ¬dp.EventIndiff ρ σ) :
                                                          ρ ≠ σ
                                                          theorem Luce1959.DecomposablePreference.eventPref_total {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} (ρ σ : E) :
                                                          dp.EventPref ρ σ ∨ dp.EventPref σ ρ
                                                          theorem Luce1959.DecomposablePreference.gt_half_or_of_not_eventIndiff {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} {ρ σ : E} (h : ¬dp.EventIndiff ρ σ) :
                                                          1 / 2 < dp.Q.binary ρ σ ∨ 1 / 2 < dp.Q.binary σ ρ

                                                          Two events that are not equi-likely are strictly ordered.

                                                          def Luce1959.DecomposablePreference.Nondegenerate {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] (dp : DecomposablePreference A E) :

                                                          A structure is nondegenerate if P(a, b) ≠ 0, 1/2, 1 for some distinct a and b, which is the hypothesis of Theorem 10 (p. 80).

                                                          Equations
                                                          • dp.Nondegenerate = ∃ (a : A) (b : A), a ≠ b ∧ dp.alt a b ≠ 0 ∧ dp.alt a b ≠ 1 / 2 ∧ dp.alt a b ≠ 1
                                                          Instances For
                                                            theorem Luce1959.DecomposablePreference.lemma5 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} {a b : A} (hab : a ≠ b) (h0 : dp.alt a b ≠ 0) (hhalf : dp.alt a b ≠ 1 / 2) (h1 : dp.alt a b ≠ 1) {ρ σ τ : E} (hρσ : ρ ≠ σ) (hστ : σ ≠ τ) (hρτ : ρ ≠ τ) :
                                                            dp.alt a b * dp.alt b a * (2 * (dp.Q.binary ρ σ + dp.Q.binary σ τ + dp.Q.binary τ ρ) - 3) + (dp.alt a b - dp.alt b a) ^ 2 * (dp.Q.binary ρ σ * dp.Q.binary σ τ * dp.Q.binary τ ρ - dp.Q.binary ρ τ * dp.Q.binary τ σ * dp.Q.binary σ ρ) = 0

                                                            With K = P(a, b)/P(b, a) - 1, (K + 1){2[Q(ρ, σ) + Q(σ, τ) + Q(τ, ρ)] - 3} + K²[Q(ρ, σ)Q(σ, τ)Q(τ, ρ) - Q(ρ, τ)Q(τ, σ)Q(σ, ρ)] vanishes, here multiplied through by P(b, a)² (Lemma 5, p. 80).

                                                            theorem Luce1959.DecomposablePreference.eventPref_trans {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} (hnd : dp.Nondegenerate) {ρ σ τ : E} (h1 : dp.EventPref ρ σ) (h2 : dp.EventPref σ τ) :
                                                            dp.EventPref ρ τ
                                                            theorem Luce1959.DecomposablePreference.lemma6 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} (hnd : dp.Nondegenerate) :
                                                            Std.Total dp.EventPref ∧ IsTrans E dp.EventPref

                                                            In a nondegenerate structure ≿ is a weak order (Lemma 6, p. 80).

                                                            theorem Luce1959.DecomposablePreference.eventIndiff_trans {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} (hnd : dp.Nondegenerate) {ρ σ τ : E} (h1 : dp.EventIndiff ρ σ) (h2 : dp.EventIndiff σ τ) :
                                                            dp.EventIndiff ρ τ
                                                            theorem Luce1959.DecomposablePreference.lemma7 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} (hnd : dp.Nondegenerate) {ρ σ τ : E} (hρσ : ρ ≠ σ) (hστ : σ ≠ τ) (hρτ : ρ ≠ τ) (himp : dp.Q.ImperfectOn {ρ, σ, τ}) :
                                                            dp.EventIndiff ρ σ ∨ dp.EventIndiff σ τ ∨ dp.EventIndiff ρ τ

                                                            In a nondegenerate structure, of three distinct events among which discrimination is imperfect, two are equi-likely (Lemma 7, p. 81).

                                                            theorem Luce1959.DecomposablePreference.lemma8 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} (hnd : dp.Nondegenerate) (ρ σ τ ω : E) :
                                                            dp.EventIndiff ρ σ ∨ dp.EventIndiff ρ τ ∨ dp.EventIndiff ρ ω ∨ dp.EventIndiff σ τ ∨ dp.EventIndiff σ ω ∨ dp.EventIndiff τ ω

                                                            In a nondegenerate structure ∼ has at most three classes, so of any four events two are equi-likely (Lemma 8, p. 81).

                                                            theorem Luce1959.DecomposablePreference.theorem10 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} (hnd : dp.Nondegenerate) :
                                                            Equivalence dp.EventIndiff ∧ ∀ (ρ σ τ ω : E), dp.EventIndiff ρ σ ∨ dp.EventIndiff ρ τ ∨ dp.EventIndiff ρ ω ∨ dp.EventIndiff σ τ ∨ dp.EventIndiff σ ω ∨ dp.EventIndiff τ ω

                                                            If some P(a, b) ≠ 0, 1/2, 1, equi-likelihood is an equivalence relation with at most three classes (Theorem 10, p. 80).

                                                            theorem Luce1959.DecomposablePreference.theorem11 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} (hnd : dp.Nondegenerate) {ρ ρ' σ σ' : E} (h1 : dp.EventIndiff ρ ρ') (h2 : dp.EventIndiff σ σ') (hρσ : ρ ≠ σ) (hρ'σ' : ρ' ≠ σ') :
                                                            dp.Q.binary ρ σ = dp.Q.binary ρ' σ'

                                                            In a nondegenerate structure ρ ∼ ρ' and σ ∼ σ' give Q(ρ, σ) = Q(ρ', σ') for ρ ≠ σ and ρ' ≠ σ' (Theorem 11, p. 82).

                                                            theorem Luce1959.DecomposablePreference.abs_two_mul_alt_sub_one {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} {a b : A} (hab : a ≠ b) (h0 : dp.alt a b ≠ 0) (hhalf : dp.alt a b ≠ 1 / 2) (h1 : dp.alt a b ≠ 1) {ρ σ τ : E} (hρσ : ρ ≠ σ) (hστ : σ ≠ τ) (hρτ : ρ ≠ τ) (hq : dp.Q.binary ρ σ = dp.Q.binary σ τ) (hρτ₁ : dp.Q.binary ρ τ = 1) :
                                                            3 / 4 < dp.Q.binary ρ σ ∧ dp.Q.binary ρ σ < 1 ∧ |2 * dp.alt a b - 1| = √(4 * dp.Q.binary ρ σ - 3) / (2 * dp.Q.binary ρ σ - 1)

                                                            If distinct events have Q(ρ, σ) = Q(σ, τ) = q and Q(ρ, τ) = 1, then any P(a, b) ≠ 0, 1/2, 1 forces 3/4 < q < 1 and P(a, b) = (1 ± √(4q - 3) / (2q - 1)) / 2 (§3.C.2, p. 85).

                                                            §3.C: Additional axioms (pp. 83–86) #

                                                            Axiom 3 identifies aρb with bρ̄a, Axiom 4 asks that neither all alternatives nor all events be indifferent, and Axiom 5 posits an event as likely as its complement. Under them the classes are exactly three, and the imperfect discriminations among pure alternatives share one probability.

                                                            def Luce1959.DecomposablePreference.Complementation {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] [BooleanAlgebra E] (dp : DecomposablePreference A E) :

                                                            Axiom 3 asks that P(aρb, x) = P(bρ̄a, x) for every x other than the two gambles (p. 83).

                                                            Equations
                                                            • One or more equations did not get rendered due to their size.
                                                            Instances For
                                                              theorem Luce1959.DecomposablePreference.complementation_unguarded_false {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] [BooleanAlgebra E] [Nontrivial A] (dp : DecomposablePreference A E) (h : ∀ (a b : A) (ρ : E) (x : Alternative A E), dp.P.binary (Sum.inl { win := a, event := ρ, lose := b }) x = dp.P.binary (Sum.inl { win := b, event := ρᶜ, lose := a }) x) :
                                                              False

                                                              Without its guards Axiom 3 would force P(aρb, bρ̄a) = P(bρ̄a, aρb) = 1.

                                                              def Luce1959.DecomposablePreference.NontrivialPreference {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] (dp : DecomposablePreference A E) :

                                                              Axiom 4 asks for distinct a and b with P(a, b) ≠ 1/2 and distinct ρ and σ with Q(ρ, σ) ≠ 1/2 (p. 83).

                                                              Equations
                                                              • dp.NontrivialPreference = ((∃ (a : A) (b : A), a ≠ b ∧ dp.alt a b ≠ 1 / 2) ∧ ∃ (ρ : E) (σ : E), ρ ≠ σ ∧ dp.Q.binary ρ σ ≠ 1 / 2)
                                                              Instances For
                                                                theorem Luce1959.DecomposablePreference.lemma9 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} [BooleanAlgebra E] (ax3 : dp.Complementation) (ax4 : dp.NontrivialPreference) (ρ σ : E) :
                                                                dp.Q.binary ρ σ = dp.Q.binary σᶜ ρᶜ

                                                                Under Axioms 3 and 4, Q(ρ, σ) = Q(σ̄, ρ̄) (Lemma 9, p. 84).

                                                                def Luce1959.DecomposablePreference.Neutral {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] [BooleanAlgebra E] (dp : DecomposablePreference A E) (ρ : E) :

                                                                An event ρ is neutral if Q(ρ, ρ̄) = 1/2, and by Lemma 10 the neutral events form Luce's class C(1/2) (p. 85).

                                                                Equations
                                                                Instances For
                                                                  theorem Luce1959.DecomposablePreference.neutral_compl_iff {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} [BooleanAlgebra E] [Nontrivial E] (ρ : E) :
                                                                  dp.Neutral ρᶜ ↔ dp.Neutral ρ
                                                                  theorem Luce1959.DecomposablePreference.neutral_indifferent {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} [BooleanAlgebra E] [Nontrivial E] (hnd : dp.Nondegenerate) (ax3 : dp.Complementation) (ax4 : dp.NontrivialPreference) {ρ σ : E} (hρ : dp.Neutral ρ) (hσ : dp.Neutral σ) (hρσ : ρ ≠ σ) :
                                                                  dp.Q.binary ρ σ = 1 / 2

                                                                  Distinct neutral events are equi-likely (Lemma 10, p. 84).

                                                                  def Luce1959.DecomposablePreference.HasNeutralEvent {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] [BooleanAlgebra E] (dp : DecomposablePreference A E) :

                                                                  Axiom 5 posits an event as likely as its complement (p. 84).

                                                                  Equations
                                                                  Instances For
                                                                    theorem Luce1959.DecomposablePreference.neutral_of_indiff_neutral {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} [BooleanAlgebra E] [Nontrivial E] (hnd : dp.Nondegenerate) (ax3 : dp.Complementation) (ax4 : dp.NontrivialPreference) {ρ σ : E} (hρ : dp.Neutral ρ) (h : dp.EventIndiff σ ρ) :
                                                                    dp.Neutral σ

                                                                    An event equi-likely with a neutral event is neutral (Lemma 10, p. 84).

                                                                    theorem Luce1959.DecomposablePreference.lemma11 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} [BooleanAlgebra E] [Nontrivial E] (hnd : dp.Nondegenerate) (ax3 : dp.Complementation) (ax4 : dp.NontrivialPreference) (ax5 : dp.HasNeutralEvent) :
                                                                    ∃ (ε : E) (ρ : E), ¬dp.EventIndiff ε ρ ∧ ¬dp.EventIndiff ε ρᶜ ∧ ¬dp.EventIndiff ρ ρᶜ

                                                                    Under Axioms 3–5 a neutral event ε, a non-neutral event ρ and ρ̄ lie in three distinct classes (Lemma 11, p. 85).

                                                                    theorem Luce1959.DecomposablePreference.theorem12 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} [BooleanAlgebra E] [Nontrivial E] (hnd : dp.Nondegenerate) (ax3 : dp.Complementation) (ax4 : dp.NontrivialPreference) (ax5 : dp.HasNeutralEvent) :
                                                                    ∃ (ρ₁ : E) (ρ₂ : E) (ρ₃ : E), (¬dp.EventIndiff ρ₁ ρ₂ ∧ ¬dp.EventIndiff ρ₁ ρ₃ ∧ ¬dp.EventIndiff ρ₂ ρ₃) ∧ ∀ (σ : E), dp.EventIndiff σ ρ₁ ∨ dp.EventIndiff σ ρ₂ ∨ dp.EventIndiff σ ρ₃

                                                                    In a nondegenerate structure satisfying Axioms 3–5, ∼ has exactly three classes (Theorem 12, p. 84).

                                                                    theorem Luce1959.DecomposablePreference.exists_class_representatives {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} [BooleanAlgebra E] [Nontrivial E] (hnd : dp.Nondegenerate) (ax3 : dp.Complementation) (ax4 : dp.NontrivialPreference) (ax5 : dp.HasNeutralEvent) :
                                                                    ∃ (ρ : E) (σ : E) (τ : E), ¬dp.EventIndiff ρ σ ∧ ¬dp.EventIndiff σ τ ∧ ¬dp.EventIndiff ρ τ ∧ 1 / 2 < dp.Q.binary ρ σ ∧ dp.Q.binary ρ σ = dp.Q.binary σ τ ∧ dp.Q.binary ρ τ = 1

                                                                    Under the hypotheses of Theorem 12 the three classes have representatives ρ ≻ σ ≻ τ with Q(ρ, σ) = Q(σ, τ) > 1/2 and Q(ρ, τ) = 1 (§3.C.2, p. 85).

                                                                    theorem Luce1959.DecomposablePreference.exists_abs_two_mul_alt_sub_one {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} [BooleanAlgebra E] [Nontrivial E] (hnd : dp.Nondegenerate) (ax3 : dp.Complementation) (ax4 : dp.NontrivialPreference) (ax5 : dp.HasNeutralEvent) :
                                                                    ∃ (q : ℝ), 3 / 4 < q ∧ q < 1 ∧ ∀ (a b : A), a ≠ b → dp.alt a b ≠ 0 → dp.alt a b ≠ 1 / 2 → dp.alt a b ≠ 1 → |2 * dp.alt a b - 1| = √(4 * q - 3) / (2 * q - 1)

                                                                    Under the hypotheses of Theorem 12, every P(a, b) ≠ 0, 1/2, 1 equals (1 ± √(4q - 3) / (2q - 1)) / 2 for one q with 3/4 < q < 1 (§3.C.2, p. 85).

                                                                    §3.D: A proposed experiment (pp. 86–90) #

                                                                    Luce's prediction concerns gambles whose outcomes are perfectly discriminated. When two gambles pay their preferred outcomes on the same event, choice between them is a step function of the event (Figure 7), and when they pay them on complementary events, the ratio scale obeys a product rule that suggests factoring it into outcome and event weights.

                                                                    theorem Luce1959.DecomposablePreference.theorem13 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} {a b c d : A} {ρ σ : E} (hab : a ≠ b) (hcd : c ≠ d) (ha1 : dp.alt a b = 1) (hc1 : dp.alt c d = 1) (himp : dp.P.ImperfectOn {Sum.inl { win := a, event := ρ, lose := b }, Sum.inl { win := a, event := σ, lose := b }, Sum.inl { win := c, event := ρ, lose := d }, Sum.inl { win := c, event := σ, lose := d }}) :
                                                                    dp.gam { win := a, event := ρ, lose := b } { win := c, event := ρ, lose := d } = dp.gam { win := a, event := σ, lose := b } { win := c, event := σ, lose := d }

                                                                    If P(a, b) = P(c, d) = 1 and discrimination among aρb, aσb, cρd and cσd is imperfect throughout, then P(aρb, cρd) = P(aσb, cσd) (Theorem 13, p. 86).

                                                                    theorem Luce1959.DecomposablePreference.theorem14 {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} [BooleanAlgebra E] [Nontrivial E] (ax3 : dp.Complementation) {a b c d : A} {ρ σ : E} {v : Alternative A E → ℝ} (hab : a ≠ b) (hcd : c ≠ d) (ha1 : dp.alt a b = 1) (hd1 : dp.alt d c = 1) (hv : dp.P.BinaryRatioScaleOn {Sum.inl { win := a, event := ρ, lose := b }, Sum.inl { win := a, event := σ, lose := b }, Sum.inl { win := c, event := ρ, lose := d }, Sum.inl { win := c, event := σ, lose := d }, Sum.inl { win := d, event := ρᶜ, lose := c }, Sum.inl { win := d, event := σᶜ, lose := c }} v) :
                                                                    v (Sum.inl { win := a, event := ρ, lose := b }) * v (Sum.inl { win := d, event := ρᶜ, lose := c }) = v (Sum.inl { win := a, event := σ, lose := b }) * v (Sum.inl { win := d, event := σᶜ, lose := c })

                                                                    Under Axiom 3, if P(a, b) = P(d, c) = 1, a ratio scale v on the gambles involved has v(aρb) v(dρ̄c) = v(aσb) v(dσ̄c) (Theorem 14, p. 89). Luce takes the scale on aρb, aσb, cρd and cσd from Theorem 4 and extends it by Axiom 3, where here it is given on all six gambles.

                                                                    theorem Luce1959.DecomposablePreference.gam_of_factored {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} {S : Set (Gamble A E)} {v : Alternative A E → ℝ} {w : A → A → ℝ} {φ : E → ℝ} (hv : dp.P.BinaryRatioScaleOn (Sum.inl '' S) v) (hφ : ∀ (τ : E), 0 < φ τ) (hfac : ∀ (x y : A) (τ : E), { win := x, event := τ, lose := y } ∈ S → v (Sum.inl { win := x, event := τ, lose := y }) = w x y * φ τ) {a b c d : A} {ρ : E} (h₁ : { win := a, event := ρ, lose := b } ∈ S) (h₂ : { win := c, event := ρ, lose := d } ∈ S) (hacbd : ¬(a = c ∧ b = d)) :
                                                                    dp.gam { win := a, event := ρ, lose := b } { win := c, event := ρ, lose := d } = w a b / (w a b + w c d)

                                                                    If the ratio scale factors as v(aρb) = w(a, b) φ(ρ), as Theorems 13 and 14 suggest, then P(aρb, cρd) = w(a, b) / (w(a, b) + w(c, d)), so the step function of Theorem 13 has at most one step strictly between 0 and 1 (pp. 89–90).

                                                                    §4: Response-strength operators (pp. 93–106) #

                                                                    A learning event transforms the vector of response strengths, and the choice probabilities follow from the strengths by the ratio rule. The alpha model takes the transformation to be a nonnegative matrix, the form Luce derives from the unboundedness, superposition and independence-of-unit conditions, the beta model multiplies each strength by a constant, and the gamma model adds a constant as well.

                                                                    §4.C: The alpha model #

                                                                    def Luce1959.ProportionalChange {A : Type u_1} [Fintype A] (M : Matrix A A ℝ) (a : ℝ) :

                                                                    An operator M satisfies the proportional change assumption (p. 97) with constant a if it multiplies the total strength of every positive vector by a.

                                                                    Equations
                                                                    Instances For
                                                                      theorem Luce1959.proportionalChange_iff {A : Type u_1} [Fintype A] [DecidableEq A] {M : Matrix A A ℝ} {a : ℝ} :
                                                                      ProportionalChange M a ↔ ∀ (j : A), ∑ i : A, M i j = a

                                                                      The proportional change assumption holds exactly when every column of M sums to a (equation (1), p. 98).

                                                                      theorem Luce1959.ProportionalChange.ratioProb_mulVec {A : Type u_1} [Fintype A] [DecidableEq A] {M : Matrix A A ℝ} {a : ℝ} (h : ProportionalChange M a) (v : A → ℝ) :
                                                                      ratioProb (M.mulVec v) Finset.univ = (a⁻¹ • M).mulVec (ratioProb v Finset.univ)

                                                                      Under the proportional change assumption the probability operator of the alpha model is linear, with matrix aᵢⱼ / a (p. 97).

                                                                      theorem Luce1959.ProportionalChange.pairwiseProb_mulVec {M : Matrix (Fin 2) (Fin 2) ℝ} {a : ℝ} (h : ProportionalChange M a) (ha : a ≠ 0) (hM : ∀ (i j : Fin 2), 0 ≤ M i j) {v : Fin 2 → ℝ} (hv : v 0 + v 1 ≠ 0) :
                                                                      pairwiseProb (M.mulVec v) 0 1 = (M 0 0 - M 0 1) / a * pairwiseProb v 0 1 + (1 - (M 0 0 - M 0 1) / a) * (M 0 1 / (M 0 1 + M 1 0))

                                                                      With two alternatives, indexed 0 and 1 for Luce's 1 and 2, the alpha model is the linear operator P' = α P + (1 − α) λ of [BM55], with α = (a₁₁ − a₁₂)/a and λ = a₁₂/(a₁₂ + a₂₁) (p. 99).

                                                                      §4.D: The beta model #

                                                                      theorem Luce1959.eq_mul_of_independenceOfUnit {f : ℝ → ℝ} (h : ∀ k > 0, ∀ x > 0, f (k * x) = k * f x) {x : ℝ} (hx : 0 < x) :
                                                                      f x = f 1 * x

                                                                      An operator on a response strength that is independent of the unit is multiplication by its value at 1 (p. 100).

                                                                      theorem Luce1959.ratioProb_mul_ratioProb {A : Type u_1} [Fintype A] [DecidableEq A] (β : A → ℝ) {v : A → ℝ} (hv : ∑ j : A, v j ≠ 0) :
                                                                      ratioProb (β * ratioProb v Finset.univ) Finset.univ = ratioProb (β * v) Finset.univ

                                                                      In probability terms the beta operator multiplies each probability by its βᵢ and renormalizes, P'(i) = βᵢ·P(i) / ∑ⱼ βⱼ·P(j) (p. 101).

                                                                      theorem Luce1959.ratioProb_mul_comm {A : Type u_1} [Fintype A] [DecidableEq A] (β γ : A → ℝ) {p : A → ℝ} (hβ : ∑ j : A, β j * p j ≠ 0) (hγ : ∑ j : A, γ j * p j ≠ 0) :
                                                                      ratioProb (β * ratioProb (γ * p) Finset.univ) Finset.univ = ratioProb (γ * ratioProb (β * p) Finset.univ) Finset.univ

                                                                      The beta operators commute on the probabilities, as they do on the strengths (p. 101).

                                                                      theorem Luce1959.ratioProb_update_mul {A : Type u_1} [Fintype A] [DecidableEq A] (i : A) (β : ℝ) {v : A → ℝ} (hv : ∑ j : A, v j ≠ 0) (j : A) :
                                                                      ratioProb (Function.update 1 i β * v) Finset.univ j = Function.update 1 i β j * ratioProb v Finset.univ j / (1 + (β - 1) * ratioProb v Finset.univ i)

                                                                      In the simple beta model only the chosen alternative i changes strength, βᵢ = β and βⱼ = 1 for j ≠ i, so P'(i) = β·P(i) / (1 + (β − 1)·P(i)) and P'(j) = P(j) / (1 + (β − 1)·P(i)) (p. 101).

                                                                      theorem Luce1959.ratioProb_mul_fin_two (β : Fin 2 → ℝ) (hβ : β 1 ≠ 0) (v : Fin 2 → ℝ) :
                                                                      ratioProb (β * v) Finset.univ = ratioProb (Function.update 1 0 (β 0 / β 1) * v) Finset.univ

                                                                      With two alternatives the general beta model is the simple one with β = β₁/β₂ (p. 102).

                                                                      §4.E: The gamma model #

                                                                      theorem Luce1959.not_exists_ratioProb_gamma {A : Type u_1} [Fintype A] [DecidableEq A] [Nontrivial A] {β γ : A → ℝ} (hβ : ∀ (i : A), 0 < β i) (hγ : ∀ (i : A), 0 ≤ γ i) (hγ₀ : γ ≠ 0) :
                                                                      ¬∃ (F : (A → ℝ) → A → ℝ), ∀ (v : A → ℝ), (∀ (i : A), 0 < v i) → ratioProb (β * v + γ) Finset.univ = F (ratioProb v Finset.univ)

                                                                      The additive constant of the gamma model vᵢ ↦ βᵢ·vᵢ + γᵢ keeps its probability operator from being a function of the probabilities, so path independence fails at the level of the probabilities (p. 106).

                                                                      §4.F: Partial reinforcement (pp. 107–110) #

                                                                      In a partial reinforcement experiment the organism chooses between aρb and aρ̄b, with a a reward and b nothing, and Theorem 14 makes the product of their strengths independent of the event. An alpha or gamma operator that keeps this product fixed confines the strengths to a few values unless it does not learn or reduces to a beta operator, and a beta operator needs only β₁ β₂ = 1.

                                                                      theorem Luce1959.DecomposablePreference.strength_mul_strength_compl {A : Type u_1} {E : Type u_2} [DecidableEq A] [DecidableEq E] [BooleanAlgebra E] [Nontrivial E] [MeasurableSpace A] [MeasurableSingletonClass A] [MeasurableSpace E] [MeasurableSingletonClass E] {dp : DecomposablePreference A E} (ax3 : dp.Complementation) {a b : A} {ρ σ : E} {v : Alternative A E → ℝ} (hab : a ≠ b) (ha : dp.alt a b = 1) (hv : dp.P.BinaryRatioScaleOn {Sum.inl { win := a, event := ρ, lose := b }, Sum.inl { win := a, event := σ, lose := b }, Sum.inl { win := b, event := ρ, lose := a }, Sum.inl { win := b, event := σ, lose := a }, Sum.inl { win := a, event := ρᶜ, lose := b }, Sum.inl { win := a, event := σᶜ, lose := b }} v) :
                                                                      v (Sum.inl { win := a, event := ρ, lose := b }) * v (Sum.inl { win := a, event := ρᶜ, lose := b }) = v (Sum.inl { win := a, event := σ, lose := b }) * v (Sum.inl { win := a, event := σᶜ, lose := b })

                                                                      If P(a, b) = 1, the product of the strengths of aρb and aρ̄b is the same for every event, by Theorem 14 with c = b and d = a (p. 108).

                                                                      theorem Luce1959.ProportionalChange.encard_le_four_or {M : Matrix (Fin 2) (Fin 2) ℝ} {a : ℝ} (h : ProportionalChange M a) (hM : ∀ (i j : Fin 2), 0 ≤ M i j) {K : ℝ} (hK : 0 < K) :
                                                                      {x : ℝ | 0 < x ∧ M.mulVec ![x, K / x] 0 * M.mulVec ![x, K / x] 1 = K}.encard ≤ 4 ∨ M = 1 ∨ M = !![0, 1; 1, 0]

                                                                      An alpha-model operator that keeps the product K of the two strengths fixed either confines v(aρb) to at most four values, the roots of a quartic, or is the identity or the swap of the two strengths, neither of which learns (pp. 108–109).

                                                                      theorem Luce1959.ratioProb_mul_eq_of_mul_eq {β : Fin 2 → ℝ} {K x : ℝ} (hK : 0 < K) (hx : 0 < x) (h : β 0 * x * (β 1 * (K / x)) = K) (v : Fin 2 → ℝ) :
                                                                      ratioProb (β * v) Finset.univ = ratioProb (Function.update 1 0 (β 0 ^ 2) * v) Finset.univ

                                                                      A beta-model operator that keeps the product of the two strengths fixed has β₁·β₂ = 1, and is then the simple beta model with β = β₁² (p. 109).

                                                                      theorem Luce1959.encard_le_two_or_gamma {β γ : Fin 2 → ℝ} {K : ℝ} (hK : 0 < K) :
                                                                      {x : ℝ | 0 < x ∧ (β 0 * x + γ 0) * (β 1 * (K / x) + γ 1) = K}.encard ≤ 2 ∨ β = 0 ∧ γ 0 * γ 1 = K ∨ γ = 0 ∧ β 0 * β 1 = 1

                                                                      A gamma-model operator vᵢ ↦ βᵢ·vᵢ + γᵢ that keeps the product K of the two strengths fixed either confines v(aρb) to at most two values, the roots of a quadratic, or holds both strengths constant, or is a beta-model operator with β₁ = 1/β₂ (p. 110).

                                                                      §4.G: Asymptotic properties of the beta model (pp. 111–120) #

                                                                      With two alternatives and two outcomes, the ratio vₙ of the response strengths is a Markov chain that moves by one of four steps on the log scale. Three equations govern its expectations, the moment recursion (10), the identity (11), and the drift (16) of the expected log ratio, and from them Theorems 15–18 relate the limit of E(Pₙ) to the moments of vₙ and 1/vₙ. Each second part is the first part for the model with the alternatives exchanged.

                                                                      The beta model for two alternatives and two outcomes multiplies the ratio v = v(1)/v(2) of the response strengths by β₁ⱼ when alternative 1 is chosen and outcome j occurs, and divides it by β₂ⱼ when alternative 2 is chosen, where outcome 1 follows the choice of i with probability πᵢ (p. 112).

                                                                      • β₁₁ : ℝ

                                                                        The multiplier of v after choice 1 and outcome 1.

                                                                      • β₁₂ : ℝ

                                                                        The multiplier of v after choice 1 and outcome 2.

                                                                      • β₂₁ : ℝ

                                                                        The divisor of v after choice 2 and outcome 1.

                                                                      • β₂₂ : ℝ

                                                                        The divisor of v after choice 2 and outcome 2.

                                                                      • π₁ : ℝ

                                                                        The probability of outcome 1 after choice 1.

                                                                      • π₂ : ℝ

                                                                        The probability of outcome 1 after choice 2.

                                                                      • β₁₁_pos : 0 < self.β₁₁
                                                                      • β₁₂_pos : 0 < self.β₁₂
                                                                      • β₂₁_pos : 0 < self.β₂₁
                                                                      • β₂₂_pos : 0 < self.β₂₂
                                                                      • π₁_nonneg : 0 ≤ self.π₁
                                                                      • π₁_le_one : self.π₁ ≤ 1
                                                                      • π₂_nonneg : 0 ≤ self.π₂
                                                                      • π₂_le_one : self.π₂ ≤ 1
                                                                      Instances For
                                                                        noncomputable def Luce1959.BetaLearner.kernel (m : BetaLearner) :
                                                                        ProbabilityTheory.Kernel ℝ ℝ

                                                                        The transition (7) moves the log ratio u = log v by log β₁₁, log β₁₂, −log β₂₁ or −log β₂₂ with probabilities Pπ₁, P(1 − π₁), (1 − P)π₂ and (1 − P)(1 − π₂), where P is the sigmoid of u (6).

                                                                        Equations
                                                                        • One or more equations did not get rendered due to their size.
                                                                        Instances For
                                                                          theorem Luce1959.BetaLearner.kernel_apply (m : BetaLearner) (u : ℝ) :
                                                                          m.kernel u = ENNReal.ofReal (u.sigmoid * m.π₁) • MeasureTheory.Measure.dirac (u + Real.log m.β₁₁) + ENNReal.ofReal (u.sigmoid * (1 - m.π₁)) • MeasureTheory.Measure.dirac (u + Real.log m.β₁₂) + ENNReal.ofReal ((1 - u.sigmoid) * m.π₂) • MeasureTheory.Measure.dirac (u - Real.log m.β₂₁) + ENNReal.ofReal ((1 - u.sigmoid) * (1 - m.π₂)) • MeasureTheory.Measure.dirac (u - Real.log m.β₂₂)

                                                                          Each row of the kernel is the four-point distribution of (7).

                                                                          theorem Luce1959.BetaLearner.integral_kernel (m : BetaLearner) (f : ℝ → ℝ) (u : ℝ) :
                                                                          ∫ (x : ℝ), f x ∂m.kernel u = u.sigmoid * m.π₁ * f (u + Real.log m.β₁₁) + u.sigmoid * (1 - m.π₁) * f (u + Real.log m.β₁₂) + (1 - u.sigmoid) * m.π₂ * f (u - Real.log m.β₂₁) + (1 - u.sigmoid) * (1 - m.π₂) * f (u - Real.log m.β₂₂)

                                                                          The conditional expectation given the log ratio u averages over the four events of (7).

                                                                          theorem Luce1959.BetaLearner.kernel_apply_univ (m : BetaLearner) (u : ℝ) :
                                                                          (m.kernel u) Set.univ = 1
                                                                          instance Luce1959.BetaLearner.instIsMarkovKernelRealKernel (m : BetaLearner) :
                                                                          ProbabilityTheory.IsMarkovKernel m.kernel
                                                                          noncomputable def Luce1959.BetaLearner.law (m : BetaLearner) (μ₀ : MeasureTheory.Measure ℝ) :
                                                                          ℕ → MeasureTheory.Measure ℝ

                                                                          m.law μ₀ n is the distribution of the log ratio on trial n from the initial distribution μ₀.

                                                                          Equations
                                                                          Instances For
                                                                            instance Luce1959.BetaLearner.isProbabilityMeasure_law (m : BetaLearner) (μ₀ : MeasureTheory.Measure ℝ) [MeasureTheory.IsProbabilityMeasure μ₀] (n : ℕ) :
                                                                            MeasureTheory.IsProbabilityMeasure (m.law μ₀ n)
                                                                            theorem Luce1959.BetaLearner.integral_law_succ (m : BetaLearner) (μ₀ : MeasureTheory.Measure ℝ) (n : ℕ) {f : ℝ → ℝ} (hf : Measurable f) (hi : ∀ (c : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => f (u + c)) (m.law μ₀ n)) :
                                                                            MeasureTheory.Integrable f (m.law μ₀ (n + 1)) ∧ ∫ (x : ℝ), f x ∂m.law μ₀ (n + 1) = ∫ (u : ℝ), ∫ (x : ℝ), f x ∂m.kernel u ∂m.law μ₀ n

                                                                            When the translates of f are integrable, the expectation of f on trial n + 1 is the expectation on trial n of its conditional expectation.

                                                                            theorem Luce1959.BetaLearner.integrable_exp_law (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) (n : ℕ) (t : ℝ) :
                                                                            MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) (m.law μ₀ n)

                                                                            Finite moments E(v₀ᵗ) of every real order persist on every trial.

                                                                            noncomputable def Luce1959.BetaLearner.A (m : BetaLearner) (k : ℝ) :
                                                                            ℝ

                                                                            The constant A(k) of (9) is π₁β₁₁ᵏ + (1 − π₁)β₁₂ᵏ.

                                                                            Equations
                                                                            Instances For
                                                                              noncomputable def Luce1959.BetaLearner.B (m : BetaLearner) (k : ℝ) :
                                                                              ℝ

                                                                              The constant B(k) of (9) is π₂/β₂₁ᵏ + (1 − π₂)/β₂₂ᵏ.

                                                                              Equations
                                                                              Instances For
                                                                                theorem Luce1959.BetaLearner.integral_exp_kernel (m : BetaLearner) (k u : ℝ) :
                                                                                ∫ (x : ℝ), Real.exp (k * x) ∂m.kernel u = (m.A k - m.B k) * u.sigmoid * Real.exp (k * u) + m.B k * Real.exp (k * u)

                                                                                Given vₙ, the expectation of vₙ₊₁ᵏ is (A(k) − B(k))Pₙvₙᵏ + B(k)vₙᵏ (8).

                                                                                theorem Luce1959.BetaLearner.sigmoid_mul_exp (u : ℝ) :
                                                                                u.sigmoid * Real.exp u = Real.exp u - u.sigmoid

                                                                                The choice probability satisfies Pₙvₙ = vₙ − Pₙ (11).

                                                                                m.swap is the model with the two alternatives exchanged, whose ratio of strengths is 1/v.

                                                                                Equations
                                                                                • One or more equations did not get rendered due to their size.
                                                                                Instances For
                                                                                  theorem Luce1959.BetaLearner.swap_A (m : BetaLearner) (k : ℝ) :
                                                                                  m.swap.A k = m.B (-k)

                                                                                  Exchanging the alternatives turns A(k) into B(−k).

                                                                                  theorem Luce1959.BetaLearner.swap_B (m : BetaLearner) (k : ℝ) :
                                                                                  m.swap.B k = m.A (-k)

                                                                                  Exchanging the alternatives turns B(k) into A(−k).

                                                                                  theorem Luce1959.BetaLearner.swap_kernel (m : BetaLearner) (u : ℝ) :
                                                                                  m.swap.kernel u = MeasureTheory.Measure.map Neg.neg (m.kernel (-u))

                                                                                  The transition of the exchanged model is the reflection of the original one.

                                                                                  theorem Luce1959.BetaLearner.law_swap (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (n : ℕ) :
                                                                                  m.swap.law (MeasureTheory.Measure.map Neg.neg μ₀) n = MeasureTheory.Measure.map Neg.neg (m.law μ₀ n)

                                                                                  The log ratio of the exchanged model is the negated log ratio.

                                                                                  noncomputable def Luce1959.BetaLearner.σ₁ (m : BetaLearner) :
                                                                                  ℝ

                                                                                  The exponent σ₁ of (14) solves β₁₁^σ₁ = 1/β₁₂, so it counts the occurrences of E₁₁ that undo one occurrence of E₁₂.

                                                                                  Equations
                                                                                  Instances For
                                                                                    noncomputable def Luce1959.BetaLearner.σ₂ (m : BetaLearner) :
                                                                                    ℝ

                                                                                    The exponent σ₂ of (14) solves β₂₁^σ₂ = 1/β₂₂.

                                                                                    Equations
                                                                                    Instances For
                                                                                      noncomputable def Luce1959.BetaLearner.drift (m : BetaLearner) :
                                                                                      ℝ

                                                                                      The drift coefficient of (16) multiplies E(Pₙ) − P* in the change of the expected log ratio.

                                                                                      Equations
                                                                                      Instances For
                                                                                        noncomputable def Luce1959.BetaLearner.Pstar (m : BetaLearner) :
                                                                                        ℝ

                                                                                        The probability P* of (15) is the limit of E(Pₙ) under the conditions of Theorem 17.

                                                                                        Equations
                                                                                        Instances For
                                                                                          theorem Luce1959.BetaLearner.integrable_sigmoid_law (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} [MeasureTheory.IsProbabilityMeasure μ₀] (n : ℕ) :
                                                                                          MeasureTheory.Integrable (fun (u : ℝ) => u.sigmoid) (m.law μ₀ n)
                                                                                          theorem Luce1959.BetaLearner.integral_law_swap (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (f : ℝ → ℝ) (n : ℕ) :
                                                                                          ∫ (x : ℝ), f x ∂m.swap.law (MeasureTheory.Measure.map Neg.neg μ₀) n = ∫ (u : ℝ), f (-u) ∂m.law μ₀ n

                                                                                          Expectations under the exchanged model are expectations of the reflected function.

                                                                                          theorem Luce1959.BetaLearner.integral_sigmoid_law_swap (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} [MeasureTheory.IsProbabilityMeasure μ₀] (n : ℕ) :
                                                                                          ∫ (x : ℝ), x.sigmoid ∂m.swap.law (MeasureTheory.Measure.map Neg.neg μ₀) n = 1 - ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n

                                                                                          The exchanged model chooses its first alternative with probability 1 − E(Pₙ).

                                                                                          theorem Luce1959.BetaLearner.integrable_sigmoid_mul_exp_law (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) (n : ℕ) (t : ℝ) :
                                                                                          MeasureTheory.Integrable (fun (u : ℝ) => u.sigmoid * Real.exp (t * u)) (m.law μ₀ n)
                                                                                          theorem Luce1959.BetaLearner.integral_exp_law_succ (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) (k : ℝ) (n : ℕ) :
                                                                                          ∫ (u : ℝ), Real.exp (k * u) ∂m.law μ₀ (n + 1) = (m.A k - m.B k) * ∫ (u : ℝ), u.sigmoid * Real.exp (k * u) ∂m.law μ₀ n + m.B k * ∫ (u : ℝ), Real.exp (k * u) ∂m.law μ₀ n

                                                                                          Taking expectations in (8) gives E(vₙ₊₁ᵏ) = (A(k) − B(k))E(Pₙvₙᵏ) + B(k)E(vₙᵏ) (10).

                                                                                          theorem Luce1959.BetaLearner.integrable_id_law (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) (n : ℕ) :
                                                                                          MeasureTheory.Integrable (fun (u : ℝ) => u) (m.law μ₀ n)
                                                                                          theorem Luce1959.BetaLearner.integral_law_succ_sub (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) [MeasureTheory.IsProbabilityMeasure μ₀] (h₁ : m.β₁₁ ≠ 1) (h₂ : m.β₂₁ ≠ 1) (hd : m.drift ≠ 0) (n : ℕ) :
                                                                                          ∫ (u : ℝ), u ∂m.law μ₀ (n + 1) - ∫ (u : ℝ), u ∂m.law μ₀ n = m.drift * (∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n - m.Pstar)

                                                                                          When β₁₁ ≠ 1, β₂₁ ≠ 1 and the coefficient of (16) is nonzero, the expected log ratio moves by that coefficient times E(Pₙ) − P* (16).

                                                                                          theorem Luce1959.BetaLearner.integral_sigmoid_mul_exp_succ (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) (t : ℝ) (n : ℕ) :
                                                                                          ∫ (u : ℝ), u.sigmoid * Real.exp ((t + 1) * u) ∂m.law μ₀ n = ∫ (u : ℝ), Real.exp ((t + 1) * u) ∂m.law μ₀ n - ∫ (u : ℝ), u.sigmoid * Real.exp (t * u) ∂m.law μ₀ n

                                                                                          Multiplying (11) by vₙᵗ and integrating gives E(Pₙvₙᵗ⁺¹) = E(vₙᵗ⁺¹) − E(Pₙvₙᵗ).

                                                                                          theorem Luce1959.BetaLearner.integral_exp_law_succ_one (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) (n : ℕ) :
                                                                                          ∫ (u : ℝ), Real.exp u ∂m.law μ₀ (n + 1) = m.A 1 * ∫ (u : ℝ), Real.exp u ∂m.law μ₀ n - (m.A 1 - m.B 1) * ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n

                                                                                          By (10) and (11) the first moment satisfies E(vₙ₊₁) = A(1)E(vₙ) − (A(1) − B(1))E(Pₙ).

                                                                                          theorem Luce1959.BetaLearner.theorem15 (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) [MeasureTheory.IsProbabilityMeasure μ₀] {k : ℕ} (hk : 1 ≤ k) {L : ℕ → ℝ} (hL : ∀ i ∈ Finset.Icc 1 k, Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp (↑i * u) ∂m.law μ₀ n) Filter.atTop (nhds (L i))) (hAB : ∀ i ∈ Finset.Icc 1 k, m.A ↑i ≠ m.B ↑i) (hA : ∀ i ∈ Finset.Icc 1 k, m.A ↑i ≠ 1) :
                                                                                          ∃ (p : ℝ), Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n) Filter.atTop (nhds p) ∧ L k = ((m.A ↑k - m.B ↑k) / (m.A ↑k - 1) * ∏ i ∈ Finset.Ico 1 k, (1 - m.B ↑i) / (m.A ↑i - 1)) * p

                                                                                          If E(vₙⁱ) converges to L i and A(i) ≠ B(i), A(i) ≠ 1 for i = 1, …, k, then E(Pₙ) converges to some p, and L k is (A(k) − B(k))/(A(k) − 1) times the product of (1 − B(i))/(A(i) − 1) over 1 ≤ i < k times p (Theorem 15 (i), p. 114).

                                                                                          theorem Luce1959.BetaLearner.theorem15_inv (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) [MeasureTheory.IsProbabilityMeasure μ₀] {k : ℕ} (hk : 1 ≤ k) {L : ℕ → ℝ} (hL : ∀ i ∈ Finset.Icc 1 k, Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp (-↑i * u) ∂m.law μ₀ n) Filter.atTop (nhds (L i))) (hBA : ∀ i ∈ Finset.Icc 1 k, m.B (-↑i) ≠ m.A (-↑i)) (hB : ∀ i ∈ Finset.Icc 1 k, m.B (-↑i) ≠ 1) :
                                                                                          ∃ (p : ℝ), Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n) Filter.atTop (nhds p) ∧ L k = ((m.A (-↑k) - m.B (-↑k)) / (1 - m.B (-↑k)) * ∏ i ∈ Finset.Ico 1 k, (m.A (-↑i) - 1) / (1 - m.B (-↑i))) * (1 - p)

                                                                                          The limits of the moments of 1/vₙ satisfy Theorem 15 (ii) with the factors (A(−i) − 1)/(1 − B(−i)), where the book prints (1 − A(−i))/(1 − B(−i)) (p. 114).

                                                                                          theorem Luce1959.BetaLearner.theorem15_corollary (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) [MeasureTheory.IsProbabilityMeasure μ₀] (h : (∃ (L : ℝ), Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp u ∂m.law μ₀ n) Filter.atTop (nhds L)) ∧ m.A 1 ≠ m.B 1 ∨ (∃ (L : ℝ), Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp (-u) ∂m.law μ₀ n) Filter.atTop (nhds L)) ∧ m.B (-1) ≠ m.A (-1)) :
                                                                                          ∃ (p : ℝ), Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n) Filter.atTop (nhds p)

                                                                                          If E(vₙ) converges and A(1) ≠ B(1), or E(1/vₙ) converges and B(−1) ≠ A(−1), then E(Pₙ) converges (the corollary to Theorem 15, p. 115).

                                                                                          theorem Luce1959.BetaLearner.theorem16 (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) [MeasureTheory.IsProbabilityMeasure μ₀] {L : ℝ} (hL : Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp u ∂m.law μ₀ n) Filter.atTop (nhds L)) :
                                                                                          (L = 0 → Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n) Filter.atTop (nhds 0) ∧ Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp (-u) ∂m.law μ₀ n) Filter.atTop Filter.atTop) ∧ (Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n) Filter.atTop (nhds 0) → m.A 1 ≠ 1 → L = 0)

                                                                                          Suppose E(vₙ) converges to L. If L = 0 then E(Pₙ) → 0 and E(1/vₙ) → ∞, and if E(Pₙ) → 0 and A(1) ≠ 1 then L = 0 (Theorem 16 (i), p. 115).

                                                                                          theorem Luce1959.BetaLearner.theorem16_inv (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) [MeasureTheory.IsProbabilityMeasure μ₀] {L : ℝ} (hL : Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp (-u) ∂m.law μ₀ n) Filter.atTop (nhds L)) :
                                                                                          (L = 0 → Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n) Filter.atTop (nhds 1) ∧ Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp u ∂m.law μ₀ n) Filter.atTop Filter.atTop) ∧ (Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n) Filter.atTop (nhds 1) → m.B (-1) ≠ 1 → L = 0)

                                                                                          Suppose E(1/vₙ) converges to L. If L = 0 then E(Pₙ) → 1 and E(vₙ) → ∞, and if E(Pₙ) → 1 and B(−1) ≠ 1 then L = 0 (Theorem 16 (ii), p. 116).

                                                                                          theorem Luce1959.BetaLearner.theorem17 (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) [MeasureTheory.IsProbabilityMeasure μ₀] (h₁ : m.β₁₁ ≠ 1) (h₂ : m.β₂₁ ≠ 1) (hd : m.drift ≠ 0) {p : ℝ} (hp : Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n) Filter.atTop (nhds p)) :
                                                                                          p = m.Pstar ∨ Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp u ∂m.law μ₀ n) Filter.atTop Filter.atTop ∨ Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp (-u) ∂m.law μ₀ n) Filter.atTop Filter.atTop

                                                                                          If E(Pₙ) converges to p and the coefficient of (16) is nonzero, then p = P*, or E(vₙ) → ∞, or E(1/vₙ) → ∞ (Theorem 17, p. 116).

                                                                                          theorem Luce1959.BetaLearner.theorem17_corollary (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) [MeasureTheory.IsProbabilityMeasure μ₀] (h₁ : m.β₁₁ ≠ 1) (h₂ : m.β₂₁ ≠ 1) (hd : m.drift ≠ 0) {L L' : ℝ} (hL : Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp u ∂m.law μ₀ n) Filter.atTop (nhds L)) (hL' : Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp (-u) ∂m.law μ₀ n) Filter.atTop (nhds L')) (hAB : m.A 1 ≠ m.B 1 ∨ m.B (-1) ≠ m.A (-1)) :
                                                                                          Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), u.sigmoid ∂m.law μ₀ n) Filter.atTop (nhds m.Pstar)

                                                                                          If E(vₙ) and E(1/vₙ) both converge, A(1) ≠ B(1) or B(−1) ≠ A(−1), and the coefficient of (16) is nonzero, then E(Pₙ) → P* (the corollary to Theorem 17, p. 117).

                                                                                          theorem Luce1959.BetaLearner.theorem18 (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) [MeasureTheory.IsProbabilityMeasure μ₀] :
                                                                                          (1 < m.A 1 → 1 < m.B 1 → Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp u ∂m.law μ₀ n) Filter.atTop Filter.atTop) ∧ (m.A 1 < 1 → m.B 1 < 1 → Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp u ∂m.law μ₀ n) Filter.atTop (nhds 0)) ∧ (Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp u ∂m.law μ₀ n) Filter.atTop Filter.atTop → 1 ≤ m.A 1)

                                                                                          If A(1), B(1) > 1 then E(vₙ) → ∞, if A(1), B(1) < 1 then E(vₙ) → 0, and if E(vₙ) → ∞ then A(1) ≥ 1 (Theorem 18 (i), p. 117).

                                                                                          theorem Luce1959.BetaLearner.theorem18_inv (m : BetaLearner) {μ₀ : MeasureTheory.Measure ℝ} (hμ₀ : ∀ (t : ℝ), MeasureTheory.Integrable (fun (u : ℝ) => Real.exp (t * u)) μ₀) [MeasureTheory.IsProbabilityMeasure μ₀] :
                                                                                          (1 < m.A (-1) → 1 < m.B (-1) → Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp (-u) ∂m.law μ₀ n) Filter.atTop Filter.atTop) ∧ (m.A (-1) < 1 → m.B (-1) < 1 → Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp (-u) ∂m.law μ₀ n) Filter.atTop (nhds 0)) ∧ (Filter.Tendsto (fun (n : ℕ) => ∫ (u : ℝ), Real.exp (-u) ∂m.law μ₀ n) Filter.atTop Filter.atTop → 1 ≤ m.B (-1))

                                                                                          If A(−1), B(−1) > 1 then E(1/vₙ) → ∞, if A(−1), B(−1) < 1 then E(1/vₙ) → 0, and if E(1/vₙ) → ∞ then B(−1) ≥ 1 (Theorem 18 (ii), p. 117).

                                                                                          theorem Luce1959.lemma12 {x y : ℝ} (hx : 1 < x) (hy : 1 < y) :
                                                                                          Real.log x / (x - 1) < y / (y - 1) * Real.log y

                                                                                          For x, y > 1, log x/(x − 1) < y log y/(y − 1) (Lemma 12, p. 119).

                                                                                          theorem Luce1959.theorem19 {x y : ℝ} (hx : 1 < x) (hy₀ : 0 < y) (hy : y < 1) :
                                                                                          (1 - y) / (x - y) < -Real.log y / Real.log x / (-Real.log y / Real.log x + 1) ∧ -Real.log y / Real.log x / (-Real.log y / Real.log x + 1) < x * (1 - y) / (x - y)

                                                                                          For x = βᵢ₁ > 1 and y = βᵢ₂ ∈ (0, 1), the ratio σᵢ/(σᵢ + 1) with σᵢ = −log y/log x from (14) lies strictly between (1 − y)/(x − y) and x(1 − y)/(x − y) (Theorem 19, p. 119).