1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: iteratedFDeriv_succ_apply_right
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: rw [← iteratedFDerivWithin_univ, ← iteratedFDerivWithin_univ, ← fderivWithin_univ]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
m : Fin (n + 1) → E
⊢ (iteratedFDeriv 𝕜 (n + 1) f x) m = ((iteratedFDeriv 𝕜 n (fun y => fderiv 𝕜 f y) x) (init m)) (m (last n))
state_after: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
m : Fin (n + 1) → E
⊢ (iteratedFDerivWithin 𝕜 (n + 1) f univ x) m =
    ((iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 f univ y) univ x) (init m)) (m (last n))

tactic: exact iteratedFDerivWithin_succ_apply_right uniqueDiffOn_univ (mem_univ _) _
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
m : Fin (n + 1) → E
⊢ (iteratedFDerivWithin 𝕜 (n + 1) f univ x) m =
    ((iteratedFDerivWithin 𝕜 n (fun y => fderivWithin 𝕜 f univ y) univ x) (init m)) (m (last n))
state_after: no goals
Theorem: Ring.mul_inverse_cancel
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rcases h with ⟨u, rfl⟩
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x : M₀
h : IsUnit x
⊢ x * inverse x = 1
state_after: case intro
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
u : M₀ˣ
⊢ ↑u * inverse ↑u = 1

tactic: rw [inverse_unit, Units.mul_inv]
state_before: case intro
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
u : M₀ˣ
⊢ ↑u * inverse ↑u = 1
state_after: no goals
Theorem: Equiv.Perm.sign_swap'
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: simp [H, swap_self]
state_before: α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Fintype α
x y : α
H : x = y
⊢ sign (swap x y) = if x = y then 1 else -1
state_after: no goals

