tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.shiftComm'
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: erw [← shiftComm_symm Y i j, ← ((shiftFunctorComm C i j).hom.naturality_assoc f)]
state_before: C : Type u
A : Type u_1
inst✝² : Category C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftFunctor C j).map ((shiftFunctor C i).map f) =
    (shiftComm X i j).hom ≫ (shiftFunctor C i).map ((shiftFunctor C j).map f) ≫ (shiftComm Y j i).hom

tactic: dsimp
state_before: C : Type u
A : Type u_1
inst✝² : Category C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftFunctor C j).map ((shiftFunctor C i).map f) =
    (shiftFunctor C i ⋙ shiftFunctor C j).map f ≫ (shiftFunctorComm C i j).hom.app Y ≫ (shiftComm Y i j).symm.hom

tactic: simp only [Iso.hom_inv_id_app, Functor.comp_obj, Category.comp_id]
state_before: C : Type u
A : Type u_1
inst✝² : Category C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftFunctor C j).map ((shiftFunctor C i).map f) =
    (shiftFunctor C j).map ((shiftFunctor C i).map f) ≫
      (shiftFunctorComm C i j).hom.app Y ≫ (shiftFunctorComm C i j).inv.app Y
Theorem: AffineSubspace.vadd_mem_of_mem_direction
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [mem_direction_iff_eq_vsub ⟨p, hp⟩] at hv
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
v : V
hv : v ∈ direction s
p : P
hp : p ∈ s
⊢ v +ᵥ p ∈ s

tactic: rcases hv with ⟨p1, hp1, p2, hp2, hv⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
v : V
hv : ∃ p1, p1 ∈ s ∧ ∃ p2, p2 ∈ s ∧ v = p1 -ᵥ p2
p : P
hp : p ∈ s
⊢ v +ᵥ p ∈ s

tactic: rw [hv]
state_before: case intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
v : V
p : P
hp : p ∈ s
p1 : P
hp1 : p1 ∈ s
p2 : P
hp2 : p2 ∈ s
hv : v = p1 -ᵥ p2
⊢ v +ᵥ p ∈ s

tactic: convert s.smul_vsub_vadd_mem 1 hp1 hp2 hp
state_before: case intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
v : V
p : P
hp : p ∈ s
p1 : P
hp1 : p1 ∈ s
p2 : P
hp2 : p2 ∈ s
hv : v = p1 -ᵥ p2
⊢ p1 -ᵥ p2 +ᵥ p ∈ s

tactic: rw [one_smul]
state_before: case a
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
v : V
p : P
hp : p ∈ s
p1 : P
hp1 : p1 ∈ s
p2 : P
hp2 : p2 ∈ s
hv : v = p1 -ᵥ p2
⊢ p1 -ᵥ p2 +ᵥ p ∈ s ↔ 1 • (p1 -ᵥ p2) +ᵥ p ∈ s.carrier

tactic: exact s.mem_coe k P _
state_before: case a
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
v : V
p : P
hp : p ∈ s
p1 : P
hp1 : p1 ∈ s
p2 : P
hp2 : p2 ∈ s
hv : v = p1 -ᵥ p2
⊢ p1 -ᵥ p2 +ᵥ p ∈ s ↔ p1 -ᵥ p2 +ᵥ p ∈ s.carrier
Theorem: Fin.succAbove_last_apply
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [succAbove_last]
state_before: n m : ℕ
i : Fin n
⊢ ↑(succAbove (last n)) i = ↑castSucc i
Theorem: eq_rec_constant
File: Std/Logic.lean

tactic: cases h
state_before: α : Sort u_1
a a' : α
β : Sort u_2
y : β
h : a = a'
⊢ h ▸ y = y

tactic: rfl
state_before: case refl
α : Sort u_1
a : α
β : Sort u_2
y : β
⊢ (_ : a = a) ▸ y = y
Theorem: Function.minimalPeriod_iterate_eq_div_gcd_aux
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: apply Nat.dvd_antisymm
state_before: α : Type u_1
β : Type ?u.28238
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < gcd (minimalPeriod f x) n
⊢ minimalPeriod (f^[n]) x = minimalPeriod f x / gcd (minimalPeriod f x) n

tactic: apply IsPeriodicPt.minimalPeriod_dvd
state_before: case a
α : Type u_1
β : Type ?u.28238
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < gcd (minimalPeriod f x) n
⊢ minimalPeriod (f^[n]) x ∣ minimalPeriod f x / gcd (minimalPeriod f x) n

