1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: isClosed_le_of_isClosed_nonneg
File: Mathlib/Analysis/Normed/Order/Lattice.lean

tactic: have : { p : G × G | p.fst ≤ p.snd } = (fun p : G × G => p.snd - p.fst) ⁻¹' { x : G | 0 ≤ x } :=
  by ext1 p; simp only [sub_nonneg, Set.preimage_setOf_eq]
state_before: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
⊢ IsClosed {p | p.1 ≤ p.2}
state_after: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
this : {p | p.1 ≤ p.2} = (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}
⊢ IsClosed {p | p.1 ≤ p.2}

tactic: rw [this]
state_before: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
this : {p | p.1 ≤ p.2} = (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}
⊢ IsClosed {p | p.1 ≤ p.2}
state_after: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
this : {p | p.1 ≤ p.2} = (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}
⊢ IsClosed ((fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x})

tactic: exact IsClosed.preimage (continuous_snd.sub continuous_fst) h
state_before: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
this : {p | p.1 ≤ p.2} = (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}
⊢ IsClosed ((fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x})
state_after: no goals

tactic: ext1 p
state_before: α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
⊢ {p | p.1 ≤ p.2} = (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}
state_after: case h
α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
p : G × G
⊢ p ∈ {p | p.1 ≤ p.2} ↔ p ∈ (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}

tactic: simp only [sub_nonneg, Set.preimage_setOf_eq]
state_before: case h
α : Type u_1
inst✝³ : NormedLatticeAddCommGroup α
G : Type u_2
inst✝² : OrderedAddCommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousSub G
h : IsClosed {x | 0 ≤ x}
p : G × G
⊢ p ∈ {p | p.1 ≤ p.2} ↔ p ∈ (fun p => p.2 - p.1) ⁻¹' {x | 0 ≤ x}
state_after: no goals
Theorem: ExistsContDiffBumpBase.u_compact_support
File: Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean

tactic: rw [hasCompactSupport_def, u_support, closure_ball (0 : E) one_ne_zero]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ HasCompactSupport u
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ IsCompact (closedBall 0 1)

tactic: exact isCompact_closedBall _ _
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ IsCompact (closedBall 0 1)
state_after: no goals
Theorem: Equiv.Perm.support_cycleOf_nonempty
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

