ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.succ_dvd_centralBinom
File: Mathlib/Data/Nat/Choose/Central.lean

Proof steps:
state_before: n : ℕ
⊢ n + 1 ∣ n.centralBinom
state_after: n : ℕ
h_s : (n + 1).Coprime (2 * n + 1)
⊢ n + 1 ∣ n.centralBinom
tactic: have h_s : (n + 1).Coprime (2 * n + 1) := by
    rw [two_mul, add_assoc, coprime_add_self_right, coprime_self_add_left]
    exact coprime_one_left n
state_before: n : ℕ
h_s : (n + 1).Coprime (2 * n + 1)
⊢ n + 1 ∣ n.centralBinom
state_after: n : ℕ
h_s : (n + 1).Coprime (2 * n + 1)
⊢ n + 1 ∣ (2 * n + 1) * n.centralBinom
tactic: apply h_s.dvd_of_dvd_mul_left
state_before: n : ℕ
h_s : (n + 1).Coprime (2 * n + 1)
⊢ n + 1 ∣ (2 * n + 1) * n.centralBinom
state_after: n : ℕ
h_s : (n + 1).Coprime (2 * n + 1)
⊢ 2 * (n + 1) ∣ 2 * ((2 * n + 1) * n.centralBinom)
tactic: apply Nat.dvd_of_mul_dvd_mul_left zero_lt_two
state_before: n : ℕ
h_s : (n + 1).Coprime (2 * n + 1)
⊢ 2 * (n + 1) ∣ 2 * ((2 * n + 1) * n.centralBinom)
state_after: n : ℕ
h_s : (n + 1).Coprime (2 * n + 1)
⊢ (n + 1) * 2 ∣ (n + 1) * (n + 1).centralBinom
tactic: rw [← mul_assoc, ← succ_mul_centralBinom_succ, mul_comm]
state_before: n : ℕ
h_s : (n + 1).Coprime (2 * n + 1)
⊢ (n + 1) * 2 ∣ (n + 1) * (n + 1).centralBinom
state_after: no goals
tactic: exact mul_dvd_mul_left _ (two_dvd_centralBinom_succ n)
Theorem: UniqueAdd.exists_iff_exists_existsUnique
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
g : G
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
state_after: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
g : G
h h' : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
tactic: have h' := h
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
g : G
h h' : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
state_after: case intro.mk.intro.intro.refl
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = (a, b).1 * (a, b).2
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
tactic: rcases h' with ⟨⟨a, b⟩, ⟨hab, rfl, -⟩, -⟩
state_before: case intro.mk.intro.intro.refl
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = (a, b).1 * (a, b).2
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
state_after: case intro.mk.intro.intro.refl.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = (a, b).1 * (a, b).2
ha : (a, b).1 ∈ A
hb : (a, b).2 ∈ B
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
tactic: cases' Finset.mem_product.mp hab with ha hb
state_before: case intro.mk.intro.intro.refl.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = (a, b).1 * (a, b).2
ha : (a, b).1 ∈ A
hb : (a, b).2 ∈ B
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
state_after: no goals
tactic: exact ⟨a, b, ha, hb, (iff_existsUnique ha hb).mpr h⟩
Theorem: Polynomial.coeff_hermite_of_lt
File: Mathlib/RingTheory/Polynomial/Hermite/Basic.lean

Proof steps:
state_before: n k : ℕ
hnk : n < k
⊢ (hermite n).coeff k = 0
state_after: case intro
n k : ℕ
hnk : n < n + k + 1
⊢ (hermite n).coeff (n + k + 1) = 0
tactic: obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_lt hnk
state_before: case intro
n k : ℕ
hnk : n < n + k + 1
⊢ (hermite n).coeff (n + k + 1) = 0
state_after: case intro
n k : ℕ
⊢ (hermite n).coeff (n + k + 1) = 0
tactic: clear hnk
state_before: case intro
n k : ℕ
⊢ (hermite n).coeff (n + k + 1) = 0
state_after: case intro.zero
k : ℕ
⊢ (hermite 0).coeff (0 + k + 1) = 0

