tasksource/leandojo huggingface dataset:
Theorem: List.map_eq_map_iff
File: Mathlib/Data/List/Basic.lean

tactic: refine' ⟨_, map_congr⟩
state_before: ι : Type ?u.130847
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β
l : List α
⊢ map f l = map g l ↔ ∀ (x : α), x ∈ l → f x = g x

tactic: intro h x hx
state_before: ι : Type ?u.130847
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β
l : List α
⊢ map f l = map g l → ∀ (x : α), x ∈ l → f x = g x

tactic: rw [mem_iff_get] at hx
state_before: ι : Type ?u.130847
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β
l : List α
h : map f l = map g l
x : α
hx : x ∈ l
⊢ f x = g x

tactic: rcases hx with ⟨n, hn, rfl⟩
state_before: ι : Type ?u.130847
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β
l : List α
h : map f l = map g l
x : α
hx : ∃ n, get l n = x
⊢ f x = g x

tactic: rw [get_map_rev f, get_map_rev g]
state_before: case intro.refl
ι : Type ?u.130847
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β
l : List α
h : map f l = map g l
n : Fin (length l)
⊢ f (get l n) = g (get l n)

tactic: congr!
state_before: case intro.refl
ι : Type ?u.130847
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β
l : List α
h : map f l = map g l
n : Fin (length l)
⊢ get (map f l) { val := ↑n, isLt := (_ : ↑n < length (map f l)) } =
    get (map g l) { val := ↑n, isLt := (_ : ↑n < length (map g l)) }
Theorem: intervalIntegral.integral_mono_interval
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [integral_of_le hab, integral_of_le (hca.trans (hab.trans hbd))]
state_before: ι : Type ?u.21446228
𝕜 : Type ?u.21446231
E : Type ?u.21446234
F : Type ?u.21446237
A : Type ?u.21446240
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hab✝ : a ≤ b
hf✝ : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
c d : ℝ
hca : c ≤ a
hab : a ≤ b
hbd : b ≤ d
hf : 0 ≤ᵐ[Measure.restrict μ (Ioc c d)] f
hfi : IntervalIntegrable f μ c d
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) ≤ ∫ (x : ℝ) in c..d, f x ∂μ

tactic: exact set_integral_mono_set hfi.1 hf (Ioc_subset_Ioc hca hbd).eventuallyLE
state_before: ι : Type ?u.21446228
𝕜 : Type ?u.21446231
E : Type ?u.21446234
F : Type ?u.21446237
A : Type ?u.21446240
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hab✝ : a ≤ b
hf✝ : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
c d : ℝ
hca : c ≤ a
hab : a ≤ b
hbd : b ≤ d
hf : 0 ≤ᵐ[Measure.restrict μ (Ioc c d)] f
hfi : IntervalIntegrable f μ c d
⊢ (∫ (x : ℝ) in Ioc a b, f x ∂μ) ≤ ∫ (x : ℝ) in Ioc c d, f x ∂μ
Theorem: MultilinearMap.cons_smul
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: simp_rw [← update_cons_zero x m (c • x), f.map_smul, update_cons_zero]
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
f : MultilinearMap R M M₂
m : (i : Fin n) → M (succ i)
c : R
x : M 0
⊢ ↑f (cons (c • x) m) = c • ↑f (cons x m)
Theorem: MeasureTheory.measure_ne_zero_iff_nonempty_of_isMulLeftInvariant
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: simpa [null_iff_of_isMulLeftInvariant (μ := μ) hs, hμ] using nonempty_iff_ne_empty.symm
state_before: 𝕜 : Type ?u.533182
G : Type u_1
H : Type ?u.533188
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : Regular μ
hμ : μ ≠ 0
s : Set G
hs : IsOpen s
⊢ ↑↑μ s ≠ 0 ↔ Set.Nonempty s
Theorem: mul_neg_of_pos_of_neg
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simpa only [mul_zero] using mul_lt_mul_of_pos_left hb ha
state_before: α : Type u_1
a b c d : α
inst✝² : MulZeroClass α
inst✝¹ : Preorder α
inst✝ : PosMulStrictMono α
ha : 0 < a
hb : b < 0
⊢ a * b < 0
Theorem: himp_compl
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [← himp_bot, himp_himp, inf_idem]
state_before: ι : Type ?u.156197
α : Type u_1
β : Type ?u.156203
inst✝ : HeytingAlgebra α
a✝ b c a : α
⊢ a ⇨ aᶜ = aᶜ
Theorem: LieSubmodule.toEndomorphism_comp_subtype_mem
File: Mathlib/Algebra/Lie/OfAssociative.lean

