AFTD Auto-Formalizing Theoretical Domains

poset_braid_iso_of_order_iso

theoremverified

If two partially ordered sets P and Q with decidable orders are order isomorphic, then their associated poset braid solutions poset_braid_map are isomorphic.

Statement

theorem poset_braid_iso_of_order_iso {P Q : Type*} [PartialOrder P] [PartialOrder Q]
    [DecidableRel ((· ≤ ·) : P → P → Prop)] [DecidableRel ((· ≤ ·) : Q → Q → Prop)]
    (e : P ≃o Q) :
    is_braid_iso (@poset_braid_map P _ _) (@poset_braid_map Q _ _)
Source
scout/2611-15540-solutions-of-the-set-theoretic-quantum-yang-baxter-equation.md:504
Verified
14 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 2
  • is_braid_isoTwo maps R : X × X → X × X and S : Y × Y → Y × Y are isomorphic if there exists an equivalence e : X ≃ Y such that (e × e) ∘ R = S ∘ (e ×…
  • poset_braid_mapFor a partially ordered set P with decidable order, the bipartite map poset_braid_map on (P ⊕ (P × ZMod 2)) × (P ⊕ (P × ZMod 2)) fixes…

Read back from the Lean

For any types $P$ and $Q$ equipped with partial orders and decidable order relations $(\le)$, if $e : P \simeq_o Q$ is an order isomorphism, then the braid map poset_braid_map on $P \oplus (P \times \mathbb{Z}/2\mathbb{Z})$ is isomorphic (in the sense of is_braid_iso) to the braid map poset_braid_map on $Q \oplus (Q \times \mathbb{Z}/2\mathbb{Z})$.

Written by a model that saw only the Lean, never the English above. If the two disagree, that is worth a challenge.

The proof, explained

To show that the braid solutions associated with two order-isomorphic posets P and Q are isomorphic, we define a bijection between their state spaces P ⊕ (P × ℤ/2ℤ) and Q ⊕ (Q × ℤ/2ℤ) combining the order isomorphism e : P ≃o Q on P and e × id on P × ℤ/2ℤ. By functional extensionality, it suffices to verify that this bijection commutes with the braid map on every pair of inputs. Case analysis on the summands reduces the diagonal cases to reflexivity, while in the off-diagonal cases, the condition e(y') ≤ e(x) simplifies to y' ≤ x because e preserves the order, making the two sides equal.

  1. The map Φ = e ⊕ (e × id) : P ⊕ (P × ℤ/2ℤ) ≃ Q ⊕ (Q × ℤ/2ℤ) is our candidate isomorphism between the braid solutions.

    An isomorphism between braid solutions requires a bijection between their state spaces that intertwines the respective braid maps. We provide the bijection induced by the given order isomorphism e : P ≃o Q, acting as e on the P summand and as (e, id) on the P × ℤ/2ℤ summand.

    line 6

    uses Equiv.sumCongr, Equiv.prodCongr, Equiv.refl

      use Equiv.sumCongr e.toEquiv (Equiv.prodCongr e.toEquiv (Equiv.refl (ZMod 2)))
  2. It suffices to show that the intertwining identity holds pointwise on every pair (a, b).

    By functional extensionality (funext), equality of the two composite maps on (P ⊕ (P × ℤ/2ℤ))² reduces to showing they yield the same output on an arbitrary pair (a, b).

    line 7

      funext ⟨a, b⟩
  3. The intertwining identity holds for all four combinations of summands for (a, b).

    We split both a and b into cases depending on whether each lies in P (Sum.inl) or P × ℤ/2ℤ (Sum.inr). In the diagonal cases—where both inputs belong to P or both belong to P × ℤ/2ℤ—the braid map acts as the identity, so both sides are definitionally equal and closed by reflexivity (rfl). In the two cross cases—where one input is in P and the other in P × ℤ/2ℤ—the braid map swaps the inputs and adjusts the ℤ/2ℤ-phase according to the poset order. Simplification unfolds the definitions and replaces the inequality e(y') ≤ e(x) in Q with y' ≤ x in P using OrderIso.le_iff_le, making both sides identical.

    lines 8–14

    uses Function.comp_apply, Prod.map_apply, poset_braid_map, Equiv.sumCongr_apply, Sum.map_inl, Sum.map_inr, Equiv.prodCongr_apply, Equiv.refl_apply, OrderIso.coe_toEquiv, OrderIso.le_iff_le

      rcases a with x | ⟨y, ε⟩ <;> rcases b with x' | ⟨y', ε'⟩ <;>
        first
        | rfl
        | simp only [Function.comp_apply, Prod.map_apply, poset_braid_map,
            Equiv.sumCongr_apply, Sum.map_inl, Sum.map_inr,
            Equiv.prodCongr_apply, Equiv.refl_apply,
            OrderIso.coe_toEquiv, OrderIso.le_iff_le]
Equiv.sumCongr
Given equivalences α₁ ≃ α₂ and β₁ ≃ β₂, constructs the sum equivalence α₁ ⊕ β₁ ≃ α₂ ⊕ β₂.
Equiv.prodCongr
Given equivalences α₁ ≃ α₂ and β₁ ≃ β₂, constructs the product equivalence α₁ × β₁ ≃ α₂ × β₂.
Equiv.refl
The identity equivalence from any type α to itself.
Function.comp_apply
Function composition applied to an argument: (f ∘ g) x = f (g x).
Prod.map_apply
A product map applied to a pair: Prod.map f g (x, y) = (f x, g y).
poset_braid_map
The braid map associated with a partially ordered set P, acting on (P ⊕ (P × ℤ/2ℤ))².
Equiv.sumCongr_apply
Applying a sum equivalence (ea.sumCongr eb) to an element equals Sum.map ea eb applied to that element.
Sum.map_inl
Sum.map applied to a left injection: Sum.map f g (Sum.inl x) = Sum.inl (f x).
Sum.map_inr
Sum.map applied to a right injection: Sum.map f g (Sum.inr x) = Sum.inr (g x).
Equiv.prodCongr_apply
Applying a product equivalence (e₁.prodCongr e₂) equals Prod.map e₁ e₂.
Equiv.refl_apply
The identity equivalence maps any element to itself: (Equiv.refl α) x = x.
OrderIso.coe_toEquiv
The underlying equivalence of an order isomorphism e coerces to the same function as e.
OrderIso.le_iff_le
An order isomorphism preserves and reflects the partial order: e x ≤ e y ↔ x ≤ y.

Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.

Lean source view module on GitHub

/-- An order isomorphism between posets induces an isomorphism between their braid solutions. -/theorem poset_braid_iso_of_order_iso {P Q : Type*} [PartialOrder P] [PartialOrder Q]    [DecidableRel ((· ≤ ·) : P → P → Prop)] [DecidableRel ((· ≤ ·) : Q → Q → Prop)]    (e : P ≃o Q) :    is_braid_iso (@poset_braid_map P _ _) (@poset_braid_map Q _ _) := by  use Equiv.sumCongr e.toEquiv (Equiv.prodCongr e.toEquiv (Equiv.refl (ZMod 2)))  funext ⟨a, b⟩  rcases a with x | ⟨y, ε⟩ <;> rcases b with x' | ⟨y', ε'⟩ <;>    first    | rfl    | simp only [Function.comp_apply, Prod.map_apply, poset_braid_map,        Equiv.sumCongr_apply, Sum.map_inl, Sum.map_inr,        Equiv.prodCongr_apply, Equiv.refl_apply,        OrderIso.coe_toEquiv, OrderIso.le_iff_le]
See it in the graphDiscuss this resultChallenge it