ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: WeierstrassCurve.Affine.nonsingular_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
⊢ W.Nonsingular 0 0 ↔ W.a₆ = 0 ∧ (W.a₃ ≠ 0 ∨ W.a₄ ≠ 0)
state_after: no goals
tactic: rw [Nonsingular, equation_zero, evalEval_polynomialX_zero, neg_ne_zero, evalEval_polynomialY_zero,
    or_comm]
Theorem: MeasureTheory.Measure.setLIntegral_condKernel_univ_left
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
t : Set Ω
ht : MeasurableSet t
⊢ ∫⁻ (b : β), ∫⁻ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω) in Set.univ ×ˢ t, f x ∂ρ
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
t : Set Ω
ht : MeasurableSet t
⊢ ∫⁻ (b : β), ∫⁻ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst =
    ∫⁻ (b : β) in Set.univ, ∫⁻ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst
tactic: rw [← setLIntegral_condKernel hf MeasurableSet.univ ht]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
t : Set Ω
ht : MeasurableSet t
⊢ ∫⁻ (b : β), ∫⁻ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst =
    ∫⁻ (b : β) in Set.univ, ∫⁻ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst
state_after: no goals
tactic: simp_rw [Measure.restrict_univ]
Theorem: LieIdeal.comap_bracket_le
File: Mathlib/Algebra/Lie/IdealOperations.lean

Proof steps:
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J J₁ J₂ : LieIdeal R L'
⊢ ⁅comap f J₁, comap f J₂⁆ ≤ comap f ⁅J₁, J₂⁆
state_after: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J J₁ J₂ : LieIdeal R L'
⊢ map f ⁅comap f J₁, comap f J₂⁆ ≤ ⁅J₁, J₂⁆
tactic: rw [← map_le_iff_le_comap]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J J₁ J₂ : LieIdeal R L'
⊢ map f ⁅comap f J₁, comap f J₂⁆ ≤ ⁅J₁, J₂⁆
state_after: no goals
tactic: exact le_trans (map_bracket_le f) (LieSubmodule.mono_lie map_comap_le map_comap_le)
Theorem: padicNormE.norm_p_lt_one
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ‖↑p‖ < 1
state_after: p : ℕ
hp : Fact (Nat.Prime p)
⊢ (↑p)⁻¹ < 1
tactic: rw [norm_p]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ (↑p)⁻¹ < 1
state_after: case ha
p : ℕ
hp : Fact (Nat.Prime p)
⊢ 1 < ↑p
tactic: apply inv_lt_one
state_before: case ha
p : ℕ
hp : Fact (Nat.Prime p)
⊢ 1 < ↑p
state_after: no goals
tactic: exact mod_cast hp.1.one_lt
Theorem: Int.neg_modEq_neg
File: Mathlib/Data/Int/ModEq.lean

Proof steps:
state_before: m n a b c d : ℤ
⊢ -a ≡ -b [ZMOD n] ↔ a ≡ b [ZMOD n]
state_after: no goals
tactic: simp [-sub_neg_eq_add, neg_sub_neg, modEq_iff_dvd, dvd_sub_comm]
Theorem: Real.deriv_mul_log
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