tactic: simpa using N.lie_mem hm
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x : L
m : M
hm : m ∈ ↑N
⊢ ↑(LinearMap.comp (↑(toEndomorphism R L M) x) (Submodule.subtype ↑N)) { val := m, property := hm } ∈ ↑N
Theorem: sup_right_comm
File: Mathlib/Order/Lattice.lean

tactic: rw [sup_assoc, sup_assoc, @sup_comm _ _ b]
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c : α
⊢ a ⊔ b ⊔ c = a ⊔ c ⊔ b
Theorem: inv_pos_lt_iff_one_lt_mul
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [inv_eq_one_div]
state_before: ι : Type ?u.40590
α : Type u_1
β : Type ?u.40596
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ a⁻¹ < b ↔ 1 < b * a

tactic: exact div_lt_iff ha
state_before: ι : Type ?u.40590
α : Type u_1
β : Type ?u.40596
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ 1 / a < b ↔ 1 < b * a
Theorem: Nat.lxor'_assoc
File: Mathlib/Data/Nat/Bitwise.lean

tactic: bitwise_assoc_tac
state_before: n m k : ℕ
⊢ lxor' (lxor' n m) k = lxor' n (lxor' m k)
Theorem: CategoryTheory.Limits.limit.coneMorphism_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: simp
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F : J ⥤ C
inst✝ : HasLimit F
c : Cone F
j : J
⊢ (coneMorphism c).Hom ≫ π F j = c.π.app j
Theorem: Finset.weightedVSubOfPoint_subtype_eq_filter
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [weightedVSubOfPoint_apply, weightedVSubOfPoint_apply, ← sum_subtype_eq_sum_filter]
state_before: k : Type u_3
V : Type u_2
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.124383
s₂ : Finset ι₂
w : ι → k
p : ι → P
b : P
pred : ι → Prop
inst✝ : DecidablePred pred
⊢ (↑(weightedVSubOfPoint (Finset.subtype pred s) (fun i => p ↑i) b) fun i => w ↑i) =
    ↑(weightedVSubOfPoint (filter pred s) p b) w
Theorem: List.length_foldr_permutationsAux2'
File: Mathlib/Data/List/Permutation.lean

tactic: rw [length_foldr_permutationsAux2, (_ : List.sum (map length L) = n * length L)]
state_before: α : Type u_1
β : Type ?u.25223
t : α
ts : List α
r L : List (List α)
n : ℕ
H : ∀ (l : List α), l ∈ L → length l = n
⊢ length (foldr (fun y r => (permutationsAux2 t ts r y id).snd) r L) = n * length L + length r

tactic: induction' L with l L ih
state_before: α : Type u_1
β : Type ?u.25223
t : α
ts : List α
r L : List (List α)
n : ℕ
H : ∀ (l : List α), l ∈ L → length l = n
⊢ sum (map length L) = n * length L

tactic: have sum_map : sum (map length L) = n * length L := ih fun l m => H l (mem_cons_of_mem _ m)
state_before: case cons
α : Type u_1
β : Type ?u.25223
t : α
ts : List α
r L✝ : List (List α)
n : ℕ
H✝ : ∀ (l : List α), l ∈ L✝ → length l = n
l : List α
L : List (List α)
ih : (∀ (l : List α), l ∈ L → length l = n) → sum (map length L) = n * length L
H : ∀ (l_1 : List α), l_1 ∈ l :: L → length l_1 = n
⊢ sum (map length (l :: L)) = n * length (l :: L)

tactic: have length_l : length l = n := H _ (mem_cons_self _ _)
state_before: case cons
α : Type u_1
β : Type ?u.25223
t : α
ts : List α
r L✝ : List (List α)
n : ℕ
H✝ : ∀ (l : List α), l ∈ L✝ → length l = n
l : List α
L : List (List α)
ih : (∀ (l : List α), l ∈ L → length l = n) → sum (map length L) = n * length L
H : ∀ (l_1 : List α), l_1 ∈ l :: L → length l_1 = n
sum_map : sum (map length L) = n * length L
⊢ sum (map length (l :: L)) = n * length (l :: L)

