ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PowerSeries.rescale_injective
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
⊢ Function.Injective ⇑(rescale a)
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
h : (rescale a) p = (rescale a) q
⊢ p = q
tactic: intro p q h
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
h : (rescale a) p = (rescale a) q
⊢ p = q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) ((rescale a) p) = (coeff R n) ((rescale a) q)
⊢ ∀ (n : ℕ), (coeff R n) p = (coeff R n) q
tactic: rw [PowerSeries.ext_iff] at *
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) ((rescale a) p) = (coeff R n) ((rescale a) q)
⊢ ∀ (n : ℕ), (coeff R n) p = (coeff R n) q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) ((rescale a) p) = (coeff R n) ((rescale a) q)
n : ℕ
⊢ (coeff R n) p = (coeff R n) q
tactic: intro n
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
h : ∀ (n : ℕ), (coeff R n) ((rescale a) p) = (coeff R n) ((rescale a) q)
n : ℕ
⊢ (coeff R n) p = (coeff R n) q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
n : ℕ
h : (coeff R n) ((rescale a) p) = (coeff R n) ((rescale a) q)
⊢ (coeff R n) p = (coeff R n) q
tactic: specialize h n
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
n : ℕ
h : (coeff R n) ((rescale a) p) = (coeff R n) ((rescale a) q)
⊢ (coeff R n) p = (coeff R n) q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
n : ℕ
h : (coeff R n) p = (coeff R n) q ∨ a ^ n = 0
⊢ (coeff R n) p = (coeff R n) q
tactic: rw [coeff_rescale, coeff_rescale, mul_eq_mul_left_iff] at h
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
n : ℕ
h : (coeff R n) p = (coeff R n) q ∨ a ^ n = 0
⊢ (coeff R n) p = (coeff R n) q
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
n : ℕ
h : (coeff R n) p = (coeff R n) q ∨ a ^ n = 0
⊢ ¬a ^ n = 0
tactic: apply h.resolve_right
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
n : ℕ
h : (coeff R n) p = (coeff R n) q ∨ a ^ n = 0
⊢ ¬a ^ n = 0
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
n : ℕ
h : (coeff R n) p = (coeff R n) q ∨ a ^ n = 0
h' : a ^ n = 0
⊢ False
tactic: intro h'
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
a : R
ha : a ≠ 0
p q : R⟦X⟧
n : ℕ
h : (coeff R n) p = (coeff R n) q ∨ a ^ n = 0
h' : a ^ n = 0
⊢ False
state_after: no goals
tactic: exact ha (pow_eq_zero h')
Theorem: exists_birkhoff_representation
File: Mathlib/Order/Birkhoff.lean

Proof steps:
state_before: α✝ : Type u_1
inst✝⁵ : DistribLattice α✝
inst✝⁴ : OrderBot α✝
inst✝³ : Fintype α✝
inst✝² : DecidablePred SupIrred
α : Type u
inst✝¹ : Finite α
inst✝ : DistribLattice α
⊢ ∃ β x x_1 f, Injective ⇑f
state_after: no goals
tactic: classical
  cases nonempty_fintype α
  exact ⟨{a : α // SupIrred a}, _, inferInstance, _, LatticeHom.birkhoffFinset_injective⟩
Theorem: Fin.insertNth_one_right
File: Mathlib/Algebra/Group/Fin/Tuple.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u_1
inst✝ : (j : Fin (n + 1)) → One (α j)
i : Fin (n + 1)
x : α i
⊢ x = Pi.mulSingle i x i ∧ 1 = i.removeNth (Pi.mulSingle i x)
state_after: m n : ℕ
α : Fin (n + 1) → Type u_1
inst✝ : (j : Fin (n + 1)) → One (α j)
i : Fin (n + 1)
x : α i
⊢ x = Pi.mulSingle i x i ∧ 1 = fun i_1 => Pi.mulSingle i x (i.succAbove i_1)
tactic: unfold removeNth
state_before: m n : ℕ
α : Fin (n + 1) → Type u_1
inst✝ : (j : Fin (n + 1)) → One (α j)
i : Fin (n + 1)
x : α i
⊢ x = Pi.mulSingle i x i ∧ 1 = fun i_1 => Pi.mulSingle i x (i.succAbove i_1)
state_after: no goals
tactic: simp [succAbove_ne, Pi.one_def]
Theorem: Multiset.measurable_prod'
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

Proof steps:
state_before: α✝ : Type u_1
M : Type u_2
ι : Type u_3
α : Type u_4
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : ι → α → M
l : Multiset (α → M)
hl : ∀ f ∈ l, Measurable f
⊢ Measurable l.prod
state_after: case mk
α✝ : Type u_1
M : Type u_2
ι : Type u_3
α : Type u_4
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : ι → α → M
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, Measurable f
⊢ Measurable (prod (Quot.mk Setoid.r l))
tactic: rcases l with ⟨l⟩
state_before: case mk
α✝ : Type u_1
M : Type u_2
ι : Type u_3
α : Type u_4
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : ι → α → M
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, Measurable f
⊢ Measurable (prod (Quot.mk Setoid.r l))
state_after: no goals
tactic: simpa using l.measurable_prod' (by simpa using hl)
Theorem: MeasurableEquiv.map_apply_eq_iff_map_symm_apply_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ : Measure α
ν : Measure β
e : α ≃ᵐ β
⊢ Measure.map (⇑e) μ = ν ↔ Measure.map (⇑e.symm) ν = μ
state_after: no goals
tactic: rw [← (map_measurableEquiv_injective e).eq_iff, map_map_symm, eq_comm]
Theorem: EisensteinSeries.eisensteinSeries_slash_apply
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/Defs.lean

Proof steps:
state_before: N : ℕ
a : Fin 2 → ZMod N
k : ℤ
γ : SL(2, ℤ)
⊢ eisensteinSeries a k ∣[k] γ = eisensteinSeries (a ᵥ* ↑((SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ)) k
state_after: case h
N : ℕ
a : Fin 2 → ZMod N
k : ℤ
γ : SL(2, ℤ)
z : ℍ
⊢ (eisensteinSeries a k ∣[k] γ) z = eisensteinSeries (a ᵥ* ↑((SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ)) k z
tactic: ext1 z
state_before: case h
N : ℕ
a : Fin 2 → ZMod N
k : ℤ
γ : SL(2, ℤ)
z : ℍ
⊢ (eisensteinSeries a k ∣[k] γ) z = eisensteinSeries (a ᵥ* ↑((SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ)) k z
state_after: case h
N : ℕ
a : Fin 2 → ZMod N
k : ℤ
γ : SL(2, ℤ)
z : ℍ
⊢ denom (↑γ) z ^ k * ∑' (x : ↑(gammaSet N a)), eisSummand k (↑x ᵥ* ↑γ) z =
    denom (↑γ) z ^ k *
      ∑' (x : ↑(gammaSet N (a ᵥ* ↑((SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ)))), eisSummand k (↑x) z
tactic: simp_rw [SL_slash, slash_def, slash, ModularGroup.det_coe', ofReal_one, one_zpow, mul_one,
    zpow_neg, mul_inv_eq_iff_eq_mul₀ (zpow_ne_zero _ <| z.denom_ne_zero _), mul_comm,
    eisensteinSeries, ← ModularGroup.sl_moeb, eisSummand_SL2_apply, tsum_mul_left]
Theorem: FiniteDimensional.finrank_le_finrank_of_rank_le_rank
File: Mathlib/LinearAlgebra/Dimension/Finrank.lean

Proof steps:
state_before: R : Type u
M : Type v
N : Type w
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h : lift.{w, v} (Module.rank R M) ≤ lift.{v, w} (Module.rank R N)
h' : Module.rank R N < ℵ₀
⊢ finrank R M ≤ finrank R N
state_after: no goals
tactic: simpa only [toNat_lift] using toNat_le_toNat h (lift_lt_aleph0.mpr h')
Theorem: latticeClosure_univ
File: Mathlib/Order/SupClosed.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝ : Lattice α
s t : Set α
⊢ latticeClosure Set.univ = Set.univ
state_after: no goals
tactic: simp
Theorem: CategoryTheory.PrelaxFunctor.map₂_inv_hom_isIso
File: Mathlib/CategoryTheory/Bicategory/Functor/Prelax.lean

Proof steps:
state_before: B : Type u₁
inst✝³ : Bicategory B
C : Type u₂
inst✝² : Bicategory C
D : Type u₃
inst✝¹ : Bicategory D
F : PrelaxFunctor B C
a b : B
f g : a ⟶ b
η : f ⟶ g
inst✝ : IsIso η
⊢ F.map₂ (inv η) ≫ F.map₂ η = 𝟙 (F.map g)
state_after: no goals
tactic: simp
Theorem: Orientation.inner_rev_eq_zero_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ ⟪y, x⟫_ℝ = 0
state_after: no goals
tactic: rw [real_inner_comm, o.inner_eq_zero_of_oangle_eq_pi_div_two h]
Theorem: CochainComplex.toSingle₀Equiv_symm_apply_f_succ
File: Mathlib/Algebra/Homology/Single.lean

Proof steps:
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : C.X 0 ⟶ X
n : ℕ
⊢ ((C.toSingle₀Equiv X).symm f).f (n + 1) = 0
state_after: no goals
tactic: rfl
Theorem: Nat.exists_mul_emod_eq_gcd
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: k n : ℕ
hk : n.gcd k < k
⊢ ∃ m, n * m % k = n.gcd k
state_after: k n : ℕ
hk : n.gcd k < k
hk' : ↑k ≠ 0
⊢ ∃ m, n * m % k = n.gcd k
tactic: have hk' := Int.ofNat_ne_zero.2 (ne_of_gt (lt_of_le_of_lt (zero_le (gcd n k)) hk))
state_before: k n : ℕ
hk : n.gcd k < k
hk' : ↑k ≠ 0
⊢ ∃ m, n * m % k = n.gcd k
state_after: k n : ℕ
hk : n.gcd k < k
hk' : ↑k ≠ 0
key : (fun m => (m % ↑k).toNat) ↑(n.gcd k) = (fun m => (m % ↑k).toNat) (↑n * n.gcdA k + ↑k * n.gcdB k)
⊢ ∃ m, n * m % k = n.gcd k
tactic: have key := congr_arg (fun (m : ℤ) => (m % k).toNat) (gcd_eq_gcd_ab n k)
state_before: k n : ℕ
hk : n.gcd k < k
hk' : ↑k ≠ 0
key : (fun m => (m % ↑k).toNat) ↑(n.gcd k) = (fun m => (m % ↑k).toNat) (↑n * n.gcdA k + ↑k * n.gcdB k)
⊢ ∃ m, n * m % k = n.gcd k
state_after: k n : ℕ
hk : n.gcd k < k
hk' : ↑k ≠ 0
key : (↑(n.gcd k) % ↑k).toNat = ((↑n * n.gcdA k + ↑k * n.gcdB k) % ↑k).toNat
⊢ ∃ m, n * m % k = n.gcd k
tactic: simp only at key
state_before: k n : ℕ
hk : n.gcd k < k
hk' : ↑k ≠ 0
key : (↑(n.gcd k) % ↑k).toNat = ((↑n * n.gcdA k + ↑k * n.gcdB k) % ↑k).toNat
⊢ ∃ m, n * m % k = n.gcd k
state_after: k n : ℕ
hk : n.gcd k < k
hk' : ↑k ≠ 0
key : n.gcd k = (↑n * n.gcdA k % ↑k).toNat
⊢ ∃ m, n * m % k = n.gcd k
tactic: rw [Int.add_mul_emod_self_left, ← Int.natCast_mod, Int.toNat_natCast, mod_eq_of_lt hk] at key
state_before: k n : ℕ
hk : n.gcd k < k
hk' : ↑k ≠ 0
key : n.gcd k = (↑n * n.gcdA k % ↑k).toNat
⊢ ∃ m, n * m % k = n.gcd k
state_after: k n : ℕ
hk : n.gcd k < k
hk' : ↑k ≠ 0
key : n.gcd k = (↑n * n.gcdA k % ↑k).toNat
⊢ Int.ofNat (n * (n.gcdA k % ↑k).toNat % k) = Int.ofNat (↑n * n.gcdA k % ↑k).toNat
tactic: refine ⟨(n.gcdA k % k).toNat, Eq.trans (Int.ofNat.inj ?_) key.symm⟩
state_before: k n : ℕ
hk : n.gcd k < k
hk' : ↑k ≠ 0
key : n.gcd k = (↑n * n.gcdA k % ↑k).toNat
⊢ Int.ofNat (n * (n.gcdA k % ↑k).toNat % k) = Int.ofNat (↑n * n.gcdA k % ↑k).toNat
state_after: no goals
tactic: rw [Int.ofNat_eq_coe, Int.natCast_mod, Int.ofNat_mul, Int.toNat_of_nonneg (Int.emod_nonneg _ hk'),
    Int.ofNat_eq_coe, Int.toNat_of_nonneg (Int.emod_nonneg _ hk'), Int.mul_emod, Int.emod_emod,
    ← Int.mul_emod]
Theorem: CategoryTheory.Subgroupoid.mul_mem_cancel_right
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d e : C
f : c ⟶ d
g : d ⟶ e
hg : g ∈ S.arrows d e
⊢ f ≫ g ∈ S.arrows c e ↔ f ∈ S.arrows c d
state_after: case mp
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d e : C
f : c ⟶ d
g : d ⟶ e
hg : g ∈ S.arrows d e
⊢ f ≫ g ∈ S.arrows c e → f ∈ S.arrows c d

case mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d e : C
f : c ⟶ d
g : d ⟶ e
hg : g ∈ S.arrows d e
⊢ f ∈ S.arrows c d → f ≫ g ∈ S.arrows c e
tactic: constructor
Theorem: subset_sSup_emptyset
File: Mathlib/Order/CompleteLatticeIntervals.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
s : Set α
inst✝² : Preorder α
inst✝¹ : SupSet α
inst✝ : Inhabited ↑s
⊢ sSup ∅ = default
state_after: no goals
tactic: simp [sSup]
Theorem: HasDerivAt.smul
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasDerivAt c c' x
hf : HasDerivAt f f' x
⊢ HasDerivAt (fun y => c y • f y) (c x • f' + c' • f x) x
state_after: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasDerivWithinAt c c' univ x
hf : HasDerivWithinAt f f' univ x
⊢ HasDerivWithinAt (fun y => c y • f y) (c x • f' + c' • f x) univ x
tactic: rw [← hasDerivWithinAt_univ] at *
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasDerivWithinAt c c' univ x
hf : HasDerivWithinAt f f' univ x
⊢ HasDerivWithinAt (fun y => c y • f y) (c x • f' + c' • f x) univ x
state_after: no goals
tactic: exact hc.smul hf
Theorem: _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_pow
File: Mathlib/RingTheory/WittVector/Basic.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
x y : 𝕎 R
m : ℕ
⊢ WittVector.ghostFun (x ^ m) = WittVector.ghostFun x ^ m
state_after: no goals
tactic: ghost_fun_tac X 0 ^ m, ![x.coeff]
Theorem: charZero_of_injective_ringHom
File: Mathlib/Algebra/CharP/Algebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : NonAssocSemiring R
inst✝¹ : NonAssocSemiring A
f : R →+* A
h : Function.Injective ⇑f
inst✝ : CharZero R
x✝² x✝¹ : ℕ
x✝ : ↑x✝² = ↑x✝¹
⊢ f ↑x✝² = f ↑x✝¹
state_after: no goals
tactic: simpa only [map_natCast f]
Theorem: Finset.inv_univ
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : InvolutiveInv α
s : Finset α
a : α
inst✝ : Fintype α
⊢ univ⁻¹ = univ
state_after: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : InvolutiveInv α
s : Finset α
a : α
inst✝ : Fintype α
a✝ : α
⊢ a✝ ∈ univ⁻¹ ↔ a✝ ∈ univ
tactic: ext
state_before: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : InvolutiveInv α
s : Finset α
a : α
inst✝ : Fintype α
a✝ : α
⊢ a✝ ∈ univ⁻¹ ↔ a✝ ∈ univ
state_after: no goals
tactic: simp
Theorem: Real.contDiff_arctan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean

Proof steps:
state_before: n : ℕ∞
x : ℝ
this : cos (arctan x) ≠ 0
⊢ 1 / cos (↑tanPartialHomeomorph.symm x) ^ 2 ≠ 0
state_after: no goals
tactic: simpa
Theorem: MeasureTheory.TendstoInMeasure.aemeasurable
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : BorelSpace E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hf : ∀ (n : ι), AEMeasurable (f n) μ
h_tendsto : TendstoInMeasure μ f u g
⊢ AEMeasurable g μ
state_after: case intro
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : BorelSpace E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hf : ∀ (n : ι), AEMeasurable (f n) μ
h_tendsto : TendstoInMeasure μ f u g
ns : ℕ → ι
hns : ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))
⊢ AEMeasurable g μ
tactic: obtain ⟨ns, hns⟩ := h_tendsto.exists_seq_tendsto_ae'
state_before: case intro
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : MeasurableSpace E
inst✝³ : NormedAddCommGroup E
inst✝² : BorelSpace E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hf : ∀ (n : ι), AEMeasurable (f n) μ
h_tendsto : TendstoInMeasure μ f u g
ns : ℕ → ι
hns : ∀ᵐ (x : α) ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))
⊢ AEMeasurable g μ
state_after: no goals
tactic: exact aemeasurable_of_tendsto_metrizable_ae atTop (fun n => hf (ns n)) hns
Theorem: DirichletCharacter.Odd.eval_neg
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
S : Type
inst✝ : CommRing S
m : ℕ
ψ : DirichletCharacter S m
x : ZMod m
hψ : ψ.Odd
⊢ ψ (-x) = -ψ x
state_after: R : Type u_1
inst✝¹ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
S : Type
inst✝ : CommRing S
m : ℕ
ψ : DirichletCharacter S m
x : ZMod m
hψ : ψ (-1) = -1
⊢ ψ (-x) = -ψ x
tactic: rw [Odd] at hψ
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
S : Type
inst✝ : CommRing S
m : ℕ
ψ : DirichletCharacter S m
x : ZMod m
hψ : ψ (-1) = -1
⊢ ψ (-x) = -ψ x
state_after: R : Type u_1
inst✝¹ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
S : Type
inst✝ : CommRing S
m : ℕ
ψ : DirichletCharacter S m
x : ZMod m
hψ : ψ (-1) = -1
⊢ ψ (-1) * ψ x = -ψ x
tactic: rw [← neg_one_mul, map_mul]
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
S : Type
inst✝ : CommRing S
m : ℕ
ψ : DirichletCharacter S m
x : ZMod m
hψ : ψ (-1) = -1
⊢ ψ (-1) * ψ x = -ψ x
state_after: no goals
tactic: simp [hψ]
Theorem: CategoryTheory.Limits.isColimitCoconeLeftOpOfCone_desc
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : J ⥤ Cᵒᵖ
c : Cone F
hc : IsLimit c
s : Cocone F.leftOp
j : Jᵒᵖ
⊢ ((coconeLeftOpOfCone c).ι.app j ≫ (fun s => (hc.lift (coneOfCoconeLeftOp s)).unop) s).op = (s.ι.app j).op
state_after: no goals
tactic: simp only [coconeLeftOpOfCone_ι_app, op_comp, Quiver.Hom.op_unop, IsLimit.fac,
        coneOfCoconeLeftOp_π_app, op_unop]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : J ⥤ Cᵒᵖ
c : Cone F
hc : IsLimit c
s : Cocone F.leftOp
m : (coconeLeftOpOfCone c).pt ⟶ s.pt
w : ∀ (j : Jᵒᵖ), (coconeLeftOpOfCone c).ι.app j ≫ m = s.ι.app j
⊢ m = (fun s => (hc.lift (coneOfCoconeLeftOp s)).unop) s
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : J ⥤ Cᵒᵖ
c : Cone F
hc : IsLimit c
s : Cocone F.leftOp
m : (coconeLeftOpOfCone c).pt ⟶ s.pt
w : ∀ (j : Jᵒᵖ), (coconeLeftOpOfCone c).ι.app j ≫ m = s.ι.app j
j : J
⊢ (m.op ≫ c.π.app j).unop = (((fun s => (hc.lift (coneOfCoconeLeftOp s)).unop) s).op ≫ c.π.app j).unop
tactic: refine Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj ?_)
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : J ⥤ Cᵒᵖ
c : Cone F
hc : IsLimit c
s : Cocone F.leftOp
m : (coconeLeftOpOfCone c).pt ⟶ s.pt
w : ∀ (j : Jᵒᵖ), (coconeLeftOpOfCone c).ι.app j ≫ m = s.ι.app j
j : J
⊢ (m.op ≫ c.π.app j).unop = (((fun s => (hc.lift (coneOfCoconeLeftOp s)).unop) s).op ≫ c.π.app j).unop
state_after: no goals
tactic: simpa only [Quiver.Hom.op_unop, IsLimit.fac, coneOfCoconeLeftOp_π_app] using w (op j)
Theorem: IsCompact.mem_nhdsSet_inf_of_forall
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t K : Set X
l : Filter X
s : Set X
hK : IsCompact K
hs : ∀ x ∈ K, s ∈ 𝓝 x ⊓ l
⊢ s ∈ ⨆ x ∈ K, 𝓝 x ⊓ l
state_after: no goals
tactic: simpa using hs
Theorem: ContinuousOn.isSeparable_image
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : TopologicalSpace β
f : α → β
s : Set α
hf : ContinuousOn f s
hs : IsSeparable s
⊢ IsSeparable (f '' s)
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : TopologicalSpace β
f : α → β
s : Set α
hf : ContinuousOn f s
hs : IsSeparable s
⊢ IsSeparable ((fun x => f ↑x) '' univ)
tactic: rw [image_eq_range, ← image_univ]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : TopologicalSpace β
f : α → β
s : Set α
hf : ContinuousOn f s
hs : IsSeparable s
⊢ IsSeparable ((fun x => f ↑x) '' univ)
state_after: no goals
tactic: exact (isSeparable_univ_iff.2 hs.separableSpace).image hf.restrict
Theorem: MeasureTheory.setIntegral_trim
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X✝ : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X✝
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f✝ g : X✝ → E
s✝ t : Set X✝
μ✝ ν : Measure X✝
l l' : Filter X✝
X : Type u_5
m m0 : MeasurableSpace X
μ : Measure X
hm : m ≤ m0
f : X → E
hf_meas : StronglyMeasurable f
s : Set X
hs : MeasurableSet s
⊢ ∫ (x : X) in s, f x ∂μ = ∫ (x : X) in s, f x ∂μ.trim hm
state_after: no goals
tactic: rwa [integral_trim hm hf_meas, restrict_trim hm μ]
Theorem: PMF.binomial_apply_self
File: Mathlib/Probability/ProbabilityMassFunction/Binomial.lean

Proof steps:
state_before: p : ℝ≥0∞
h : p ≤ 1
n : ℕ
⊢ (binomial p h n) ↑n = p ^ n
state_after: no goals
tactic: simp
Theorem: Finset.Nat.antidiagonal_succ'
File: Mathlib/Data/Finset/NatAntidiagonal.lean

Proof steps:
state_before: n : ℕ
⊢ (n + 1, 0) ∉ map ((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }) (antidiagonal n)
state_after: no goals
tactic: simp
state_before: n : ℕ
⊢ antidiagonal (n + 1) =
    cons (n + 1, 0)
      (map ((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }) (antidiagonal n)) ⋯
state_after: case a
n : ℕ
⊢ (antidiagonal (n + 1)).val =
    (cons (n + 1, 0)
        (map ((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }) (antidiagonal n)) ⋯).val
tactic: apply eq_of_veq
state_before: case a
n : ℕ
⊢ (antidiagonal (n + 1)).val =
    (cons (n + 1, 0)
        (map ((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }) (antidiagonal n)) ⋯).val
state_after: case a
n : ℕ
⊢ (antidiagonal (n + 1)).val =
    (n + 1, 0) ::ₘ
      Multiset.map (⇑((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }))
        (antidiagonal n).val
tactic: rw [cons_val, map_val]
state_before: case a
n : ℕ
⊢ (antidiagonal (n + 1)).val =
    (n + 1, 0) ::ₘ
      Multiset.map (⇑((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }))
        (antidiagonal n).val
state_after: no goals
tactic: exact Multiset.Nat.antidiagonal_succ'
Theorem: Finset.Ico_subset_Ici_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderTop α
⊢ Ico a b ⊆ Ici a
state_after: no goals
tactic: simpa [← coe_subset] using Set.Ico_subset_Ici_self