1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: hasFDerivAt_apply
File: Mathlib/Analysis/Calculus/FDeriv/Prod.lean

tactic: apply HasStrictFDerivAt.hasFDerivAt
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 ι
F' : ι → Type u_7
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
i : ι
f : (i : ι) → F' i
⊢ HasFDerivAt (fun f => f i) (proj i) f
state_after: case hf
𝕜 : 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 ι
F' : ι → Type u_7
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
i : ι
f : (i : ι) → F' i
⊢ HasStrictFDerivAt (fun f => f i) (proj i) f

tactic: apply hasStrictFDerivAt_apply
state_before: case hf
𝕜 : 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 ι
F' : ι → Type u_7
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
i : ι
f : (i : ι) → F' i
⊢ HasStrictFDerivAt (fun f => f i) (proj i) f
state_after: no goals
Theorem: Nat.dvd_gcd_mul_gcd_iff_dvd_mul
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [dvd_gcd_mul_iff_dvd_mul, dvd_mul_gcd_iff_dvd_mul]
state_before: x n m : ℕ
⊢ x ∣ x.gcd n * x.gcd m ↔ x ∣ n * m
state_after: no goals
Theorem: Int.toNat_lt_toNat
File: Mathlib/Data/Int/Defs.lean

tactic: cases a
state_before: a✝ b✝ c d m n a b : ℤ
hb : 0 < b
h : a.toNat < b.toNat
⊢ a < b
state_after: case ofNat
a b✝ c d m n b : ℤ
hb : 0 < b
a✝ : ℕ
h : (ofNat a✝).toNat < b.toNat
⊢ ofNat a✝ < b

case negSucc
a b✝ c d m n b : ℤ
hb : 0 < b
a✝ : ℕ
h : -[a✝+1].toNat < b.toNat
⊢ -[a✝+1] < b

tactic: exacts [lt_toNat.1 h, Int.lt_trans (neg_of_sign_eq_neg_one rfl) hb]
state_before: case ofNat
a b✝ c d m n b : ℤ
hb : 0 < b
a✝ : ℕ
h : (ofNat a✝).toNat < b.toNat
⊢ ofNat a✝ < b

case negSucc
a b✝ c d m n b : ℤ
hb : 0 < b
a✝ : ℕ
h : -[a✝+1].toNat < b.toNat
⊢ -[a✝+1] < b
state_after: no goals

tactic: rw [lt_toNat]
state_before: a✝ b✝ c d m n a b : ℤ
hb : 0 < b
h : a < b
⊢ a.toNat < b.toNat
state_after: a✝ b✝ c d m n a b : ℤ
hb : 0 < b
h : a < b
⊢ ↑a.toNat < b

tactic: cases a
state_before: a✝ b✝ c d m n a b : ℤ
hb : 0 < b
h : a < b
⊢ ↑a.toNat < b
state_after: case ofNat
a b✝ c d m n b : ℤ
hb : 0 < b
a✝ : ℕ
h : ofNat a✝ < b
⊢ ↑(ofNat a✝).toNat < b

case negSucc
a b✝ c d m n b : ℤ
hb : 0 < b
a✝ : ℕ
h : -[a✝+1] < b
⊢ ↑-[a✝+1].toNat < b

tactic: exacts [h, hb]
state_before: case ofNat
a b✝ c d m n b : ℤ
hb : 0 < b
a✝ : ℕ
h : ofNat a✝ < b
⊢ ↑(ofNat a✝).toNat < b

case negSucc
a b✝ c d m n b : ℤ
hb : 0 < b
a✝ : ℕ
h : -[a✝+1] < b
⊢ ↑-[a✝+1].toNat < b
state_after: no goals
Theorem: card_zpowers_le
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [Fintype.card_zpowers]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
a : G
k : ℕ
k_pos : k ≠ 0
ha : a ^ k = 1
⊢ card ↥(zpowers a) ≤ k
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
a : G
k : ℕ
k_pos : k ≠ 0
ha : a ^ k = 1
⊢ orderOf a ≤ k

tactic: apply orderOf_le_of_pow_eq_one k_pos.bot_lt ha
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
a : G
k : ℕ
k_pos : k ≠ 0
ha : a ^ k = 1
⊢ orderOf a ≤ k
state_after: no goals
Theorem: Doset.disjoint_out'
File: Mathlib/GroupTheory/DoubleCoset.lean