tactic: rw [IsPeriodicPt, IsFixedPt, ← iterate_mul, ← Nat.mul_div_assoc _ (gcd_dvd_left _ _),
  mul_comm, Nat.mul_div_assoc _ (gcd_dvd_right _ _), mul_comm, iterate_mul]
state_before: case a.hx
α : Type u_1
β : Type ?u.28238
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < gcd (minimalPeriod f x) n
⊢ IsPeriodicPt (f^[n]) (minimalPeriod f x / gcd (minimalPeriod f x) n) x

tactic: exact (isPeriodicPt_minimalPeriod f x).iterate _
state_before: case a.hx
α : Type u_1
β : Type ?u.28238
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < gcd (minimalPeriod f x) n
⊢ (f^[n / gcd (minimalPeriod f x) n]^[minimalPeriod f x]) x = x

tactic: apply coprime.dvd_of_dvd_mul_right (coprime_div_gcd_div_gcd h)
state_before: case a
α : Type u_1
β : Type ?u.28238
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < gcd (minimalPeriod f x) n
⊢ minimalPeriod f x / gcd (minimalPeriod f x) n ∣ minimalPeriod (f^[n]) x

tactic: apply Nat.dvd_of_mul_dvd_mul_right h
state_before: case a
α : Type u_1
β : Type ?u.28238
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < gcd (minimalPeriod f x) n
⊢ minimalPeriod f x / gcd (minimalPeriod f x) n ∣ minimalPeriod (f^[n]) x * (n / gcd (minimalPeriod f x) n)

tactic: rw [Nat.div_mul_cancel (gcd_dvd_left _ _), mul_assoc, Nat.div_mul_cancel (gcd_dvd_right _ _),
  mul_comm]
state_before: case a
α : Type u_1
β : Type ?u.28238
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < gcd (minimalPeriod f x) n
⊢ minimalPeriod f x / gcd (minimalPeriod f x) n * gcd (minimalPeriod f x) n ∣
    minimalPeriod (f^[n]) x * (n / gcd (minimalPeriod f x) n) * gcd (minimalPeriod f x) n

tactic: apply IsPeriodicPt.minimalPeriod_dvd
state_before: case a
α : Type u_1
β : Type ?u.28238
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < gcd (minimalPeriod f x) n
⊢ minimalPeriod f x ∣ n * minimalPeriod (f^[n]) x

tactic: rw [IsPeriodicPt, IsFixedPt, iterate_mul]
state_before: case a.hx
α : Type u_1
β : Type ?u.28238
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < gcd (minimalPeriod f x) n
⊢ IsPeriodicPt f (n * minimalPeriod (f^[n]) x) x

tactic: exact isPeriodicPt_minimalPeriod _ _
state_before: case a.hx
α : Type u_1
β : Type ?u.28238
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : 0 < gcd (minimalPeriod f x) n
⊢ (f^[n]^[minimalPeriod (f^[n]) x]) x = x
Theorem: Set.preimage_mul_const_Ico
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ici_inter_Iio, h]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ (fun x => x * c) ⁻¹' Ico a b = Ico (a / c) (b / c)
Theorem: Nat.card_prod
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: simp only [Nat.card, mk_prod, toNat_mul, toNat_lift]
state_before: α✝ : Type ?u.11201
β✝ : Type ?u.11204
α : Type u_1
β : Type u_2
⊢ Nat.card (α × β) = Nat.card α * Nat.card β
Theorem: Finset.univ_filter_exists
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.24327
inst✝³ : Fintype α
s t : Finset α
f : α → β
inst✝² : Fintype β
inst✝¹ : DecidablePred fun y => ∃ x, f x = y
inst✝ : DecidableEq β
⊢ filter (fun y => ∃ x, f x = y) univ = image f univ

tactic: simp
state_before: case a
α : Type u_2
β : Type u_1
γ : Type ?u.24327
inst✝³ : Fintype α
s t : Finset α
f : α → β
inst✝² : Fintype β
inst✝¹ : DecidablePred fun y => ∃ x, f x = y
inst✝ : DecidableEq β
a✝ : β
⊢ a✝ ∈ filter (fun y => ∃ x, f x = y) univ ↔ a✝ ∈ image f univ
Theorem: ENNReal.le_of_forall_nnreal_lt
File: Mathlib/Data/Real/ENNReal.lean

