ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Complex.continuousAt_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z : ℂ
h : x ∈ slitPlane
⊢ ContinuousAt arg x
state_after: a x z : ℂ
h : x ∈ slitPlane
h₀ : abs x ≠ 0
⊢ ContinuousAt arg x
tactic: have h₀ : abs x ≠ 0 := by
    rw [abs.ne_zero_iff]
    exact slitPlane_ne_zero h
state_before: a x z : ℂ
h : x ∈ slitPlane
h₀ : abs x ≠ 0
⊢ ContinuousAt arg x
state_after: a x z : ℂ
h : 0 < x.re ∨ x.im < 0 ∨ 0 < x.im
h₀ : abs x ≠ 0
⊢ ContinuousAt arg x
tactic: rw [mem_slitPlane_iff, ← lt_or_lt_iff_ne] at h
state_before: a x z : ℂ
h : 0 < x.re ∨ x.im < 0 ∨ 0 < x.im
h₀ : abs x ≠ 0
⊢ ContinuousAt arg x
state_after: case inl
a x z : ℂ
h₀ : abs x ≠ 0
hx_re : 0 < x.re
⊢ ContinuousAt arg x

case inr.inl
a x z : ℂ
h₀ : abs x ≠ 0
hx_im : x.im < 0
⊢ ContinuousAt arg x

case inr.inr
a x z : ℂ
h₀ : abs x ≠ 0
hx_im : 0 < x.im
⊢ ContinuousAt arg x
tactic: rcases h with (hx_re | hx_im | hx_im)
state_before: case inl
a x z : ℂ
h₀ : abs x ≠ 0
hx_re : 0 < x.re
⊢ ContinuousAt arg x

case inr.inl
a x z : ℂ
h₀ : abs x ≠ 0
hx_im : x.im < 0
⊢ ContinuousAt arg x

case inr.inr
a x z : ℂ
h₀ : abs x ≠ 0
hx_im : 0 < x.im
⊢ ContinuousAt arg x
state_after: no goals
tactic: exacts [(Real.continuousAt_arcsin.comp
          (continuous_im.continuousAt.div continuous_abs.continuousAt h₀)).congr
      (arg_eq_nhds_of_re_pos hx_re).symm,
    (Real.continuous_arccos.continuousAt.comp
            (continuous_re.continuousAt.div continuous_abs.continuousAt h₀)).neg.congr
      (arg_eq_nhds_of_im_neg hx_im).symm,
    (Real.continuous_arccos.continuousAt.comp
          (continuous_re.continuousAt.div continuous_abs.continuousAt h₀)).congr
      (arg_eq_nhds_of_im_pos hx_im).symm]
Theorem: FirstOrder.Language.card_withConstants
File: Mathlib/ModelTheory/LanguageMap.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
α : Type w'
⊢ L[[α]].card = lift.{w', max u v} L.card + lift.{max u v, w'} #α
state_after: no goals
tactic: rw [withConstants, card_sum, card_constantsOn]
Theorem: CategoryTheory.Functor.Monoidal.leftUnitor_inv_app
File: Mathlib/CategoryTheory/ChosenFiniteProducts/FunctorCategory.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_1} J
inst✝¹ : Category.{u_4, u_2} C
inst✝ : ChosenFiniteProducts C
F : J ⥤ C
j : J
⊢ (λ_ F).inv.app j = (λ_ (F.obj j)).inv
state_after: no goals
tactic: rw [← cancel_mono ((λ_ (F.obj j)).hom), Iso.inv_hom_id, ← leftUnitor_hom_app,
    Iso.inv_hom_id_app]
