ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Complex.HadamardThreeLines.norm_le_interpStrip_of_mem_verticalStrip_zero
File: Mathlib/Analysis/Complex/Hadamard.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
hz : z ∈ verticalStrip 0 1
⊢ ‖f z‖ ≤ ‖interpStrip f z‖
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
hz : z ∈ verticalStrip 0 1
⊢ Tendsto (fun x => ‖f z‖) (𝓝[>] 0) (𝓝 ‖f z‖)

E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → E
z : ℂ
hd : DiffContOnCl ℂ f (verticalStrip 0 1)
hB : BddAbove (norm ∘ f '' verticalClosedStrip 0 1)
hz : z ∈ verticalStrip 0 1
⊢ Tendsto (fun ε => ‖(↑ε + ↑(sSupNormIm f 0)) ^ (1 - z) * (↑ε + ↑(sSupNormIm f 1)) ^ z‖) (𝓝[>] 0) (𝓝 ‖interpStrip f z‖)
tactic: apply tendsto_le_of_eventuallyLE _ _ (eventuallyle f z hB hd hz)
Theorem: MvPolynomial.algebraTensorAlgEquiv_symm_monomial
File: Mathlib/RingTheory/TensorProduct/MvPolynomial.lean

Proof steps:
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : CommSemiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
σ : Type u_1
inst✝⁶ : DecidableEq σ
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : CommSemiring N
inst✝² : Algebra R N
A : Type u_3
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
m : σ →₀ ℕ
a : A
⊢ (algebraTensorAlgEquiv R A).symm ((monomial m) a) = a ⊗ₜ[R] (monomial m) 1
state_after: case h0
R : Type u
M : Type v
N : Type w
inst✝⁹ : CommSemiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
σ : Type u_1
inst✝⁶ : DecidableEq σ
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : CommSemiring N
inst✝² : Algebra R N
A : Type u_3
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
m : σ →₀ ℕ
a : A
⊢ (algebraTensorAlgEquiv R A).symm ((monomial 0) a) = a ⊗ₜ[R] (monomial 0) 1

case ha
R : Type u
M : Type v
N : Type w
inst✝⁹ : CommSemiring R
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
σ : Type u_1
inst✝⁶ : DecidableEq σ
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
inst✝³ : CommSemiring N
inst✝² : Algebra R N
A : Type u_3
inst✝¹ : CommSemiring A
inst✝ : Algebra R A
m : σ →₀ ℕ
a : A
⊢ ∀ (a_1 : σ) (b : ℕ) (f : σ →₀ ℕ),
    a_1 ∉ f.support →
      b ≠ 0 →
        (algebraTensorAlgEquiv R A).symm ((monomial f) a) = a ⊗ₜ[R] (monomial f) 1 →
          (algebraTensorAlgEquiv R A).symm ((monomial (Finsupp.single a_1 b + f)) a) =
            a ⊗ₜ[R] (monomial (Finsupp.single a_1 b + f)) 1
tactic: apply @Finsupp.induction σ ℕ _ _ m
Theorem: Metric.mem_thickening_iff
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
E : Set X
x : X
⊢ x ∈ thickening δ E ↔ ∃ z ∈ E, dist x z < δ
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
E : Set X
x : X
key_iff : ∀ (z : X), edist x z < ENNReal.ofReal δ ↔ dist x z < δ
⊢ x ∈ thickening δ E ↔ ∃ z ∈ E, dist x z < δ
tactic: have key_iff : ∀ z : X, edist x z < ENNReal.ofReal δ ↔ dist x z < δ := fun z ↦ by
    rw [dist_edist, lt_ofReal_iff_toReal_lt (edist_ne_top _ _)]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
E : Set X
x : X
key_iff : ∀ (z : X), edist x z < ENNReal.ofReal δ ↔ dist x z < δ
⊢ x ∈ thickening δ E ↔ ∃ z ∈ E, dist x z < δ
state_after: no goals
tactic: simp_rw [mem_thickening_iff_exists_edist_lt, key_iff]
Theorem: AlgebraicGeometry.Scheme.ofRestrict_appLE
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
U : TopCat
X : Scheme
f : U ⟶ TopCat.of ↑↑X.toPresheafedSpace
h : OpenEmbedding ⇑f
V : X.Opens
W : (X.restrict h).Opens
e : W ≤ X.ofRestrict h ⁻¹ᵁ V
⊢ X.ofRestrict h ''ᵁ unop (op W) ≤ V
state_after: no goals
tactic: exact Set.image_subset_iff.mpr e
state_before: C : Type u
inst✝ : Category.{v, u} C
U : TopCat
X : Scheme
f : U ⟶ TopCat.of ↑↑X.toPresheafedSpace
h : OpenEmbedding ⇑f
V : X.Opens
W : (X.restrict h).Opens
e : W ≤ X.ofRestrict h ⁻¹ᵁ V
⊢ Hom.appLE (X.ofRestrict h) V W e = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u
inst✝ : Category.{v, u} C
U : TopCat
X : Scheme
f : U ⟶ TopCat.of ↑↑X.toPresheafedSpace
h : OpenEmbedding ⇑f
V : X.Opens
W : (X.restrict h).Opens
e : W ≤ X.ofRestrict h ⁻¹ᵁ V
⊢ X.presheaf.map (⋯.adjunction.counit.app V).op ≫ (X.restrict h).presheaf.map (homOfLE e).op =
    X.presheaf.map (homOfLE ⋯).op