tactic: contrapose!
state_before: G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : Quotient ↑H.toSubmonoid ↑K
⊢ a ≠ b → Disjoint (doset (Quotient.out' a) ↑H ↑K) (doset (Quotient.out' b) ↑H ↑K)
state_after: G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : Quotient ↑H.toSubmonoid ↑K
⊢ ¬Disjoint (doset (Quotient.out' a) ↑H ↑K) (doset (Quotient.out' b) ↑H ↑K) → a = b

tactic: intro h
state_before: G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : Quotient ↑H.toSubmonoid ↑K
⊢ ¬Disjoint (doset (Quotient.out' a) ↑H ↑K) (doset (Quotient.out' b) ↑H ↑K) → a = b
state_after: G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : Quotient ↑H.toSubmonoid ↑K
h : ¬Disjoint (doset (Quotient.out' a) ↑H ↑K) (doset (Quotient.out' b) ↑H ↑K)
⊢ a = b

tactic: simpa [out_eq'] using mk_eq_of_doset_eq (eq_of_not_disjoint h)
state_before: G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : Quotient ↑H.toSubmonoid ↑K
h : ¬Disjoint (doset (Quotient.out' a) ↑H ↑K) (doset (Quotient.out' b) ↑H ↑K)
⊢ a = b
state_after: no goals
Theorem: DirectSum.mulHom_of_of
File: Mathlib/Algebra/DirectSum/Ring.lean

tactic: unfold mulHom
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ((mulHom A) ((of A i) a)) ((of A j) b) = (of A (i + j)) (GradedMonoid.GMul.mul a b)
state_after: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ((toAddMonoid fun x => (toAddMonoid fun x_1 => ((compHom (of A (x + x_1))).comp (gMulHom A)).flip).flip) ((of A i) a))
      ((of A j) b) =
    (of A (i + j)) (GradedMonoid.GMul.mul a b)

tactic: simp only [toAddMonoid_of, flip_apply, coe_comp, Function.comp_apply]
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ((toAddMonoid fun x => (toAddMonoid fun x_1 => ((compHom (of A (x + x_1))).comp (gMulHom A)).flip).flip) ((of A i) a))
      ((of A j) b) =
    (of A (i + j)) (GradedMonoid.GMul.mul a b)
state_after: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ((compHom (of A (i + j))) ((gMulHom A) a)) b = (of A (i + j)) (GradedMonoid.GMul.mul a b)

tactic: rfl
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ((compHom (of A (i + j))) ((gMulHom A) a)) b = (of A (i + j)) (GradedMonoid.GMul.mul a b)
state_after: no goals
Theorem: Multiset.countP_congr
File: Mathlib/Data/Multiset/Basic.lean

tactic: revert hs hp
state_before: α : Type u_1
β : Type v
γ : Type u_2
p✝ : α → Prop
inst✝² : DecidablePred p✝
s s' : Multiset α
hs : s = s'
p p' : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred p'
hp : ∀ x ∈ s, p x = p' x
⊢ countP p s = countP p' s'
state_after: α : Type u_1
β : Type v
γ : Type u_2
p✝ : α → Prop
inst✝² : DecidablePred p✝
s s' : Multiset α
p p' : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred p'
⊢ s = s' → (∀ x ∈ s, p x = p' x) → countP p s = countP p' s'

tactic: exact Quot.induction_on₂ s s'
  (fun l l' hs hp => by
    simp only [quot_mk_to_coe'', coe_eq_coe] at hs
    apply hs.countP_congr
    simpa using hp)
state_before: α : Type u_1
β : Type v
γ : Type u_2
p✝ : α → Prop
inst✝² : DecidablePred p✝
s s' : Multiset α
p p' : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred p'
⊢ s = s' → (∀ x ∈ s, p x = p' x) → countP p s = countP p' s'
state_after: no goals

tactic: simp only [quot_mk_to_coe'', coe_eq_coe] at hs
state_before: α : Type u_1
β : Type v
γ : Type u_2
p✝ : α → Prop
inst✝² : DecidablePred p✝
s s' : Multiset α
p p' : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred p'
l l' : List α
hs : Quot.mk Setoid.r l = Quot.mk Setoid.r l'
hp : ∀ x ∈ Quot.mk Setoid.r l, p x = p' x
⊢ countP p (Quot.mk Setoid.r l) = countP p' (Quot.mk Setoid.r l')
state_after: α : Type u_1
β : Type v
γ : Type u_2
p✝ : α → Prop
inst✝² : DecidablePred p✝
s s' : Multiset α
p p' : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred p'
l l' : List α
hp : ∀ x ∈ Quot.mk Setoid.r l, p x = p' x
hs : l ~ l'
⊢ countP p (Quot.mk Setoid.r l) = countP p' (Quot.mk Setoid.r l')