tactic: simp [sign_swap H, H]
state_before: α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Fintype α
x y : α
H : ¬x = y
⊢ sign (swap x y) = if x = y then 1 else -1
state_after: no goals
Theorem: Finsupp.apply_single
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp only [single_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝⁴ : Zero M
a✝ a' : α
b✝ : M
inst✝³ : AddCommMonoid N
inst✝² : AddCommMonoid P
F : Type u_13
inst✝¹ : FunLike F N P
inst✝ : AddMonoidHomClass F N P
e : F
a : α
n : N
b : α
⊢ e ((single a n) b) = (single a (e n)) b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝⁴ : Zero M
a✝ a' : α
b✝ : M
inst✝³ : AddCommMonoid N
inst✝² : AddCommMonoid P
F : Type u_13
inst✝¹ : FunLike F N P
inst✝ : AddMonoidHomClass F N P
e : F
a : α
n : N
b : α
⊢ e (if a = b then n else 0) = if a = b then e n else 0

tactic: split_ifs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝⁴ : Zero M
a✝ a' : α
b✝ : M
inst✝³ : AddCommMonoid N
inst✝² : AddCommMonoid P
F : Type u_13
inst✝¹ : FunLike F N P
inst✝ : AddMonoidHomClass F N P
e : F
a : α
n : N
b : α
⊢ e (if a = b then n else 0) = if a = b then e n else 0
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝⁴ : Zero M
a✝ a' : α
b✝ : M
inst✝³ : AddCommMonoid N
inst✝² : AddCommMonoid P
F : Type u_13
inst✝¹ : FunLike F N P
inst✝ : AddMonoidHomClass F N P
e : F
a : α
n : N
b : α
h✝ : a = b
⊢ e n = e n

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝⁴ : Zero M
a✝ a' : α
b✝ : M
inst✝³ : AddCommMonoid N
inst✝² : AddCommMonoid P
F : Type u_13
inst✝¹ : FunLike F N P
inst✝ : AddMonoidHomClass F N P
e : F
a : α
n : N
b : α
h✝ : ¬a = b
⊢ e 0 = 0

tactic: rfl
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝⁴ : Zero M
a✝ a' : α
b✝ : M
inst✝³ : AddCommMonoid N
inst✝² : AddCommMonoid P
F : Type u_13
inst✝¹ : FunLike F N P
inst✝ : AddMonoidHomClass F N P
e : F
a : α
n : N
b : α
h✝ : a = b
⊢ e n = e n
state_after: no goals

tactic: exact map_zero e
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝⁴ : Zero M
a✝ a' : α
b✝ : M
inst✝³ : AddCommMonoid N
inst✝² : AddCommMonoid P
F : Type u_13
inst✝¹ : FunLike F N P
inst✝ : AddMonoidHomClass F N P
e : F
a : α
n : N
b : α
h✝ : ¬a = b
⊢ e 0 = 0
state_after: no goals
Theorem: IsClosed.nhdsSet_le_sup
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [Set.inter_union_compl s t]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ s = 𝓝ˢ (s ∩ t ∪ s ∩ tᶜ)
state_after: no goals

tactic: rw [nhdsSet_union]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ (s ∩ t ∪ s ∩ tᶜ) = 𝓝ˢ (s ∩ t) ⊔ 𝓝ˢ (s ∩ tᶜ)
state_after: no goals

tactic: rw [h.isOpen_compl.nhdsSet_eq]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h : IsClosed t
⊢ 𝓝ˢ (s ∩ t) ⊔ 𝓝ˢ tᶜ = 𝓝ˢ (s ∩ t) ⊔ 𝓟 tᶜ
state_after: no goals
Theorem: Cardinal.mk_eq_nat_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_mk_fin, ← lift_uzero #α, lift_mk_eq']
state_before: α✝ β α : Type u
n : ℕ
⊢ #α = ↑n ↔ Nonempty (α ≃ Fin n)
state_after: no goals
Theorem: Real.vector_fourierIntegral_eq_integral_exp_smul
File: Mathlib/Analysis/Fourier/FourierTransform.lean

tactic: simp_rw [VectorFourier.fourierIntegral, Submonoid.smul_def, Real.fourierChar_apply, mul_neg,
  neg_mul]
state_before: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℂ E
V : Type u_2
inst✝⁴ : AddCommGroup V
inst✝³ : Module ℝ V
inst✝² : MeasurableSpace V
W : Type u_3
inst✝¹ : AddCommGroup W
inst✝ : Module ℝ W
L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ
μ : Measure V
f : V → E
w : W
⊢ VectorFourier.fourierIntegral 𝐞 μ L f w = ∫ (v : V), Complex.exp (↑(-2 * π * (L v) w) * Complex.I) • f v ∂μ
state_after: no goals
Theorem: Set.Nontrivial.ne_singleton
File: Mathlib/Data/Set/Subsingleton.lean

tactic: rw [H] at hs
state_before: α : Type u
a : α
s t : Set α
x : α
hs : s.Nontrivial
H : s = {x}
⊢ False
state_after: α : Type u
a : α
s t : Set α
x : α
hs : {x}.Nontrivial
H : s = {x}
⊢ False

tactic: exact not_nontrivial_singleton hs
state_before: α : Type u
a : α
s t : Set α
x : α
hs : {x}.Nontrivial
H : s = {x}
⊢ False
state_after: no goals
Theorem: IsHausdorff.subsingleton
File: Mathlib/RingTheory/AdicCompletion/Basic.lean

tactic: rw [Ideal.top_pow, top_smul]
state_before: R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h : IsHausdorff ⊤ M
x y : M
n : ℕ
⊢ x - y ≡ 0 [SMOD ⊤ ^ n • ⊤]
state_after: R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h : IsHausdorff ⊤ M
x y : M
n : ℕ
⊢ x - y ≡ 0 [SMOD ⊤]

tactic: exact SModEq.top
state_before: R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
h : IsHausdorff ⊤ M
x y : M
n : ℕ
⊢ x - y ≡ 0 [SMOD ⊤]
state_after: no goals
Theorem: SimpleGraph.edgeFinset_top
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

tactic: rw [← coe_inj]
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
G₁ G₂ : SimpleGraph V
inst✝⁴ : Fintype ↑G.edgeSet
inst✝³ : Fintype ↑G₁.edgeSet
inst✝² : Fintype ↑G₂.edgeSet
inst✝¹ : Fintype V
inst✝ : DecidableEq V
⊢ ⊤.edgeFinset = filter (fun e => ¬e.IsDiag) univ
state_after: V : Type u_1
G : SimpleGraph V
e : Sym2 V
G₁ G₂ : SimpleGraph V
inst✝⁴ : Fintype ↑G.edgeSet
inst✝³ : Fintype ↑G₁.edgeSet
inst✝² : Fintype ↑G₂.edgeSet
inst✝¹ : Fintype V
inst✝ : DecidableEq V
⊢ ↑⊤.edgeFinset = ↑(filter (fun e => ¬e.IsDiag) univ)

tactic: simp
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
G₁ G₂ : SimpleGraph V
inst✝⁴ : Fintype ↑G.edgeSet
inst✝³ : Fintype ↑G₁.edgeSet
inst✝² : Fintype ↑G₂.edgeSet
inst✝¹ : Fintype V
inst✝ : DecidableEq V
⊢ ↑⊤.edgeFinset = ↑(filter (fun e => ¬e.IsDiag) univ)
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.add_of_Z_eq_zero_right
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [add, if_neg <| not_equiv_of_Z_eq_zero_right hPz hQz, addXYZ_of_Z_eq_zero_right hQ hQz]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hQ : W'.Equation Q
hPz : P z ≠ 0
hQz : Q z = 0
⊢ W'.add P Q = -(Q x * P z) • P
state_after: no goals
Theorem: Vector.get_ofFn
File: Mathlib/Data/Vector/Basic.lean

tactic: conv_rhs => erw [← List.get_ofFn f ⟨i, by simp⟩]
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).get i = f i
state_after: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).get i = (List.ofFn f).get ⟨↑i, ⋯⟩