tactic: dsimp [Hom.appLE]
state_before: C : Type u
inst✝ : Category.{v, u} C
U : TopCat
X : Scheme
f : U ⟶ TopCat.of ↑↑X.toPresheafedSpace
h : OpenEmbedding ⇑f
V : X.Opens
W : (X.restrict h).Opens
e : W ≤ X.ofRestrict h ⁻¹ᵁ V
⊢ X.presheaf.map (⋯.adjunction.counit.app V).op ≫ (X.restrict h).presheaf.map (homOfLE e).op =
    X.presheaf.map (homOfLE ⋯).op
state_after: no goals
tactic: exact (X.presheaf.map_comp _ _).symm
Theorem: Polynomial.evalEvalRingHom_eq
File: Mathlib/Algebra/Polynomial/Bivariate.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝ : CommSemiring R
x : R
⊢ evalEvalRingHom x = eval₂RingHom (evalRingHom x)
state_after: no goals
tactic: ext <;> simp
Theorem: Set.image2_congr
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
h : ∀ a ∈ s, ∀ b ∈ t, f a b = f' a b
⊢ image2 f s t = image2 f' s t
state_after: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
h : ∀ a ∈ s, ∀ b ∈ t, f a b = f' a b
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ image2 f' s t
tactic: ext
state_before: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
h : ∀ a ∈ s, ∀ b ∈ t, f a b = f' a b
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ image2 f' s t
state_after: no goals
tactic: constructor <;> rintro ⟨a, ha, b, hb, rfl⟩ <;> exact ⟨a, ha, b, hb, by rw [h a ha b hb]⟩
Theorem: Quiver.Path.comp_inj'
File: Mathlib/Combinatorics/Quiver/Path.lean

