/-- The additive monoid morphism `dyadicMap` sends ⟦⟨m, 2^n⟩⟧ to m • half ^ n. -/
def dyadicMap : Localization.Away (2 : ℤ) →+ Surreal where
  toFun x :=
    (Localization.liftOn x fun x y => x • powHalf (Submonoid.log y)) <| by
      intro m₁ m₂ n₁ n₂ h₁
      obtain ⟨⟨n₃, y₃, hn₃⟩, h₂⟩ := Localization.r_iff_exists.mp h₁
      simp only [Subtype.coe_mk, mul_eq_mul_left_iff] at h₂
      cases h₂
      · obtain ⟨a₁, ha₁⟩ := n₁.prop
        obtain ⟨a₂, ha₂⟩ := n₂.prop
        simp only at ha₁ ha₂ ⊢
        have hn₁ : n₁ = Submonoid.pow 2 a₁ := Subtype.ext ha₁.symm
        have hn₂ : n₂ = Submonoid.pow 2 a₂ := Subtype.ext ha₂.symm
        have h₂ : 1 < (2 : ℤ).natAbs := one_lt_two
        rw [hn₁, hn₂, Submonoid.log_pow_int_eq_self h₂, Submonoid.log_pow_int_eq_self h₂]
        apply dyadic_aux
        rwa [ha₁, ha₂, mul_comm, mul_comm m₂]
      · have : (1 : ℤ) ≤ 2 ^ y₃ := mod_cast Nat.one_le_pow y₃ 2 Nat.succ_pos'
        linarith
  map_zero' := Localization.liftOn_zero _ _
  map_add' x y :=
    Localization.induction_on₂ x y <| by
      rintro ⟨a, ⟨b, ⟨b', rfl⟩⟩⟩ ⟨c, ⟨d, ⟨d', rfl⟩⟩⟩
      

Proof state:
case mk.mk.intro.mk.mk.intro
x y : Localization.Away 2
a : ℤ
b' : ℕ
c : ℤ
d' : ℕ
⊢ ZeroHom.toFun
      {
        toFun := fun x =>
          Localization.liftOn x (fun x y => x • powHalf (Submonoid.log y))
            (_ :
              ∀ {m₁ m₂ : ℤ} {n₁ n₂ : ↥(Submonoid.powers 2)},
                (Localization.r (Submonoid.powers 2)) (m₁, n₁) (m₂, n₂) →
                  m₁ • powHalf (Submonoid.log n₁) = m₂ • powHalf (Submonoid.log n₂)),
        map_zero' :=
          (_ :
            Localization.liftOn 0 (fun x y => x • powHalf (Submonoid.log y))
                (_ :
                  ∀ {m₁ m₂ : ℤ} {n₁ n₂ : ↥(Submonoid.powers 2)},
                    (Localization.r (Submonoid.powers 2)) (m₁, n₁) (m₂, n₂) →
                      m₁ • powHalf (Submonoid.log n₁) = m₂ • powHalf (Submonoid.log n₂)) =
              0 • powHalf (Submonoid.log 1)) }
      (Localization.mk
          (a, { val := (fun x => 2 ^ x) b', property := (_ : ∃ y, (fun x => 2 ^ x) y = (fun x => 2 ^ x) b') }).1
          (a, { val := (fun x => 2 ^ x) b', property := (_ : ∃ y, (fun x => 2 ^ x) y = (fun x => 2 ^ x) b') }).2 +
        Localization.mk
          (c, { val := (fun x => 2 ^ x) d', property := (_ : ∃ y, (fun x => 2 ^ x) y = (fun x => 2 ^ x) d') }).1
          (c, { val := (fun x => 2 ^ x) d', property := (_ : ∃ y, (fun x => 2 ^ x) y = (fun x => 2 ^ x) d') }).2) =
    ZeroHom.toFun
        {
          toFun := fun x =>
            Localization.liftOn x (fun x y => x • powHalf (Submonoid.log y))
              (_ :
                ∀ {m₁ m₂ : ℤ} {n₁ n₂ : ↥(Submonoid.powers 2)},
                  (Localization.r (Submonoid.powers 2)) (m₁, n₁) (m₂, n₂) →
                    m₁ • powHalf (Submonoid.log n₁) = m₂ • powHalf (Submonoid.log n₂)),
          map_zero' :=
            (_ :
              Localization.liftOn 0 (fun x y => x • powHalf (Submonoid.log y))
                  (_ :
                    ∀ {m₁ m₂ : ℤ} {n₁ n₂ : ↥(Submonoid.powers 2)},
                      (Localization.r (Submonoid.powers 2)) (m₁, n₁) (m₂, n₂) →
                        m₁ • powHalf (Submonoid.log n₁) = m₂ • powHalf (Submonoid.log n₂)) =
                0 • powHalf (Submonoid.log 1)) }
        (Localization.mk
          (a, { val := (fun x => 2 ^ x) b', property := (_ : ∃ y, (fun x => 2 ^ x) y = (fun x => 2 ^ x) b') }).1
          (a, { val := (fun x => 2 ^ x) b', property := (_ : ∃ y, (fun x => 2 ^ x) y = (fun x => 2 ^ x) b') }).2) +
      ZeroHom.toFun
        {
          toFun := fun x =>
            Localization.liftOn x (fun x y => x • powHalf (Submonoid.log y))
              (_ :
                ∀ {m₁ m₂ : ℤ} {n₁ n₂ : ↥(Submonoid.powers 2)},
                  (Localization.r (Submonoid.powers 2)) (m₁, n₁) (m₂, n₂) →
                    m₁ • powHalf (Submonoid.log n₁) = m₂ • powHalf (Submonoid.log n₂)),
          map_zero' :=
            (_ :
              Localization.liftOn 0 (fun x y => x • powHalf (Submonoid.log y))
                  (_ :
                    ∀ {m₁ m₂ : ℤ} {n₁ n₂ : ↥(Submonoid.powers 2)},
                      (Localization.r (Submonoid.powers 2)) (m₁, n₁) (m₂, n₂) →
                        m₁ • powHalf (Submonoid.log n₁) = m₂ • powHalf (Submonoid.log n₂)) =
                0 • powHalf (Submonoid.log 1)) }
        (Localization.mk
          (c, { val := (fun x => 2 ^ x) d', property := (_ : ∃ y, (fun x => 2 ^ x) y = (fun x => 2 ^ x) d') }).1
          (c, { val := (fun x => 2 ^ x) d', property := (_ : ∃ y, (fun x => 2 ^ x) y = (fun x => 2 ^ x) d') }).2)

Next tactic:
have h₂ : 1 < (2 : ℤ).natAbs := one_lt_two