tactic: simp [sum_map, length_l, mul_add, add_comm, mul_succ]
state_before: case cons
α : Type u_1
β : Type ?u.25223
t : α
ts : List α
r L✝ : List (List α)
n : ℕ
H✝ : ∀ (l : List α), l ∈ L✝ → length l = n
l : List α
L : List (List α)
ih : (∀ (l : List α), l ∈ L → length l = n) → sum (map length L) = n * length L
H : ∀ (l_1 : List α), l_1 ∈ l :: L → length l_1 = n
sum_map : sum (map length L) = n * length L
length_l : length l = n
⊢ sum (map length (l :: L)) = n * length (l :: L)

tactic: simp
state_before: case nil
α : Type u_1
β : Type ?u.25223
t : α
ts : List α
r L : List (List α)
n : ℕ
H✝ : ∀ (l : List α), l ∈ L → length l = n
H : ∀ (l : List α), l ∈ [] → length l = n
⊢ sum (map length []) = n * length []
Theorem: Commute.add_pow'
File: Mathlib/Data/Nat/Choose/Sum.lean

tactic: simp_rw [Finset.Nat.sum_antidiagonal_eq_sum_range_succ fun m p ↦ choose n m • (x ^ m * y ^ p),
  _root_.nsmul_eq_mul, cast_comm, h.add_pow]
state_before: R : Type u_1
inst✝ : Semiring R
x y : R
h : Commute x y
n : ℕ
⊢ (x + y) ^ n = ∑ m in Nat.antidiagonal n, Nat.choose n m.fst • (x ^ m.fst * y ^ m.snd)
Theorem: CategoryTheory.Limits.pushoutIsoUnopPullback_inv_snd
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: apply Quiver.Hom.unop_inj
state_before: C : Type u₁
inst✝³ : Category C
J : Type u₂
inst✝² : Category J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ (pushoutIsoUnopPullback f g).inv.op ≫ pullback.snd = pushout.inr.op

tactic: dsimp
state_before: case a
C : Type u₁
inst✝³ : Category C
J : Type u₂
inst✝² : Category J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ ((pushoutIsoUnopPullback f g).inv.op ≫ pullback.snd).unop = pushout.inr.op.unop

