ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Fintype.card_subtype_or
File: Mathlib/Data/Fintype/Sum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
p q : α → Prop
inst✝² : Fintype { x // p x }
inst✝¹ : Fintype { x // q x }
inst✝ : Fintype { x // p x ∨ q x }
⊢ card { x // p x ∨ q x } ≤ card { x // p x } + card { x // q x }
state_after: no goals
tactic: classical
    convert Fintype.card_le_of_embedding (subtypeOrLeftEmbedding p q)
    rw [Fintype.card_sum]
Theorem: Ordnode.Raised.add_right
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
k n m : ℕ
H : Raised n m
⊢ Raised (n + k) (m + k)
state_after: α : Type u_1
k n m : ℕ
H : Raised n m
⊢ Raised (k + n) (k + m)
tactic: rw [add_comm, add_comm m]
state_before: α : Type u_1
k n m : ℕ
H : Raised n m
⊢ Raised (k + n) (k + m)
state_after: no goals
tactic: exact H.add_left _
Theorem: Finset.hasProd
File: Mathlib/Topology/Algebra/InfiniteSum/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b : α
s✝ s : Finset β
f : β → α
⊢ HasProd (f ∘ Subtype.val) (∏ b ∈ s, f b)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b : α
s✝ s : Finset β
f : β → α
⊢ HasProd (f ∘ Subtype.val) (∏ x ∈ s.attach, f ↑x)
tactic: rw [← prod_attach]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b : α
s✝ s : Finset β
f : β → α
⊢ HasProd (f ∘ Subtype.val) (∏ x ∈ s.attach, f ↑x)
state_after: no goals
tactic: exact hasProd_fintype _
Theorem: Sylow.smul_eq_iff_mem_normalizer
File: Mathlib/GroupTheory/Sylow.lean

Proof steps:
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
g : G
P : Sylow p G
⊢ g • P = P ↔ g ∈ (↑P).normalizer
state_after: p : ℕ
G : Type u_1
inst✝ : Group G
g : G
P : Sylow p G
⊢ (∀ (x : G), x ∈ P ↔ x ∈ g • P) ↔ ∀ (h : G), h ∈ ↑P ↔ g⁻¹ * h * g ∈ ↑P
tactic: rw [eq_comm, SetLike.ext_iff, ← inv_mem_iff (G := G) (H := normalizer P.toSubgroup),
      mem_normalizer_iff, inv_inv]
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
g : G
P : Sylow p G
⊢ (∀ (x : G), x ∈ P ↔ x ∈ g • P) ↔ ∀ (h : G), h ∈ ↑P ↔ g⁻¹ * h * g ∈ ↑P
state_after: no goals
tactic: exact
    forall_congr' fun h =>
      iff_congr Iff.rfl
        ⟨fun ⟨a, b, c⟩ => c ▸ by simpa [mul_assoc] using b,
          fun hh => ⟨(MulAut.conj g)⁻¹ h, hh, MulAut.apply_inv_self G (MulAut.conj g) h⟩⟩
Theorem: goldConj_irrational
File: Mathlib/Data/Real/GoldenRatio.lean

Proof steps:
state_before: ⊢ Irrational ψ
state_after: this : Irrational √↑5
⊢ Irrational ψ
tactic: have := Nat.Prime.irrational_sqrt (show Nat.Prime 5 by norm_num)
state_before: this : Irrational √↑5
⊢ Irrational ψ
state_after: this✝ : Irrational √↑5
this : Irrational (↑1 - √↑5)
⊢ Irrational ψ
tactic: have := this.rat_sub 1
state_before: this✝ : Irrational √↑5
this : Irrational (↑1 - √↑5)
⊢ Irrational ψ
state_after: this✝¹ : Irrational √↑5
this✝ : Irrational (↑1 - √↑5)
this : Irrational (↑0.5 * (↑1 - √↑5))
⊢ Irrational ψ
tactic: have := this.rat_mul (show (0.5 : ℚ) ≠ 0 by norm_num)
state_before: this✝¹ : Irrational √↑5
this✝ : Irrational (↑1 - √↑5)
this : Irrational (↑0.5 * (↑1 - √↑5))
⊢ Irrational ψ
state_after: case h.e'_1
this✝¹ : Irrational √↑5
this✝ : Irrational (↑1 - √↑5)
this : Irrational (↑0.5 * (↑1 - √↑5))
⊢ ψ = ↑0.5 * (↑1 - √↑5)
tactic: convert this
state_before: case h.e'_1
this✝¹ : Irrational √↑5
this✝ : Irrational (↑1 - √↑5)
this : Irrational (↑0.5 * (↑1 - √↑5))
⊢ ψ = ↑0.5 * (↑1 - √↑5)
state_after: case h.e'_1
this✝¹ : Irrational √↑5
this✝ : Irrational (↑1 - √↑5)
this : Irrational (↑0.5 * (↑1 - √↑5))
⊢ ψ = 1 / 2 * (1 - √5)
tactic: norm_num
state_before: case h.e'_1
this✝¹ : Irrational √↑5
this✝ : Irrational (↑1 - √↑5)
this : Irrational (↑0.5 * (↑1 - √↑5))
⊢ ψ = 1 / 2 * (1 - √5)
state_after: no goals
tactic: field_simp
Theorem: _private.Mathlib.Algebra.Lie.BaseChange.0.LieAlgebra.ExtendScalars.bracket_lie_self
File: Mathlib/Algebra/Lie/BaseChange.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : A ⊗[R] L
⊢ ⁅x, x⁆ = 0
state_after: R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : A ⊗[R] L
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L L) x) x = 0
tactic: simp only [bracket_def]
state_before: R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : A ⊗[R] L
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L L) x) x = 0
state_after: case refine_1
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : A ⊗[R] L
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L L) 0) 0 = 0