Theorem: Set.preimage_mul_preimage_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Mul α
inst✝² : Mul β
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
⊢ ⇑m ⁻¹' s * ⇑m ⁻¹' t ⊆ ⇑m ⁻¹' (s * t)
state_after: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Mul α
inst✝² : Mul β
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
w✝¹ : α
left✝¹ : w✝¹ ∈ ⇑m ⁻¹' s
w✝ : α
left✝ : w✝ ∈ ⇑m ⁻¹' t
⊢ (fun x x_1 => x * x_1) w✝¹ w✝ ∈ ⇑m ⁻¹' (s * t)
tactic: rintro _ ⟨_, _, _, _, rfl⟩
state_before: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Mul α
inst✝² : Mul β
inst✝¹ : FunLike F α β
inst✝ : MulHomClass F α β
m : F
s✝ t✝ : Set α
s t : Set β
w✝¹ : α
left✝¹ : w✝¹ ∈ ⇑m ⁻¹' s
w✝ : α
left✝ : w✝ ∈ ⇑m ⁻¹' t
⊢ (fun x x_1 => x * x_1) w✝¹ w✝ ∈ ⇑m ⁻¹' (s * t)
state_after: no goals
tactic: exact ⟨_, ‹_›, _, ‹_›, (map_mul m _ _).symm⟩
Theorem: Ordinal.cof_zero
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
⊢ cof 0 = 0
state_after: α : Type u_1
r : α → α → Prop
⊢ cof 0 ≤ 0
tactic: refine LE.le.antisymm  ?_ (Cardinal.zero_le _)
state_before: α : Type u_1
r : α → α → Prop
⊢ cof 0 ≤ 0
state_after: α : Type u_1
r : α → α → Prop
⊢ cof 0 ≤ card 0
tactic: rw [← card_zero]
state_before: α : Type u_1
r : α → α → Prop
⊢ cof 0 ≤ card 0
state_after: no goals
tactic: exact cof_le_card 0
Theorem: Caratheodory.affineIndependent_minCardFinsetOfMemConvexHull
File: Mathlib/Analysis/Convex/Caratheodory.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
⊢ AffineIndependent 𝕜 Subtype.val
state_after: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
k : ℕ := (minCardFinsetOfMemConvexHull hx).card - 1
⊢ AffineIndependent 𝕜 Subtype.val
tactic: let k := (minCardFinsetOfMemConvexHull hx).card - 1
state_before: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
k : ℕ := (minCardFinsetOfMemConvexHull hx).card - 1
⊢ AffineIndependent 𝕜 Subtype.val
state_after: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
k : ℕ := (minCardFinsetOfMemConvexHull hx).card - 1
hk : (minCardFinsetOfMemConvexHull hx).card = k + 1
⊢ AffineIndependent 𝕜 Subtype.val
tactic: have hk : (minCardFinsetOfMemConvexHull hx).card = k + 1 :=
    (Nat.succ_pred_eq_of_pos (Finset.card_pos.mpr (minCardFinsetOfMemConvexHull_nonempty hx))).symm
state_before: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
k : ℕ := (minCardFinsetOfMemConvexHull hx).card - 1
hk : (minCardFinsetOfMemConvexHull hx).card = k + 1
⊢ AffineIndependent 𝕜 Subtype.val
state_after: no goals
tactic: classical
  by_contra h
  obtain ⟨p, hp⟩ := mem_convexHull_erase h (mem_minCardFinsetOfMemConvexHull hx)
  have contra := minCardFinsetOfMemConvexHull_card_le_card hx (Set.Subset.trans
    (Finset.erase_subset (p : E) (minCardFinsetOfMemConvexHull hx))
    (minCardFinsetOfMemConvexHull_subseteq hx)) hp
  rw [← not_lt] at contra
  apply contra
  erw [card_erase_of_mem p.2, hk]
  exact lt_add_one _
Theorem: LSeries.norm_term_le_of_re_le_re
File: Mathlib/NumberTheory/LSeries/Basic.lean

