Documentation

ThreeMajority.Model

The 3-majority opinion-dynamics process on the complete graph #

A round configuration: every agent draws an ordered triple of samples, independently and uniformly, with replacement.

Equations
Instances For
    @[implicit_reducible]
    Equations
    theorem ThreeMajority.tgt3_nonempty {n : ℕ} (hn : 1 ≤ n) :
    def ThreeMajority.sampleCountOf {n : ℕ} (I : Finset (Fin n)) (s : Fin n × Fin n × Fin n) :

    The number (0, 1, 2, or 3) of a sample triple s that currently lie in I.

    Equations
    Instances For
      def ThreeMajority.sampleCount {n : ℕ} (I : Finset (Fin n)) (r : Tgt3 n) (v : Fin n) :

      The number (0, 1, 2, or 3) of agent v's three samples, under round r, that currently lie in I.

      Equations
      Instances For
        def ThreeMajority.step {n : ℕ} (I : Finset (Fin n)) (r : Tgt3 n) :

        One round of the 3-majority process: every agent adopts the majority opinion among its three samples.

        Equations
        Instances For
          theorem ThreeMajority.mem_step {n : ℕ} {I : Finset (Fin n)} {r : Tgt3 n} {v : Fin n} :
          v ∈ step I r ↔ 2 ≤ sampleCount I r v
          theorem ThreeMajority.sampleCount_mono {n : ℕ} {I I' : Finset (Fin n)} (h : I ⊆ I') (r : Tgt3 n) (v : Fin n) :
          theorem ThreeMajority.step_mono {n : ℕ} {I I' : Finset (Fin n)} (h : I ⊆ I') (r : Tgt3 n) :
          step I r ⊆ step I' r

          Monotone coupling: for a fixed round r, step is monotone in the current opinion-1 set. This is purely combinatorial (no probability involved).

          def ThreeMajority.run {n : ℕ} (I : Finset (Fin n)) :
          List (Tgt3 n) → Finset (Fin n)

          The opinion-1 set after consuming a list of rounds.

          Equations
          Instances For
            @[simp]
            theorem ThreeMajority.run_nil {n : ℕ} (I : Finset (Fin n)) :
            run I [] = I
            @[simp]
            theorem ThreeMajority.run_cons {n : ℕ} (I : Finset (Fin n)) (r : Tgt3 n) (l : List (Tgt3 n)) :
            run I (r :: l) = run (step I r) l
            theorem ThreeMajority.run_append {n : ℕ} (I : Finset (Fin n)) (l₁ l₂ : List (Tgt3 n)) :
            run I (l₁ ++ l₂) = run (run I l₁) l₂
            theorem ThreeMajority.run_mono {n : ℕ} {I I' : Finset (Fin n)} (h : I ⊆ I') (l : List (Tgt3 n)) :
            run I l ⊆ run I' l

            Monotone coupling, iterated over a whole trajectory.