tactic: refine' le_of_forall_ge_of_dense fun r hr => _
state_before: α : Type ?u.305340
β : Type ?u.305343
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y : ℝ≥0∞
h : ∀ (r : ℝ≥0), ↑r < x → ↑r ≤ y
⊢ x ≤ y

tactic: lift r to ℝ≥0 using ne_top_of_lt hr
state_before: α : Type ?u.305340
β : Type ?u.305343
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y : ℝ≥0∞
h : ∀ (r : ℝ≥0), ↑r < x → ↑r ≤ y
r : ℝ≥0∞
hr : r < x
⊢ r ≤ y

tactic: exact h r hr
state_before: case intro
α : Type ?u.305340
β : Type ?u.305343
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y : ℝ≥0∞
h : ∀ (r : ℝ≥0), ↑r < x → ↑r ≤ y
r : ℝ≥0
hr : ↑r < x
⊢ ↑r ≤ y
Theorem: Submonoid.LocalizationMap.lift_mul_right
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: erw [mul_assoc, IsUnit.liftRight_inv_mul, mul_one]
state_before: M : Type u_2
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_3
inst✝¹ : CommMonoid N
P : Type u_1
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
z : N
⊢ ↑(lift f hg) z * ↑g ↑(sec f z).snd = ↑g (sec f z).fst
Theorem: Finset.map_affineCombination
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: have b := Classical.choice (inferInstance : AffineSpace V P).Nonempty
state_before: k : Type u_3
V : Type u_5
P : Type u_6
inst✝⁵ : Ring k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type ?u.403226
s₂ : Finset ι₂
V₂ : Type u_1
P₂ : Type u_2
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
w : ι → k
hw : Finset.sum s w = 1
f : P →ᵃ[k] P₂
⊢ ↑f (↑(affineCombination k s p) w) = ↑(affineCombination k s (↑f ∘ p)) w

tactic: have b₂ := Classical.choice (inferInstance : AffineSpace V₂ P₂).Nonempty
state_before: k : Type u_3
V : Type u_5
P : Type u_6
inst✝⁵ : Ring k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type ?u.403226
s₂ : Finset ι₂
V₂ : Type u_1
P₂ : Type u_2
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
w : ι → k
hw : Finset.sum s w = 1
f : P →ᵃ[k] P₂
b : P
⊢ ↑f (↑(affineCombination k s p) w) = ↑(affineCombination k s (↑f ∘ p)) w

tactic: rw [s.affineCombination_eq_weightedVSubOfPoint_vadd_of_sum_eq_one w p hw b,
  s.affineCombination_eq_weightedVSubOfPoint_vadd_of_sum_eq_one w (f ∘ p) hw b₂, ←
  s.weightedVSubOfPoint_vadd_eq_of_sum_eq_one w (f ∘ p) hw (f b) b₂]
state_before: k : Type u_3
V : Type u_5
P : Type u_6
inst✝⁵ : Ring k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type ?u.403226
s₂ : Finset ι₂
V₂ : Type u_1
P₂ : Type u_2
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
w : ι → k
hw : Finset.sum s w = 1
f : P →ᵃ[k] P₂
b : P
b₂ : P₂
⊢ ↑f (↑(affineCombination k s p) w) = ↑(affineCombination k s (↑f ∘ p)) w

tactic: simp only [weightedVSubOfPoint_apply, RingHom.id_apply, AffineMap.map_vadd,
  LinearMap.map_smulₛₗ, AffineMap.linearMap_vsub, LinearMap.map_sum, Function.comp_apply]
state_before: k : Type u_3
V : Type u_5
P : Type u_6
inst✝⁵ : Ring k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type ?u.403226
s₂ : Finset ι₂
V₂ : Type u_1
P₂ : Type u_2
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
w : ι → k
hw : Finset.sum s w = 1
f : P →ᵃ[k] P₂
b : P
b₂ : P₂
⊢ ↑f (↑(weightedVSubOfPoint s p b) w +ᵥ b) = ↑(weightedVSubOfPoint s (↑f ∘ p) (↑f b)) w +ᵥ ↑f b
Theorem: Part.eq_none_iff
File: Mathlib/Data/Part.lean

