Documentation

LeanPool.AharoniKorman.Counterexample

Disproof of the Aharoni–Korman conjecture #

The Aharoni–Korman conjecture (sometimes called the fishbone conjecture) says that every partial order satisfies at least one of the following:

In November 2024, Hollom disproved this conjecture. In this file, we construct Hollom's counterexample P_5 and show it satisfies neither of the above, and thus disprove the conjecture. See https://arxiv.org/abs/2411.16844 for further details.

We show a number of key properties of P_5:

  1. It is a partial order
  2. It is countable
  3. It has no infinite antichains
  4. It is scattered (it does not contain a suborder which is order-isomorphic to ℚ)
  5. It does not contain a chain C and a partition into antichains such that every part meets C

Points 1, 3, 5 are sufficient to disprove the conjecture, but we include points 2 and 4 nonetheless as they represent other important properties of the partial order.

The final point is the most involved, so we sketch its proof here.

The proof structure is as follows:

From this point forward, we assume C is a chain and that we have a spinal map to C, with the aim of reaching a contradiction (as then, no such partition can exist). We may further assume that n ≠ 0 and C ∩ level n is finite.

A type synonym on ℕ³ on which we will construct Hollom's partial order P_5.

Equations
Instances For

    The backward equivalence between ℕ³ and the underlying set in Hollom's partial order. Note that this equivalence does not respect the partial order relation, and therefore should be used explicitly to transfer between the two types, despite their being equal.

    Equations
    Instances For

      The forward equivalence between ℕ³ and the underlying set in Hollom's partial order. Note that this equivalence does not respect the partial order relation, and therefore should be used explicitly to transfer between the two types, despite their being equal.

      Equations
      Instances For
        @[simp]
        theorem LeanPool.AharoniKorman.Hollom.forall {p : HollomProp} :
        (∀ (x : Hollom), p x) ∀ (x : × × ), p (toHollom x)
        @[simp]
        theorem LeanPool.AharoniKorman.Hollom.exists {p : HollomProp} :
        (∃ (x : Hollom), p x) ∃ (x : × × ), p (toHollom x)
        theorem LeanPool.AharoniKorman.Hollom.induction {p : HollomProp} (h : ∀ (x y z : ), p (toHollom (x, y, z))) (x : Hollom) :
        p x

        The Hollom partial order is countable. This is very easy to see, since it is just ℕ³ with a different order.

        The ordering on ℕ³ which is used to define Hollom's example P₅

        Instances For
          theorem LeanPool.AharoniKorman.Hollom.hollomOrder_iff (a✝ a✝¹ : × × ) :
          HollomOrder a✝ a✝¹ (∃ (x : ) (y : ) (n : ) (u : ) (v : ) (m : ), m + 2 n a✝ = (x, y, n) a✝¹ = (u, v, m)) (∃ (x : ) (y : ) (u : ) (v : ) (m : ), x u y v a✝ = (x, y, m) a✝¹ = (u, v, m)) (∃ (x : ) (y : ) (u : ) (v : ) (m : ), min x y + 1 min u v a✝ = (x, y, m + 1) a✝¹ = (u, v, m)) ∃ (x : ) (y : ) (u : ) (v : ) (m : ), x + y 2 * (u + v) a✝ = (x, y, m + 1) a✝¹ = (u, v, m)
          @[implicit_reducible]
          Equations
          • One or more equations did not get rendered due to their size.
          theorem LeanPool.AharoniKorman.Hollom.toHollom_le_toHollom {a b c d e f : } (h : (a, b) (d, e)) (hcf : f c) :

          The Hollom partial order is divided into "levels", indexed by the natural numbers. These correspond to the third coordinate of the tuple. This is written L_n in the paper.

          Equations
          Instances For
            theorem LeanPool.AharoniKorman.Hollom.induction_on_level {n : } {p : (x : Hollom) → x level nProp} (h : ∀ (x y : ), p (toHollom (x, y, n)) ) {x : Hollom} (h✝ : x level n) :
            p x h✝

            For each n, there is an order embedding from ℕ × ℕ (which has the product order) to the Hollom partial order.

            Equations
            Instances For
              theorem LeanPool.AharoniKorman.Hollom.no_infinite_antichain_level {n : } {A : Set Hollom} (hA : A level n) (hA' : IsAntichain (fun (x1 x2 : Hollom) => x1 x2) A) :

              If A is a subset of level n and is an antichain, then A is finite. This is a special case of the fact that any antichain in the Hollom order is finite, but is a useful lemma to prove that fact later: no_infinite_antichain.

              Each level is order-connected, i.e. for any xlevel n and ylevel n we have [x, y] ⊆ level n. This corresponds to 5.8 (i) in the paper.

              theorem LeanPool.AharoniKorman.Hollom.line_injOn {C : Set Hollom} (n : ) (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) (hCn : C level n) :
              theorem LeanPool.AharoniKorman.Hollom.add_lt_add_of_lt {a b c d n : } (h : toHollom (a, b, n) < toHollom (c, d, n)) :
              a + b < c + d

              The Hollom partial order is scattered: it does not contain a suborder which is order-isomorphic to . We state this as saying there is no strictly monotone function from to Hollom.

              Any antichain in the Hollom partial order is finite. This corresponds to Lemma 5.9 in the paper.

              Show that every chain in the Hollom partial order has a finite intersection with infinitely many levels. This corresponds to Lemma 5.10 from the paper.

              In this section we define spinal maps, and prove important properties about them.

              structure LeanPool.AharoniKorman.Hollom.SpinalMap {α : Type u_1} [PartialOrder α] (C : Set α) :
              Type u_1

              A spinal map is a function f : α → C which is the identity on C, and for which each fiber is an antichain. Provided C is a chain, the existence of a spinal map is equivalent to the fact that C is a spine.

              • toFun : αα

                The underlying function of a spinal map.

              • mem' (x : α) : self.toFun x C
              • eq_self_of_mem' (x : α) : x Cself.toFun x = x
              • fibre_antichain' (x : α) : IsAntichain (fun (x1 x2 : α) => x1 x2) (self.toFun ⁻¹' {x})
              Instances For

                Basic lemmas for spinal maps #

                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.ext {α : Type u_1} [PartialOrder α] {C : Set α} {f g : SpinalMap C} (h : ∀ (x : α), f x = g x) :
                f = g
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.ext_iff {α : Type u_1} [PartialOrder α] {C : Set α} {f g : SpinalMap C} :
                f = g ∀ (x : α), f x = g x
                @[simp]
                @[simp]
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.mem {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) (x : α) :
                f x C
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.eq_self_of_mem {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x : α} (hx : x C) :
                f x = x
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.fibre_antichain {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) (x : α) :
                IsAntichain (fun (x1 x2 : α) => x1 x2) (f ⁻¹' {x})
                @[simp]
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.idempotent {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) (x : α) :
                f (f x) = f x
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.not_le_of_eq {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x y : α} (hfxy : f x = f y) (hxy : x y) :
                ¬x y
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.eq_of_le {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x y : α} (hfxy : f x = f y) (hxy : x y) :
                x = y
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.not_lt_of_eq {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x y : α} (hfxy : f x = f y) :
                ¬x < y
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.incomp_of_eq {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x y : α} (hfxy : f x = f y) (hxy : x y) :
                ¬(x y y x)
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.incomp_apply {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x : α} (hx : f x x) :
                ¬(f x x x f x)
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.not_apply_lt {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x : α} :
                ¬f x < x
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.not_lt_apply {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x : α} :
                ¬x < f x
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.le_apply_of_le {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x y : α} (hC : IsChain (fun (x1 x2 : α) => x1 x2) C) (hy : y C) (hx : y x) :
                y f x
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.apply_le_of_le {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x y : α} (hC : IsChain (fun (x1 x2 : α) => x1 x2) C) (hy : y C) (hx : x y) :
                f x y
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.lt_apply_of_lt {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x y : α} (hC : IsChain (fun (x1 x2 : α) => x1 x2) C) (hy : y C) (hx : y < x) :
                y < f x
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.apply_lt_of_lt {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x y : α} (hC : IsChain (fun (x1 x2 : α) => x1 x2) C) (hy : y C) (hx : x < y) :
                f x < y
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.apply_mem_Icc_of_mem_Icc {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {x y z : α} (hC : IsChain (fun (x1 x2 : α) => x1 x2) C) (hy : y C) (hz : z C) (hx : x Set.Icc y z) :
                f x Set.Icc y z
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.mapsTo_Icc_self {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {y z : α} (hC : IsChain (fun (x1 x2 : α) => x1 x2) C) (hy : y C) (hz : z C) :
                Set.MapsTo (⇑f) (Set.Icc y z) (Set.Icc y z)
                theorem LeanPool.AharoniKorman.Hollom.SpinalMap.injOn_of_isChain {α : Type u_1} [PartialOrder α] {C : Set α} (f : SpinalMap C) {D : Set α} (hD : IsChain (fun (x1 x2 : α) => x1 x2) D) :
                Set.InjOn (⇑f) D
                theorem LeanPool.AharoniKorman.Hollom.exists_partition_iff_nonempty_spinalMap {α : Type u_2} [PartialOrder α] {C : Set α} (hC : IsChain (fun (x1 x2 : α) => x1 x2) C) :
                (∃ (S : Set (Set α)), Setoid.IsPartition S AS, IsAntichain (fun (x1 x2 : α) => x1 x2) A (A C).Nonempty) Nonempty (SpinalMap C)

                Given a chain C in a partial order α, the existence of the following are equivalent:

                • a partition of α into antichains, each which meets C
                • a function f : α → C which is the identity on C and for which each fiber is an antichain

                In fact, these two are in bijection, but we only need the weaker version that their existence is equivalent.

                Explicit chains #

                In this section we construct an explicit chain in ℕ × ℕ that will be useful later. These comprise part of 5.8(iv) from the paper: the full strength of that observation is not actually needed.

                An explicit contiguous chain between (a, b) and (c, d) in ℕ × ℕ. We implement this as the union of two disjoint sets: the first is the chain from (a, b) to (a, d), and the second is the chain from (a, d) to (c, d).

                Equations
                Instances For
                  theorem LeanPool.AharoniKorman.Hollom.chainBetween_isChain {a b c d : } :
                  IsChain (fun (x1 x2 : × ) => x1 x2) (chainBetween a b c d)
                  theorem LeanPool.AharoniKorman.Hollom.image_chainBetween_isChain {a b c d n : } :
                  IsChain (fun (x1 x2 : Hollom) => x1 x2) (Finset.image (⇑(embed n)) (chainBetween a b c d))
                  theorem LeanPool.AharoniKorman.Hollom.card_chainBetween {a b c d : } (hac : a c) (hbd : b d) :
                  (chainBetween a b c d).card = c + d + 1 - (a + b)
                  theorem LeanPool.AharoniKorman.Hollom.mapsTo_Icc_image {C : Set Hollom} {f : SpinalMap C} (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) {a b c d n : } (hab : toHollom (a, b, n) C) (hcd : toHollom (c, d, n) C) :
                  Set.MapsTo f (Finset.image (⇑(embed n)) (Finset.Icc (a, b) (c, d))) (Finset.image (⇑(embed n)) (Finset.Icc (a, b) (c, d)))
                  theorem LeanPool.AharoniKorman.Hollom.C_inter_Icc_large {C : Set Hollom} [DecidablePred fun (x : Hollom) => x C] (f : SpinalMap C) {n xl yl xh yh : } (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) (hx : xl xh) (hy : yl yh) (hlo : toHollom (xl, yl, n) C) (hhi : toHollom (xh, yh, n) C) :
                  xh + yh + 1 - (xl + yl) {xFinset.image (⇑(embed n)) (Finset.Icc (xl, yl) (xh, yh)) | x C}.card

                  The collection of points between (xl, yl, n) and (xh, yh, n) that are also in C has at least xh + yh + 1 - (xl + yl) elements. In other words, this collection must be a maximal chain relative to the interval it is contained in. Note card_C_inter_Icc_eq strengthens this to an equality.

                  theorem LeanPool.AharoniKorman.Hollom.card_C_inter_Icc_eq {C : Set Hollom} [DecidablePred fun (x : Hollom) => x C] (f : SpinalMap C) {n xl yl xh yh : } (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) (hx : xl xh) (hy : yl yh) (hlo : toHollom (xl, yl, n) C) (hhi : toHollom (xh, yh, n) C) :
                  {xFinset.image (⇑(embed n)) (Finset.Icc (xl, yl) (xh, yh)) | x C}.card = xh + yh + 1 - (xl + yl)

                  The collection of points between (xl, yl, n) and (xh, yh, n) that are also in C has exactly xh + yh + 1 - (xl + yl) elements. In other words, this collection must be a maximal chain relative to the interval it is contained in. Alternatively speaking, it has the same size as any maximal chain in that interval.

                  theorem LeanPool.AharoniKorman.Hollom.apply_eq_of_line_eq_step {C : Set Hollom} (f : SpinalMap C) {n xl yl xh yh : } (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) (hlo : toHollom (xl, yl, n) C) (hhi : toHollom (xh, yh, n) C) (hx : xl xh) (hy : yl yh) {x y : } (h₁l : toHollom (xl, yl, n) toHollom (x + 1, y, n)) (h₂l : toHollom (xl, yl, n) toHollom (x, y + 1, n)) (h₁h : toHollom (x + 1, y, n) toHollom (xh, yh, n)) (h₂h : toHollom (x, y + 1, n) toHollom (xh, yh, n)) :
                  f (toHollom (x + 1, y, n)) = f (toHollom (x, y + 1, n))

                  The important helper lemma to prove apply_eq_of_line_eq. That lemma says that given (xl, yl, n) and (xh, yh, n) in a chain C, and two points (a, b, n) and (c, d, n) between them, if a + b = c + d then a spinal map f : SpinalMap C sends them to the same place. Here we show the special case where the two points are (x + 1, y, n) and (x, y + 1, n), i.e. they are beside each other.

                  theorem LeanPool.AharoniKorman.Hollom.apply_eq_of_line_eq_aux {C : Set Hollom} (f : SpinalMap C) {n xl yl xh yh : } (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) (hlo : toHollom (xl, yl, n) C) (hhi : toHollom (xh, yh, n) C) (hx : xl xh) (hy : yl yh) {x y k : } (h₁l : toHollom (xl, yl, n) toHollom (x + k, y, n)) (h₂l : toHollom (xl, yl, n) toHollom (x, y + k, n)) (h₁h : toHollom (x + k, y, n) toHollom (xh, yh, n)) (h₂h : toHollom (x, y + k, n) toHollom (xh, yh, n)) :
                  f (toHollom (x + k, y, n)) = f (toHollom (x, y + k, n))

                  A simple helper lemma to prove apply_eq_of_line_eq. Here we show the special case where the two points are (x + k, y, n) and (x, y + k, n) by induction on k with apply_eq_of_line_eq_step.

                  theorem LeanPool.AharoniKorman.Hollom.apply_eq_of_line_eq {C : Set Hollom} (f : SpinalMap C) {n : } (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) {lo hi : Hollom} (hlo : lo C level n) (hhi : hi C level n) (hlohi : lo hi) {x y : Hollom} (h : line x = line y) (h₁l : lo x) (h₂l : lo y) (h₁h : x hi) (h₂h : y hi) :
                  f x = f y

                  For two points of C in the same level, and two points (a, b, n) and (c, d, n) between them, if a + b = c + d then f (a, b, n) = f (c, d, n).

                  Construction of the set R, which has the following key properties:

                  • It is a subset of level n.
                  • Each of its elements is comparable to all of C ∩ level n.
                  • There exists an a such that {(x, y, n) | x ≥ a ∧ y ≥ a} ⊆ R.
                  Equations
                  Instances For
                    theorem LeanPool.AharoniKorman.Hollom.square_subset_above {C : Set Hollom} {n : } (h : (C level n).Finite) :
                    ∀ᶠ (a : ) in Filter.atTop, (embed n) '' Set.Ici (a, a) {x : Hollom | yC level n, y x} \ (C level n)

                    A helper lemma to show square_subset_R. In particular shows that if C ∩ level n is finite, the set of points x such that x is at least as large as every element of C ∩ level n contains an "infinite square", i.e. a set of the form {(x, y, n) | x ≥ a ∧ y ≥ a}. The precise statement here is stronger in two ways:

                    • Instead of showing that some a works, we instead show that any sufficiently large a work. This is not much of a strengthening, but is convenient to have for chaining "sufficiently large" choices later.
                    • We also exclude C ∩ level n itself on the right.
                    theorem LeanPool.AharoniKorman.Hollom.not_R_hits_same {C : Set Hollom} {f : SpinalMap C} {n : } {x : Hollom} (hx : x R n C) (hx' : xC level n) :
                    f xC level n
                    noncomputable def LeanPool.AharoniKorman.Hollom.x0y0 (n : ) (C : Set Hollom) :

                    Given a subset C of the Hollom partial order, and an index n, find the smallest element of C ∩ level (n + 1), expressed as (x₀, y₀, n + 1). This is only the global minimum provided C is a chain, which it is in context.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      theorem LeanPool.AharoniKorman.Hollom.x0y0_mem {C : Set Hollom} {n : } (h : (C level (n + 1)).Nonempty) :
                      (embed (n + 1)) (x0y0 n C) C
                      theorem LeanPool.AharoniKorman.Hollom.x0y0_min {C : Set Hollom} {n : } (z : × ) (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) (h : (embed (n + 1)) z C) :
                      (embed (n + 1)) (x0y0 n C) (embed (n + 1)) z
                      noncomputable def LeanPool.AharoniKorman.Hollom.x0 (n : ) (C : Set Hollom) :

                      Given a subset C of the Hollom partial order, and an index n, find the smallest element of C ∩ level (n + 1), and x0 n C will be the x-coordinate thereof.

                      Equations
                      Instances For
                        noncomputable def LeanPool.AharoniKorman.Hollom.y0 (n : ) (C : Set Hollom) :

                        Given a subset C of the Hollom partial order, and an index n, find the smallest element of C ∩ level (n + 1), and y0 n C will be the y-coordinate thereof.

                        Equations
                        Instances For
                          theorem LeanPool.AharoniKorman.Hollom.x0_y0_mem {C : Set Hollom} {n : } (h : (C level (n + 1)).Nonempty) :
                          toHollom (x0 n C, y0 n C, n + 1) C
                          theorem LeanPool.AharoniKorman.Hollom.x0_y0_min {C : Set Hollom} {n : } (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) {a b : } (h : toHollom (a, b, n + 1) C) :
                          toHollom (x0 n C, y0 n C, n + 1) toHollom (a, b, n + 1)
                          noncomputable def LeanPool.AharoniKorman.Hollom.S (n : ) (C : Set Hollom) :

                          Construction of the set S, which has the following key properties:

                          • It is a subset of R.
                          • No element of it can be mapped to an element of C ∩ level (n + 1) by f.
                          • There exists an a such that {(x, y, n) | x ≥ a ∧ y ≥ a} ⊆ S.

                          If C ∩ level (n + 1) is finite, it is all elements of R which are comparable to C ∩ level (n + 1). Otherwise, say (x0, y0, n + 1) is the smallest element of C ∩ level (n + 1), and take all elements of R of the form (a, b, n) with max x0 y0 + 1 ≤ min a b.

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            theorem LeanPool.AharoniKorman.Hollom.square_subset_S_case_1 {C : Set Hollom} {n : } (h : (C level n).Finite) (h' : (C level (n + 1)).Finite) :
                            ∀ᶠ (a : ) in Filter.atTop, (embed n) '' Set.Ici (a, a) S n C \ (C level n)

                            Assuming C ∩ level n is finite, and C ∩ level (n + 1) is finite, that there exists cofinitely many a such that {(x, y, n) | x ≥ a ∧ y ≥ a} ⊆ S \ (C ∩ level n). We will later show the same assuming C ∩ level (n + 1) is infinite.

                            Assuming C ∩ level n is finite, and C ∩ level (n + 1) is infinite, that there exists cofinitely many a such that {(x, y, n) | x ≥ a ∧ y ≥ a} ⊆ S \ (C ∩ level n). We earlier showed the same assuming C ∩ level (n + 1) is finite.

                            theorem LeanPool.AharoniKorman.Hollom.left_or_right_bias {C : Set Hollom} {n : } (a b : ) (hab : ∀ (x y : ), toHollom (x, y, n) CtoHollom (a, b, n) toHollom (x, y, n)) (hCn : (C level n).Infinite) :
                            (∀ (i : ), jC level n, toHollom (a, i, n) j) ∀ (i : ), jC level n, toHollom (i, b, n) j

                            Given (a, b, n) which is a lower bound on C ∩ level n, and assuming C ∩ level n is infinite, we either have:

                            • for any i, there is an element of C ∩ level n greater than (a, i, n)
                            • for any i, there is an element of C ∩ level n greater than (i, b, n)
                            theorem LeanPool.AharoniKorman.Hollom.not_S_hits_next {C : Set Hollom} {n : } (f : SpinalMap C) (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) {x : Hollom} (hx : x S n C) (hx' : xC level n) :
                            f xC level (n + 1)

                            Given a point x in S which is not in C ∩ level n, its image under f cannot be in C ∩ level (n + 1).

                            theorem LeanPool.AharoniKorman.Hollom.S_mapsTo_previous {C : Set Hollom} {n : } (f : SpinalMap C) (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) (hn : n 0) (x : Hollom) :
                            x S n C \ (C level n) → f x C level (n - 1)

                            Every element of S \ (C ∩ level n) must be mapped into C ∩ level (n - 1).

                            theorem LeanPool.AharoniKorman.Hollom.not_S_mapsTo_previous {C : Set Hollom} {f : SpinalMap C} {n : } (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) (hCn : (C level n).Finite) (hn : n 0) (h : xS n C \ (C level n), f x C level (n - 1)) :

                            Supposing that all of S \ (C ∩ level n) is sent to C ∩ level (n - 1), we deduce a contradiction.

                            theorem LeanPool.AharoniKorman.Hollom.no_spinalMap {C : Set Hollom} (hC : IsChain (fun (x1 x2 : Hollom) => x1 x2) C) (f : SpinalMap C) :

                            The Hollom partial order has no spinal maps.

                            theorem LeanPool.AharoniKorman.aharoni_korman_false :
                            ¬∀ (α : Type) (x : PartialOrder α), (∃ (A : Set α), IsAntichain (fun (x1 x2 : α) => x1 x2) A A.Infinite) ∃ (C : Set α), IsChain (fun (x1 x2 : α) => x1 x2) C ∃ (S : Set (Set α)), Setoid.IsPartition S AS, IsAntichain (fun (x1 x2 : α) => x1 x2) A (A C).Nonempty

                            The Aharoni–Korman conjecture (sometimes called the fishbone conjecture) says that every partial order satisfies one of the following:

                            • It contains an infinite antichain
                            • It contains a chain C, and has a partition into antichains such that every part meets C.

                            In November 2024, Hollom disproved this conjecture.

                            This statement says that it is not the case that every partially ordered set satisfies one of the above conditions.