tasksource/leandojo huggingface dataset:
Theorem: circleIntegral.integral_eq_zero_of_hasDerivWithinAt'
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: by_cases hi : CircleIntegrable f' c R
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f f' : ℂ → E
c : ℂ
R : ℝ
h : ∀ (z : ℂ), z ∈ sphere c (Abs.abs R) → HasDerivWithinAt f (f' z) (sphere c (Abs.abs R)) z
⊢ (∮ (z : ℂ) in C(c, R), f' z) = 0

tactic: rw [← sub_eq_zero.2 ((periodic_circleMap c R).comp f).eq]
state_before: case pos
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f f' : ℂ → E
c : ℂ
R : ℝ
h : ∀ (z : ℂ), z ∈ sphere c (Abs.abs R) → HasDerivWithinAt f (f' z) (sphere c (Abs.abs R)) z
hi : CircleIntegrable f' c R
⊢ (∮ (z : ℂ) in C(c, R), f' z) = 0

tactic: refine' intervalIntegral.integral_eq_sub_of_hasDerivAt (fun θ _ => _) hi.out
state_before: case pos
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f f' : ℂ → E
c : ℂ
R : ℝ
h : ∀ (z : ℂ), z ∈ sphere c (Abs.abs R) → HasDerivWithinAt f (f' z) (sphere c (Abs.abs R)) z
hi : CircleIntegrable f' c R
⊢ (∮ (z : ℂ) in C(c, R), f' z) = (f ∘ circleMap c R) (2 * π) - (f ∘ circleMap c R) 0

tactic: exact (h _ (circleMap_mem_sphere' _ _ _)).scomp_hasDerivAt θ
  (differentiable_circleMap _ _ _).hasDerivAt (circleMap_mem_sphere' _ _)
state_before: case pos
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f f' : ℂ → E
c : ℂ
R : ℝ
h : ∀ (z : ℂ), z ∈ sphere c (Abs.abs R) → HasDerivWithinAt f (f' z) (sphere c (Abs.abs R)) z
hi : CircleIntegrable f' c R
θ : ℝ
x✝ : θ ∈ [[0, 2 * π]]
⊢ HasDerivAt (f ∘ circleMap c R) (deriv (circleMap c R) θ • (fun z => f' z) (circleMap c R θ)) θ

tactic: exact integral_undef hi
state_before: case neg
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f f' : ℂ → E
c : ℂ
R : ℝ
h : ∀ (z : ℂ), z ∈ sphere c (Abs.abs R) → HasDerivWithinAt f (f' z) (sphere c (Abs.abs R)) z
hi : ¬CircleIntegrable f' c R
⊢ (∮ (z : ℂ) in C(c, R), f' z) = 0
Theorem: SignType.nonpos_iff
File: Mathlib/Data/Sign.lean

tactic: cases a <;> decide
state_before: a : SignType
⊢ a ≤ 0 ↔ a = -1 ∨ a = 0
Theorem: Matrix.coe_units_zpow
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [_root_.zpow_coe_nat, zpow_ofNat, Units.val_pow_eq_pow_val]
state_before: n' : Type u_2
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_1
inst✝ : CommRing R
u : Mˣ
n : ℕ
⊢ ↑(u ^ ↑n) = ↑u ^ ↑n

tactic: rw [zpow_negSucc, zpow_negSucc, ← inv_pow, u⁻¹.val_pow_eq_pow_val, ← inv_pow', coe_units_inv]
state_before: n' : Type u_2
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_1
inst✝ : CommRing R
u : Mˣ
k : ℕ
⊢ ↑(u ^ -[k+1]) = ↑u ^ -[k+1]
Theorem: Equiv.Perm.subtypeCongr.symm
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext x
state_before: ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
⊢ (subtypeCongr ep en).symm = subtypeCongr ep.symm en.symm

tactic: by_cases h:p x
state_before: case H
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
⊢ ↑(subtypeCongr ep en).symm x = ↑(subtypeCongr ep.symm en.symm) x

tactic: have : p (ep.symm ⟨x, h⟩) := Subtype.property _
state_before: case pos
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
h : p x
⊢ ↑(subtypeCongr ep en).symm x = ↑(subtypeCongr ep.symm en.symm) x

tactic: simp [Perm.subtypeCongr.apply, h, symm_apply_eq, this]
state_before: case pos
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
h : p x
this : p ↑(↑ep.symm { val := x, property := h })
⊢ ↑(subtypeCongr ep en).symm x = ↑(subtypeCongr ep.symm en.symm) x

tactic: have : ¬p (en.symm ⟨x, h⟩) := Subtype.property (en.symm _)
state_before: case neg
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
h : ¬p x
⊢ ↑(subtypeCongr ep en).symm x = ↑(subtypeCongr ep.symm en.symm) x

tactic: simp [Perm.subtypeCongr.apply, h, symm_apply_eq, this]
state_before: case neg
ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
x : ε
h : ¬p x
this : ¬p ↑(↑en.symm { val := x, property := h })
⊢ ↑(subtypeCongr ep en).symm x = ↑(subtypeCongr ep.symm en.symm) x
Theorem: Real.sin_eq_sin_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: exact_mod_cast @Complex.sin_eq_sin_iff x y
state_before: x y : ℝ
⊢ sin x = sin y ↔ ∃ k, y = 2 * ↑k * π + x ∨ y = (2 * ↑k + 1) * π - x
Theorem: PrimeSpectrum.zeroLocus_subset_zeroLocus_singleton_iff
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [← zeroLocus_span {f}, ← zeroLocus_span {g}, zeroLocus_subset_zeroLocus_iff, Ideal.span_le,
  Set.singleton_subset_iff, SetLike.mem_coe]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f g : R
⊢ zeroLocus {f} ⊆ zeroLocus {g} ↔ g ∈ Ideal.radical (Ideal.span {f})
Theorem: eventually_closedBall_subset
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: obtain ⟨ε, εpos, hε⟩ : ∃ ε, 0 < ε ∧ closedBall x ε ⊆ u := nhds_basis_closedBall.mem_iff.1 hu
state_before: α : Type u
β : Type v
X : Type ?u.215446
ι : Type ?u.215449
inst✝ : PseudoMetricSpace α
x : α
u : Set α
hu : u ∈ 𝓝 x
⊢ ∀ᶠ (r : ℝ) in 𝓝 0, closedBall x r ⊆ u

tactic: have : Iic ε ∈ 𝓝 (0 : ℝ) := Iic_mem_nhds εpos
state_before: case intro.intro
α : Type u
β : Type v
X : Type ?u.215446
ι : Type ?u.215449
inst✝ : PseudoMetricSpace α
x : α
u : Set α
hu : u ∈ 𝓝 x
ε : ℝ
εpos : 0 < ε
hε : closedBall x ε ⊆ u
⊢ ∀ᶠ (r : ℝ) in 𝓝 0, closedBall x r ⊆ u

tactic: filter_upwards [this] with _ hr using Subset.trans (closedBall_subset_closedBall hr) hε
state_before: case intro.intro
α : Type u
β : Type v
X : Type ?u.215446
ι : Type ?u.215449
inst✝ : PseudoMetricSpace α
x : α
u : Set α
hu : u ∈ 𝓝 x
ε : ℝ
εpos : 0 < ε
hε : closedBall x ε ⊆ u
this : Iic ε ∈ 𝓝 0
⊢ ∀ᶠ (r : ℝ) in 𝓝 0, closedBall x r ⊆ u
Theorem: Polynomial.C_mul_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: induction p using Polynomial.induction_on' with
| h_add p q hp hq =>
  simp [hp, hq, mul_add]
| h_monomial n b =>
  simp [mul_assoc]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ comp (↑C a * p) r = ↑C a * comp p r

tactic: simp [hp, hq, mul_add]
state_before: case h_add
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
hp : comp (↑C a * p) r = ↑C a * comp p r
hq : comp (↑C a * q) r = ↑C a * comp q r
⊢ comp (↑C a * (p + q)) r = ↑C a * comp (p + q) r

tactic: simp [mul_assoc]
state_before: case h_monomial
R : Type u
S : Type v
T : Type w
ι : Type y
a b✝ : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
b : R
⊢ comp (↑C a * ↑(monomial n) b) r = ↑C a * comp (↑(monomial n) b) r
Theorem: ContinuousMap.tendsto_iff_forall_compact_tendstoUniformlyOn
File: Mathlib/Topology/UniformSpace/CompactConvergence.lean

tactic: rw [compactOpen_eq_compactConvergence, tendsto_iff_forall_compact_tendstoUniformlyOn']
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
⊢ Tendsto F p (𝓝 f) ↔ ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => ↑(F i) a) (↑f) p K
Theorem: not_decide_eq_true
File: src/lean/Init/SimpLemmas.lean

tactic: cases h <;> simp [decide, *]
state_before: p : Prop
h : Decidable p
⊢ ((!decide p) = true) = ¬p
Theorem: Equiv.prod_assoc_symm_image
File: Mathlib/Logic/Equiv/Set.lean

tactic: simpa only [Equiv.image_eq_preimage] using prod_assoc_preimage
state_before: α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
⊢ ↑(prodAssoc α β γ).symm '' s ×ˢ t ×ˢ u = (s ×ˢ t) ×ˢ u
Theorem: CategoryTheory.kernel_ι_eq_zero_of_exact_zero_left
File: Mathlib/Algebra/Homology/Exact.lean

tactic: rw [← kernelSubobject_arrow']
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝¹ : HasZeroMorphisms V
inst✝ : HasEqualizers V
h : Exact 0 g
⊢ kernel.ι g = 0

tactic: simp [kernelSubobject_arrow_eq_zero_of_exact_zero_left A h]
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝¹ : HasZeroMorphisms V
inst✝ : HasEqualizers V
h : Exact 0 g
⊢ (kernelSubobjectIso g).inv ≫ Subobject.arrow (kernelSubobject g) = 0
Theorem: Fin.lt_last_iff_coe_castPred
File: Mathlib/Data/Fin/Basic.lean

tactic: rcases i.le_last.eq_or_lt with (rfl | H)
state_before: n m : ℕ
i : Fin (n + 2)
⊢ i < last (n + 1) ↔ ↑(castPred i) = ↑i

tactic: simp
state_before: case inl
n m : ℕ
⊢ last (n + 1) < last (n + 1) ↔ ↑(castPred (last (n + 1))) = ↑(last (n + 1))

tactic: simp only [H]
state_before: case inr
n m : ℕ
i : Fin (n + 2)
H : i < last (n + 1)
⊢ i < last (n + 1) ↔ ↑(castPred i) = ↑i

tactic: rw [← castSucc_castPred H]
state_before: case inr
n m : ℕ
i : Fin (n + 2)
H : i < last (n + 1)
⊢ True ↔ ↑(castPred i) = ↑i

tactic: simp
state_before: case inr
n m : ℕ
i : Fin (n + 2)
H : i < last (n + 1)
⊢ True ↔ ↑(castPred (↑castSucc (castPred i))) = ↑(↑castSucc (castPred i))
Theorem: Nat.add_succ_sub_one
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [add_succ, succ_sub_one]
state_before: m✝ n✝ k n m : ℕ
⊢ n + succ m - 1 = n + m
Theorem: IsLocalizedModule.fromLocalizedModule.surj
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [fromLocalizedModule_mk, Module.End_algebraMap_isUnit_inv_apply_eq_iff, ← eq1]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type ?u.663918
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
x : M'
m : M
s : { x // x ∈ S }
eq1 : (m, s).snd • x = ↑f (m, s).fst
⊢ ↑(fromLocalizedModule S f) (LocalizedModule.mk m s) = x

tactic: rfl
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type ?u.663918
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
x : M'
m : M
s : { x // x ∈ S }
eq1 : (m, s).snd • x = ↑f (m, s).fst
⊢ (m, s).snd • x = ↑s • x
Theorem: MeasureTheory.Measure.sigmaFinite_of_countable
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: obtain ⟨s, hμ, hs⟩ : ∃ s : ℕ → Set α, (∀ n, μ (s n) < ∞) ∧ (⋃ n, s n) = univ
state_before: α : Type u_1
β : Type ?u.758001
γ : Type ?u.758004
δ : Type ?u.758007
ι : Type ?u.758010
R : Type ?u.758013
R' : Type ?u.758016
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
S : Set (Set α)
hc : Set.Countable S
hμ : ∀ (s : Set α), s ∈ S → ↑↑μ s < ⊤
hU : ⋃₀ S = univ
⊢ SigmaFinite μ

tactic: exact (@exists_seq_cover_iff_countable _ (fun x => μ x < ⊤) ⟨∅, by simp⟩).2 ⟨S, hc, hμ, hU⟩
state_before: α : Type u_1
β : Type ?u.758001
γ : Type ?u.758004
δ : Type ?u.758007
ι : Type ?u.758010
R : Type ?u.758013
R' : Type ?u.758016
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
S : Set (Set α)
hc : Set.Countable S
hμ : ∀ (s : Set α), s ∈ S → ↑↑μ s < ⊤
hU : ⋃₀ S = univ
⊢ ∃ s, (∀ (n : ℕ), ↑↑μ (s n) < ⊤) ∧ (⋃ (n : ℕ), s n) = univ

case intro.intro
α : Type u_1
β : Type ?u.758001
γ : Type ?u.758004
δ : Type ?u.758007
ι : Type ?u.758010
R : Type ?u.758013
R' : Type ?u.758016
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
S : Set (Set α)
hc : Set.Countable S
hμ✝ : ∀ (s : Set α), s ∈ S → ↑↑μ s < ⊤
hU : ⋃₀ S = univ
s : ℕ → Set α
hμ : ∀ (n : ℕ), ↑↑μ (s n) < ⊤
hs : (⋃ (n : ℕ), s n) = univ
⊢ SigmaFinite μ

tactic: exact ⟨⟨⟨fun n => s n, fun _ => trivial, hμ, hs⟩⟩⟩
state_before: case intro.intro
α : Type u_1
β : Type ?u.758001
γ : Type ?u.758004
δ : Type ?u.758007
ι : Type ?u.758010
R : Type ?u.758013
R' : Type ?u.758016
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
S : Set (Set α)
hc : Set.Countable S
hμ✝ : ∀ (s : Set α), s ∈ S → ↑↑μ s < ⊤
hU : ⋃₀ S = univ
s : ℕ → Set α
hμ : ∀ (n : ℕ), ↑↑μ (s n) < ⊤
hs : (⋃ (n : ℕ), s n) = univ
⊢ SigmaFinite μ

tactic: simp
state_before: α : Type u_1
β : Type ?u.758001
γ : Type ?u.758004
δ : Type ?u.758007
ι : Type ?u.758010
R : Type ?u.758013
R' : Type ?u.758016
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
S : Set (Set α)
hc : Set.Countable S
hμ : ∀ (s : Set α), s ∈ S → ↑↑μ s < ⊤
hU : ⋃₀ S = univ
⊢ (fun x => ↑↑μ x < ⊤) ∅
Theorem: EMetric.preimage_mul_right_closedBall
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: rw [div_eq_mul_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoEMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoEMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ≥0∞
⊢ (fun x => x * a) ⁻¹' closedBall b r = closedBall (b / a) r

tactic: exact preimage_smul_closedBall (MulOpposite.op a) b r
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoEMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoEMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ≥0∞
⊢ (fun x => x * a) ⁻¹' closedBall b r = closedBall (b * a⁻¹) r
Theorem: PiNat.apply_eq_of_dist_lt
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: rcases eq_or_ne x y with (rfl | hne)
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
h : dist x y < (1 / 2) ^ n
i : ℕ
hi : i ≤ n
⊢ x i = y i

tactic: have : n < firstDiff x y := by
  simpa [dist_eq_of_ne hne, inv_lt_inv, pow_lt_pow_iff, one_lt_two] using h
state_before: case inr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
h : dist x y < (1 / 2) ^ n
i : ℕ
hi : i ≤ n
hne : x ≠ y
⊢ x i = y i

tactic: exact apply_eq_of_lt_firstDiff (hi.trans_lt this)
state_before: case inr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
h : dist x y < (1 / 2) ^ n
i : ℕ
hi : i ≤ n
hne : x ≠ y
this : n < firstDiff x y
⊢ x i = y i

tactic: rfl
state_before: case inl
E : ℕ → Type u_1
x : (n : ℕ) → E n
n i : ℕ
hi : i ≤ n
h : dist x x < (1 / 2) ^ n
⊢ x i = x i

tactic: simpa [dist_eq_of_ne hne, inv_lt_inv, pow_lt_pow_iff, one_lt_two] using h
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
h : dist x y < (1 / 2) ^ n
i : ℕ
hi : i ≤ n
hne : x ≠ y
⊢ n < firstDiff x y
Theorem: Basis.equiv_symm
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp
state_before: ι : Type u_4
ι' : Type u_5
R : Type u_3
R₂ : Type ?u.553119
K : Type ?u.553122
M : Type u_1
M' : Type u_2
M'' : Type ?u.553131
V : Type u
V' : Type ?u.553136
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : AddCommMonoid M''
inst✝ : Module R M''
i : ι'
⊢ ↑(Basis.equiv b b' e) (↑(LinearEquiv.symm (Basis.equiv b b' e)) (↑b' i)) =
    ↑(Basis.equiv b b' e) (↑(Basis.equiv b' b e.symm) (↑b' i))
Theorem: MonotoneOn.ae_differentiableWithinAt
File: Mathlib/Analysis/Calculus/Monotone.lean

tactic: rw [ae_restrict_iff' hs]
state_before: f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
hs : MeasurableSet s
⊢ ∀ᵐ (x : ℝ) ∂Measure.restrict volume s, DifferentiableWithinAt ℝ f s x

tactic: exact hf.ae_differentiableWithinAt_of_mem
state_before: f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
hs : MeasurableSet s
⊢ ∀ᵐ (x : ℝ), x ∈ s → DifferentiableWithinAt ℝ f s x
Theorem: SimpleGraph.map_monotone
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rintro G G' h _ _ ⟨u, v, ha, rfl, rfl⟩
state_before: ι : Sort ?u.207467
𝕜 : Type ?u.207470
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
f : V ↪ W
⊢ Monotone (SimpleGraph.map f)

tactic: exact ⟨_, _, h ha, rfl, rfl⟩
state_before: case intro.intro.intro.intro
ι : Sort ?u.207467
𝕜 : Type ?u.207470
V : Type u
W : Type v
X : Type w
G✝ : SimpleGraph V
G'✝ : SimpleGraph W
a b c u✝ v✝ w : V
e : Sym2 V
f : V ↪ W
G G' : SimpleGraph V
h : G ≤ G'
u v : V
ha : Adj G u v
⊢ Adj (SimpleGraph.map f G') (↑f u) (↑f v)
Theorem: LieHom.surjective_rangeRestrict
File: Mathlib/Algebra/Lie/Subalgebra.lean

tactic: rintro ⟨y, hy⟩
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
⊢ Function.Surjective ↑(rangeRestrict f)

tactic: erw [mem_range] at hy
state_before: case mk
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
y : L₂
hy : y ∈ range f
⊢ ∃ a, ↑(rangeRestrict f) a = { val := y, property := hy }

tactic: obtain ⟨x, rfl⟩ := hy
state_before: case mk
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
y : L₂
hy✝ : y ∈ range f
hy : ∃ y_1, ↑f y_1 = y
⊢ ∃ a, ↑(rangeRestrict f) a = { val := y, property := hy✝ }

tactic: use x
state_before: case mk.intro
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
x : L
hy : ↑f x ∈ range f
⊢ ∃ a, ↑(rangeRestrict f) a = { val := ↑f x, property := hy }

tactic: simp only [Subtype.mk_eq_mk, rangeRestrict_apply]
state_before: case mk.intro
R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
x : L
hy : ↑f x ∈ range f
⊢ ↑(rangeRestrict f) x = { val := ↑f x, property := hy }
Theorem: mul_lt_iff_lt_one_left'
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: rw [mul_one]
state_before: α : Type u_1
β : Type ?u.26156
inst✝³ : MulOneClass α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
⊢ a * b < a ↔ a * b < a * 1
Theorem: Pmf.support_normalize
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: simp [hf, mem_support_iff]
state_before: α : Type u_1
β : Type ?u.137804
γ : Type ?u.137807
f : α → ℝ≥0∞
hf0 : tsum f ≠ 0
hf : tsum f ≠ ⊤
a : α
⊢ a ∈ support (normalize f hf0 hf) ↔ a ∈ Function.support f
Theorem: MvPolynomial.pderiv_def
File: Mathlib/Data/MvPolynomial/PDeriv.lean

tactic: unfold pderiv
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : DecidableEq σ
i : σ
⊢ pderiv i = mkDerivation R (Pi.single i 1)

tactic: congr!
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : DecidableEq σ
i : σ
⊢ mkDerivation R (Pi.single i 1) = mkDerivation R (Pi.single i 1)
Theorem: Finset.mk'_mem_sym2_iff
File: Mathlib/Data/Finset/Sym.lean

tactic: rw [mem_sym2_iff, Sym2.ball]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ Quotient.mk (Sym2.Rel.setoid α) (a, b) ∈ Finset.sym2 s ↔ a ∈ s ∧ b ∈ s
Theorem: CategoryTheory.FunctorToTypes.map_comp_apply
File: Mathlib/CategoryTheory/Types.lean

tactic: simp [types_comp]
state_before: C : Type u
inst✝ : Category C
F G H : C ⥤ Type w
X Y Z : C
σ : F ⟶ G
τ : G ⟶ H
f : X ⟶ Y
g : Y ⟶ Z
a : F.obj X
⊢ F.map (f ≫ g) a = F.map g (F.map f a)
Theorem: MonotoneOn.sum_le_integral_Ico
File: Mathlib/Analysis/SumIntegralComparisons.lean

tactic: rw [← neg_le_neg_iff, ← Finset.sum_neg_distrib, ← intervalIntegral.integral_neg]
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : MonotoneOn f (Icc ↑a ↑b)
⊢ ∑ x in Finset.Ico a b, f ↑x ≤ ∫ (x : ℝ) in ↑a..↑b, f x

tactic: exact hf.neg.integral_le_sum_Ico hab
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : MonotoneOn f (Icc ↑a ↑b)
⊢ (∫ (x : ℝ) in ↑a..↑b, -f x) ≤ ∑ x in Finset.Ico a b, -f ↑x
Theorem: List.nodup_permutations'Aux_of_not_mem
File: Mathlib/Data/List/Perm.lean

tactic: induction' s with y s IH
state_before: α : Type uu
β : Type vv
l₁ l₂ s : List α
x : α
hx : ¬x ∈ s
⊢ Nodup (permutations'Aux x s)

tactic: simp
state_before: case nil
α : Type uu
β : Type vv
l₁ l₂ s : List α
x : α
hx✝ : ¬x ∈ s
hx : ¬x ∈ []
⊢ Nodup (permutations'Aux x [])

tactic: simp only [not_or, mem_cons] at hx
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ s✝ : List α
x : α
hx✝ : ¬x ∈ s✝
y : α
s : List α
IH : ¬x ∈ s → Nodup (permutations'Aux x s)
hx : ¬x ∈ y :: s
⊢ Nodup (permutations'Aux x (y :: s))

tactic: simp only [permutations'Aux, nodup_cons, mem_map, cons.injEq, exists_eq_right_right, not_and]
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ s✝ : List α
x : α
hx✝ : ¬x ∈ s✝
y : α
s : List α
IH : ¬x ∈ s → Nodup (permutations'Aux x s)
hx : ¬x = y ∧ ¬x ∈ s
⊢ Nodup (permutations'Aux x (y :: s))

tactic: refine' ⟨fun _ => Ne.symm hx.left, _⟩
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ s✝ : List α
x : α
hx✝ : ¬x ∈ s✝
y : α
s : List α
IH : ¬x ∈ s → Nodup (permutations'Aux x s)
hx : ¬x = y ∧ ¬x ∈ s
⊢ (y :: s ∈ permutations'Aux x s → ¬y = x) ∧ Nodup (map (cons y) (permutations'Aux x s))

tactic: rw [nodup_map_iff]
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ s✝ : List α
x : α
hx✝ : ¬x ∈ s✝
y : α
s : List α
IH : ¬x ∈ s → Nodup (permutations'Aux x s)
hx : ¬x = y ∧ ¬x ∈ s
⊢ Nodup (map (cons y) (permutations'Aux x s))

tactic: exact IH hx.right
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ s✝ : List α
x : α
hx✝ : ¬x ∈ s✝
y : α
s : List α
IH : ¬x ∈ s → Nodup (permutations'Aux x s)
hx : ¬x = y ∧ ¬x ∈ s
⊢ Nodup (permutations'Aux x s)

tactic: simp
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ s✝ : List α
x : α
hx✝ : ¬x ∈ s✝
y : α
s : List α
IH : ¬x ∈ s → Nodup (permutations'Aux x s)
hx : ¬x = y ∧ ¬x ∈ s
⊢ Function.Injective (cons y)
Theorem: CharTwo.neg_eq
File: Mathlib/Algebra/CharP/Two.lean

tactic: rw [neg_eq_iff_add_eq_zero, ← two_smul R x, two_eq_zero, zero_smul]
state_before: R : Type u_1
ι : Type ?u.6385
inst✝¹ : Ring R
inst✝ : CharP R 2
x : R
⊢ -x = x
Theorem: Cardinal.bddAbove_image
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [bddAbove_iff_small] at hs ⊢
state_before: α β : Type u
f : Cardinal → Cardinal
s : Set Cardinal
hs : BddAbove s
⊢ BddAbove (f '' s)

tactic: exact small_lift.{_,v,_} _
state_before: α β : Type u
f : Cardinal → Cardinal
s : Set Cardinal
hs : Small ↑s
⊢ Small ↑(f '' s)
Theorem: Matrix.vandermonde_cons
File: Mathlib/LinearAlgebra/Vandermonde.lean

tactic: ext (i j)
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
v0 : R
v : Fin n → R
⊢ vandermonde (Fin.cons v0 v) = Fin.cons (fun j => v0 ^ ↑j) fun i => Fin.cons 1 fun j => v i * vandermonde v i j

tactic: refine' Fin.cases (by simp) (fun i => _) i
state_before: case a.h
R : Type u_1
inst✝ : CommRing R
n : ℕ
v0 : R
v : Fin n → R
i j : Fin (n + 1)
⊢ vandermonde (Fin.cons v0 v) i j =
    Fin.cons (fun j => v0 ^ ↑j) (fun i => Fin.cons 1 fun j => v i * vandermonde v i j) i j

tactic: refine' Fin.cases (by simp) (fun j => _) j
state_before: case a.h
R : Type u_1
inst✝ : CommRing R
n : ℕ
v0 : R
v : Fin n → R
i✝ j : Fin (n + 1)
i : Fin n
⊢ vandermonde (Fin.cons v0 v) (Fin.succ i) j =
    Fin.cons (fun j => v0 ^ ↑j) (fun i => Fin.cons 1 fun j => v i * vandermonde v i j) (Fin.succ i) j

tactic: simp [pow_succ]
state_before: case a.h
R : Type u_1
inst✝ : CommRing R
n : ℕ
v0 : R
v : Fin n → R
i✝ j✝ : Fin (n + 1)
i j : Fin n
⊢ vandermonde (Fin.cons v0 v) (Fin.succ i) (Fin.succ j) =
    Fin.cons (fun j => v0 ^ ↑j) (fun i => Fin.cons 1 fun j => v i * vandermonde v i j) (Fin.succ i) (Fin.succ j)

tactic: simp
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
v0 : R
v : Fin n → R
i j : Fin (n + 1)
⊢ vandermonde (Fin.cons v0 v) 0 j =
    Fin.cons (fun j => v0 ^ ↑j) (fun i => Fin.cons 1 fun j => v i * vandermonde v i j) 0 j

tactic: simp
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
v0 : R
v : Fin n → R
i✝ j : Fin (n + 1)
i : Fin n
⊢ vandermonde (Fin.cons v0 v) (Fin.succ i) 0 =
    Fin.cons (fun j => v0 ^ ↑j) (fun i => Fin.cons 1 fun j => v i * vandermonde v i j) (Fin.succ i) 0