tactic: simp only [get_eq_get]
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).get i = (List.ofFn f).get ⟨↑i, ⋯⟩
state_after: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).toList.get (Fin.cast ⋯ i) = (List.ofFn f).get ⟨↑i, ⋯⟩

tactic: congr <;> simp [Fin.heq_ext_iff]
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).toList.get (Fin.cast ⋯ i) = (List.ofFn f).get ⟨↑i, ⋯⟩
state_after: no goals

tactic: simp
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ ↑i < (List.ofFn f).length
state_after: no goals
Theorem: PMF.bindOnSupport_eq_bind
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: ext b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : PMF α
f✝ : (a : α) → a ∈ p✝.support → PMF β
p : PMF α
f : α → PMF β
⊢ (p.bindOnSupport fun a x => f a) = p.bind f
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : PMF α
f✝ : (a : α) → a ∈ p✝.support → PMF β
p : PMF α
f : α → PMF β
b : β
⊢ (p.bindOnSupport fun a x => f a) b = (p.bind f) b

tactic: have : ∀ a, ite (p a = 0) 0 (p a * f a b) = p a * f a b :=
  fun a => ite_eq_right_iff.2 fun h => h.symm ▸ symm (zero_mul <| f a b)
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : PMF α
f✝ : (a : α) → a ∈ p✝.support → PMF β
p : PMF α
f : α → PMF β
b : β
⊢ (p.bindOnSupport fun a x => f a) b = (p.bind f) b
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : PMF α
f✝ : (a : α) → a ∈ p✝.support → PMF β
p : PMF α
f : α → PMF β
b : β
this : ∀ (a : α), (if p a = 0 then 0 else p a * (f a) b) = p a * (f a) b
⊢ (p.bindOnSupport fun a x => f a) b = (p.bind f) b

tactic: simp only [bindOnSupport_apply fun a _ => f a, p.bind_apply f, dite_eq_ite, mul_ite,
  mul_zero, this]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ : PMF α
f✝ : (a : α) → a ∈ p✝.support → PMF β
p : PMF α
f : α → PMF β
b : β
this : ∀ (a : α), (if p a = 0 then 0 else p a * (f a) b) = p a * (f a) b
⊢ (p.bindOnSupport fun a x => f a) b = (p.bind f) b
state_after: no goals
Theorem: Con.sSup_def
File: Mathlib/GroupTheory/Congruence/Basic.lean

tactic: rw [sSup_eq_conGen, sSup_image]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ sSup S = conGen (sSup (DFunLike.coe '' S))
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ (conGen fun x y => ∃ c ∈ S, c x y) = conGen (⨆ a ∈ S, ⇑a)

tactic: congr with (x y)
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ (conGen fun x y => ∃ c ∈ S, c x y) = conGen (⨆ a ∈ S, ⇑a)
state_after: case e_r.h.h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x y : M
⊢ (∃ c ∈ S, c x y) ↔ (⨆ a ∈ S, ⇑a) x y

