awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).num = (↑n : ℤ)
have out₁ : Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
    (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
          (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
      ℤ) =
  (↑n : ℤ)
Tactic: simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₁ :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).num = (↑n : ℤ)
have out₂ : Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ /
    (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹)) : ℤ) =
  (↑n : ℤ)
Tactic: simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₁ :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₂ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ /
      (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹)) : ℤ) =
    (↑n : ℤ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).num = (↑n : ℤ)
have out₃ : Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ / (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
Tactic: simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₁ :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₂ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ /
      (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹)) : ℤ) =
    (↑n : ℤ)
out₃ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ / (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).num = (↑n : ℤ)
have out₄ : Rat.num (↑n : ℚ) * 1 / (↑((Rat.num (↑n : ℚ) * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
Tactic: simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₁ :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₂ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ /
      (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹)) : ℤ) =
    (↑n : ℤ)
out₃ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ / (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₄ : Rat.num (↑n : ℚ) * 1 / (↑((Rat.num (↑n : ℚ) * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).num = (↑n : ℤ)
have out₅ : n * 1 / (↑((n * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
Tactic: simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₁ :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₂ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ /
      (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹)) : ℤ) =
    (↑n : ℤ)
out₃ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ / (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₄ : Rat.num (↑n : ℚ) * 1 / (↑((Rat.num (↑n : ℚ) * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₅ : n * 1 / (↑((n * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).num = (↑n : ℤ)
have out₆ : n * 1 / (↑((n * 1).natAbs.gcd d) : ℤ) = (↑n : ℤ)
Tactic: simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₁ :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₂ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ /
      (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹)) : ℤ) =
    (↑n : ℤ)
out₃ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ / (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₄ : Rat.num (↑n : ℚ) * 1 / (↑((Rat.num (↑n : ℚ) * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₅ : n * 1 / (↑((n * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₆ : n * 1 / (↑((n * 1).natAbs.gcd d) : ℤ) = (↑n : ℤ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).num = (↑n : ℤ)
have out₇ : n / (↑(n.natAbs.gcd d) : ℤ) = (↑n : ℤ)
Tactic: simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₁ :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₂ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ /
      (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹)) : ℤ) =
    (↑n : ℤ)
out₃ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ / (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₄ : Rat.num (↑n : ℚ) * 1 / (↑((Rat.num (↑n : ℚ) * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₅ : n * 1 / (↑((n * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₆ : n * 1 / (↑((n * 1).natAbs.gcd d) : ℤ) = (↑n : ℤ)
out₇ : n / (↑(n.natAbs.gcd d) : ℤ) = (↑n : ℤ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).num = (↑n : ℤ)
have out₈ : n / (↑1 : ℤ) = (↑n : ℤ)
Tactic: simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₁ :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₂ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ /
      (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹)) : ℤ) =
    (↑n : ℤ)
out₃ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ / (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₄ : Rat.num (↑n : ℚ) * 1 / (↑((Rat.num (↑n : ℚ) * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₅ : n * 1 / (↑((n * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₆ : n * 1 / (↑((n * 1).natAbs.gcd d) : ℤ) = (↑n : ℤ)
out₇ : n / (↑(n.natAbs.gcd d) : ℤ) = (↑n : ℤ)
out₈ : n / (↑1 : ℤ) = (↑n : ℤ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).num = (↑n : ℤ)
have out₉ : n / 1 = (↑n : ℤ)
Tactic: simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₁ :
  Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (↑((Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
            (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _))) :
        ℤ) =
    (↑n : ℤ)
out₂ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ /
      (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹)) : ℤ) =
    (↑n : ℤ)
out₃ :
  Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹ / (↑((Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₄ : Rat.num (↑n : ℚ) * 1 / (↑((Rat.num (↑n : ℚ) * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₅ : n * 1 / (↑((n * 1).natAbs.gcd (1 * d)) : ℤ) = (↑n : ℤ)
out₆ : n * 1 / (↑((n * 1).natAbs.gcd d) : ℤ) = (↑n : ℤ)
out₇ : n / (↑(n.natAbs.gcd d) : ℤ) = (↑n : ℤ)
out₈ : n / (↑1 : ℤ) = (↑n : ℤ)
out₉ : n / 1 = (↑n : ℤ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).num = (↑n : ℤ)
have out₁₀ : n = (↑n : ℤ)
Tactic: simp_rw [Rat.mul_num, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, h, Nat.cast_one, Int.ediv_one, Int.cast_id]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
⊢ IsNat (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).den d
have out : (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).den = (↑d : ℕ)
Tactic: constructor
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (hypothesis)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).den = (↑d : ℕ)
have this : 0 < d
Tactic: have : 0 < d := Nat.pos_iff_ne_zero.mpr <| by simpa using hi.ne_zero
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).den = (↑d : ℕ)
have out : Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
    (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
      (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
  (↑d : ℕ)
Tactic: simp_rw [Rat.mul_den, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, Nat.cast_id, h, Nat.div_one]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
        (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
    (↑d : ℕ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).den = (↑d : ℕ)
have out₁ : 1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
    (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
      (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
  (↑d : ℕ)
Tactic: simp_rw [Rat.mul_den, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, Nat.cast_id, h, Nat.div_one]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
        (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
    (↑d : ℕ)
out₁ :
  1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
        (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
    (↑d : ℕ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).den = (↑d : ℕ)
have out₂ : 1 * Rat.den (↑d : ℚ)⁻¹ / (Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹) = (↑d : ℕ)
Tactic: simp_rw [Rat.mul_den, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, Nat.cast_id, h, Nat.div_one]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
        (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
    (↑d : ℕ)
out₁ :
  1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
        (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
    (↑d : ℕ)
out₂ : 1 * Rat.den (↑d : ℚ)⁻¹ / (Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹) = (↑d : ℕ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).den = (↑d : ℕ)
have out₃ : 1 * d / (Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d) = (↑d : ℕ)
Tactic: simp_rw [Rat.mul_den, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, Nat.cast_id, h, Nat.div_one]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
        (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
    (↑d : ℕ)
out₁ :
  1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
        (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
    (↑d : ℕ)
out₂ : 1 * Rat.den (↑d : ℚ)⁻¹ / (Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹) = (↑d : ℕ)
out₃ : 1 * d / (Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d) = (↑d : ℕ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).den = (↑d : ℕ)
have out₄ : 1 * d / (Rat.num (↑n : ℚ) * 1).natAbs.gcd (1 * d) = (↑d : ℕ)
Tactic: simp_rw [Rat.mul_den, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, Nat.cast_id, h, Nat.div_one]
-- Lean 4 proof step from Mathlib.Tactic.NormNum.GCD (goal)
Goal:
n : ℤ
d : ℕ
hi : Invertible (α := ℚ) (↑d : ℚ)
h : n.natAbs.gcd d = 1
this : 0 < d
out :
  Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
        (Rat.den (↑n : ℚ) * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
    (↑d : ℕ)
out₁ :
  1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _) /
      (Rat.num (↑n : ℚ) * Rat.num (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).natAbs.gcd
        (1 * Rat.den (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)) =
    (↑d : ℕ)
out₂ : 1 * Rat.den (↑d : ℚ)⁻¹ / (Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * Rat.den (↑d : ℚ)⁻¹) = (↑d : ℕ)
out₃ : 1 * d / (Rat.num (↑n : ℚ) * Rat.num (↑d : ℚ)⁻¹).natAbs.gcd (1 * d) = (↑d : ℕ)
out₄ : 1 * d / (Rat.num (↑n : ℚ) * 1).natAbs.gcd (1 * d) = (↑d : ℕ)
⊢ (HMul.hMul (α := ℚ) (↑n : ℚ) (@Invertible.invOf _ Distrib.toMul AddMonoidWithOne.toOne (↑d : ℚ) _)).den = (↑d : ℕ)
have out₅ : 1 * d / (n * 1).natAbs.gcd (1 * d) = (↑d : ℕ)
Tactic: simp_rw [Rat.mul_den, Rat.den_intCast, invOf_eq_inv,
      Rat.inv_natCast_den_of_pos this, Rat.inv_natCast_num_of_pos this,
      Rat.num_intCast, one_mul, mul_one, Nat.cast_id, h, Nat.div_one]