case intro.succ
n : ℕ
ih : ∀ (k : ℕ), (hermite n).coeff (n + k + 1) = 0
k : ℕ
⊢ (hermite (n + 1)).coeff (n + 1 + k + 1) = 0
tactic: induction' n with n ih generalizing k
Theorem: MultilinearMap.domCoprod_alternization_eq
File: Mathlib/LinearAlgebra/Alternating/DomCoprod.lean

Proof steps:
state_before: ιa : Type u_1
ιb : Type u_2
inst✝¹⁰ : Fintype ιa
inst✝⁹ : Fintype ιb
R' : Type u_3
Mᵢ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
inst✝⁸ : CommSemiring R'
inst✝⁷ : AddCommGroup N₁
inst✝⁶ : Module R' N₁
inst✝⁵ : AddCommGroup N₂
inst✝⁴ : Module R' N₂
inst✝³ : AddCommMonoid Mᵢ
inst✝² : Module R' Mᵢ
inst✝¹ : DecidableEq ιa
inst✝ : DecidableEq ιb
a : Mᵢ [⋀^ιa]→ₗ[R'] N₁
b : Mᵢ [⋀^ιb]→ₗ[R'] N₂
⊢ alternatization ((↑a).domCoprod ↑b) = ((Fintype.card ιa).factorial * (Fintype.card ιb).factorial) • a.domCoprod b
state_after: no goals
tactic: rw [MultilinearMap.domCoprod_alternization, coe_alternatization, coe_alternatization, mul_smul,
    ← AlternatingMap.domCoprod'_apply, ← AlternatingMap.domCoprod'_apply,
    ← TensorProduct.smul_tmul', TensorProduct.tmul_smul,
    LinearMap.map_smul_of_tower AlternatingMap.domCoprod',
    LinearMap.map_smul_of_tower AlternatingMap.domCoprod']
Theorem: AffineIsometry.dist_map
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
V₁ : Type u_3
V₁' : Type u_4
V₂ : Type u_5
V₃ : Type u_6
V₄ : Type u_7
P₁ : Type u_8
P₁' : Type u_9
P : Type u_10
P₂ : Type u_11
P₃ : Type u_12
P₄ : Type u_13
inst✝²⁴ : NormedField 𝕜
inst✝²³ : SeminormedAddCommGroup V
inst✝²² : NormedSpace 𝕜 V
inst✝²¹ : PseudoMetricSpace P
inst✝²⁰ : NormedAddTorsor V P
inst✝¹⁹ : SeminormedAddCommGroup V₁
inst✝¹⁸ : NormedSpace 𝕜 V₁
inst✝¹⁷ : PseudoMetricSpace P₁
inst✝¹⁶ : NormedAddTorsor V₁ P₁
inst✝¹⁵ : SeminormedAddCommGroup V₁'
inst✝¹⁴ : NormedSpace 𝕜 V₁'
inst✝¹³ : MetricSpace P₁'
inst✝¹² : NormedAddTorsor V₁' P₁'
inst✝¹¹ : SeminormedAddCommGroup V₂
inst✝¹⁰ : NormedSpace 𝕜 V₂
inst✝⁹ : PseudoMetricSpace P₂
inst✝⁸ : NormedAddTorsor V₂ P₂
inst✝⁷ : SeminormedAddCommGroup V₃
inst✝⁶ : NormedSpace 𝕜 V₃
inst✝⁵ : PseudoMetricSpace P₃
inst✝⁴ : NormedAddTorsor V₃ P₃
inst✝³ : SeminormedAddCommGroup V₄
inst✝² : NormedSpace 𝕜 V₄
inst✝¹ : PseudoMetricSpace P₄
inst✝ : NormedAddTorsor V₄ P₄
f : P →ᵃⁱ[𝕜] P₂
f₁ : P₁' →ᵃⁱ[𝕜] P₂
x y : P
⊢ dist (f x) (f y) = dist x y
state_after: no goals
tactic: rw [dist_eq_norm_vsub V₂, dist_eq_norm_vsub V, ← map_vsub, f.linearIsometry.norm_map]
Theorem: Polynomial.cyclotomic_one
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
⊢ cyclotomic 1 R = X - 1
state_after: R : Type u_1
inst✝ : Ring R
hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ
⊢ cyclotomic 1 R = X - 1
tactic: have hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ := by
    simp only [cyclotomic'_one, PNat.one_coe, map_X, Polynomial.map_one, Polynomial.map_sub]
state_before: R : Type u_1
inst✝ : Ring R
hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ
⊢ cyclotomic 1 R = X - 1
state_after: R : Type u_1
inst✝ : Ring R
hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ
⊢ X - 1 = cyclotomic 1 R
tactic: symm
state_before: R : Type u_1
inst✝ : Ring R
hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ
⊢ X - 1 = cyclotomic 1 R
state_after: R : Type u_1
inst✝ : Ring R
hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ
⊢ X - 1 = map (Int.castRingHom R) (X - 1)
tactic: rw [← map_cyclotomic_int, ← int_cyclotomic_unique hspec]
state_before: R : Type u_1
inst✝ : Ring R
hspec : map (Int.castRingHom ℂ) (X - 1) = cyclotomic' 1 ℂ
⊢ X - 1 = map (Int.castRingHom R) (X - 1)
state_after: no goals
tactic: simp only [map_X, Polynomial.map_one, Polynomial.map_sub]
Theorem: CategoryTheory.Functor.preimageIso_inv
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.4319, u_1} E
X✝ Y✝ : C
F : C ⥤ D
X Y Z : C
inst✝¹ : F.Full
inst✝ : F.Faithful
f : F.obj X ≅ F.obj Y
⊢ F.map (F.preimage f.hom ≫ F.preimage f.inv) = F.map (𝟙 X)
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{?u.4319, u_1} E
X✝ Y✝ : C
F : C ⥤ D
X Y Z : C
inst✝¹ : F.Full
inst✝ : F.Faithful
f : F.obj X ≅ F.obj Y
⊢ F.map (F.preimage f.inv ≫ F.preimage f.hom) = F.map (𝟙 Y)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.inl_inr_pushoutAssoc_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Assoc.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr g₁ g₂) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl g₃ g₄)
⊢ pushout.inl g₃ g₄ ≫ pushout.inr g₁ (g₂ ≫ pushout.inl g₃ g₄) ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv =
    pushout.inr g₁ g₂ ≫ pushout.inl (g₃ ≫ pushout.inr g₁ g₂) g₄
state_after: no goals
tactic: rw [← Category.assoc, Iso.comp_inv_eq, Category.assoc, inr_inl_pushoutAssoc_hom]
Theorem: Finset.piecewise_eq_of_mem
File: Mathlib/Data/Finset/Piecewise.lean

Proof steps:
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝ : (j : ι) → Decidable (j ∈ s)
i : ι
hi : i ∈ s
⊢ s.piecewise f g i = f i
state_after: no goals
tactic: simp [piecewise, hi]
Theorem: TensorProduct.finsuppLeft_apply_tmul
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : CommSemiring R
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
N : Type u_3
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
ι : Type u_4
inst✝ : DecidableEq ι
p : ι →₀ M
n : N
⊢ (finsuppLeft R M N ι) (p ⊗ₜ[R] n) = p.sum fun i m => Finsupp.single i (m ⊗ₜ[R] n)
state_after: case h0
R : Type u_1
inst✝⁵ : CommSemiring R
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
N : Type u_3
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
ι : Type u_4
inst✝ : DecidableEq ι
p : ι →₀ M
n : N
⊢ (finsuppLeft R M N ι) (0 ⊗ₜ[R] n) = Finsupp.sum 0 fun i m => Finsupp.single i (m ⊗ₜ[R] n)

case hadd
R : Type u_1
inst✝⁵ : CommSemiring R
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
N : Type u_3
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
ι : Type u_4
inst✝ : DecidableEq ι
p : ι →₀ M
n : N
⊢ ∀ (f g : ι →₀ M),
    ((finsuppLeft R M N ι) (f ⊗ₜ[R] n) = f.sum fun i m => Finsupp.single i (m ⊗ₜ[R] n)) →
      ((finsuppLeft R M N ι) (g ⊗ₜ[R] n) = g.sum fun i m => Finsupp.single i (m ⊗ₜ[R] n)) →
        (finsuppLeft R M N ι) ((f + g) ⊗ₜ[R] n) = (f + g).sum fun i m => Finsupp.single i (m ⊗ₜ[R] n)

case hsingle
R : Type u_1
inst✝⁵ : CommSemiring R
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
N : Type u_3
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
ι : Type u_4
inst✝ : DecidableEq ι
p : ι →₀ M
n : N
⊢ ∀ (a : ι) (b : M),
    (finsuppLeft R M N ι) (Finsupp.single a b ⊗ₜ[R] n) =
      (Finsupp.single a b).sum fun i m => Finsupp.single i (m ⊗ₜ[R] n)
tactic: apply p.induction_linear
Theorem: CategoryTheory.Functor.mapSquare_map_τ₃
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F : C ⥤ D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ ((fun sq => sq.map F) X✝).f₁₂ ≫ F.map φ.τ₂ = F.map φ.τ₁ ≫ ((fun sq => sq.map F) Y✝).f₁₂
state_after: no goals
tactic: simpa only [Functor.map_comp] using F.congr_map φ.comm₁₂
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F : C ⥤ D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ ((fun sq => sq.map F) X✝).f₁₃ ≫ F.map φ.τ₃ = F.map φ.τ₁ ≫ ((fun sq => sq.map F) Y✝).f₁₃
state_after: no goals
tactic: simpa only [Functor.map_comp] using F.congr_map φ.comm₁₃
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F : C ⥤ D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ ((fun sq => sq.map F) X✝).f₂₄ ≫ F.map φ.τ₄ = F.map φ.τ₂ ≫ ((fun sq => sq.map F) Y✝).f₂₄
state_after: no goals
tactic: simpa only [Functor.map_comp] using F.congr_map φ.comm₂₄
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
F : C ⥤ D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ ((fun sq => sq.map F) X✝).f₃₄ ≫ F.map φ.τ₄ = F.map φ.τ₃ ≫ ((fun sq => sq.map F) Y✝).f₃₄
state_after: no goals
tactic: simpa only [Functor.map_comp] using F.congr_map φ.comm₃₄
Theorem: MeasureTheory.ofReal_integral_norm_eq_lintegral_nnnorm
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
G : Type u_5
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
P : Type u_7
inst✝ : NormedAddCommGroup P
f : α → P
hf : Integrable f μ
⊢ ENNReal.ofReal (∫ (x : α), ‖f x‖ ∂μ) = ∫⁻ (x : α), ↑‖f x‖₊ ∂μ
state_after: no goals
tactic: rw [integral_norm_eq_lintegral_nnnorm hf.aestronglyMeasurable,
    ENNReal.ofReal_toReal (lt_top_iff_ne_top.mp hf.2)]
Theorem: IsClosed.frontier_eq
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
hs : IsClosed s
⊢ frontier s = s \ interior s
state_after: no goals
tactic: rw [frontier, hs.closure_eq]
Theorem: Complex.hasDerivAt_Gamma_nat
File: Mathlib/NumberTheory/Harmonic/GammaDeriv.lean

Proof steps:
state_before: n : ℕ
⊢ HasDerivAt Gamma (↑n ! * (-↑γ + ↑(harmonic n))) (↑n + 1)
state_after: no goals
tactic: exact_mod_cast HasDerivAt.complex_of_real
    (by exact_mod_cast differentiable_at_Gamma_nat_add_one n)
    (Real.hasDerivAt_Gamma_nat n) Gamma_ofReal
Theorem: List.next_cons_concat
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hy : x ≠ y
hx : x ∉ l
h : optParam (x ∈ y :: l ++ [x]) ⋯
⊢ (y :: l ++ [x]).next x h = y
state_after: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hy : x ≠ y
hx : x ∉ l
h : optParam (x ∈ y :: l ++ [x]) ⋯
⊢ (y :: l ++ [x]).get ⟨0, ⋯⟩ = y

case h
α : Type u_1
inst✝ : DecidableEq α
l : List α
x y : α
hy : x ≠ y
hx : x ∉ l
h : optParam (x ∈ y :: l ++ [x]) ⋯
⊢ x ∉ y :: l
tactic: rw [next, nextOr_concat]
Theorem: Set.preimage_iInter
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : ι → Set β
⊢ f ⁻¹' ⋂ i, s i = ⋂ i, f ⁻¹' s i
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : ι → Set β
x✝ : α
⊢ x✝ ∈ f ⁻¹' ⋂ i, s i ↔ x✝ ∈ ⋂ i, f ⁻¹' s i
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : ι → Set β
x✝ : α
⊢ x✝ ∈ f ⁻¹' ⋂ i, s i ↔ x✝ ∈ ⋂ i, f ⁻¹' s i
state_after: no goals
tactic: simp
Theorem: Ordinal.mod_one
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
⊢ a % 1 = 0
state_after: no goals
tactic: simp only [mod_def, div_one, one_mul, sub_self]
Theorem: Set.indicator_ae_eq_zero
File: Mathlib/MeasureTheory/OuterMeasure/AE.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : FunLike F (Set α) ℝ≥0∞
inst✝¹ : OuterMeasureClass F α
μ : F
s✝ t : Set α
M : Type u_4
inst✝ : One M
f : α → M
s : Set α
⊢ s.mulIndicator f =ᶠ[ae μ] 1 ↔ μ (s ∩ Function.mulSupport f) = 0
state_after: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : FunLike F (Set α) ℝ≥0∞
inst✝¹ : OuterMeasureClass F α
μ : F
s✝ t : Set α
M : Type u_4
inst✝ : One M
f : α → M
s : Set α
⊢ μ {a | a ∈ s ∧ ¬f a = 1} = 0 ↔ μ (s ∩ Function.mulSupport f) = 0
tactic: simp [EventuallyEq, eventually_iff, ae, compl_setOf]
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : FunLike F (Set α) ℝ≥0∞
inst✝¹ : OuterMeasureClass F α
μ : F
s✝ t : Set α
M : Type u_4
inst✝ : One M
f : α → M
s : Set α
⊢ μ {a | a ∈ s ∧ ¬f a = 1} = 0 ↔ μ (s ∩ Function.mulSupport f) = 0
state_after: no goals
tactic: rfl
Theorem: Set.preimage_add
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 α
hm : Injective ⇑m
s t : Set β
hs : s ⊆ range ⇑m
ht : t ⊆ range ⇑m
⊢ ⇑m '' (⇑m ⁻¹' (s * t)) = ⇑m '' (⇑m ⁻¹' s * ⇑m ⁻¹' t)
state_after: no goals
tactic: rw [image_mul, image_preimage_eq_iff.2 hs, image_preimage_eq_iff.2 ht,
      image_preimage_eq_iff.2 (mul_subset_range m hs ht)]
Theorem: pi_generateFrom_eq
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π✝ : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π✝ i)
f : X → (i : ι) → π✝ i
π : ι → Type u_8
g : (a : ι) → Set (Set (π a))
⊢ Pi.topologicalSpace = generateFrom {t | ∃ s i, (∀ a ∈ i, s a ∈ g a) ∧ t = (↑i).pi s}
state_after: case refine_1
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π✝ : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π✝ i)
f : X → (i : ι) → π✝ i
π : ι → Type u_8
g : (a : ι) → Set (Set (π a))
⊢ Pi.topologicalSpace ≤ generateFrom {t | ∃ s i, (∀ a ∈ i, s a ∈ g a) ∧ t = (↑i).pi s}