tactic: simp only [sSup_image, iSup_apply, iSup_Prop_eq, exists_prop, rel_eq_coe]
state_before: case e_r.h.h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x y : M
⊢ (∃ c ∈ S, c x y) ↔ (⨆ a ∈ S, ⇑a) x y
state_after: no goals
Theorem: Zsqrtd.sqLe_cancel
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: apply le_of_not_gt
state_before: d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
⊢ SqLe z c w d
state_after: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
⊢ ¬c * z * z > d * w * w

tactic: intro l
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
⊢ ¬c * z * z > d * w * w
state_after: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
⊢ False

tactic: refine not_le_of_gt ?_ h
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
⊢ False
state_after: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
⊢ c * (x + z) * (x + z) > d * (y + w) * (y + w)

tactic: simp only [SqLe, mul_add, mul_comm, mul_left_comm, add_assoc, gt_iff_lt]
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
⊢ c * (x + z) * (x + z) > d * (y + w) * (y + w)
state_after: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
⊢ d * (y * y) + (d * (y * w) + (d * (y * w) + d * (w * w))) < c * (x * x) + (c * (x * z) + (c * (x * z) + c * (z * z)))

tactic: have hm := sqLe_add_mixed zw (le_of_lt l)
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
⊢ d * (y * y) + (d * (y * w) + (d * (y * w) + d * (w * w))) < c * (x * x) + (c * (x * z) + (c * (x * z) + c * (z * z)))
state_after: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
hm : d * (y * w) ≤ c * (x * z)
⊢ d * (y * y) + (d * (y * w) + (d * (y * w) + d * (w * w))) < c * (x * x) + (c * (x * z) + (c * (x * z) + c * (z * z)))

tactic: simp only [SqLe, mul_assoc, gt_iff_lt] at l zw
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
zw : SqLe y d x c
h : SqLe (x + z) c (y + w) d
l : c * z * z > d * w * w
hm : d * (y * w) ≤ c * (x * z)
⊢ d * (y * y) + (d * (y * w) + (d * (y * w) + d * (w * w))) < c * (x * x) + (c * (x * z) + (c * (x * z) + c * (z * z)))
state_after: case a
d✝ : ℤ
c d x y z w : ℕ
h : SqLe (x + z) c (y + w) d
hm : d * (y * w) ≤ c * (x * z)
l : d * (w * w) < c * (z * z)
zw : d * (y * y) ≤ c * (x * x)
⊢ d * (y * y) + (d * (y * w) + (d * (y * w) + d * (w * w))) < c * (x * x) + (c * (x * z) + (c * (x * z) + c * (z * z)))

tactic: exact
  lt_of_le_of_lt (add_le_add_right zw _)
    (add_lt_add_left (add_lt_add_of_le_of_lt hm (add_lt_add_of_le_of_lt hm l)) _)
state_before: case a
d✝ : ℤ
c d x y z w : ℕ
h : SqLe (x + z) c (y + w) d
hm : d * (y * w) ≤ c * (x * z)
l : d * (w * w) < c * (z * z)
zw : d * (y * y) ≤ c * (x * x)
⊢ d * (y * y) + (d * (y * w) + (d * (y * w) + d * (w * w))) < c * (x * x) + (c * (x * z) + (c * (x * z) + c * (z * z)))
state_after: no goals
Theorem: Nat.coprime_prod_left_iff
File: Mathlib/Data/Nat/GCD/BigOperators.lean

tactic: simpa using coprime_multiset_prod_left_iff (m := t.val.map s)
state_before: ι : Type u_1
t : Finset ι
s : ι → ℕ
x : ℕ
⊢ (∏ i ∈ t, s i).Coprime x ↔ ∀ i ∈ t, (s i).Coprime x
state_after: no goals
Theorem: Polynomial.poly_binom_aux2
File: Mathlib/Algebra/Polynomial/Identities.lean

tactic: unfold eval
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
⊢ eval (x + y) f = f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)
state_after: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
⊢ eval₂ (RingHom.id R) (x + y) f =
    f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)

tactic: rw [eval₂_eq_sum]
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
⊢ eval₂ (RingHom.id R) (x + y) f =
    f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)
state_after: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
⊢ (f.sum fun e a => (RingHom.id R) a * (x + y) ^ e) =
    f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)

tactic: congr with (n z)
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
⊢ (f.sum fun e a => (RingHom.id R) a * (x + y) ^ e) =
    f.sum fun e a => a * (x ^ e + ↑e * x ^ (e - 1) * y + ↑(Polynomial.polyBinomAux1 x y e a) * y ^ 2)