Proof steps:
state_before: f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
n : ℕ
⊢ ‖term f s' n‖ ≤ ‖term f s n‖
state_after: f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
n : ℕ
⊢ (if n = 0 then 0 else ‖f n‖ / ↑n ^ s'.re) ≤ if n = 0 then 0 else ‖f n‖ / ↑n ^ s.re
tactic: simp only [norm_term_eq]
state_before: f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
n : ℕ
⊢ (if n = 0 then 0 else ‖f n‖ / ↑n ^ s'.re) ≤ if n = 0 then 0 else ‖f n‖ / ↑n ^ s.re
state_after: case isTrue
f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
n : ℕ
h✝ : n = 0
⊢ 0 ≤ 0

case isFalse
f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
n : ℕ
h✝ : ¬n = 0
⊢ ‖f n‖ / ↑n ^ s'.re ≤ ‖f n‖ / ↑n ^ s.re
tactic: split
state_before: case isTrue
f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
n : ℕ
h✝ : n = 0
⊢ 0 ≤ 0

case isFalse
f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
n : ℕ
h✝ : ¬n = 0
⊢ ‖f n‖ / ↑n ^ s'.re ≤ ‖f n‖ / ↑n ^ s.re
state_after: case isFalse
f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
n : ℕ
h✝ : ¬n = 0
⊢ ‖f n‖ / ↑n ^ s'.re ≤ ‖f n‖ / ↑n ^ s.re
tactic: next => rfl
state_before: case isFalse
f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
n : ℕ
h✝ : ¬n = 0
⊢ ‖f n‖ / ↑n ^ s'.re ≤ ‖f n‖ / ↑n ^ s.re
state_after: no goals
tactic: next hn => gcongr; exact Nat.one_le_cast.mpr <| Nat.one_le_iff_ne_zero.mpr hn
Theorem: Ring.multichoose_neg_self
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n : ℕ
⊢ multichoose (-↑n) n = (-1) ^ n
state_after: case a
R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n : ℕ
⊢ (fun x => ?m.77547.factorial • x) (multichoose (-↑n) n) = (fun x => ?m.77547.factorial • x) ((-1) ^ n)

R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n : ℕ
⊢ ℕ
tactic: apply nsmul_right_injective _ (Nat.factorial_ne_zero _)
state_before: case a
R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n : ℕ
⊢ (fun x => ?m.77547.factorial • x) (multichoose (-↑n) n) = (fun x => ?m.77547.factorial • x) ((-1) ^ n)

R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n : ℕ
⊢ ℕ
state_after: case a
R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n : ℕ
⊢ ?m.77547.factorial • multichoose (-↑n) n = ?m.77547.factorial • (-1) ^ n

R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n : ℕ
⊢ ℕ
tactic: on_goal 1 => simp only
state_before: case a
R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n : ℕ
⊢ ?m.77547.factorial • multichoose (-↑n) n = ?m.77547.factorial • (-1) ^ n

R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n : ℕ
⊢ ℕ
state_after: no goals
tactic: rw [factorial_nsmul_multichoose_eq_ascPochhammer, smeval_ascPochhammer_self_neg, nsmul_eq_mul,
    Nat.cast_comm]
Theorem: IsSubgroup.center_normal
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
⊢ 1 ∈ center G
state_after: no goals
tactic: simp [center]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
a✝ b✝ : G
ha : a✝ ∈ center G
hb : b✝ ∈ center G
g : G
⊢ g * (a✝ * b✝) = a✝ * b✝ * g
state_after: no goals
tactic: rw [← mul_assoc, mem_center.2 ha g, mul_assoc, mem_center.2 hb g, ← mul_assoc]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ g * a⁻¹ = a⁻¹ * (g * a) * a⁻¹
state_after: no goals
tactic: simp [ha g]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ a⁻¹ * (g * a) * a⁻¹ = a⁻¹ * g
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ a⁻¹ * g * (a * a⁻¹) = a⁻¹ * g
tactic: rw [← mul_assoc, mul_assoc]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ a⁻¹ * g * (a * a⁻¹) = a⁻¹ * g
state_after: no goals
tactic: simp
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ h * (g * n * g⁻¹) = h * n
state_after: no goals
tactic: simp [ha g, mul_assoc]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ h * n = g * g⁻¹ * n * h
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ n * h = g * g⁻¹ * n * h
tactic: rw [ha h]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ n * h = g * g⁻¹ * n * h
state_after: no goals
tactic: simp
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ g * g⁻¹ * n * h = g * n * g⁻¹ * h
state_after: no goals
tactic: rw [mul_assoc g, ha g⁻¹, ← mul_assoc]
Theorem: Polynomial.coe_eq_one_iff
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ : R[X]
⊢ ↑φ = 1 ↔ φ = 1
state_after: no goals
tactic: rw [← coe_one, coe_inj]
Theorem: AlternatingMap.smulRight_apply
File: Mathlib/LinearAlgebra/Alternating/Basic.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝¹⁵ : Semiring R✝
M : Type u_2
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R✝ M
N : Type u_3
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R✝ N
P : Type u_4
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R✝ P
M' : Type u_5
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R✝ M'
N' : Type u_6
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R✝ N'
ι✝ : Type u_7
ι' : Type u_8
ι'' : Type u_9
f✝ f' : M [⋀^ι✝]→ₗ[R✝] N
g g₂ : M [⋀^ι✝]→ₗ[R✝] N'
g' : M' [⋀^ι✝]→ₗ[R✝] N'
v✝ : ι✝ → M
v' : ι✝ → M'
R : Type u_10
M₁ : Type u_11
M₂ : Type u_12
ι : Type u_13
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M₁
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
f : M₁ [⋀^ι]→ₗ[R] R
z : M₂
v : ι → M₁
i j : ι
h : v i = v j
hne : i ≠ j
⊢ __src✝.toFun v = 0
state_after: no goals
tactic: simp [f.map_eq_zero_of_eq v h hne]
Theorem: Matrix.StdBasisMatrix.mul_left_apply_of_ne
File: Mathlib/Data/Matrix/Basis.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
i j : n
c : α
i' j' : n
inst✝ : Fintype n
a b : n
h : a ≠ i
M : Matrix n n α
⊢ (stdBasisMatrix i j c * M) a b = 0
state_after: no goals
tactic: simp [mul_apply, h.symm]
Theorem: EuclideanGeometry.dist_eq_add_dist_iff_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
hp1p2 : p1 ≠ p2
hp3p2 : p3 ≠ p2
⊢ dist p1 p3 = dist p1 p2 + dist p3 p2 ↔ ∠ p1 p2 p3 = π
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
hp1p2 : p1 ≠ p2
hp3p2 : p3 ≠ p2
⊢ ‖p1 -ᵥ ?p₃ - (p3 -ᵥ ?p₃)‖ = ‖p1 -ᵥ p2‖ + ‖p3 -ᵥ p2‖ ↔ ∠ p1 p2 p3 = π

case p₃
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
hp1p2 : p1 ≠ p2
hp3p2 : p3 ≠ p2
⊢ P
tactic: rw [dist_eq_norm_vsub V, dist_eq_norm_vsub V, dist_eq_norm_vsub V, ← vsub_sub_vsub_cancel_right]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
hp1p2 : p1 ≠ p2
hp3p2 : p3 ≠ p2
⊢ ‖p1 -ᵥ ?p₃ - (p3 -ᵥ ?p₃)‖ = ‖p1 -ᵥ p2‖ + ‖p3 -ᵥ p2‖ ↔ ∠ p1 p2 p3 = π

case p₃
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 : P
hp1p2 : p1 ≠ p2
hp3p2 : p3 ≠ p2
⊢ P
state_after: no goals
tactic: exact
    norm_sub_eq_add_norm_iff_angle_eq_pi (fun he => hp1p2 (vsub_eq_zero_iff_eq.1 he)) fun he =>
      hp3p2 (vsub_eq_zero_iff_eq.1 he)
Theorem: IsUltrametricDist.closedBall_eq_of_mem
File: Mathlib/Topology/MetricSpace/Ultra/Basic.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : PseudoMetricSpace X
inst✝ : IsUltrametricDist X
x✝ y✝ z : X
r✝ s : ℝ
x y : X
r : ℝ
h : y ∈ closedBall x r
⊢ closedBall x r = closedBall y r
state_after: case h
X : Type u_1
inst✝¹ : PseudoMetricSpace X
inst✝ : IsUltrametricDist X
x✝¹ y✝ z : X
r✝ s : ℝ
x y : X
r : ℝ
h : y ∈ closedBall x r
x✝ : X
⊢ x✝ ∈ closedBall x r ↔ x✝ ∈ closedBall y r
tactic: ext
state_before: case h
X : Type u_1
inst✝¹ : PseudoMetricSpace X
inst✝ : IsUltrametricDist X
x✝¹ y✝ z : X
r✝ s : ℝ
x y : X
r : ℝ
h : y ∈ closedBall x r
x✝ : X
⊢ x✝ ∈ closedBall x r ↔ x✝ ∈ closedBall y r
state_after: case h
X : Type u_1
inst✝¹ : PseudoMetricSpace X
inst✝ : IsUltrametricDist X
x✝¹ y✝ z : X
r✝ s : ℝ
x y : X
r : ℝ
x✝ : X
h : dist y x ≤ r
⊢ dist x✝ x ≤ r ↔ dist x✝ y ≤ r
tactic: simp_rw [mem_closedBall] at h ⊢
state_before: case h
X : Type u_1
inst✝¹ : PseudoMetricSpace X
inst✝ : IsUltrametricDist X
x✝¹ y✝ z : X
r✝ s : ℝ
x y : X
r : ℝ
x✝ : X
h : dist y x ≤ r
⊢ dist x✝ x ≤ r ↔ dist x✝ y ≤ r
state_after: no goals
tactic: constructor <;> intro h' <;>
  exact (dist_triangle_max _ _ _).trans (max_le h' (dist_comm x _ ▸ h))
Theorem: IsOfFinOrder.orderOf_pow
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : IsOfFinOrder x
⊢ orderOf (x ^ n) = orderOf x / (orderOf x).gcd n
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : IsOfFinOrder x
⊢ minimalPeriod (fun x_1 => x ^ n * x_1) 1 =
    minimalPeriod (fun x_1 => x * x_1) 1 / (minimalPeriod (fun x_1 => x * x_1) 1).gcd n
tactic: unfold orderOf
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : IsOfFinOrder x
⊢ minimalPeriod (fun x_1 => x ^ n * x_1) 1 =
    minimalPeriod (fun x_1 => x * x_1) 1 / (minimalPeriod (fun x_1 => x * x_1) 1).gcd n
state_after: no goals
tactic: rw [← minimalPeriod_iterate_eq_div_gcd' h, mul_left_iterate]
Theorem: PFunctor.Approx.agree_children
File: Mathlib/Data/PFunctor/Univariate/M.lean

Proof steps:
state_before: F : PFunctor.{u}
n : ℕ
x : CofixA F n.succ
y : CofixA F (n.succ + 1)
i : F.B (head' x)
j : F.B (head' y)
h₀ : HEq i j
h₁ : Agree x y
⊢ Agree (children' x i) (children' y j)
state_after: case intro
F : PFunctor.{u}
n : ℕ
a✝ : F.A
x✝ : F.B a✝ → CofixA F n
x'✝ : F.B a✝ → CofixA F (n + 1)
hagree : ∀ (i : F.B a✝), Agree (x✝ i) (x'✝ i)
i : F.B (head' (CofixA.intro a✝ x✝))
j : F.B (head' (CofixA.intro a✝ x'✝))
h₀ : HEq i j
⊢ Agree (children' (CofixA.intro a✝ x✝) i) (children' (CofixA.intro a✝ x'✝) j)
tactic: cases' h₁ with _ _ _ _ _ _ hagree
state_before: case intro
F : PFunctor.{u}
n : ℕ
a✝ : F.A
x✝ : F.B a✝ → CofixA F n
x'✝ : F.B a✝ → CofixA F (n + 1)
hagree : ∀ (i : F.B a✝), Agree (x✝ i) (x'✝ i)
i : F.B (head' (CofixA.intro a✝ x✝))
j : F.B (head' (CofixA.intro a✝ x'✝))
h₀ : HEq i j
⊢ Agree (children' (CofixA.intro a✝ x✝) i) (children' (CofixA.intro a✝ x'✝) j)
state_after: case intro.refl
F : PFunctor.{u}
n : ℕ
a✝ : F.A
x✝ : F.B a✝ → CofixA F n
x'✝ : F.B a✝ → CofixA F (n + 1)
hagree : ∀ (i : F.B a✝), Agree (x✝ i) (x'✝ i)
i : F.B (head' (CofixA.intro a✝ x✝))
⊢ Agree (children' (CofixA.intro a✝ x✝) i) (children' (CofixA.intro a✝ x'✝) i)
tactic: cases h₀
state_before: case intro.refl
F : PFunctor.{u}
n : ℕ
a✝ : F.A
x✝ : F.B a✝ → CofixA F n
x'✝ : F.B a✝ → CofixA F (n + 1)
hagree : ∀ (i : F.B a✝), Agree (x✝ i) (x'✝ i)
i : F.B (head' (CofixA.intro a✝ x✝))
⊢ Agree (children' (CofixA.intro a✝ x✝) i) (children' (CofixA.intro a✝ x'✝) i)
state_after: no goals
tactic: apply hagree
Theorem: Nat.Prime.sum_properDivisors
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
inst✝ : CommMonoid α
p : ℕ
f : ℕ → α
h : Prime p
⊢ ∏ x ∈ p.properDivisors, f x = f 1
state_after: no goals
tactic: simp [h.properDivisors]
Theorem: Compactum.isClosed_cl
File: Mathlib/Topology/Category/Compactum.lean

Proof steps:
state_before: X : Compactum
A : Set X.A
⊢ IsClosed (Compactum.cl A)
state_after: X : Compactum
A : Set X.A
⊢ ∀ (F : Ultrafilter X.A), Compactum.cl A ∈ F → X.str F ∈ Compactum.cl A
tactic: rw [isClosed_iff]
state_before: X : Compactum
A : Set X.A
⊢ ∀ (F : Ultrafilter X.A), Compactum.cl A ∈ F → X.str F ∈ Compactum.cl A
state_after: X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : Compactum.cl A ∈ F
⊢ X.str F ∈ Compactum.cl A
tactic: intro F hF
state_before: X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : Compactum.cl A ∈ F
⊢ X.str F ∈ Compactum.cl A
state_after: no goals
tactic: exact cl_cl _ ⟨F, hF, rfl⟩
Theorem: Set.Finite.prod
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hs : s.Finite
ht : t.Finite
⊢ (s ×ˢ t).Finite
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hs : s.Finite
ht : t.Finite
this : Finite ↑s
⊢ (s ×ˢ t).Finite
tactic: have := hs.to_subtype
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hs : s.Finite
ht : t.Finite
this : Finite ↑s
⊢ (s ×ˢ t).Finite
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hs : s.Finite
ht : t.Finite
this✝ : Finite ↑s
this : Finite ↑t
⊢ (s ×ˢ t).Finite
tactic: have := ht.to_subtype
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
t : Set β
hs : s.Finite
ht : t.Finite
this✝ : Finite ↑s
this : Finite ↑t
⊢ (s ×ˢ t).Finite
state_after: no goals
tactic: apply toFinite
Theorem: AffineSubspace.directionOfNonempty_eq_direction
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : (↑s).Nonempty
⊢ directionOfNonempty h = s.direction
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : (↑s).Nonempty
⊢ directionOfNonempty h ≤ s.direction
tactic: refine le_antisymm ?_ (Submodule.span_le.2 Set.Subset.rfl)
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : (↑s).Nonempty
⊢ directionOfNonempty h ≤ s.direction
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : (↑s).Nonempty
⊢ ↑{ carrier := ↑s -ᵥ ↑s, add_mem' := ⋯ } ⊆ ↑(vectorSpan k ↑s)
tactic: rw [← SetLike.coe_subset_coe, directionOfNonempty, direction, Submodule.coe_set_mk,
    AddSubmonoid.coe_set_mk]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
h : (↑s).Nonempty
⊢ ↑{ carrier := ↑s -ᵥ ↑s, add_mem' := ⋯ } ⊆ ↑(vectorSpan k ↑s)
state_after: no goals
tactic: exact vsub_set_subset_vectorSpan k _
Theorem: Finmap.union_empty
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ : Finmap β
s₁ : AList β
⊢ ⟦s₁⟧ ∪ ∅ = ⟦s₁⟧
state_after: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ : Finmap β
s₁ : AList β
⊢ ⟦s₁⟧ ∪ ⟦∅⟧ = ⟦s₁⟧
tactic: rw [← empty_toFinmap]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ : Finmap β
s₁ : AList β
⊢ ⟦s₁⟧ ∪ ⟦∅⟧ = ⟦s₁⟧
state_after: no goals
tactic: simp [-empty_toFinmap, AList.toFinmap_eq, union_toFinmap, AList.union_assoc]
Theorem: FreeAbelianGroup.toFinsupp_of
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

Proof steps:
state_before: X : Type u_1
x : X
⊢ toFinsupp (of x) = single x 1
state_after: no goals
tactic: simp only [toFinsupp, lift.of]
Theorem: Equiv.prod_assoc_image
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
⊢ ⇑(prodAssoc α β γ) '' (s ×ˢ t) ×ˢ u = s ×ˢ t ×ˢ u
state_after: no goals
tactic: simpa only [Equiv.image_eq_preimage] using prod_assoc_symm_preimage
Theorem: Associates.factors_eq_top_iff_zero
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : Associates α
⊢ a.factors = ⊤ ↔ a = 0
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : Associates α
a✝ : Nontrivial α
⊢ a.factors = ⊤ ↔ a = 0
tactic: nontriviality α
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : Associates α
a✝ : Nontrivial α
⊢ a.factors = ⊤ ↔ a = 0
state_after: no goals
tactic: exact ⟨fun h ↦ by rwa [← factors_prod a, FactorSet.prod_eq_zero_iff], fun h ↦ h ▸ factors_zero⟩
Theorem: Multiset.single_le_prod
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
l : List α
hl : ∀ x ∈ ⟦l⟧, 1 ≤ x
x : α
hx : x ∈ ⟦l⟧
⊢ x ≤ prod ⟦l⟧
state_after: no goals
tactic: simpa using List.single_le_prod hl x hx
Theorem: SimpleGraph.Walk.reverse_map
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : G.Walk u v
⊢ (Walk.map f p).reverse = Walk.map f p.reverse
state_after: no goals
tactic: induction p <;> simp [map_append, *]
Theorem: Real.deriv_negMulLog
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

Proof steps:
state_before: x : ℝ
hx : x ≠ 0
⊢ deriv negMulLog x = -log x - 1
state_after: x : ℝ
hx : x ≠ 0
⊢ -(log x + 1) = -log x - 1
tactic: rw [negMulLog_eq_neg, deriv.neg, deriv_mul_log hx]
state_before: x : ℝ
hx : x ≠ 0
⊢ -(log x + 1) = -log x - 1
state_after: no goals
tactic: ring