case refine_2
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π✝ : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π✝ i)
f : X → (i : ι) → π✝ i
π : ι → Type u_8
g : (a : ι) → Set (Set (π a))
⊢ generateFrom {t | ∃ s i, (∀ a ∈ i, s a ∈ g a) ∧ t = (↑i).pi s} ≤ Pi.topologicalSpace
tactic: refine le_antisymm ?_ ?_
Theorem: Equiv.Perm.decomposeFin_symm_apply_one
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
e : Perm (Fin (n + 1))
p : Fin (n + 2)
⊢ (decomposeFin.symm (p, e)) 1 = (swap 0 p) (e 0).succ
state_after: no goals
tactic: rw [← Fin.succ_zero_eq_one, Equiv.Perm.decomposeFin_symm_apply_succ e p 0]
Theorem: PadicSeq.lift_index_right
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v2 : ℕ
⊢ padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑f (max v1 (max v2 (stationaryPoint hf))))
state_after: case a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v2 : ℕ
⊢ stationaryPoint hf ≤ max v1 (max v2 (stationaryPoint hf))

case a
p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
v1 v2 : ℕ
⊢ stationaryPoint hf ≤ stationaryPoint hf
tactic: apply stationaryPoint_spec hf
Theorem: HahnModule.single_zero_smul_coeff
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