tactic: apply hs.countP_congr
state_before: α : Type u_1
β : Type v
γ : Type u_2
p✝ : α → Prop
inst✝² : DecidablePred p✝
s s' : Multiset α
p p' : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred p'
l l' : List α
hp : ∀ x ∈ Quot.mk Setoid.r l, p x = p' x
hs : l ~ l'
⊢ countP p (Quot.mk Setoid.r l) = countP p' (Quot.mk Setoid.r l')
state_after: α : Type u_1
β : Type v
γ : Type u_2
p✝ : α → Prop
inst✝² : DecidablePred p✝
s s' : Multiset α
p p' : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred p'
l l' : List α
hp : ∀ x ∈ Quot.mk Setoid.r l, p x = p' x
hs : l ~ l'
⊢ ∀ x ∈ l, decide (p x) = decide (p' x)

tactic: simpa using hp
state_before: α : Type u_1
β : Type v
γ : Type u_2
p✝ : α → Prop
inst✝² : DecidablePred p✝
s s' : Multiset α
p p' : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred p'
l l' : List α
hp : ∀ x ∈ Quot.mk Setoid.r l, p x = p' x
hs : l ~ l'
⊢ ∀ x ∈ l, decide (p x) = decide (p' x)
state_after: no goals
Theorem: MeasureTheory.Measure.map_linearMap_addHaar_pi_eq_smul_addHaar
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: cases nonempty_fintype ι
state_before: ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : μ.IsAddHaarMeasure
⊢ map (⇑f) μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ
state_after: case intro
ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : μ.IsAddHaarMeasure
val✝ : Fintype ι
⊢ map (⇑f) μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ

tactic: have := addHaarMeasure_unique μ (piIcc01 ι)
state_before: case intro
ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : μ.IsAddHaarMeasure
val✝ : Fintype ι
⊢ map (⇑f) μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ
state_after: case intro
ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : μ.IsAddHaarMeasure
val✝ : Fintype ι
this : μ = μ ↑(piIcc01 ι) • addHaarMeasure (piIcc01 ι)
⊢ map (⇑f) μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ

tactic: rw [this, addHaarMeasure_eq_volume_pi, Measure.map_smul,
  Real.map_linearMap_volume_pi_eq_smul_volume_pi hf, smul_comm]
state_before: case intro
ι : Type u_1
inst✝¹ : Finite ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : LinearMap.det f ≠ 0
μ : Measure (ι → ℝ)
inst✝ : μ.IsAddHaarMeasure
val✝ : Fintype ι
this : μ = μ ↑(piIcc01 ι) • addHaarMeasure (piIcc01 ι)
⊢ map (⇑f) μ = ENNReal.ofReal |(LinearMap.det f)⁻¹| • μ
state_after: no goals
Theorem: MeasureTheory.Measure.InnerRegularWRT.smul
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: intro U hU r hr
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
c : ℝ≥0∞
⊢ (c • μ).InnerRegularWRT p q
state_after: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
c : ℝ≥0∞
U : Set α
hU : q U
r : ℝ≥0∞
hr : r < (c • μ) U
⊢ ∃ K ⊆ U, p K ∧ r < (c • μ) K

tactic: rw [smul_apply, H.measure_eq_iSup hU, smul_eq_mul] at hr
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
c : ℝ≥0∞
U : Set α
hU : q U
r : ℝ≥0∞
hr : r < (c • μ) U
⊢ ∃ K ⊆ U, p K ∧ r < (c • μ) K
state_after: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
c : ℝ≥0∞
U : Set α
hU : q U
r : ℝ≥0∞
hr : r < c * ⨆ K, ⨆ (_ : K ⊆ U), ⨆ (_ : p K), μ K
⊢ ∃ K ⊆ U, p K ∧ r < (c • μ) K

tactic: simpa only [ENNReal.mul_iSup, lt_iSup_iff, exists_prop] using hr
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
c : ℝ≥0∞
U : Set α
hU : q U
r : ℝ≥0∞
hr : r < c * ⨆ K, ⨆ (_ : K ⊆ U), ⨆ (_ : p K), μ K
⊢ ∃ K ⊆ U, p K ∧ r < (c • μ) K
state_after: no goals
Theorem: ZeroAtInftyContinuousMap.tendsto_iff_tendstoUniformly
File: Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean

tactic: simpa only [Metric.tendsto_nhds] using
  @BoundedContinuousFunction.tendsto_iff_tendstoUniformly _ _ _ _ _ (fun i => (F i).toBCF)
    f.toBCF l
state_before: F✝ : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : PseudoMetricSpace β
inst✝² : Zero β
inst✝¹ : FunLike F✝ α β
inst✝ : ZeroAtInftyContinuousMapClass F✝ α β
C : ℝ
f✝ g : α →C₀ β
ι : Type u_2
F : ι → α →C₀ β
f : α →C₀ β
l : Filter ι
⊢ Tendsto F l (𝓝 f) ↔ TendstoUniformly (fun i => ⇑(F i)) (⇑f) l
state_after: no goals
Theorem: IsFractionRing.eq_zero_of_num_eq_zero
File: Mathlib/RingTheory/Localization/NumDen.lean

tactic: rw [zero_mul, h, RingHom.map_zero]
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
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
h : num A x = 0
⊢ 0 * (algebraMap ?m.27442 K) ↑(den ?m.27442 x) = (algebraMap ?m.27442 K) (num ?m.27442 x)
state_after: no goals
Theorem: Finset.univ_prod_mulSingle
File: Mathlib/Algebra/BigOperators/Pi.lean

tactic: ext a
state_before: I : Type u_1
inst✝² : DecidableEq I
Z : I → Type u_2
inst✝¹ : (i : I) → CommMonoid (Z i)
inst✝ : Fintype I
f : (i : I) → Z i
⊢ ∏ i : I, Pi.mulSingle i (f i) = f
state_after: case h
I : Type u_1
inst✝² : DecidableEq I
Z : I → Type u_2
inst✝¹ : (i : I) → CommMonoid (Z i)
inst✝ : Fintype I
f : (i : I) → Z i
a : I
⊢ (∏ i : I, Pi.mulSingle i (f i)) a = f a

tactic: simp
state_before: case h
I : Type u_1
inst✝² : DecidableEq I
Z : I → Type u_2
inst✝¹ : (i : I) → CommMonoid (Z i)
inst✝ : Fintype I
f : (i : I) → Z i
a : I
⊢ (∏ i : I, Pi.mulSingle i (f i)) a = f a
state_after: no goals
Theorem: continuousAt_dslope_of_ne
File: Mathlib/Analysis/Calculus/Dslope.lean

tactic: simp only [← continuousWithinAt_univ, continuousWithinAt_dslope_of_ne h]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
⊢ ContinuousAt (dslope f a) b ↔ ContinuousAt f b
state_after: no goals
Theorem: finAddFlip_apply_mk_right
File: Mathlib/Logic/Equiv/Fin.lean

tactic: omega
state_before: m n k : ℕ
h₁ : m ≤ k
h₂ : k < m + n
⊢ k - m < n + m
state_after: no goals

tactic: convert @finAddFlip_apply_natAdd n ⟨k - m, by omega⟩ m
state_before: m n k : ℕ
h₁ : m ≤ k
h₂ : k < m + n
⊢ finAddFlip ⟨k, h₂⟩ = ⟨k - m, ⋯⟩
state_after: case h.e'_2.h.e'_6.h.e'_2
m n k : ℕ
h₁ : m ≤ k
h₂ : k < m + n
⊢ k = ↑(Fin.natAdd m ⟨k - m, ⋯⟩)

tactic: simp [Nat.add_sub_cancel' h₁]
state_before: case h.e'_2.h.e'_6.h.e'_2
m n k : ℕ
h₁ : m ≤ k
h₂ : k < m + n
⊢ k = ↑(Fin.natAdd m ⟨k - m, ⋯⟩)
state_after: no goals

tactic: omega
state_before: m n k : ℕ
h₁ : m ≤ k
h₂ : k < m + n
⊢ k - m < n
state_after: no goals
Theorem: Order.Ideal.inter_nonempty
File: Mathlib/Order/Ideal.lean

tactic: obtain ⟨a, ha⟩ := I.nonempty
state_before: P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
⊢ (↑I ∩ ↑J).Nonempty
state_after: case intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
⊢ (↑I ∩ ↑J).Nonempty

tactic: obtain ⟨b, hb⟩ := J.nonempty
state_before: case intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
⊢ (↑I ∩ ↑J).Nonempty
state_after: case intro.intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
b : P
hb : b ∈ ↑J
⊢ (↑I ∩ ↑J).Nonempty

tactic: obtain ⟨c, hac, hbc⟩ := exists_le_le a b
state_before: case intro.intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
b : P
hb : b ∈ ↑J
⊢ (↑I ∩ ↑J).Nonempty
state_after: case intro.intro.intro.intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
b : P
hb : b ∈ ↑J
c : P
hac : c ≤ a
hbc : c ≤ b
⊢ (↑I ∩ ↑J).Nonempty

tactic: exact ⟨c, I.lower hac ha, J.lower hbc hb⟩
state_before: case intro.intro.intro.intro
P : Type u_1
inst✝¹ : LE P
I✝ J✝ s t : Ideal P
x y : P
inst✝ : IsDirected P fun x x_1 => x ≥ x_1
I J : Ideal P
a : P
ha : a ∈ ↑I
b : P
hb : b ∈ ↑J
c : P
hac : c ≤ a
hbc : c ≤ b
⊢ (↑I ∩ ↑J).Nonempty
state_after: no goals
Theorem: LSeries_add
File: Mathlib/NumberTheory/LSeries/Linearity.lean

tactic: simpa only [LSeries, term_add, Pi.add_apply] using tsum_add hf hg
state_before: f g : ℕ → ℂ
s : ℂ
hf : LSeriesSummable f s
hg : LSeriesSummable g s
⊢ LSeries (f + g) s = LSeries f s + LSeries g s
state_after: no goals
Theorem: Real.le_def'
File: Mathlib/Data/Real/Basic.lean

tactic: rw [le_def]
state_before: x✝ y✝ x y : ℝ
⊢ Real.le x y ↔ x < y ∨ x = y
state_after: no goals
Theorem: List.Chain'.count_not_le_count_add_one
File: Mathlib/Data/Bool/Count.lean

tactic: cases' l with x l
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ count (!b) l ≤ count b l + 1
state_after: case nil
b : Bool
hl : Chain' (fun x x_1 => x ≠ x_1) []
⊢ count (!b) [] ≤ count b [] + 1

case cons
b x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
⊢ count (!b) (x :: l) ≤ count b (x :: l) + 1

tactic: obtain rfl | rfl : b = x ∨ b = !x := by simp only [Bool.eq_not_iff, em]
state_before: case cons
b x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
⊢ count (!b) (x :: l) ≤ count b (x :: l) + 1
state_after: case cons.inl
b : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (b :: l)
⊢ count (!b) (b :: l) ≤ count b (b :: l) + 1

case cons.inr
x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
⊢ count (!!x) (x :: l) ≤ count (!x) (x :: l) + 1

tactic: exact zero_le _
state_before: case nil
b : Bool
hl : Chain' (fun x x_1 => x ≠ x_1) []
⊢ count (!b) [] ≤ count b [] + 1
state_after: no goals

tactic: simp only [Bool.eq_not_iff, em]
state_before: b x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
⊢ b = x ∨ b = !x
state_after: no goals

tactic: rw [count_cons_of_ne b.not_ne_self, count_cons_self, hl.count_not, add_assoc]
state_before: case cons.inl
b : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (b :: l)
⊢ count (!b) (b :: l) ≤ count b (b :: l) + 1
state_after: case cons.inl
b : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (b :: l)
⊢ count b l + l.length % 2 ≤ count b l + (1 + 1)

tactic: exact add_le_add_left (Nat.mod_lt _ two_pos).le _
state_before: case cons.inl
b : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (b :: l)
⊢ count b l + l.length % 2 ≤ count b l + (1 + 1)
state_after: no goals

tactic: rw [Bool.not_not, count_cons_self, count_cons_of_ne x.not_ne_self, hl.count_not]
state_before: case cons.inr
x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
⊢ count (!!x) (x :: l) ≤ count (!x) (x :: l) + 1
state_after: case cons.inr
x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
⊢ count x l + 1 ≤ count x l + l.length % 2 + 1

tactic: exact add_le_add_right (le_add_right le_rfl) _
state_before: case cons.inr
x : Bool
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) (x :: l)
⊢ count x l + 1 ≤ count x l + l.length % 2 + 1
state_after: no goals
Theorem: Set.image2_eq_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : Set β
⊢ image2 f s t = ⋃ i ∈ s, ⋃ j ∈ t, {f i j}
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : Set β
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ ⋃ i ∈ s, ⋃ j ∈ t, {f i j}

tactic: simp [eq_comm]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : Set β
x✝ : γ
⊢ x✝ ∈ image2 f s t ↔ x✝ ∈ ⋃ i ∈ s, ⋃ j ∈ t, {f i j}
state_after: no goals
Theorem: lt_smul_iff_one_lt_left
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: rw [one_smul]
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁷ : Monoid α
inst✝⁶ : Zero α
inst✝⁵ : Zero β
inst✝⁴ : MulAction α β
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : SMulPosStrictMono α β
inst✝ : SMulPosReflectLT α β
hb : 0 < b
⊢ b < a • b ↔ 1 • b < a • b
state_after: no goals