tactic: rw [← two_le_card_support_cycleOf_iff, ← card_pos, ← Nat.succ_le_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ (f.cycleOf x).support.Nonempty ↔ f x ≠ x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ Nat.succ 0 ≤ (f.cycleOf x).support.card ↔ 2 ≤ (f.cycleOf x).support.card

tactic: exact ⟨fun h => Or.resolve_left h.eq_or_lt (card_support_ne_one _).symm, zero_lt_two.trans_le⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ Nat.succ 0 ≤ (f.cycleOf x).support.card ↔ 2 ≤ (f.cycleOf x).support.card
state_after: no goals
Theorem: Fin.univ_image_get
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp [univ_image_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l : List α
⊢ image l.get univ = l.toFinset
state_after: no goals
Theorem: Filter.EventuallyEq.hasDerivAtFilter_iff
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simp [h₁]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h₀ : f₀ =ᶠ[L] f₁
hx : f₀ x = f₁ x
h₁ : f₀' = f₁'
⊢ ∀ (x : 𝕜), (smulRight 1 f₀') x = (smulRight 1 f₁') x
state_after: no goals
Theorem: Polynomial.degree_normalize
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: simp
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
inst✝ : DecidableEq R
⊢ (normalize p).degree = p.degree
state_after: no goals
Theorem: HasProd.prod_mk
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

tactic: simp [HasProd, ← prod_mk_prod, Filter.Tendsto.prod_mk_nhds hf hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : CommMonoid γ
inst✝ : TopologicalSpace γ
f : β → α
g : β → γ
a : α
b : γ
hf : HasProd f a
hg : HasProd g b
⊢ HasProd (fun x => (f x, g x)) (a, b)
state_after: no goals
Theorem: WeakFEPair.h_feq'
File: Mathlib/NumberTheory/LSeries/AbstractFuncEq.lean

tactic: rw [(div_div_cancel' (one_ne_zero' ℝ) ▸ P.h_feq (1 / x) (one_div_pos.mpr hx) :), ← mul_smul]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ P.g (1 / x) = (P.ε⁻¹ * ↑(x ^ P.k)) • P.f x
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ P.g (1 / x) = (P.ε⁻¹ * ↑(x ^ P.k) * (P.ε * ↑((1 / x) ^ P.k))) • P.g (1 / x)

tactic: convert (one_smul ℂ (P.g (1 / x))).symm using 2
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ P.g (1 / x) = (P.ε⁻¹ * ↑(x ^ P.k) * (P.ε * ↑((1 / x) ^ P.k))) • P.g (1 / x)
state_after: case h.e'_3.h.e'_5
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ P.ε⁻¹ * ↑(x ^ P.k) * (P.ε * ↑((1 / x) ^ P.k)) = 1

tactic: rw [one_div, inv_rpow hx.le, ofReal_inv]
state_before: case h.e'_3.h.e'_5
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ P.ε⁻¹ * ↑(x ^ P.k) * (P.ε * ↑((1 / x) ^ P.k)) = 1
state_after: case h.e'_3.h.e'_5
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ P.ε⁻¹ * ↑(x ^ P.k) * (P.ε * (↑(x ^ P.k))⁻¹) = 1

tactic: field_simp [P.hε, (rpow_pos_of_pos hx _).ne']
state_before: case h.e'_3.h.e'_5
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
P : WeakFEPair E
x : ℝ
hx : 0 < x
⊢ P.ε⁻¹ * ↑(x ^ P.k) * (P.ε * (↑(x ^ P.k))⁻¹) = 1
state_after: no goals
Theorem: toIocMod_add_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIocMod_add_zsmul hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp a (b + p) = toIocMod hp a b
state_after: no goals
Theorem: Finset.sum_affineCombinationSingleWeights
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [← affineCombinationSingleWeights_apply_self k i]
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 : ι
h : i ∈ s
⊢ ∑ j ∈ s, affineCombinationSingleWeights k i j = 1
state_after: 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 : ι
h : i ∈ s
⊢ ∑ j ∈ s, affineCombinationSingleWeights k i j = affineCombinationSingleWeights k i i

tactic: exact sum_eq_single_of_mem i h fun j _ hj => affineCombinationSingleWeights_apply_of_ne k hj
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 : ι
h : i ∈ s
⊢ ∑ j ∈ s, affineCombinationSingleWeights k i j = affineCombinationSingleWeights k i i
state_after: no goals
Theorem: fderiv_continuousMultilinear_apply_const_apply
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

tactic: simp [fderiv_continuousMultilinear_apply_const hc]
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
G' : Type u_5
inst✝⁶ : NormedAddCommGroup G'
inst✝⁵ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_6
inst✝⁴ : Fintype ι
M : ι → Type u_7
inst✝³ : (i : ι) → NormedAddCommGroup (M i)
inst✝² : (i : ι) → NormedSpace 𝕜 (M i)
H : Type u_8
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
c : E → ContinuousMultilinearMap 𝕜 M H
c' : E →L[𝕜] ContinuousMultilinearMap 𝕜 M H
hc : DifferentiableAt 𝕜 c x
u : (i : ι) → M i
m : E
⊢ (fderiv 𝕜 (fun y => (c y) u) x) m = ((fderiv 𝕜 c x) m) u
state_after: no goals
Theorem: Finset.uIcc_subset_uIcc_union_uIcc
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: push_cast
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ ↑[[a, c]] ⊆ ↑([[a, b]] ∪ [[b, c]])
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.uIcc a c ⊆ Set.uIcc a b ∪ Set.uIcc b c

tactic: exact Set.uIcc_subset_uIcc_union_uIcc
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.uIcc a c ⊆ Set.uIcc a b ∪ Set.uIcc b c
state_after: no goals
Theorem: Quot.subsingleton_iff
File: Mathlib/Data/Setoid/Basic.lean

tactic: simp only [_root_.subsingleton_iff, _root_.eq_top_iff, Pi.le_def, Pi.top_apply, forall_const]
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
⊢ Subsingleton (Quot r) ↔ EqvGen r = ⊤
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
⊢ (∀ (x y : Quot r), x = y) ↔ ∀ (i i_1 : α), ⊤ ≤ EqvGen r i i_1

tactic: refine (surjective_quot_mk _).forall.trans (forall_congr' fun a => ?_)
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
⊢ (∀ (x y : Quot r), x = y) ↔ ∀ (i i_1 : α), ⊤ ≤ EqvGen r i i_1
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
a : α
⊢ (∀ (y : Quot r), mk r a = y) ↔ ∀ (i : α), ⊤ ≤ EqvGen r a i

tactic: refine (surjective_quot_mk _).forall.trans (forall_congr' fun b => ?_)
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
a : α
⊢ (∀ (y : Quot r), mk r a = y) ↔ ∀ (i : α), ⊤ ≤ EqvGen r a i
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
a b : α
⊢ mk r a = mk r b ↔ ⊤ ≤ EqvGen r a b

tactic: rw [Quot.eq]
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
a b : α
⊢ mk r a = mk r b ↔ ⊤ ≤ EqvGen r a b
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
a b : α
⊢ EqvGen r a b ↔ ⊤ ≤ EqvGen r a b

tactic: simp only [forall_const, le_Prop_eq, Pi.top_apply, Prop.top_eq_true, true_implies]
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
a b : α
⊢ EqvGen r a b ↔ ⊤ ≤ EqvGen r a b
state_after: no goals
Theorem: div_mabs_eq_inv_leOnePart_sq
File: Mathlib/Algebra/Order/Group/PosPart.lean

tactic: rw [← mabs_div_eq_leOnePart_sq, inv_div]
state_before: α : Type u_1
β : Type u_2
inst✝³ inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ a / mabs a = (a⁻ᵐ ^ 2)⁻¹
state_after: no goals
Theorem: CategoryTheory.IsPullback.isoPullback_inv_snd
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: simp [Iso.inv_comp_eq]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
h : IsPullback fst snd f g
inst✝ : HasPullback f g
⊢ h.isoPullback.inv ≫ snd = pullback.snd
state_after: no goals
Theorem: BooleanRing.inf_assoc
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: ring
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b c : α
⊢ a * b * c = a * (b * c)
state_after: no goals
Theorem: RightDerivMeasurableAux.le_of_mem_A
File: Mathlib/Analysis/Calculus/FDeriv/Measurable.lean

tactic: rcases hx with ⟨r', r'mem, hr'⟩
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r ε : ℝ
L : F
x : ℝ
hx : x ∈ A f L r ε
y z : ℝ
hy : y ∈ Icc x (x + r / 2)
hz : z ∈ Icc x (x + r / 2)
⊢ ‖f z - f y - (z - y) • L‖ ≤ ε * r
state_after: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r ε : ℝ
L : F
x y z : ℝ
hy : y ∈ Icc x (x + r / 2)
hz : z ∈ Icc x (x + r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
⊢ ‖f z - f y - (z - y) • L‖ ≤ ε * r

tactic: have A : x + r / 2 ≤ x + r' := by linarith [r'mem.1]
state_before: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r ε : ℝ
L : F
x y z : ℝ
hy : y ∈ Icc x (x + r / 2)
hz : z ∈ Icc x (x + r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
⊢ ‖f z - f y - (z - y) • L‖ ≤ ε * r
state_after: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r ε : ℝ
L : F
x y z : ℝ
hy : y ∈ Icc x (x + r / 2)
hz : z ∈ Icc x (x + r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
A : x + r / 2 ≤ x + r'
⊢ ‖f z - f y - (z - y) • L‖ ≤ ε * r

tactic: exact hr' _ ((Icc_subset_Icc le_rfl A) hy) _ ((Icc_subset_Icc le_rfl A) hz)
state_before: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r ε : ℝ
L : F
x y z : ℝ
hy : y ∈ Icc x (x + r / 2)
hz : z ∈ Icc x (x + r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
A : x + r / 2 ≤ x + r'
⊢ ‖f z - f y - (z - y) • L‖ ≤ ε * r
state_after: no goals

tactic: linarith [r'mem.1]
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r ε : ℝ
L : F
x y z : ℝ
hy : y ∈ Icc x (x + r / 2)
hz : z ∈ Icc x (x + r / 2)
r' : ℝ
r'mem : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
⊢ x + r / 2 ≤ x + r'
state_after: no goals
Theorem: SimpleGraph.IsSRGWith.card_neighborFinset_union_of_not_adj
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

tactic: rw [← h.of_not_adj hne ha]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
hne : v ≠ w
ha : ¬G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - μ
state_after: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
hne : v ≠ w
ha : ¬G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - Fintype.card ↑(G.commonNeighbors v w)

tactic: apply h.card_neighborFinset_union_eq
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : G.IsSRGWith n k ℓ μ
hne : v ≠ w
ha : ¬G.Adj v w
⊢ (G.neighborFinset v ∪ G.neighborFinset w).card = 2 * k - Fintype.card ↑(G.commonNeighbors v w)
state_after: no goals
Theorem: List.rotate'_eq_drop_append_take
File: Mathlib/Data/List/Rotate.lean

tactic: simp [drop_append_of_le_length h]
state_before: α : Type u
n : ℕ
h : n ≤ [].length
⊢ [].rotate' n = drop n [] ++ take n []
state_after: no goals

tactic: simp [take_append_of_le_length h]
state_before: α : Type u
l : List α
h : 0 ≤ l.length
⊢ l.rotate' 0 = drop 0 l ++ take 0 l
state_after: no goals

tactic: have hnl : n ≤ l.length := le_of_succ_le_succ h
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ (a :: l).length
⊢ (a :: l).rotate' (n + 1) = drop (n + 1) (a :: l) ++ take (n + 1) (a :: l)
state_after: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ (a :: l).length
hnl : n ≤ l.length
⊢ (a :: l).rotate' (n + 1) = drop (n + 1) (a :: l) ++ take (n + 1) (a :: l)

tactic: have hnl' : n ≤ (l ++ [a]).length := by
  rw [length_append, length_cons, List.length]; exact le_of_succ_le h
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ (a :: l).length
hnl : n ≤ l.length
⊢ (a :: l).rotate' (n + 1) = drop (n + 1) (a :: l) ++ take (n + 1) (a :: l)
state_after: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ (a :: l).length
hnl : n ≤ l.length
hnl' : n ≤ (l ++ [a]).length
⊢ (a :: l).rotate' (n + 1) = drop (n + 1) (a :: l) ++ take (n + 1) (a :: l)

tactic: rw [rotate'_cons_succ, rotate'_eq_drop_append_take hnl', drop, take,
    drop_append_of_le_length hnl, take_append_of_le_length hnl]
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ (a :: l).length
hnl : n ≤ l.length
hnl' : n ≤ (l ++ [a]).length
⊢ (a :: l).rotate' (n + 1) = drop (n + 1) (a :: l) ++ take (n + 1) (a :: l)
state_after: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ (a :: l).length
hnl : n ≤ l.length
hnl' : n ≤ (l ++ [a]).length
⊢ drop n l ++ [a] ++ take n l = drop n l ++ a :: take n l

tactic: simp
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ (a :: l).length
hnl : n ≤ l.length
hnl' : n ≤ (l ++ [a]).length
⊢ drop n l ++ [a] ++ take n l = drop n l ++ a :: take n l
state_after: no goals

tactic: rw [length_append, length_cons, List.length]
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ (a :: l).length
hnl : n ≤ l.length
⊢ n ≤ (l ++ [a]).length
state_after: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ (a :: l).length
hnl : n ≤ l.length
⊢ n ≤ l.length + (0 + 1)

tactic: exact le_of_succ_le h
state_before: α : Type u
a : α
l : List α
n : ℕ
h : n + 1 ≤ (a :: l).length
hnl : n ≤ l.length
⊢ n ≤ l.length + (0 + 1)
state_after: no goals
Theorem: CategoryTheory.Limits.IsLimit.hom_ext
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: rw [h.hom_lift f, h.hom_lift f']
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
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ t.π.app j = f' ≫ t.π.app j
⊢ f = f'
state_after: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ t.π.app j = f' ≫ t.π.app j
⊢ h.lift { pt := W, π := { app := fun b => f ≫ t.π.app b, naturality := ⋯ } } =
    h.lift { pt := W, π := { app := fun b => f' ≫ t.π.app b, naturality := ⋯ } }

tactic: congr
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
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ t.π.app j = f' ≫ t.π.app j
⊢ h.lift { pt := W, π := { app := fun b => f ≫ t.π.app b, naturality := ⋯ } } =
    h.lift { pt := W, π := { app := fun b => f' ≫ t.π.app b, naturality := ⋯ } }
state_after: case h.e_8.h.e_π.e_app
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ t.π.app j = f' ≫ t.π.app j
⊢ (fun b => f ≫ t.π.app b) = fun b => f' ≫ t.π.app b

tactic: exact funext w
state_before: case h.e_8.h.e_π.e_app
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ t.π.app j = f' ≫ t.π.app j
⊢ (fun b => f ≫ t.π.app b) = fun b => f' ≫ t.π.app b
state_after: no goals
Theorem: integral_bernoulliFun_eq_zero
File: Mathlib/NumberTheory/ZetaValues.lean

tactic: rw [integral_eq_sub_of_hasDerivAt (fun x _ => antideriv_bernoulliFun k x)
    ((Polynomial.continuous _).intervalIntegrable _ _)]
state_before: k : ℕ
hk : k ≠ 0
⊢ ∫ (x : ℝ) in 0 ..1, bernoulliFun k x = 0
state_after: k : ℕ
hk : k ≠ 0
⊢ bernoulliFun (k + 1) 1 / (↑k + 1) - bernoulliFun (k + 1) 0 / (↑k + 1) = 0

tactic: rw [bernoulliFun_eval_one]
state_before: k : ℕ
hk : k ≠ 0
⊢ bernoulliFun (k + 1) 1 / (↑k + 1) - bernoulliFun (k + 1) 0 / (↑k + 1) = 0
state_after: k : ℕ
hk : k ≠ 0
⊢ (bernoulliFun (k + 1) 0 + if k + 1 = 1 then 1 else 0) / (↑k + 1) - bernoulliFun (k + 1) 0 / (↑k + 1) = 0

tactic: split_ifs with h
state_before: k : ℕ
hk : k ≠ 0
⊢ (bernoulliFun (k + 1) 0 + if k + 1 = 1 then 1 else 0) / (↑k + 1) - bernoulliFun (k + 1) 0 / (↑k + 1) = 0
state_after: case pos
k : ℕ
hk : k ≠ 0
h : k + 1 = 1
⊢ (bernoulliFun (k + 1) 0 + 1) / (↑k + 1) - bernoulliFun (k + 1) 0 / (↑k + 1) = 0

case neg
k : ℕ
hk : k ≠ 0
h : ¬k + 1 = 1
⊢ (bernoulliFun (k + 1) 0 + 0) / (↑k + 1) - bernoulliFun (k + 1) 0 / (↑k + 1) = 0

tactic: exfalso
state_before: case pos
k : ℕ
hk : k ≠ 0
h : k + 1 = 1
⊢ (bernoulliFun (k + 1) 0 + 1) / (↑k + 1) - bernoulliFun (k + 1) 0 / (↑k + 1) = 0
state_after: case pos
k : ℕ
hk : k ≠ 0
h : k + 1 = 1
⊢ False

tactic: exact hk (Nat.succ_inj'.mp h)
state_before: case pos
k : ℕ
hk : k ≠ 0
h : k + 1 = 1
⊢ False
state_after: no goals

tactic: simp
state_before: case neg
k : ℕ
hk : k ≠ 0
h : ¬k + 1 = 1
⊢ (bernoulliFun (k + 1) 0 + 0) / (↑k + 1) - bernoulliFun (k + 1) 0 / (↑k + 1) = 0
state_after: no goals
Theorem: map_le_lineMap_iff_slope_le_slope_left
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: rw [lineMap_apply, lineMap_apply, slope, slope, vsub_eq_sub, vsub_eq_sub, vsub_eq_sub,
  vadd_eq_add, vadd_eq_add, smul_eq_mul, add_sub_cancel_right, smul_sub, smul_sub, smul_sub,
  sub_le_iff_le_add, mul_inv_rev, mul_smul, mul_smul, ← smul_sub, ← smul_sub, ← smul_add,
  smul_smul, ← mul_inv_rev, inv_smul_le_iff_of_pos h, smul_smul,
  mul_inv_cancel_right₀ (right_ne_zero_of_mul h.ne'), smul_add,
  smul_inv_smul₀ (left_ne_zero_of_mul h.ne')]
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : LinearOrderedField k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
f : k → E
a b r : k
h : 0 < r * (b - a)
⊢ f ((lineMap a b) r) ≤ (lineMap (f a) (f b)) r ↔ slope f a ((lineMap a b) r) ≤ slope f a b
state_after: no goals
Theorem: add_div_eq_mul_add_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [right_distrib, div_mul_cancel₀ _ hc]
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝ : DivisionSemiring α
a✝ b✝ c d a b : α
hc : c ≠ 0
⊢ (a + b / c) * c = a * c + b
state_after: no goals
Theorem: Zsqrtd.decompose
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: ext <;> simp
state_before: d x y : ℤ
⊢ { re := x, im := y } = ↑x + sqrtd * ↑y
state_after: no goals
Theorem: dist_inv_inv₀
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rw [dist_eq_norm, inv_sub_inv' hz hw, norm_mul, norm_mul, norm_inv, norm_inv, mul_comm ‖z‖⁻¹,
  mul_assoc, dist_eq_norm', div_eq_mul_inv, mul_inv]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : NormedDivisionRing α
a z w : α
hz : z ≠ 0
hw : w ≠ 0
⊢ dist z⁻¹ w⁻¹ = dist z w / (‖z‖ * ‖w‖)
state_after: no goals