Proof steps:
state_before: Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁹ : PartialOrder Γ✝
inst✝⁸ : PartialOrder Γ'
inst✝⁷ : VAdd Γ✝ Γ'
inst✝⁶ : IsOrderedCancelVAdd Γ✝ Γ'
inst✝⁵ : AddCommMonoid V
Γ : Type u_5
inst✝⁴ : OrderedAddCommMonoid Γ
inst✝³ : AddAction Γ Γ'
inst✝² : IsOrderedCancelVAdd Γ Γ'
inst✝¹ : MulZeroClass R
inst✝ : SMulWithZero R V
r : R
x : HahnModule Γ' R V
a : Γ'
⊢ ((of R).symm ((HahnSeries.single 0) r • x)).coeff a = r • ((of R).symm x).coeff a
state_after: Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁹ : PartialOrder Γ✝
inst✝⁸ : PartialOrder Γ'
inst✝⁷ : VAdd Γ✝ Γ'
inst✝⁶ : IsOrderedCancelVAdd Γ✝ Γ'
inst✝⁵ : AddCommMonoid V
Γ : Type u_5
inst✝⁴ : OrderedAddCommMonoid Γ
inst✝³ : AddAction Γ Γ'
inst✝² : IsOrderedCancelVAdd Γ Γ'
inst✝¹ : MulZeroClass R
inst✝ : SMulWithZero R V
r : R
x : HahnModule Γ' R V
a : Γ'
⊢ ((of R).symm ((HahnSeries.single 0) r • x)).coeff (0 +ᵥ a) = r • ((of R).symm x).coeff a
tactic: nth_rw 1 [← zero_vadd Γ a]
state_before: Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁹ : PartialOrder Γ✝
inst✝⁸ : PartialOrder Γ'
inst✝⁷ : VAdd Γ✝ Γ'
inst✝⁶ : IsOrderedCancelVAdd Γ✝ Γ'
inst✝⁵ : AddCommMonoid V
Γ : Type u_5
inst✝⁴ : OrderedAddCommMonoid Γ
inst✝³ : AddAction Γ Γ'
inst✝² : IsOrderedCancelVAdd Γ Γ'
inst✝¹ : MulZeroClass R
inst✝ : SMulWithZero R V
r : R
x : HahnModule Γ' R V
a : Γ'
⊢ ((of R).symm ((HahnSeries.single 0) r • x)).coeff (0 +ᵥ a) = r • ((of R).symm x).coeff a
state_after: no goals
tactic: exact single_smul_coeff_add
Theorem: TopCat.piIsoPi_inv_π
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
ι : Type v
α : ι → TopCat
i : ι
⊢ (piIsoPi α).inv ≫ Pi.π α i = piπ α i
state_after: no goals
tactic: simp [piIsoPi]
Theorem: Real.Angle.two_nsmul_eq_pi_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ 2 • θ = ↑π ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
state_after: θ : Angle
h : ↑π = ↑(2 • (π / 2))
⊢ 2 • θ = ↑π ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
tactic: have h : (π : Angle) = ((2 : ℕ) • (π / 2 : ℝ):) := by rw [two_nsmul, add_halves]
state_before: θ : Angle
h : ↑π = ↑(2 • (π / 2))
⊢ 2 • θ = ↑π ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
state_after: θ : Angle
h : ↑π = ↑(2 • (π / 2))
⊢ 2 • θ = ↑(2 • (π / 2)) ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
tactic: nth_rw 1 [h]
state_before: θ : Angle
h : ↑π = ↑(2 • (π / 2))
⊢ 2 • θ = ↑(2 • (π / 2)) ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
state_after: θ : Angle
h : ↑π = ↑(2 • (π / 2))
⊢ θ = ↑(π / 2) ∨ θ = ↑(π / 2) + ↑π ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
tactic: rw [coe_nsmul, two_nsmul_eq_iff]
state_before: θ : Angle
h : ↑π = ↑(2 • (π / 2))
⊢ θ = ↑(π / 2) ∨ θ = ↑(π / 2) + ↑π ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
state_after: case h.e'_2.h.e'_2.h.e'_3
θ : Angle
h : ↑π = ↑(2 • (π / 2))
⊢ ↑(-π / 2) = ↑(π / 2) + ↑π
tactic: convert Iff.rfl
state_before: case h.e'_2.h.e'_2.h.e'_3
θ : Angle
h : ↑π = ↑(2 • (π / 2))
⊢ ↑(-π / 2) = ↑(π / 2) + ↑π
state_after: no goals
tactic: rw [add_comm, ← coe_add, ← sub_eq_zero, ← coe_sub, neg_div, ← neg_sub, sub_neg_eq_add, add_assoc,
    add_halves, ← two_mul, coe_neg, coe_two_pi, neg_zero]
Theorem: ZNum.mul_to_int
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : ZNum
⊢ ↑(0 * a) = ↑0 * ↑a
state_after: no goals
tactic: cases a <;> exact (zero_mul _).symm
state_before: α : Type u_1
b : ZNum
⊢ ↑(b * 0) = ↑b * ↑0
state_after: no goals
tactic: cases b <;> exact (mul_zero _).symm
state_before: α : Type u_1
a b : PosNum
⊢ -↑(a * b) = ↑a * -↑b
state_after: no goals
tactic: rw [PosNum.cast_mul, neg_mul_eq_mul_neg]
state_before: α : Type u_1
a b : PosNum
⊢ -↑(a * b) = -↑a * ↑b
state_after: no goals
tactic: rw [PosNum.cast_mul, neg_mul_eq_neg_mul]
state_before: α : Type u_1
a b : PosNum
⊢ ↑(a * b) = -↑a * -↑b
state_after: no goals
tactic: rw [PosNum.cast_mul, neg_mul_neg]