state_after: case e_f.h.h
R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n✝ : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
n : ℕ
z : R
⊢ (RingHom.id R) z * (x + y) ^ n = z * (x ^ n + ↑n * x ^ (n - 1) * y + ↑(Polynomial.polyBinomAux1 x y n z) * y ^ 2)

tactic: apply (polyBinomAux1 x y _ _).property
state_before: case e_f.h.h
R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n✝ : ℕ
inst✝ : CommRing R
f : R[X]
x y : R
n : ℕ
z : R
⊢ (RingHom.id R) z * (x + y) ^ n = z * (x ^ n + ↑n * x ^ (n - 1) * y + ↑(Polynomial.polyBinomAux1 x y n z) * y ^ 2)
state_after: no goals
Theorem: Rat.add_le_add_left
File: Mathlib/Algebra/Order/Ring/Rat.lean

tactic: rw [Rat.le_iff_sub_nonneg, add_sub_add_left_eq_sub, ← Rat.le_iff_sub_nonneg]
state_before: a✝ b✝ c✝ p q a b c : ℚ
⊢ c + a ≤ c + b ↔ a ≤ b
state_after: no goals
Theorem: Ordinal.nfpFamily_le_fp
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: by_cases hι : IsEmpty ι
state_before: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal.{max u v}
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
⊢ List.foldr f a l ≤ b
state_after: case pos
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal.{max u v}
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
hι : IsEmpty ι
⊢ List.foldr f a l ≤ b

case neg
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal.{max u v}
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
hι : ¬IsEmpty ι
⊢ List.foldr f a l ≤ b

tactic: rwa [Unique.eq_default l]
state_before: case pos
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal.{max u v}
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
hι : IsEmpty ι
⊢ List.foldr f a l ≤ b
state_after: no goals

tactic: induction' l with i l IH generalizing a
state_before: case neg
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal.{max u v}
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
hι : ¬IsEmpty ι
⊢ List.foldr f a l ≤ b
state_after: case neg.nil
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ b
hι : ¬IsEmpty ι
a : Ordinal.{max u v}
ab : a ≤ b
⊢ List.foldr f a [] ≤ b

case neg.cons
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ b
hι : ¬IsEmpty ι
i : ι
l : List ι
IH : ∀ {a : Ordinal.{max u v}}, a ≤ b → List.foldr f a l ≤ b
a : Ordinal.{max u v}
ab : a ≤ b
⊢ List.foldr f a (i :: l) ≤ b

tactic: exact (H i (IH ab)).trans (h i)
state_before: case neg.cons
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ b
hι : ¬IsEmpty ι
i : ι
l : List ι
IH : ∀ {a : Ordinal.{max u v}}, a ≤ b → List.foldr f a l ≤ b
a : Ordinal.{max u v}
ab : a ≤ b
⊢ List.foldr f a (i :: l) ≤ b
state_after: no goals

tactic: exact ab
state_before: case neg.nil
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ b
hι : ¬IsEmpty ι
a : Ordinal.{max u v}
ab : a ≤ b
⊢ List.foldr f a [] ≤ b
state_after: no goals
Theorem: FractionRing.mk_eq_div
File: Mathlib/RingTheory/Localization/FractionRing.lean

tactic: rw [Localization.mk_eq_mk', IsFractionRing.mk'_eq_div]
state_before: R : Type u_1
inst✝⁵ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁴ : CommRing S
inst✝³ : Algebra R S
P : Type u_3
inst✝² : CommRing P
A : Type u_4
inst✝¹ : CommRing A
inst✝ : IsDomain A
K : Type u_5
r : A
s : ↥(nonZeroDivisors A)
⊢ Localization.mk r s = (algebraMap A (FractionRing A)) r / (algebraMap A (FractionRing A)) ↑s
state_after: no goals
Theorem: bernoulliFourierCoeff_zero
File: Mathlib/NumberTheory/ZetaValues.lean

tactic: simp_rw [bernoulliFourierCoeff, fourierCoeffOn_eq_integral, neg_zero, fourier_zero, sub_zero,
  div_one, one_smul, intervalIntegral.integral_ofReal, integral_bernoulliFun_eq_zero hk,
  ofReal_zero]
state_before: k : ℕ
hk : k ≠ 0
⊢ bernoulliFourierCoeff k 0 = 0
state_after: no goals