case refine_2
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : A ⊗[R] L
⊢ ∀ (x : A) (y : L), ((LieAlgebra.ExtendScalars.bracket' R A L L) (x ⊗ₜ[R] y)) (x ⊗ₜ[R] y) = 0

case refine_3
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : A ⊗[R] L
⊢ ∀ (x y : A ⊗[R] L),
    ((LieAlgebra.ExtendScalars.bracket' R A L L) x) x = 0 →
      ((LieAlgebra.ExtendScalars.bracket' R A L L) y) y = 0 →
        ((LieAlgebra.ExtendScalars.bracket' R A L L) (x + y)) (x + y) = 0
tactic: refine x.induction_on ?_ ?_ ?_
Theorem: realPart_add_I_smul_imaginaryPart
File: Mathlib/Data/Complex/Module.lean

Proof steps:
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(ℜ a) + I • ↑(ℑ a) = a
state_after: no goals
tactic: simpa only [smul_smul, realPart_apply_coe, imaginaryPart_apply_coe, neg_smul, I_mul_I, one_smul,
    neg_sub, add_add_sub_cancel, smul_sub, smul_add, neg_sub_neg, invOf_eq_inv] using
    invOf_two_smul_add_invOf_two_smul ℝ a
Theorem: RatFunc.num_denom_neg
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
⊢ (-x).num * x.denom = -x.num * (-x).denom
state_after: no goals
tactic: rw [num_mul_eq_mul_denom_iff (denom_ne_zero x), _root_.map_neg, neg_div, num_div_denom]
Theorem: LieModule.weightSpace_neg_add_chainBot
File: Mathlib/Algebra/Lie/Weights/Chain.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
⊢ weightSpace M (-α + ⇑(chainBot α β)) = ⊥
state_after: no goals
tactic: rw [← chainTop_neg, weightSpace_add_chainTop _ _ (by simpa using hα)]
Theorem: FDerivMeasurableAux.le_of_mem_A
File: Mathlib/Analysis/Calculus/FDeriv/Measurable.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
f : E → F
K : Set (E →L[𝕜] F)
r ε : ℝ
L : E →L[𝕜] F
x : E
hx : x ∈ A f L r ε
y z : E
hy : y ∈ closedBall x (r / 2)
hz : z ∈ closedBall x (r / 2)
⊢ ‖f z - f y - L (z - y)‖ ≤ ε * r
state_after: case intro.intro
𝕜 : 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
f : E → F
K : Set (E →L[𝕜] F)
r ε : ℝ
L : E →L[𝕜] F
x y z : E
hy : y ∈ closedBall x (r / 2)
hz : z ∈ closedBall x (r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ ball x r', ∀ z ∈ ball x r', ‖f z - f y - L (z - y)‖ < ε * r
⊢ ‖f z - f y - L (z - y)‖ ≤ ε * r
tactic: rcases hx with ⟨r', r'mem, hr'⟩
state_before: case intro.intro
𝕜 : 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
f : E → F
K : Set (E →L[𝕜] F)
r ε : ℝ
L : E →L[𝕜] F
x y z : E
hy : y ∈ closedBall x (r / 2)
hz : z ∈ closedBall x (r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ ball x r', ∀ z ∈ ball x r', ‖f z - f y - L (z - y)‖ < ε * r
⊢ ‖f z - f y - L (z - y)‖ ≤ ε * r
state_after: case intro.intro.a
𝕜 : 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
f : E → F
K : Set (E →L[𝕜] F)
r ε : ℝ
L : E →L[𝕜] F
x y z : E
hy : y ∈ closedBall x (r / 2)
hz : z ∈ closedBall x (r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ ball x r', ∀ z ∈ ball x r', ‖f z - f y - L (z - y)‖ < ε * r
⊢ ‖f z - f y - L (z - y)‖ < ε * r
tactic: apply le_of_lt
state_before: case intro.intro.a
𝕜 : 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
f : E → F
K : Set (E →L[𝕜] F)
r ε : ℝ
L : E →L[𝕜] F
x y z : E
hy : y ∈ closedBall x (r / 2)
hz : z ∈ closedBall x (r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ ball x r', ∀ z ∈ ball x r', ‖f z - f y - L (z - y)‖ < ε * r
⊢ ‖f z - f y - L (z - y)‖ < ε * r
state_after: no goals
tactic: exact hr' _ ((mem_closedBall.1 hy).trans_lt r'mem.1) _ ((mem_closedBall.1 hz).trans_lt r'mem.1)
Theorem: CategoryTheory.ShortComplex.SnakeInput.exact_C₃_up
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.28046, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ S.v₀₁.τ₃ ≫ S.v₁₂.τ₃ = 0
state_after: no goals
tactic: rw [← comp_τ₃, S.w₀₂, zero_τ₃]
Theorem: Linarith.mul_zero_eq
File: Mathlib/Tactic/Linarith/Lemmas.lean

Proof steps:
state_before: α : Type u_1
R : α → α → Prop
inst✝ : Semiring α
a b : α
x✝ : R a 0
h : b = 0
⊢ a * b = 0
state_after: no goals
tactic: simp [h]
Theorem: CategoryTheory.Dial.leftUnitor_hom_f
File: Mathlib/CategoryTheory/Dialectica/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X : Dial C
⊢ (tensorUnit.tensorObj X).rel =
    (Subobject.pullback (prod.map (prod.leftUnitor X.src).hom (prod.leftUnitor X.tgt).hom)).obj X.rel
state_after: no goals
tactic: simp [Subobject.pullback_top]
Theorem: exists_unique_const
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: α✝ : Sort u_1
β : Sort u_2
p q : α✝ → Prop
b : Prop
α : Sort u_3
i : Nonempty α
inst✝ : Subsingleton α
⊢ (∃! x, b) ↔ b
state_after: no goals
tactic: simp
Theorem: Filter.mem_prod_iff_right
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
⊢ s ∈ f ×ˢ g ↔ ∃ t ∈ g, ∀ᶠ (x : α) in f, ∀ y ∈ t, (x, y) ∈ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
⊢ (∃ t ∈ g, ∀ᶠ (y : α) in f, ∀ x ∈ t, (x, y) ∈ (fun p => (p.2, p.1)) ⁻¹' s) ↔
    ∃ t ∈ g, ∀ᶠ (x : α) in f, ∀ y ∈ t, (x, y) ∈ s
tactic: rw [prod_comm, mem_map, mem_prod_iff_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
⊢ (∃ t ∈ g, ∀ᶠ (y : α) in f, ∀ x ∈ t, (x, y) ∈ (fun p => (p.2, p.1)) ⁻¹' s) ↔
    ∃ t ∈ g, ∀ᶠ (x : α) in f, ∀ y ∈ t, (x, y) ∈ s
state_after: no goals
tactic: rfl
Theorem: Int.ofNat_add_negSucc_of_ge
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m✝ n✝ : ℤ
m n : ℕ
h : n.succ ≤ m
⊢ ofNat m + -[n+1] = ofNat (m - n.succ)
state_after: no goals
tactic: rw [negSucc_eq, ofNat_eq_natCast, ofNat_eq_natCast, ← natCast_one, ← natCast_add,
    ← Int.sub_eq_add_neg, ← Int.natCast_sub h]
Theorem: WittVector.ext
File: Mathlib/RingTheory/WittVector/Defs.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
x y : 𝕎 R
h : ∀ (n : ℕ), x.coeff n = y.coeff n
⊢ x = y
state_after: case mk'
p : ℕ
R : Type u_1
y : 𝕎 R
coeff✝ : ℕ → R
h : ∀ (n : ℕ), { coeff := coeff✝ }.coeff n = y.coeff n
⊢ { coeff := coeff✝ } = y
tactic: cases x
state_before: case mk'
p : ℕ
R : Type u_1
y : 𝕎 R
coeff✝ : ℕ → R
h : ∀ (n : ℕ), { coeff := coeff✝ }.coeff n = y.coeff n
⊢ { coeff := coeff✝ } = y
state_after: case mk'.mk'
p : ℕ
R : Type u_1
coeff✝¹ coeff✝ : ℕ → R
h : ∀ (n : ℕ), { coeff := coeff✝¹ }.coeff n = { coeff := coeff✝ }.coeff n
⊢ { coeff := coeff✝¹ } = { coeff := coeff✝ }
tactic: cases y
state_before: case mk'.mk'
p : ℕ
R : Type u_1
coeff✝¹ coeff✝ : ℕ → R
h : ∀ (n : ℕ), { coeff := coeff✝¹ }.coeff n = { coeff := coeff✝ }.coeff n
⊢ { coeff := coeff✝¹ } = { coeff := coeff✝ }
state_after: case mk'.mk'
p : ℕ
R : Type u_1
coeff✝¹ coeff✝ : ℕ → R
h : ∀ (n : ℕ), coeff✝¹ n = coeff✝ n
⊢ { coeff := coeff✝¹ } = { coeff := coeff✝ }
tactic: simp only at h
state_before: case mk'.mk'
p : ℕ
R : Type u_1
coeff✝¹ coeff✝ : ℕ → R
h : ∀ (n : ℕ), coeff✝¹ n = coeff✝ n
⊢ { coeff := coeff✝¹ } = { coeff := coeff✝ }
state_after: no goals
tactic: simp [Function.funext_iff, h]
Theorem: Polynomial.X_pow_mul
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ X ^ n * p = p * X ^ n
state_after: case zero
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ X ^ 0 * p = p * X ^ 0

case succ
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
ih : X ^ n * p = p * X ^ n
⊢ X ^ (n + 1) * p = p * X ^ (n + 1)
tactic: induction' n with n ih
Theorem: Finset.map_ofDual_max
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset αᵒᵈ
⊢ WithBot.map (⇑ofDual) s.max = (image (⇑ofDual) s).min
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset αᵒᵈ
⊢ WithBot.map (⇑ofDual) s.max = s.inf (WithTop.some ∘ ⇑ofDual)
tactic: rw [min_eq_inf_withTop, inf_image]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset αᵒᵈ
⊢ WithBot.map (⇑ofDual) s.max = s.inf (WithTop.some ∘ ⇑ofDual)
state_after: no goals
tactic: exact congr_fun Option.map_id _
Theorem: Polynomial.iterate_derivative_map
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
f : R →+* S
k : ℕ
⊢ (⇑derivative)^[k] (map f p) = map f ((⇑derivative)^[k] p)
state_after: case zero
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
p : R[X]
⊢ (⇑derivative)^[0] (map f p) = map f ((⇑derivative)^[0] p)

case succ
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
k : ℕ
ih : ∀ (p : R[X]), (⇑derivative)^[k] (map f p) = map f ((⇑derivative)^[k] p)
p : R[X]
⊢ (⇑derivative)^[k + 1] (map f p) = map f ((⇑derivative)^[k + 1] p)
tactic: induction' k with k ih generalizing p
Theorem: Zsqrtd.smul_im
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d a : ℤ
b : ℤ√d
⊢ (↑a * b).im = a * b.im
state_after: no goals
tactic: simp
Theorem: IsCompact.add_closedBall_zero
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsCompact s
hδ : 0 ≤ δ
⊢ s * closedBall 1 δ = cthickening δ s
state_after: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsCompact s
hδ : 0 ≤ δ
⊢ s * closedBall 1 δ = ⋃ x ∈ s, closedBall x δ
tactic: rw [hs.cthickening_eq_biUnion_closedBall hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsCompact s
hδ : 0 ≤ δ
⊢ s * closedBall 1 δ = ⋃ x ∈ s, closedBall x δ
state_after: case h
E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x✝ y : E
hs : IsCompact s
hδ : 0 ≤ δ
x : E
⊢ x ∈ s * closedBall 1 δ ↔ x ∈ ⋃ x ∈ s, closedBall x δ
tactic: ext x
state_before: case h
E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x✝ y : E
hs : IsCompact s
hδ : 0 ≤ δ
x : E
⊢ x ∈ s * closedBall 1 δ ↔ x ∈ ⋃ x ∈ s, closedBall x δ
state_after: no goals
tactic: simp only [mem_mul, dist_eq_norm_div, exists_prop, mem_iUnion, mem_closedBall, exists_and_left,
    mem_closedBall_one_iff, ← eq_div_iff_mul_eq'', div_one, exists_eq_right]
Theorem: Behrend.lower_bound_le_one'
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
hN' : N ≤ 4096
⊢ ↑N * rexp (-4 * √(log ↑N)) ≤ 1
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
hN' : N ≤ 4096
⊢ ↑N ≤ rexp (4 ^ 2)
tactic: rw [← log_le_log_iff (mul_pos (cast_pos.2 (zero_lt_two.trans_le hN)) (exp_pos _)) zero_lt_one,
    log_one, log_mul (cast_pos.2 (zero_lt_two.trans_le hN)).ne' (exp_pos _).ne', log_exp, neg_mul, ←
    sub_eq_add_neg, sub_nonpos, ←
    div_le_iff (Real.sqrt_pos.2 <| log_pos <| one_lt_cast.2 <| one_lt_two.trans_le hN), div_sqrt,
    sqrt_le_left zero_le_four, log_le_iff_le_exp (cast_pos.2 (zero_lt_two.trans_le hN))]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
hN' : N ≤ 4096
⊢ ↑N ≤ rexp (4 ^ 2)
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
hN' : N ≤ 4096
⊢ ↑N ≤ rexp 16
tactic: norm_num1
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
hN' : N ≤ 4096
⊢ ↑N ≤ rexp 16
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
hN' : N ≤ 4096
⊢ ↑N ≤ 4096
tactic: apply le_trans _ four_zero_nine_six_lt_exp_sixteen.le
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hN : 2 ≤ N
hN' : N ≤ 4096
⊢ ↑N ≤ 4096
state_after: no goals
tactic: exact mod_cast hN'
Theorem: CategoryTheory.leftDistributor_ext₂_right
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X Y Z : C
f : J → C
g h : X ⟶ Y ⊗ Z ⊗ ⨁ f
w : ∀ (j : J), g ≫ Y ◁ Z ◁ biproduct.π f j = h ≫ Y ◁ Z ◁ biproduct.π f j
⊢ g = h
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X Y Z : C
f : J → C
g h : X ⟶ Y ⊗ Z ⊗ ⨁ f
w : ∀ (j : J), g ≫ Y ◁ Z ◁ biproduct.π f j = h ≫ Y ◁ Z ◁ biproduct.π f j
⊢ g ≫ (α_ Y Z (⨁ f)).inv = h ≫ (α_ Y Z (⨁ f)).inv
tactic: apply (cancel_mono (α_ _ _ _).inv).mp
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X Y Z : C
f : J → C
g h : X ⟶ Y ⊗ Z ⊗ ⨁ f
w : ∀ (j : J), g ≫ Y ◁ Z ◁ biproduct.π f j = h ≫ Y ◁ Z ◁ biproduct.π f j
⊢ g ≫ (α_ Y Z (⨁ f)).inv = h ≫ (α_ Y Z (⨁ f)).inv
state_after: case w
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X Y Z : C
f : J → C
g h : X ⟶ Y ⊗ Z ⊗ ⨁ f
w : ∀ (j : J), g ≫ Y ◁ Z ◁ biproduct.π f j = h ≫ Y ◁ Z ◁ biproduct.π f j
j✝ : J
⊢ (g ≫ (α_ Y Z (⨁ f)).inv) ≫ (Y ⊗ Z) ◁ biproduct.π f j✝ = (h ≫ (α_ Y Z (⨁ f)).inv) ≫ (Y ⊗ Z) ◁ biproduct.π f j✝
tactic: ext
state_before: case w
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X Y Z : C
f : J → C
g h : X ⟶ Y ⊗ Z ⊗ ⨁ f
w : ∀ (j : J), g ≫ Y ◁ Z ◁ biproduct.π f j = h ≫ Y ◁ Z ◁ biproduct.π f j
j✝ : J
⊢ (g ≫ (α_ Y Z (⨁ f)).inv) ≫ (Y ⊗ Z) ◁ biproduct.π f j✝ = (h ≫ (α_ Y Z (⨁ f)).inv) ≫ (Y ⊗ Z) ◁ biproduct.π f j✝
state_after: no goals
tactic: simp [w]
Theorem: OpenEmbedding.functor_isContinuous
File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
h : OpenEmbedding ⇑f
⊢ ⋯.functor.IsContinuous (Opens.grothendieckTopology ↑X) (Opens.grothendieckTopology ↑Y)
state_after: case hF₁
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
h : OpenEmbedding ⇑f
⊢ CompatiblePreserving (Opens.grothendieckTopology ↑Y) ⋯.functor

case hF₂
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
h : OpenEmbedding ⇑f
⊢ CoverPreserving (Opens.grothendieckTopology ↑X) (Opens.grothendieckTopology ↑Y) ⋯.functor
tactic: apply Functor.isContinuous_of_coverPreserving
Theorem: Real.tendsto_sin_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ Tendsto sin (𝓝[<] (π / 2)) (𝓝 1)
state_after: case h.e'_5.h.e'_3

⊢ 1 = sin (π / 2)
tactic: convert continuous_sin.continuousWithinAt.tendsto
state_before: case h.e'_5.h.e'_3

⊢ 1 = sin (π / 2)
state_after: no goals
tactic: simp
Theorem: Lagrange.basisDivisor_self
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝ : Field F
x y : F
⊢ basisDivisor x x = 0
state_after: no goals
tactic: simp only [basisDivisor, sub_self, inv_zero, map_zero, zero_mul]
Theorem: Valuation.val_le_one_or_val_inv_le_one
File: Mathlib/RingTheory/Valuation/Basic.lean

Proof steps:
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v✝ : Valuation R Γ₀
x✝ y z : R
v : Valuation K Γ₀
x : K
⊢ v x ≤ 1 ∨ v x⁻¹ ≤ 1
state_after: case pos
K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v✝ : Valuation R Γ₀
x✝ y z : R
v : Valuation K Γ₀
x : K
h : x = 0
⊢ v x ≤ 1 ∨ v x⁻¹ ≤ 1

case neg
K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v✝ : Valuation R Γ₀
x✝ y z : R
v : Valuation K Γ₀
x : K
h : ¬x = 0
⊢ v x ≤ 1 ∨ v x⁻¹ ≤ 1
tactic: by_cases h : x = 0