tactic: simpa
state_before: α : Type u_1
β : Type ?u.4852
γ : Type ?u.4855
o : Part α
h : ∀ (a : α), ¬a ∈ o
⊢ ∀ (a : α), a ∈ o ↔ a ∈ none
Theorem: gauge_neg_set_neg
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: simp_rw [gauge_def', smul_neg, neg_mem_neg]
state_before: 𝕜 : Type ?u.40367
E : Type u_1
F : Type ?u.40373
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
x : E
⊢ gauge (-s) (-x) = gauge s x
Theorem: FractionalIdeal.one_div_spanSingleton
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simp [h]
state_before: R : Type ?u.1522445
inst✝⁷ : CommRing R
S : Submonoid R
P : Type ?u.1522652
inst✝⁶ : CommRing P
inst✝⁵ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_2
inst✝⁴ : CommRing R₁
K : Type u_1
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
x : K
h : x = 0
⊢ 1 / spanSingleton R₁⁰ x = spanSingleton R₁⁰ x⁻¹

tactic: simp [h]
state_before: R : Type ?u.1522445
inst✝⁷ : CommRing R
S : Submonoid R
P : Type ?u.1522652
inst✝⁶ : CommRing P
inst✝⁵ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_2
inst✝⁴ : CommRing R₁
K : Type u_1
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
x : K
h : ¬x = 0
⊢ spanSingleton R₁⁰ x * spanSingleton R₁⁰ x⁻¹ = 1
Theorem: Matrix.det_smul
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: rw [smul_eq_diagonal_mul]
state_before: m : Type ?u.1307018
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
c : R
⊢ det (c • A) = det ((diagonal fun x => c) ⬝ A)

tactic: simp [card_univ]
state_before: m : Type ?u.1307018
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
c : R
⊢ det (diagonal fun x => c) * det A = c ^ Fintype.card n * det A
Theorem: image_subtype_ne_univ_eq_image_erase
File: Mathlib/Data/Fintype/Sum.lean

tactic: apply subset_antisymm
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
k : β
b : α → β
⊢ image (fun i => b ↑i) univ = erase (image b univ) k

tactic: rw [image_subset_iff]
state_before: case a
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
k : β
b : α → β
⊢ image (fun i => b ↑i) univ ⊆ erase (image b univ) k

tactic: intro i _
state_before: case a
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
k : β
b : α → β
⊢ ∀ (x : { a // b a ≠ k }), x ∈ univ → b ↑x ∈ erase (image b univ) k

tactic: apply mem_erase_of_ne_of_mem i.2 (mem_image_of_mem _ (mem_univ _))
state_before: case a
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
k : β
b : α → β
i : { a // b a ≠ k }
a✝ : i ∈ univ
⊢ b ↑i ∈ erase (image b univ) k

tactic: intro i hi
state_before: case a
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
k : β
b : α → β
⊢ erase (image b univ) k ⊆ image (fun i => b ↑i) univ

tactic: rw [mem_image]
state_before: case a
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
k : β
b : α → β
i : β
hi : i ∈ erase (image b univ) k
⊢ i ∈ image (fun i => b ↑i) univ

tactic: rcases mem_image.1 (erase_subset _ _ hi) with ⟨a, _, ha⟩
state_before: case a
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
k : β
b : α → β
i : β
hi : i ∈ erase (image b univ) k
⊢ ∃ a, a ∈ univ ∧ b ↑a = i

tactic: subst ha
state_before: case a.intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
k : β
b : α → β
i : β
hi : i ∈ erase (image b univ) k
a : α
left✝ : a ∈ univ
ha : b a = i
⊢ ∃ a, a ∈ univ ∧ b ↑a = i

tactic: exact ⟨⟨a, ne_of_mem_erase hi⟩, mem_univ _, rfl⟩
state_before: case a.intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
k : β
b : α → β
a : α
left✝ : a ∈ univ
hi : b a ∈ erase (image b univ) k
⊢ ∃ a_1, a_1 ∈ univ ∧ b ↑a_1 = b a
Theorem: Finset.sum_range_id_mul_two
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [sum_range_reflect (fun i => i) n, mul_two]
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f : α → β
inst✝ : CommMonoid β
n : ℕ
⊢ (∑ i in range n, i) * 2 = ∑ i in range n, i + ∑ i in range n, (n - 1 - i)

tactic: rw [sum_const, card_range, Nat.nsmul_eq_mul]
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f : α → β
inst✝ : CommMonoid β
n : ℕ
⊢ ∑ i in range n, (n - 1) = n * (n - 1)
Theorem: VitaliFamily.eventually_filterAt_subset_of_nhds
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: rw [eventually_filterAt_iff]
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
o : Set α
hx : o ∈ 𝓝 x
⊢ ∀ᶠ (a : Set α) in filterAt v x, a ⊆ o

tactic: rcases Metric.mem_nhds_iff.1 hx with ⟨ε, εpos, hε⟩
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
o : Set α
hx : o ∈ 𝓝 x
⊢ ∃ ε, ε > 0 ∧ ∀ (a : Set α), a ∈ setsAt v x → a ⊆ closedBall x ε → a ⊆ o

tactic: exact ⟨ε / 2, half_pos εpos,
  fun a _ ha => ha.trans ((closedBall_subset_ball (half_lt_self εpos)).trans hε)⟩
state_before: case intro.intro
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
o : Set α
hx : o ∈ 𝓝 x
ε : ℝ
εpos : ε > 0
hε : ball x ε ⊆ o
⊢ ∃ ε, ε > 0 ∧ ∀ (a : Set α), a ∈ setsAt v x → a ⊆ closedBall x ε → a ⊆ o
Theorem: Real.sinh_strictMono
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: rw [Real.deriv_sinh]
state_before: x y z : ℝ
⊢ ∀ (x : ℝ), 0 < deriv sinh x

tactic: exact cosh_pos
state_before: x y z : ℝ
⊢ ∀ (x : ℝ), 0 < cosh x
Theorem: ContinuousLinearMap.toSpanSingleton_add
File: Mathlib/Analysis/NormedSpace/ContinuousLinearMap.lean

tactic: ext1
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.379365
E : Type u_2
F : Type ?u.379371
G : Type ?u.379374
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜₂
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x y : E
⊢ toSpanSingleton 𝕜 (x + y) = toSpanSingleton 𝕜 x + toSpanSingleton 𝕜 y

tactic: simp [toSpanSingleton_apply]
state_before: case h
𝕜 : Type u_1
𝕜₂ : Type ?u.379365
E : Type u_2
F : Type ?u.379371
G : Type ?u.379374
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜₂
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x y : E
⊢ ↑(toSpanSingleton 𝕜 (x + y)) 1 = ↑(toSpanSingleton 𝕜 x + toSpanSingleton 𝕜 y) 1
Theorem: Matrix.cons_sub_cons
File: Mathlib/Data/Fin/VecNotation.lean

tactic: simp
state_before: α : Type u
m n o : ℕ
m' : Type ?u.73859
n' : Type ?u.73862
o' : Type ?u.73865
inst✝ : Sub α
x : α
v : Fin n → α
y : α
w : Fin n → α
⊢ vecCons x v - vecCons y w = vecCons (x - y) (v - w)
Theorem: Matrix.zpow_add_one_of_ne_neg_one
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: simp only [pow_succ', ← Nat.cast_succ, zpow_ofNat]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℕ
x✝ : ↑n ≠ -1
⊢ A ^ (↑n + 1) = A ^ ↑n * A

tactic: rcases nonsing_inv_cancel_or_zero A with (⟨h, _⟩ | h)
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℕ
x✝ : -(↑n + 2) ≠ -1
⊢ A ^ (-(↑n + 2) + 1) = A ^ (-(↑n + 2)) * A

tactic: apply zpow_add_one (isUnit_det_of_left_inverse h)
state_before: case inl.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℕ
x✝ : -(↑n + 2) ≠ -1
h : A⁻¹ ⬝ A = 1
right✝ : A ⬝ A⁻¹ = 1
⊢ A ^ (-(↑n + 2) + 1) = A ^ (-(↑n + 2)) * A

tactic: show A ^ (-((n + 1 : ℕ) : ℤ)) = A ^ (-((n + 2 : ℕ) : ℤ)) * A
state_before: case inr
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℕ
x✝ : -(↑n + 2) ≠ -1
h : A⁻¹ = 0
⊢ A ^ (-(↑n + 2) + 1) = A ^ (-(↑n + 2)) * A

tactic: simp_rw [zpow_neg_coe_nat, ← inv_pow', h, zero_pow Nat.succ_pos', MulZeroClass.zero_mul]
state_before: case inr
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℕ
x✝ : -(↑n + 2) ≠ -1
h : A⁻¹ = 0
⊢ A ^ (-↑(n + 1)) = A ^ (-↑(n + 2)) * A
Theorem: SimpleGraph.Subgraph.deleteEdges_inter_edgeSet_left_eq
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext <;> simp (config := { contextual := true }) [imp_false]
state_before: ι : Sort ?u.252003
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
⊢ deleteEdges G' (edgeSet G' ∩ s) = deleteEdges G' s
Theorem: Equiv.Perm.IsSwap.mul_mem_closure_three_cycles
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: obtain ⟨a, b, ab, rfl⟩ := hσ
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
hσ : IsSwap σ
hτ : IsSwap τ
⊢ σ * τ ∈ closure {σ | IsThreeCycle σ}

tactic: obtain ⟨c, d, cd, rfl⟩ := hτ
state_before: case intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
τ : Perm α
hτ : IsSwap τ
a b : α
ab : a ≠ b
⊢ swap a b * τ ∈ closure {σ | IsThreeCycle σ}

tactic: by_cases ac : a = c
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
⊢ swap a b * swap c d ∈ closure {σ | IsThreeCycle σ}

tactic: have h' : swap a b * swap c d = swap a b * swap a c * (swap c a * swap c d) := by
  simp [swap_comm c a, mul_assoc]
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : ¬a = c
⊢ swap a b * swap c d ∈ closure {σ | IsThreeCycle σ}

tactic: rw [h']
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : ¬a = c
h' : swap a b * swap c d = swap a b * swap a c * (swap c a * swap c d)
⊢ swap a b * swap c d ∈ closure {σ | IsThreeCycle σ}

tactic: exact
  mul_mem (swap_mul_swap_same_mem_closure_three_cycles ab ac)
    (swap_mul_swap_same_mem_closure_three_cycles (Ne.symm ac) cd)
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : ¬a = c
h' : swap a b * swap c d = swap a b * swap a c * (swap c a * swap c d)
⊢ swap a b * swap a c * (swap c a * swap c d) ∈ closure {σ | IsThreeCycle σ}

tactic: subst ac
state_before: case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : a = c
⊢ swap a b * swap c d ∈ closure {σ | IsThreeCycle σ}

tactic: exact swap_mul_swap_same_mem_closure_three_cycles ab cd
state_before: case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
d : α
cd : a ≠ d
⊢ swap a b * swap a d ∈ closure {σ | IsThreeCycle σ}

tactic: simp [swap_comm c a, mul_assoc]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
a b : α
ab : a ≠ b
c d : α
cd : c ≠ d
ac : ¬a = c
⊢ swap a b * swap c d = swap a b * swap a c * (swap c a * swap c d)
Theorem: mul_mem_closedBall_iff_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [mem_closedBall_iff_norm'', mul_div_cancel''']
state_before: 𝓕 : Type ?u.742261
𝕜 : Type ?u.742264
α : Type ?u.742267
ι : Type ?u.742270
κ : Type ?u.742273
E : Type u_1
F : Type ?u.742279
G : Type ?u.742282
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ a * b ∈ closedBall a r ↔ ‖b‖ ≤ r
Theorem: eventuallyEq_zero_nhds
File: Mathlib/Topology/Basic.lean

tactic: rw [← mem_compl_iff, ← interior_compl, mem_interior_iff_mem_nhds, Function.compl_support]
state_before: α : Type u_2
β : Type ?u.166489
γ : Type ?u.166492
δ : Type ?u.166495
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
M₀ : Type u_1
inst✝ : Zero M₀
a : α
f : α → M₀
⊢ f =ᶠ[𝓝 a] 0 ↔ ¬a ∈ closure (Function.support f)

tactic: rfl
state_before: α : Type u_2
β : Type ?u.166489
γ : Type ?u.166492
δ : Type ?u.166495
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
M₀ : Type u_1
inst✝ : Zero M₀
a : α
f : α → M₀
⊢ f =ᶠ[𝓝 a] 0 ↔ {x | f x = 0} ∈ 𝓝 a
Theorem: ZMod.cast_neg_one
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases' n with n
state_before: R : Type u_1
inst✝ : Ring R
n : ℕ
⊢ ↑(-1) = ↑n - 1

tactic: dsimp [ZMod, ZMod.cast]
state_before: case zero
R : Type u_1
inst✝ : Ring R
⊢ ↑(-1) = ↑Nat.zero - 1

tactic: simp
state_before: case zero
R : Type u_1
inst✝ : Ring R
⊢ ↑(-1) = ↑0 - 1

tactic: rw [← nat_cast_val, val_neg_one, Nat.cast_succ, add_sub_cancel]
state_before: case succ
R : Type u_1
inst✝ : Ring R
n : ℕ
⊢ ↑(-1) = ↑(Nat.succ n) - 1