tactic: rw [← pushoutIsoUnopPullback_inr_hom, Category.assoc, Iso.hom_inv_id, Category.comp_id]
state_before: case a
C : Type u₁
inst✝³ : Category C
J : Type u₂
inst✝² : Category J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ pullback.snd.unop ≫ (pushoutIsoUnopPullback f g).inv = pushout.inr
Theorem: Submodule.eq_top_of_finrank_eq
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: simp [h, finrank_top]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
S : Submodule K V
h : finrank K { x // x ∈ S } = finrank K V
⊢ finrank K { x // x ∈ S } = finrank K { x // x ∈ ⊤ }
Theorem: CategoryTheory.StructuredArrow.w
File: Mathlib/CategoryTheory/StructuredArrow.lean

tactic: have := f.w
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
S S' S'' : D
Y Y' : C
T : C ⥤ D
A B : StructuredArrow S T
f : A ⟶ B
⊢ A.hom ≫ T.map f.right = B.hom

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
S S' S'' : D
Y Y' : C
T : C ⥤ D
A B : StructuredArrow S T
f : A ⟶ B
this : (Functor.fromPUnit S).map f.left ≫ B.hom = A.hom ≫ T.map f.right
⊢ A.hom ≫ T.map f.right = B.hom
Theorem: map_uniformity_set_coe
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [uniformity_setCoe, map_comap, range_prod_map, Subtype.range_val]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.148683
s : Set α
inst✝ : UniformSpace α
⊢ map (Prod.map Subtype.val Subtype.val) (𝓤 ↑s) = 𝓤 α ⊓ 𝓟 (s ×ˢ s)
Theorem: taylorWithinEval_self
File: Mathlib/Analysis/Calculus/Taylor.lean

tactic: induction' n with k hk
state_before: 𝕜 : Type ?u.226174
E : Type u_1
F : Type ?u.226180
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
n : ℕ
s : Set ℝ
x₀ : ℝ
⊢ taylorWithinEval f n s x₀ x₀ = f x₀

tactic: simp [hk]
state_before: case succ
𝕜 : Type ?u.226174
E : Type u_1
F : Type ?u.226180
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ : ℝ
k : ℕ
hk : taylorWithinEval f k s x₀ x₀ = f x₀
⊢ taylorWithinEval f (Nat.succ k) s x₀ x₀ = f x₀

tactic: exact taylor_within_zero_eval _ _ _ _
state_before: case zero
𝕜 : Type ?u.226174
E : Type u_1
F : Type ?u.226180
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
s : Set ℝ
x₀ : ℝ
⊢ taylorWithinEval f Nat.zero s x₀ x₀ = f x₀
Theorem: CommGroup.nilpotencyClass_le_one
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: apply upperCentralSeries_eq_top_iff_nilpotencyClass_le.mp
state_before: G✝ : Type ?u.323424
inst✝² : Group G✝
H : Subgroup G✝
inst✝¹ : Normal H
G : Type u_1
inst✝ : CommGroup G
⊢ nilpotencyClass G ≤ 1

tactic: rw [upperCentralSeries_one]
state_before: G✝ : Type ?u.323424
inst✝² : Group G✝
H : Subgroup G✝
inst✝¹ : Normal H
G : Type u_1
inst✝ : CommGroup G
⊢ upperCentralSeries G 1 = ⊤

tactic: apply CommGroup.center_eq_top
state_before: G✝ : Type ?u.323424
inst✝² : Group G✝
H : Subgroup G✝
inst✝¹ : Normal H
G : Type u_1
inst✝ : CommGroup G
⊢ center G = ⊤
Theorem: Turing.reaches₁_eq
File: Mathlib/Computability/TuringMachine.lean

tactic: rw [h]
state_before: σ : Type u_1
f : σ → Option σ
a b c : σ
h : f a = f b
⊢ (∃ b_1, b_1 ∈ f b ∧ ReflTransGen (fun a b => b ∈ f a) b_1 c) ↔ ∃ b, b ∈ f a ∧ ReflTransGen (fun a b => b ∈ f a) b c
Theorem: HasDerivAt.mul
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: rw [← hasDerivWithinAt_univ] at *
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 𝕜
𝕜' : Type ?u.215941
𝔸 : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivAt c c' x
hd : HasDerivAt d d' x
⊢ HasDerivAt (fun y => c y * d y) (c' * d x + c x * d') x

tactic: exact hc.mul hd
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 𝕜
𝕜' : Type ?u.215941
𝔸 : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivWithinAt c c' univ x
hd : HasDerivWithinAt d d' univ x
⊢ HasDerivWithinAt (fun y => c y * d y) (c' * d x + c x * d') univ x
Theorem: contDiff_succ_iff_fderiv
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp only [← contDiffOn_univ, ← differentiableOn_univ, ← fderivWithin_univ,
  contDiffOn_succ_iff_fderivWithin uniqueDiffOn_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 : ℕ
⊢ ContDiff 𝕜 (↑(n + 1)) f ↔ Differentiable 𝕜 f ∧ ContDiff 𝕜 ↑n fun y => fderiv 𝕜 f y
Theorem: Finset.mem_image₂
File: Mathlib/Data/Finset/NAry.lean

tactic: simp [image₂, and_assoc]
state_before: α : Type u_2
α' : Type ?u.752
β : Type u_3
β' : Type ?u.758
γ : Type u_1
γ' : Type ?u.764
δ : Type ?u.767
δ' : Type ?u.770
ε : Type ?u.773
ε' : Type ?u.776
ζ : Type ?u.779
ζ' : Type ?u.782
ν : Type ?u.785
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
⊢ c ∈ image₂ f s t ↔ ∃ a b, a ∈ s ∧ b ∈ t ∧ f a b = c
Theorem: Mathlib.Meta.NormNum.isRat_eq_false
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rw [Rat.invOf_denom_swap]
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : CharZero α
num✝¹ num✝ : ℤ
denom✝¹ denom✝ : ℕ
inv✝¹ : Invertible ↑denom✝¹
inv✝ : Invertible ↑denom✝
h : decide (Int.mul num✝¹ (Int.ofNat denom✝) = Int.mul num✝ (Int.ofNat denom✝¹)) = false
⊢ ¬↑num✝¹ * ⅟↑denom✝¹ = ↑num✝ * ⅟↑denom✝

tactic: exact_mod_cast of_decide_eq_false h
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : CharZero α
num✝¹ num✝ : ℤ
denom✝¹ denom✝ : ℕ
inv✝¹ : Invertible ↑denom✝¹
inv✝ : Invertible ↑denom✝
h : decide (Int.mul num✝¹ (Int.ofNat denom✝) = Int.mul num✝ (Int.ofNat denom✝¹)) = false
⊢ ¬↑num✝¹ * ↑denom✝ = ↑num✝ * ↑denom✝¹
Theorem: Fin.succAbove_ne
File: Mathlib/Data/Fin/Basic.lean

tactic: intro eq
state_before: n m : ℕ
p : Fin (n + 1)
i : Fin n
⊢ ↑(succAbove p) i ≠ p

tactic: by_cases H : castSucc i < p
state_before: n m : ℕ
p : Fin (n + 1)
i : Fin n
eq : ↑(succAbove p) i = p
⊢ False

tactic: simp [lt_irrefl, ← succAbove_below _ _ H, eq] at H
state_before: case pos
n m : ℕ
p : Fin (n + 1)
i : Fin n
eq : ↑(succAbove p) i = p
H : ↑castSucc i < p
⊢ False

tactic: simpa [← succAbove_above _ _ (le_of_not_lt H), eq, H] using castSucc_lt_succ i
state_before: case neg
n m : ℕ
p : Fin (n + 1)
i : Fin n
eq : ↑(succAbove p) i = p
H : ¬↑castSucc i < p
⊢ False
Theorem: MeasureTheory.absolutelyContinuous_of_isMulLeftInvariant
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: refine' AbsolutelyContinuous.mk fun s sm hνs => _
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hν : ν ≠ 0
⊢ μ ≪ ν

tactic: have h1 := measure_mul_lintegral_eq μ ν sm 1 measurable_one
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s✝ : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hν : ν ≠ 0
s : Set G
sm : MeasurableSet s
hνs : ↑↑ν s = 0
⊢ ↑↑μ s = 0

tactic: simp_rw [Pi.one_apply, lintegral_one, mul_one, (measure_mul_right_null ν _).mpr hνs,
  lintegral_zero, mul_eq_zero (M₀ := ℝ≥0∞), measure_univ_eq_zero.not.mpr hν, or_false_iff] at h1
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s✝ : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hν : ν ≠ 0
s : Set G
sm : MeasurableSet s
hνs : ↑↑ν s = 0
h1 : (↑↑μ s * ∫⁻ (y : G), OfNat.ofNat 1 y ∂ν) = ∫⁻ (x : G), ↑↑ν ((fun z => z * x) ⁻¹' s) * OfNat.ofNat 1 x⁻¹ ∂μ
⊢ ↑↑μ s = 0

tactic: exact h1
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s✝ : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hν : ν ≠ 0
s : Set G
sm : MeasurableSet s
hνs : ↑↑ν s = 0
h1 : ↑↑μ s = 0
⊢ ↑↑μ s = 0
Theorem: Filter.HasBasis.uniformContinuous_iff
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp only [Prod.forall]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_2
inst✝¹ : UniformSpace α
ι' : Sort u_1
inst✝ : UniformSpace β
p : ι → Prop
s : ι → Set (α × α)
ha : HasBasis (𝓤 α) p s
q : ι' → Prop
t : ι' → Set (β × β)
hb : HasBasis (𝓤 β) q t
f : α → β
⊢ (∀ (ib : ι'), q ib → ∃ ia, p ia ∧ ∀ (x : α × α), x ∈ s ia → (f x.fst, f x.snd) ∈ t ib) ↔
    ∀ (i : ι'), q i → ∃ j, p j ∧ ∀ (x y : α), (x, y) ∈ s j → (f x, f y) ∈ t i
Theorem: Set.iUnionLift_of_mem
File: Mathlib/Data/Set/UnionLift.lean

tactic: cases' x with x hx
state_before: α : Type u_1
ι : Sort u_3
β : Sort u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    f i { val := x, property := hxi } = f j { val := x, property := hxj }
T : Set α
hT : T ⊆ iUnion S
hT' : T = iUnion S
x : ↑T
i : ι
hx : ↑x ∈ S i
⊢ iUnionLift S f hf T hT x = f i { val := ↑x, property := hx }

tactic: exact hf _ _ _ _ _
state_before: case mk
α : Type u_1
ι : Sort u_3
β : Sort u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf :
  ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j),
    f i { val := x, property := hxi } = f j { val := x, property := hxj }
T : Set α
hT : T ⊆ iUnion S
hT' : T = iUnion S
i : ι
x : α
hx✝ : x ∈ T
hx : ↑{ val := x, property := hx✝ } ∈ S i
⊢ iUnionLift S f hf T hT { val := x, property := hx✝ } = f i { val := ↑{ val := x, property := hx✝ }, property := hx }
Theorem: eq_of_sdiff_eq_sdiff
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [← sdiff_sdiff_eq_self hxz, h, sdiff_sdiff_eq_self hyz]
state_before: α : Type u
β : Type ?u.30734
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hxz : x ≤ z
hyz : y ≤ z
h : z \ x = z \ y
⊢ x = y
Theorem: Polynomial.natDegree_hasseDeriv_le
File: Mathlib/Data/Polynomial/HasseDeriv.lean

tactic: rw [hasseDeriv_apply, sum_def]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
⊢ natDegree (↑(hasseDeriv n) p) ≤ natDegree p - n

tactic: refine' (natDegree_sum_le _ _).trans _
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
⊢ natDegree (∑ n_1 in support p, ↑(monomial (n_1 - n)) (↑(choose n_1 n) * coeff p n_1)) ≤ natDegree p - n

tactic: simp_rw [Function.comp, natDegree_monomial]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
⊢ Finset.fold max 0 (natDegree ∘ fun n_1 => ↑(monomial (n_1 - n)) (↑(choose n_1 n) * coeff p n_1)) (support p) ≤
    natDegree p - n

tactic: rw [Finset.fold_ite, Finset.fold_const]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
⊢ Finset.fold max 0 (fun x => if ↑(choose x n) * coeff p x = 0 then 0 else x - n) (support p) ≤ natDegree p - n

tactic: simp only [ite_self, max_eq_right, zero_le', Finset.fold_max_le, true_and_iff, and_imp,
  tsub_le_iff_right, mem_support_iff, Ne.def, Finset.mem_filter]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
⊢ max (if Finset.filter (fun x => ↑(choose x n) * coeff p x = 0) (support p) = ∅ then 0 else max 0 0)
      (Finset.fold max 0 (fun x => x - n) (Finset.filter (fun i => ¬↑(choose i n) * coeff p i = 0) (support p))) ≤
    natDegree p - n

tactic: intro x hx hx'
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
⊢ ∀ (x : ℕ), ¬coeff p x = 0 → ¬↑(choose x n) * coeff p x = 0 → x ≤ natDegree p - n + n

tactic: have hxp : x ≤ p.natDegree := le_natDegree_of_ne_zero hx
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n x : ℕ
hx : ¬coeff p x = 0
hx' : ¬↑(choose x n) * coeff p x = 0
⊢ x ≤ natDegree p - n + n

tactic: have hxn : n ≤ x := by
  contrapose! hx'
  simp [Nat.choose_eq_zero_of_lt hx']
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n x : ℕ
hx : ¬coeff p x = 0
hx' : ¬↑(choose x n) * coeff p x = 0
hxp : x ≤ natDegree p
⊢ x ≤ natDegree p - n + n

tactic: rwa [tsub_add_cancel_of_le (hxn.trans hxp)]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n x : ℕ
hx : ¬coeff p x = 0
hx' : ¬↑(choose x n) * coeff p x = 0
hxp : x ≤ natDegree p
hxn : n ≤ x
⊢ x ≤ natDegree p - n + n

tactic: contrapose! hx'
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n x : ℕ
hx : ¬coeff p x = 0
hx' : ¬↑(choose x n) * coeff p x = 0
hxp : x ≤ natDegree p
⊢ n ≤ x

tactic: simp [Nat.choose_eq_zero_of_lt hx']
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n x : ℕ
hx : ¬coeff p x = 0
hxp : x ≤ natDegree p
hx' : x < n
⊢ ↑(choose x n) * coeff p x = 0

tactic: simp
state_before: case h
R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
⊢ max 0 (max 0 0) = max 0 0