Proof steps:
state_before: x : ℝ
hx : x ≠ 0
⊢ deriv (fun x => x * log x) x = log x + 1
state_after: x : ℝ
hx : x ≠ 0
⊢ deriv (fun x => x) x * log x + x * deriv log x = log x + 1
tactic: rw [deriv_mul differentiableAt_id' (differentiableAt_log hx)]
state_before: x : ℝ
hx : x ≠ 0
⊢ deriv (fun x => x) x * log x + x * deriv log x = log x + 1
state_after: x : ℝ
hx : x ≠ 0
⊢ x * x⁻¹ = 1
tactic: simp only [deriv_id'', one_mul, deriv_log', ne_eq, add_right_inj]
state_before: x : ℝ
hx : x ≠ 0
⊢ x * x⁻¹ = 1
state_after: no goals
tactic: exact mul_inv_cancel hx
Theorem: Polynomial.toLaurent_C_mul_X_pow
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
r : R
⊢ toLaurent (Polynomial.C r * X ^ n) = C r * T ↑n
state_after: no goals
tactic: simp only [_root_.map_mul, Polynomial.toLaurent_C, Polynomial.toLaurent_X_pow]
Theorem: mellin_comp_mul_left
File: Mathlib/Analysis/MellinTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s : ℂ
a : ℝ
ha : 0 < a
⊢ mellin (fun t => f (a * t)) s = ↑a ^ (-s) • mellin f s
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s : ℂ
a : ℝ
ha : 0 < a
⊢ ∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) • f (a * t) = ↑a ^ (-s) • ∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) • f t
tactic: simp_rw [mellin]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s : ℂ
a : ℝ
ha : 0 < a
⊢ ∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) • f (a * t) = ↑a ^ (-s) • ∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) • f t
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s : ℂ
a : ℝ
ha : 0 < a
this : EqOn (fun t => ↑t ^ (s - 1) • f (a * t)) (fun t => ↑a ^ (1 - s) • (fun u => ↑u ^ (s - 1) • f u) (a * t)) (Ioi 0)
⊢ ∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) • f (a * t) = ↑a ^ (-s) • ∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) • f t
tactic: have : EqOn (fun t : ℝ => (t : ℂ) ^ (s - 1) • f (a * t))
      (fun t : ℝ => (a : ℂ) ^ (1 - s) • (fun u : ℝ => (u : ℂ) ^ (s - 1) • f u) (a * t))
        (Ioi 0) := fun t ht ↦ by
    dsimp only
    rw [ofReal_mul, mul_cpow_ofReal_nonneg ha.le (le_of_lt ht), ← mul_smul,
      (by ring : 1 - s = -(s - 1)), cpow_neg, inv_mul_cancel_left₀]
    rw [Ne, cpow_eq_zero_iff, ofReal_eq_zero, not_and_or]
    exact Or.inl ha.ne'
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s : ℂ
a : ℝ
ha : 0 < a
this : EqOn (fun t => ↑t ^ (s - 1) • f (a * t)) (fun t => ↑a ^ (1 - s) • (fun u => ↑u ^ (s - 1) • f u) (a * t)) (Ioi 0)
⊢ ∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) • f (a * t) = ↑a ^ (-s) • ∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) • f t
state_after: no goals
tactic: rw [setIntegral_congr measurableSet_Ioi this, integral_smul,
    integral_comp_mul_left_Ioi (fun u ↦ (u : ℂ) ^ (s - 1) • f u) _ ha,
    mul_zero, ← Complex.coe_smul, ← mul_smul, sub_eq_add_neg,
    cpow_add _ _ (ofReal_ne_zero.mpr ha.ne'), cpow_one, ofReal_inv,
    mul_assoc, mul_comm, inv_mul_cancel_right₀ (ofReal_ne_zero.mpr ha.ne')]
Theorem: Fin.castpred_succ_le_iff
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
a b : Fin (n + 1)
ha : a.succ ≠ last (n + 1)
⊢ a.succ.castPred ha ≤ b ↔ a < b
state_after: no goals
tactic: rw [castPred_le_iff, succ_le_castSucc_iff]
Theorem: DenseInducing.comap_nhds_neBot
File: Mathlib/Topology/DenseEmbedding.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
inst✝ : TopologicalSpace δ
f : γ → α
g : γ → δ
h : δ → β
di : DenseInducing i
b : β
s : Set β
hs : s ∈ 𝓝 b
⊢ ∃ a, i a ∈ s
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
inst✝ : TopologicalSpace δ
f : γ → α
g : γ → δ
h : δ → β
di : DenseInducing i
b : β
s : Set β
hs : s ∈ 𝓝 b
a : α
ha : i a ∈ s
⊢ ∃ a, i a ∈ s
tactic: rcases mem_closure_iff_nhds.1 (di.dense b) s hs with ⟨_, ⟨ha, a, rfl⟩⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
inst✝ : TopologicalSpace δ
f : γ → α
g : γ → δ
h : δ → β
di : DenseInducing i
b : β
s : Set β
hs : s ∈ 𝓝 b
a : α
ha : i a ∈ s
⊢ ∃ a, i a ∈ s
state_after: no goals
tactic: exact ⟨a, ha⟩
Theorem: List.pairwise_lt_finRange
File: Mathlib/Data/List/Range.lean

Proof steps:
state_before: α : Type u
n : ℕ
⊢ ∀ x ∈ range n, x < n
state_after: no goals
tactic: simp
state_before: α : Type u
n : ℕ
⊢ ∀ ⦃x : ℕ⦄ (hx : x < n) ⦃y : ℕ⦄ (hy : y < n), x < y → ⟨x, hx⟩ < ⟨y, hy⟩
state_after: no goals
tactic: simp
Theorem: Set.toFinset_iUnion
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝² : Fintype β
inst✝¹ : DecidableEq α
f : β → Set α
inst✝ : (w : β) → Fintype ↑(f w)
⊢ (⋃ x, f x).toFinset = Finset.univ.biUnion fun x => (f x).toFinset
state_after: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝² : Fintype β
inst✝¹ : DecidableEq α
f : β → Set α
inst✝ : (w : β) → Fintype ↑(f w)
v : α
⊢ v ∈ (⋃ x, f x).toFinset ↔ v ∈ Finset.univ.biUnion fun x => (f x).toFinset
tactic: ext v
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝² : Fintype β
inst✝¹ : DecidableEq α
f : β → Set α
inst✝ : (w : β) → Fintype ↑(f w)
v : α
⊢ v ∈ (⋃ x, f x).toFinset ↔ v ∈ Finset.univ.biUnion fun x => (f x).toFinset
state_after: no goals
tactic: simp only [mem_toFinset, mem_iUnion, Finset.mem_biUnion, Finset.mem_univ, true_and]
Theorem: WeierstrassCurve.Affine.CoordinateRing.XClass_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
W : Affine R
f : R →+* S
inst✝ : Nontrivial R
x : R
⊢ (C (X - C x)).natDegree < W.polynomial.natDegree
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
W : Affine R
f : R →+* S
inst✝ : Nontrivial R
x : R
⊢ 0 < 2
tactic: rw [natDegree_polynomial, natDegree_C]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
W : Affine R
f : R →+* S
inst✝ : Nontrivial R
x : R
⊢ 0 < 2
state_after: no goals
tactic: norm_num1
Theorem: MDifferentiableWithinAt.mfderivWithin
File: Mathlib/Geometry/Manifold/MFDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedSpace 𝕜 E
H : Type u_3
inst✝¹² : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝¹¹ : TopologicalSpace M
inst✝¹⁰ : ChartedSpace H M
E' : Type u_5
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝⁷ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : ChartedSpace H' M'
E'' : Type u_8
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : NormedSpace 𝕜 E''
H'' : Type u_9
inst✝² : TopologicalSpace H''
I'' : ModelWithCorners 𝕜 E'' H''
M'' : Type u_10
inst✝¹ : TopologicalSpace M''
inst✝ : ChartedSpace H'' M''
f f₀ f₁ : M → M'
x : M
s t : Set M
g : M' → M''
u : Set M'
Is : SmoothManifoldWithCorners I M
I's : SmoothManifoldWithCorners I' M'
I''s : SmoothManifoldWithCorners I'' M''
f' f₀' f₁' : TangentSpace I x →L[𝕜] TangentSpace I' (f x)
g' : TangentSpace I' (f x) →L[𝕜] TangentSpace I'' (g (f x))
h : MDifferentiableWithinAt I I' f s x
⊢ mfderivWithin I I' f s x =
    fderivWithin 𝕜 (writtenInExtChartAt I I' x f) (↑(extChartAt I x).symm ⁻¹' s ∩ range ↑I) (↑(extChartAt I x) x)
state_after: no goals
tactic: simp only [mfderivWithin, h, if_pos]
Theorem: IsUnifLocDoublingMeasure.ae_tendsto_measure_inter_div
File: Mathlib/MeasureTheory/Covering/DensityTheorem.lean

Proof steps:
state_before: α : Type u_1
inst✝⁶ : MetricSpace α
inst✝⁵ : MeasurableSpace α
μ : Measure α
inst✝⁴ : IsUnifLocDoublingMeasure μ
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
E : Type u_2
inst✝ : NormedAddCommGroup E
S : Set α
K : ℝ
⊢ ∀ᵐ (x : α) ∂μ.restrict S,
    ∀ {ι : Type u_3} {l : Filter ι} (w : ι → α) (δ : ι → ℝ),
      Tendsto δ l (𝓝[>] 0) →
        (∀ᶠ (j : ι) in l, x ∈ closedBall (w j) (K * δ j)) →
          Tendsto (fun j => μ (S ∩ closedBall (w j) (δ j)) / μ (closedBall (w j) (δ j))) l (𝓝 1)
state_after: no goals
tactic: filter_upwards [(vitaliFamily μ K).ae_tendsto_measure_inter_div S] with x hx ι l w δ δlim
    xmem using hx.comp (tendsto_closedBall_filterAt μ _ _ δlim xmem)
Theorem: Order.PFilter.principal_le_principal_iff
File: Mathlib/Order/PFilter.lean

Proof steps:
state_before: P : Type u_1
inst✝ : Preorder P
x y : P
F s t : PFilter P
p q : P
⊢ principal q ≤ principal p ↔ p ≤ q
state_after: no goals
tactic: simp
Theorem: StarAlgEquiv.symm_symm
File: Mathlib/Algebra/Star/StarAlgHom.lean

Proof steps:
state_before: F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
C : Type u_5
inst✝¹¹ : Add A
inst✝¹⁰ : Add B
inst✝⁹ : Mul A
inst✝⁸ : Mul B
inst✝⁷ : SMul R A
inst✝⁶ : SMul R B
inst✝⁵ : Star A
inst✝⁴ : Star B
inst✝³ : Add C
inst✝² : Mul C
inst✝¹ : SMul R C
inst✝ : Star C
e : A ≃⋆ₐ[R] B
⊢ e.symm.symm = e
state_after: case h
F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
C : Type u_5
inst✝¹¹ : Add A
inst✝¹⁰ : Add B
inst✝⁹ : Mul A
inst✝⁸ : Mul B
inst✝⁷ : SMul R A
inst✝⁶ : SMul R B
inst✝⁵ : Star A
inst✝⁴ : Star B
inst✝³ : Add C
inst✝² : Mul C
inst✝¹ : SMul R C
inst✝ : Star C
e : A ≃⋆ₐ[R] B
a✝ : A
⊢ e.symm.symm a✝ = e a✝
tactic: ext
state_before: case h
F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
C : Type u_5
inst✝¹¹ : Add A
inst✝¹⁰ : Add B
inst✝⁹ : Mul A
inst✝⁸ : Mul B
inst✝⁷ : SMul R A
inst✝⁶ : SMul R B
inst✝⁵ : Star A
inst✝⁴ : Star B
inst✝³ : Add C
inst✝² : Mul C
inst✝¹ : SMul R C
inst✝ : Star C
e : A ≃⋆ₐ[R] B
a✝ : A
⊢ e.symm.symm a✝ = e a✝
state_after: no goals
tactic: rfl
Theorem: Batteries.HashMap.Imp.expand_WF.foldl
File: .lake/packages/batteries/Batteries/Data/HashMap/WF.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : BEq α
inst✝ : Hashable α
rank : α → Nat
l : List (α × β)
i : Nat
hl₁ : ∀ [inst : PartialEquivBEq α] [inst : LawfulHashable α], List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) l
hl₂ : ∀ (x : α × β), x ∈ l → rank x.fst = i
target : Buckets α β
ht₁ : target.WF
ht₂ :
  ∀ (bucket : AssocList α β),
    bucket ∈ target.val.data →
      AssocList.All
        (fun k x =>
          rank k ≤ i ∧ ∀ [inst : PartialEquivBEq α] [inst : LawfulHashable α] (x : α × β), x ∈ l → ¬(x.fst == k) = true)
        bucket
⊢ (List.foldl (fun d x => reinsertAux d x.fst x.snd) target l).WF ∧
    ∀ (bucket : AssocList α β),
      bucket ∈ (List.foldl (fun d x => reinsertAux d x.fst x.snd) target l).val.data →
        AssocList.All (fun k x => rank k ≤ i) bucket
state_after: no goals
tactic: induction l generalizing target with
  | nil => exact ⟨ht₁, fun _ h₁ _ h₂ => (ht₂ _ h₁ _ h₂).1⟩
  | cons _ _ ih =>
    simp only [List.pairwise_cons, List.mem_cons, forall_eq_or_imp] at hl₁ hl₂ ht₂
    refine ih hl₁.2 hl₂.2
      (reinsertAux_WF ht₁ fun _ h => (ht₂ _ (Array.getElem_mem_data ..) _ h).2.1)
      (fun _ h => ?_)
    simp only [reinsertAux, Buckets.update, Array.uset, Array.data_length,
      Array.ugetElem_eq_getElem, Array.data_set] at h
    match List.mem_or_eq_of_mem_set h with
    | .inl h =>
      intro _ hf
      have ⟨h₁, h₂⟩ := ht₂ _ h _ hf
      exact ⟨h₁, h₂.2⟩
    | .inr h => subst h; intro
      | _, .head .. =>
        exact ⟨hl₂.1 ▸ Nat.le_refl _, fun _ h h' => hl₁.1 _ h (PartialEquivBEq.symm h')⟩
      | _, .tail _ h =>
        have ⟨h₁, h₂⟩ := ht₂ _ (Array.getElem_mem_data ..) _ h
        exact ⟨h₁, h₂.2⟩
Theorem: Polynomial.Chebyshev.U_complex_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
n : ℤ
⊢ eval (cos θ) (U ℂ n) * sin θ = sin ((↑n + 1) * θ)
state_after: no goals
tactic: induction n using Polynomial.Chebyshev.induct with
  | zero => simp
  | one => simp [one_add_one_eq_two, sin_two_mul]; ring
  | add_two n ih1 ih2 =>
    simp only [U_add_two, add_sub_cancel_right, eval_sub, eval_mul, eval_X, eval_ofNat, sub_mul,
      mul_assoc, ih1, ih2, sub_eq_iff_eq_add, sin_add_sin]
    push_cast
    ring_nf
  | neg_add_one n ih1 ih2 =>
    simp only [U_sub_one, add_sub_cancel_right, eval_sub, eval_mul, eval_X, eval_ofNat, sub_mul,
      mul_assoc, ih1, ih2, sub_eq_iff_eq_add', sin_add_sin]
    push_cast
    ring_nf
Theorem: SimpleGraph.edgeSet_sdiff
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
⊢ (G₁ \ G₂).edgeSet = G₁.edgeSet \ G₂.edgeSet
state_after: case h.mk.mk
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
x✝ : Sym2 V
x y : V
⊢ Quot.mk (Sym2.Rel V) (x, y) ∈ (G₁ \ G₂).edgeSet ↔ Quot.mk (Sym2.Rel V) (x, y) ∈ G₁.edgeSet \ G₂.edgeSet
tactic: ext ⟨x, y⟩
state_before: case h.mk.mk
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
x✝ : Sym2 V
x y : V
⊢ Quot.mk (Sym2.Rel V) (x, y) ∈ (G₁ \ G₂).edgeSet ↔ Quot.mk (Sym2.Rel V) (x, y) ∈ G₁.edgeSet \ G₂.edgeSet
state_after: no goals
tactic: rfl
Theorem: Nat.Partrec'.comp'
File: Mathlib/Computability/Halting.lean

Proof steps:
state_before: n m : ℕ
f : Vector ℕ m →. ℕ
g : Vector ℕ n → Vector ℕ m
hf : Partrec' f
hg : Vec g
v : Vector ℕ n
⊢ (mOfFn fun i => ↑(some ((g v).get i))) >>= f = f (g v)
state_after: no goals
tactic: simp
Theorem: round_add_int
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
y : ℤ
⊢ round (x + ↑y) = round x + y
state_after: no goals
tactic: rw [round, round, Int.fract_add_int, Int.floor_add_int, Int.ceil_add_int, ← apply_ite₂, ite_self]
Theorem: ENNReal.mul_sub
File: Mathlib/Data/ENNReal/Operations.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < c → c < b → a ≠ ⊤
⊢ a * (b - c) = a * b - a * c
state_after: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < c → c < b → a ≠ ⊤
⊢ (b - c) * a = b * a - c * a
tactic: simp only [mul_comm a]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < c → c < b → a ≠ ⊤
⊢ (b - c) * a = b * a - c * a
state_after: no goals
tactic: exact sub_mul h
Theorem: Fin.rev_predAbove
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n✝ m n : ℕ
p : Fin n
i : Fin (n + 1)
⊢ (p.predAbove i).rev = p.rev.predAbove i.rev
state_after: no goals
tactic: rw [predAbove_rev_left, rev_rev]
Theorem: OrderIso.bddAbove_preimage
File: Mathlib/Order/GaloisConnection.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
s : Set β
⊢ BddAbove (⇑e ⁻¹' s) ↔ BddAbove s
state_after: no goals
tactic: rw [← e.bddAbove_image, e.image_preimage]
Theorem: Set.covBy_iff_exists_sdiff_singleton
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
a : α
⊢ (∃ a ∈ t, t \ {a} = s) → s ⋖ t
state_after: case intro.intro
α : Type u_1
β : Type u_2
t : Set α
a✝ a : α
ha : a ∈ t
⊢ t \ {a} ⋖ t
tactic: rintro ⟨a, ha, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
t : Set α
a✝ a : α
ha : a ∈ t
⊢ t \ {a} ⋖ t
state_after: no goals
tactic: exact sdiff_singleton_covBy ha
Theorem: Finset.insert_val_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
h : a ∉ s
⊢ (insert a s).val = a ::ₘ s.val
state_after: no goals
tactic: rw [insert_val, ndinsert_of_not_mem h]
Theorem: List.IsInfix.filter
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l₁ l₂ : List α
h : l₁ <:+: l₂
⊢ List.filter p l₁ <:+: List.filter p l₂
state_after: case intro.intro
α : Type u_1
p : α → Bool
l₁ xs ys : List α
⊢ List.filter p l₁ <:+: List.filter p (xs ++ l₁ ++ ys)
tactic: obtain ⟨xs, ys, rfl⟩ := h
state_before: case intro.intro
α : Type u_1
p : α → Bool
l₁ xs ys : List α
⊢ List.filter p l₁ <:+: List.filter p (xs ++ l₁ ++ ys)
state_after: case intro.intro
α : Type u_1
p : α → Bool
l₁ xs ys : List α
⊢ List.filter p l₁ <:+: List.filter p xs ++ List.filter p l₁ ++ List.filter p ys
tactic: rw [filter_append, filter_append]
state_before: case intro.intro
α : Type u_1
p : α → Bool
l₁ xs ys : List α
⊢ List.filter p l₁ <:+: List.filter p xs ++ List.filter p l₁ ++ List.filter p ys
state_after: no goals
tactic: apply infix_append _
Theorem: CategoryTheory.Pretriangulated.comp_distTriang_mor_zero₃₁
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
H : T ∈ distinguishedTriangles
⊢ T.mor₃ ≫ (shiftFunctor C 1).map T.mor₁ = 0
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
H : T ∈ distinguishedTriangles
H₂ : T.rotate.rotate ∈ distinguishedTriangles
⊢ T.mor₃ ≫ (shiftFunctor C 1).map T.mor₁ = 0
tactic: have H₂ := rot_of_distTriang T.rotate (rot_of_distTriang T H)
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
H : T ∈ distinguishedTriangles
H₂ : T.rotate.rotate ∈ distinguishedTriangles
⊢ T.mor₃ ≫ (shiftFunctor C 1).map T.mor₁ = 0
state_after: no goals
tactic: simpa using comp_distTriang_mor_zero₁₂ T.rotate.rotate H₂
Theorem: Set.Nonempty.subset_preimage_const
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s✝ t✝ s : Set α
hs : s.Nonempty
t : Set β
a : β
⊢ s ⊆ (fun x => a) ⁻¹' t ↔ a ∈ t
state_after: no goals
tactic: rw [← image_subset_iff, hs.image_const, singleton_subset_iff]