Proof steps:
state_before: V : Type u
inst✝ : Quiver V
a b c d : V
p₁ p₂ : Path a b
q₁ q₂ : Path b c
h : p₁.length = p₂.length
h_eq : p₁.comp q₁ = p₂.comp q₂
⊢ p₂.length + q₁.length = p₂.length + q₂.length
state_after: no goals
tactic: simpa [h] using congr_arg length h_eq
state_before: V : Type u
inst✝ : Quiver V
a b c d : V
p₁ p₂ : Path a b
q₁ q₂ : Path b c
h : p₁.length = p₂.length
⊢ p₁ = p₂ ∧ q₁ = q₂ → p₁.comp q₁ = p₂.comp q₂
state_after: case intro
V : Type u
inst✝ : Quiver V
a b c d : V
p₁ : Path a b
q₁ : Path b c
h : p₁.length = p₁.length
⊢ p₁.comp q₁ = p₁.comp q₁
tactic: rintro ⟨rfl, rfl⟩
state_before: case intro
V : Type u
inst✝ : Quiver V
a b c d : V
p₁ : Path a b
q₁ : Path b c
h : p₁.length = p₁.length
⊢ p₁.comp q₁ = p₁.comp q₁
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.MonoidalCategory.whiskerRight_id_symm
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z X Y : C
f : X ⟶ Y
⊢ f = (ρ_ X).inv ≫ f ▷ 𝟙_ C ≫ (ρ_ Y).hom
state_after: no goals
tactic: simp
Theorem: Nat.sqrt_lt'
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m.sqrt < n ↔ m < n ^ 2
state_after: no goals
tactic: simp only [← not_le, le_sqrt']
Theorem: MeasureTheory.integrableOn_empty
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
⊢ IntegrableOn f ∅ μ
state_after: no goals
tactic: simp [IntegrableOn, integrable_zero_measure]
Theorem: padicValInt.of_ne_one_ne_zero
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ (multiplicity (↑p) z).Dom
state_after: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ (↑p).natAbs ≠ 1 ∧ z ≠ 0
tactic: apply multiplicity.finite_int_iff.2
state_before: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ (↑p).natAbs ≠ 1 ∧ z ≠ 0
state_after: no goals
tactic: simp [hp, hz]
state_before: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ padicValInt p z = (multiplicity (↑p) z).get ⋯
state_after: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ (multiplicity p z.natAbs).get ⋯ = (multiplicity (↑p) z).get ⋯
tactic: rw [padicValInt, padicValNat, dif_pos (And.intro hp (Int.natAbs_pos.mpr hz))]
state_before: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ (multiplicity p z.natAbs).get ⋯ = (multiplicity (↑p) z).get ⋯
state_after: no goals
tactic: simp only [multiplicity.Int.natAbs p z]
Theorem: Polynomial.leadingCoeff_of_injective
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
⊢ (map f p).leadingCoeff = f p.leadingCoeff
state_after: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
⊢ (map f p).coeff (map f p).natDegree = f (p.coeff p.natDegree)
tactic: delta leadingCoeff
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
⊢ (map f p).coeff (map f p).natDegree = f (p.coeff p.natDegree)
state_after: no goals
tactic: rw [coeff_map f, natDegree_map_eq_of_injective hf p]
Theorem: Pi.isAtom_iff_eq_single
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι✝ : Sort u_1
α : Type u_2
β : Type u_3
ι : Type u_4
π : ι → Type u
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
f : (i : ι) → π i
⊢ IsAtom f ↔ ∃ i a, IsAtom a ∧ f = Function.update ⊥ i a
state_after: case mp
ι✝ : Sort u_1
α : Type u_2
β : Type u_3
ι : Type u_4
π : ι → Type u
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
f : (i : ι) → π i
⊢ IsAtom f → ∃ i a, IsAtom a ∧ f = Function.update ⊥ i a

case mpr
ι✝ : Sort u_1
α : Type u_2
β : Type u_3
ι : Type u_4
π : ι → Type u
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
f : (i : ι) → π i
⊢ (∃ i a, IsAtom a ∧ f = Function.update ⊥ i a) → IsAtom f
tactic: constructor
state_before: case mp
ι✝ : Sort u_1
α : Type u_2
β : Type u_3
ι : Type u_4
π : ι → Type u
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
f : (i : ι) → π i
⊢ IsAtom f → ∃ i a, IsAtom a ∧ f = Function.update ⊥ i a

case mpr
ι✝ : Sort u_1
α : Type u_2
β : Type u_3
ι : Type u_4
π : ι → Type u
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
f : (i : ι) → π i
⊢ (∃ i a, IsAtom a ∧ f = Function.update ⊥ i a) → IsAtom f
state_after: case mpr
ι✝ : Sort u_1
α : Type u_2
β : Type u_3
ι : Type u_4
π : ι → Type u
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
f : (i : ι) → π i
⊢ (∃ i a, IsAtom a ∧ f = Function.update ⊥ i a) → IsAtom f
tactic: case mp =>
    intro h
    have ⟨i, h, hbot⟩ := isAtom_iff.1 h
    refine ⟨_, _, h, funext fun j => if hij : j = i then hij ▸ by simp else ?_⟩
    rw [Function.update_noteq hij, hbot _ hij, bot_apply]
state_before: case mpr
ι✝ : Sort u_1
α : Type u_2
β : Type u_3
ι : Type u_4
π : ι → Type u
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
f : (i : ι) → π i
⊢ (∃ i a, IsAtom a ∧ f = Function.update ⊥ i a) → IsAtom f
state_after: no goals
tactic: case mpr =>
    rintro ⟨i, a, h, rfl⟩
    exact isAtom_single h
Theorem: Mathlib.Tactic.Monoidal.evalWhiskerLeft_nil
File: Mathlib/Tactic/CategoryTheory/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
f✝ f' g g' h i j f : C
α : g ⟶ h
⊢ f ◁ α = f ◁ α
state_after: no goals
tactic: simp
Theorem: Filter.iInf_sets_induct
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
hs : s ∈ iInf f
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
⊢ p s
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
hs : ∃ t, s ∈ ⨅ i ∈ t, f i.down
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
⊢ p s
tactic: rw [mem_iInf_finite'] at hs
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
hs : ∃ t, s ∈ ⨅ i ∈ t, f i.down
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
⊢ p s
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
hs : ∃ t, s ∈ t.inf fun a => f a.down
⊢ p s
tactic: simp only [← Finset.inf_eq_iInf] at hs
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
hs : ∃ t, s ∈ t.inf fun a => f a.down
⊢ p s
state_after: case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
is : Finset (PLift ι)
his : s ∈ is.inf fun a => f a.down
⊢ p s
tactic: rcases hs with ⟨is, his⟩
state_before: case intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : ι → Filter α
s : Set α
p : Set α → Prop
uni : p univ
ins : ∀ {i : ι} {s₁ s₂ : Set α}, s₁ ∈ f i → p s₂ → p (s₁ ∩ s₂)
is : Finset (PLift ι)
his : s ∈ is.inf fun a => f a.down
⊢ p s
state_after: no goals
tactic: induction is using Finset.induction_on generalizing s with
  | empty => rwa [mem_top.1 his]
  | insert _ ih =>
    rw [Finset.inf_insert, mem_inf_iff] at his
    rcases his with ⟨s₁, hs₁, s₂, hs₂, rfl⟩
    exact ins hs₁ (ih hs₂)
Theorem: CategoryTheory.homOfLE_isIso_of_eq
File: Mathlib/CategoryTheory/Category/Preorder.lean

Proof steps:
state_before: X : Type u
inst✝ : Preorder X
x y : X
h : x ≤ y
heq : x = y
⊢ homOfLE h ≫ homOfLE ⋯ = 𝟙 x ∧ homOfLE ⋯ ≫ homOfLE h = 𝟙 y
state_after: no goals
tactic: simp
Theorem: Nat.ceil_one
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
⊢ ⌈1⌉₊ = 1
state_after: no goals
tactic: rw [← Nat.cast_one, ceil_natCast]
Theorem: WeierstrassCurve.ΨSq_four
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.ΨSq 4 = W.preΨ₄ ^ 2 * W.Ψ₂Sq
state_after: no goals
tactic: erw [ΨSq_ofNat, preΨ'_four, if_pos <| by decide]
Theorem: Nat.totient_prime
File: Mathlib/Data/Nat/Totient.lean

Proof steps:
state_before: p : ℕ
hp : Prime p
⊢ φ p = p - 1
state_after: no goals
tactic: rw [← pow_one p, totient_prime_pow hp] <;> simp
Theorem: CategoryTheory.Limits.colimit.toOver_ι_app
File: Mathlib/CategoryTheory/Limits/ConeCategory.lean

Proof steps:
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
F : J ⥤ C
inst✝ : HasColimit F
j : J
⊢ ι F j ≫ (((const J).obj (Over.mk (𝟙 (colimit F)))).obj j).hom =
    ((toCostructuredArrow F ⋙ CostructuredArrow.toOver F (colimit F)).obj j).hom
state_after: no goals
tactic: simp
Theorem: Hyperreal.infinitesimal_iff_infinite_inv
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x : ℝ*
h : x ≠ 0
⊢ x.Infinitesimal ↔ x⁻¹⁻¹.Infinitesimal
state_after: no goals
tactic: rw [inv_inv]
Theorem: CircleDeg1Lift.translate_zpow
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f g : CircleDeg1Lift
x : ℝ
n : ℤ
⊢ translate (Multiplicative.ofAdd x) ^ n = translate (Multiplicative.ofAdd (↑n * x))
state_after: no goals
tactic: simp only [← zsmul_eq_mul, ofAdd_zsmul, MonoidHom.map_zpow]
Theorem: Set.preimage_add_const_Ioo
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x + a) ⁻¹' Ioo b c = Ioo (b - a) (c - a)
state_after: no goals
tactic: simp [← Ioi_inter_Iio]
Theorem: MvPolynomial.killCompl_comp_rename
File: Mathlib/Algebra/MvPolynomial/Rename.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
i : σ
⊢ ((killCompl hf).comp (rename f)) (X i) = (AlgHom.id R (MvPolynomial σ R)) (X i)
state_after: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
i : σ
⊢ (killCompl hf) ((rename f) (X i)) = X i
tactic: dsimp
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
i : σ
⊢ (killCompl hf) ((rename f) (X i)) = X i
state_after: no goals
tactic: rw [rename, killCompl, aeval_X, comp_apply, aeval_X, dif_pos, Equiv.ofInjective_symm_apply]
Theorem: ContinuousLinearMap.map_smul₂
File: Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type u_3
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
R : Type u_5
𝕜₂ : Type u_6
𝕜' : Type u_7
inst✝⁶ : NontriviallyNormedField 𝕜'
inst✝⁵ : NontriviallyNormedField 𝕜₂
M : Type u_8
inst✝⁴ : TopologicalSpace M
σ₁₂ : 𝕜 →+* 𝕜₂
G' : Type u_9
inst✝³ : NormedAddCommGroup G'
inst✝² : NormedSpace 𝕜₂ G'
inst✝¹ : NormedSpace 𝕜' G'
inst✝ : SMulCommClass 𝕜₂ 𝕜' G'
f : E →L[𝕜] F →L[𝕜] G
c : 𝕜
x : E
y : F
⊢ (f (c • x)) y = c • (f x) y
state_after: no goals
tactic: rw [f.map_smul, smul_apply]
Theorem: MeasureTheory.Measure.count_injective_image'
File: Mathlib/MeasureTheory/Measure/Count.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s✝ : Set α
f : β → α
hf : Function.Injective f
s : Set β
s_mble : MeasurableSet s
fs_mble : MeasurableSet (f '' s)
⊢ count (f '' s) = count s
state_after: case pos
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s✝ : Set α
f : β → α
hf : Function.Injective f
s : Set β
s_mble : MeasurableSet s
fs_mble : MeasurableSet (f '' s)
hs : s.Finite
⊢ count (f '' s) = count s

case neg
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s✝ : Set α
f : β → α
hf : Function.Injective f
s : Set β
s_mble : MeasurableSet s
fs_mble : MeasurableSet (f '' s)
hs : ¬s.Finite
⊢ count (f '' s) = count s
tactic: by_cases hs : s.Finite
Theorem: SimpleGraph.TripartiteFromTriangles.Graph.in₂₁_iff
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (graph t).Adj (in₂ c) (in₁ b) → ∃ a, (a, b, c) ∈ t
state_after: case in₂₁
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
a✝¹ : α
a✝ : (a✝¹, b, c) ∈ t
⊢ ∃ a, (a, b, c) ∈ t
tactic: rintro ⟨⟩
state_before: case in₂₁
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
a✝¹ : α
a✝ : (a✝¹, b, c) ∈ t
⊢ ∃ a, (a, b, c) ∈ t
state_after: no goals
tactic: exact ⟨_, ‹_›⟩
Theorem: Set.powerset_singleton
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
⊢ 𝒫{x} = {∅, {x}}
state_after: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
y : Set α
⊢ y ∈ 𝒫{x} ↔ y ∈ {∅, {x}}
tactic: ext y
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
y : Set α
⊢ y ∈ 𝒫{x} ↔ y ∈ {∅, {x}}
state_after: no goals
tactic: rw [mem_powerset_iff, subset_singleton_iff_eq, mem_insert_iff, mem_singleton_iff]
Theorem: abs_dist_sub_le_dist_mul_mul
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁✝ a₂✝ b b₁✝ b₂✝ : E
r r₁ r₂ : ℝ
a₁ a₂ b₁ b₂ : E
⊢ |dist a₁ b₁ - dist a₂ b₂| ≤ dist (a₁ * a₂) (b₁ * b₂)
state_after: no goals
tactic: simpa only [dist_mul_left, dist_mul_right, dist_comm b₂] using
    abs_dist_sub_le (a₁ * a₂) (b₁ * b₂) (b₁ * a₂)
Theorem: Complex.continuous_cosh
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ Continuous cosh
state_after: ⊢ Continuous fun z => (cexp z + cexp (-z)) / 2
tactic: change Continuous fun z => (exp z + exp (-z)) / 2
state_before: ⊢ Continuous fun z => (cexp z + cexp (-z)) / 2
state_after: no goals
tactic: continuity
Theorem: Real.tendsto_Icc_vitaliFamily_left
File: Mathlib/MeasureTheory/Covering/OneDim.lean

Proof steps:
state_before: x : ℝ
⊢ Tendsto (fun y => Icc y x) (𝓝[<] x) ((vitaliFamily volume 1).filterAt x)
state_after: case refine_1
x : ℝ
⊢ ∀ᶠ (i : ℝ) in 𝓝[<] x, Icc i x ∈ (vitaliFamily volume 1).setsAt x

case refine_2
x : ℝ
⊢ ∀ ε > 0, ∀ᶠ (i : ℝ) in 𝓝[<] x, Icc i x ⊆ Metric.closedBall x ε
tactic: refine (VitaliFamily.tendsto_filterAt_iff _).2 ⟨?_, ?_⟩
Theorem: Finset.affineCombinationSingleWeights_apply_of_ne
File: Mathlib/LinearAlgebra/AffineSpace/Combination.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
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j : ι
h : j ≠ i
⊢ affineCombinationSingleWeights k i j = 0
state_after: no goals
tactic: simp [affineCombinationSingleWeights, h]