1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.mulVec_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext i
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁵ : NonUnitalNonAssocSemiring α
inst✝⁴ : Fintype n
inst✝³ : Monoid R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : DistribMulAction R S
inst✝ : SMulCommClass R S S
M : Matrix m n S
b : R
v : n → S
⊢ M *ᵥ b • v = b • M *ᵥ v
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁵ : NonUnitalNonAssocSemiring α
inst✝⁴ : Fintype n
inst✝³ : Monoid R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : DistribMulAction R S
inst✝ : SMulCommClass R S S
M : Matrix m n S
b : R
v : n → S
i : m
⊢ (M *ᵥ b • v) i = (b • M *ᵥ v) i

tactic: simp only [mulVec, dotProduct, Finset.smul_sum, Pi.smul_apply, mul_smul_comm]
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁵ : NonUnitalNonAssocSemiring α
inst✝⁴ : Fintype n
inst✝³ : Monoid R
inst✝² : NonUnitalNonAssocSemiring S
inst✝¹ : DistribMulAction R S
inst✝ : SMulCommClass R S S
M : Matrix m n S
b : R
v : n → S
i : m
⊢ (M *ᵥ b • v) i = (b • M *ᵥ v) i
state_after: no goals
Theorem: CategoryTheory.isCoseparator_iff_faithful_preadditiveYoneda
File: Mathlib/CategoryTheory/Preadditive/Generator.lean

tactic: rw [isCoseparator_iff_faithful_yoneda_obj, ← whiskering_preadditiveYoneda, Functor.comp_obj,
  whiskeringRight_obj_obj]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ IsCoseparator G ↔ (preadditiveYoneda.obj G).Faithful
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ (preadditiveYoneda.obj G ⋙ forget AddCommGrp).Faithful ↔ (preadditiveYoneda.obj G).Faithful

tactic: exact ⟨fun h => Functor.Faithful.of_comp _ (forget AddCommGrp),
  fun h => Functor.Faithful.comp _ _⟩
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ (preadditiveYoneda.obj G ⋙ forget AddCommGrp).Faithful ↔ (preadditiveYoneda.obj G).Faithful
state_after: no goals
Theorem: MeasurableSpace.inf_le_invariants_comp
File: Mathlib/MeasureTheory/MeasurableSpace/Invariants.lean

tactic: rw [preimage_comp, hs.1.2, hs.2.2]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
f g : α → α
s : Set α
hs : MeasurableSet s
⊢ f ∘ g ⁻¹' s = s
state_after: no goals
Theorem: Nat.sInf_add'
File: Mathlib/Data/Nat/Lattice.lean

tactic: suffices h₁ : n ≤ sInf {m | p (m - n)} by
  convert sInf_add h₁
  simp_rw [Nat.add_sub_cancel_right]
state_before: n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
⊢ sInf {m | p m} + n = sInf {m | p (m - n)}
state_after: n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
⊢ n ≤ sInf {m | p (m - n)}

tactic: obtain ⟨m, hm⟩ := nonempty_of_pos_sInf h
state_before: n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
⊢ n ≤ sInf {m | p (m - n)}
state_after: case intro
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ n ≤ sInf {m | p (m - n)}

tactic: refine
  le_csInf ⟨m + n, ?_⟩ fun b hb ↦
    le_of_not_lt fun hbn ↦
      ne_of_mem_of_not_mem ?_ (not_mem_of_lt_sInf h) (Nat.sub_eq_zero_of_le hbn.le)
state_before: case intro
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ n ≤ sInf {m | p (m - n)}
state_after: case intro.refine_1
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ m + n ∈ {m | p (m - n)}

case intro.refine_2
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
b : ℕ
hb : b ∈ {m | p (m - n)}
hbn : b < n
⊢ b - n ∈ {m | p m}

tactic: convert sInf_add h₁
state_before: n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
h₁ : n ≤ sInf {m | p (m - n)}
⊢ sInf {m | p m} + n = sInf {m | p (m - n)}
state_after: case h.e'_2.h.e'_5.h.e'_3.h.e'_2.h.h.e'_1
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
h₁ : n ≤ sInf {m | p (m - n)}
x✝ : ℕ
⊢ x✝ = x✝ + n - n

tactic: simp_rw [Nat.add_sub_cancel_right]
state_before: case h.e'_2.h.e'_5.h.e'_3.h.e'_2.h.h.e'_1
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
h₁ : n ≤ sInf {m | p (m - n)}
x✝ : ℕ
⊢ x✝ = x✝ + n - n
state_after: no goals

tactic: dsimp
state_before: case intro.refine_1
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ m + n ∈ {m | p (m - n)}
state_after: case intro.refine_1
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ p (m + n - n)

tactic: rwa [Nat.add_sub_cancel_right]
state_before: case intro.refine_1
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ p (m + n - n)
state_after: no goals

tactic: exact hb
state_before: case intro.refine_2
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
b : ℕ
hb : b ∈ {m | p (m - n)}
hbn : b < n
⊢ b - n ∈ {m | p m}
state_after: no goals
Theorem: Finset.piecewise_empty
File: Mathlib/Data/Finset/Piecewise.lean

tactic: ext i
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝ : (i : ι) → Decidable (i ∈ ∅)
⊢ ∅.piecewise f g = g
state_after: case h
ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝ : (i : ι) → Decidable (i ∈ ∅)
i : ι
⊢ ∅.piecewise f g i = g i

tactic: simp [piecewise]
state_before: case h
ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝ : (i : ι) → Decidable (i ∈ ∅)
i : ι
⊢ ∅.piecewise f g i = g i
state_after: no goals
Theorem: Real.sin_two_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sin_two_mul]
state_before: x y : ℝ
⊢ ↑(sin (2 * x)) = ↑(2 * sin x * cos x)
state_after: no goals
Theorem: div_div_eq_mul_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
⊢ a / (b / c) = a * c / b
state_after: no goals
Theorem: MonoidHom.cancel_left
File: Mathlib/Algebra/Group/Hom/Defs.lean

tactic: rw [← MonoidHom.comp_apply, h, MonoidHom.comp_apply]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
g : N →* P
f₁ f₂ : M →* N
hg : Function.Injective ⇑g
h : g.comp f₁ = g.comp f₂
x : M
⊢ g (f₁ x) = g (f₂ x)
state_after: no goals
Theorem: Set.exists_mem_image
File: Mathlib/Data/Set/Image.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t : Set α
f : α → β
s : Set α
p : β → Prop
⊢ (∃ y ∈ f '' s, p y) ↔ ∃ x ∈ s, p (f x)
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.affineBasisCover_map_range
File: Mathlib/AlgebraicGeometry/Cover/Open.lean

tactic: erw [coe_comp, Set.range_comp]
state_before: X✝ Y Z : Scheme
𝒰 : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰.J), HasPullback (𝒰.map x ≫ f) g
X : Scheme
x : ↑↑X.toPresheafedSpace
r : ↑⋯.choose
⊢ Set.range ⇑(X.affineBasisCover.map ⟨x, r⟩).val.base =
    ⇑(X.affineCover.map x).val.base '' (PrimeSpectrum.basicOpen r).carrier
state_after: X✝ Y Z : Scheme
𝒰 : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰.J), HasPullback (𝒰.map x ≫ f) g
X : Scheme
x : ↑↑X.toPresheafedSpace
r : ↑⋯.choose
⊢ ⇑(X.affineCover.map ⟨x, r⟩.fst).val.base ''
      Set.range ⇑(((fun x => affineBasisCoverOfAffine ⋯.choose) ⟨x, r⟩.fst).map ⟨x, r⟩.snd).val.base =
    ⇑(X.affineCover.map x).val.base '' (PrimeSpectrum.basicOpen r).carrier

tactic: exact (PrimeSpectrum.localization_away_comap_range (Localization.Away r) r : _)
state_before: X✝ Y Z : Scheme
𝒰 : X✝.OpenCover
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (x : 𝒰.J), HasPullback (𝒰.map x ≫ f) g
X : Scheme
x : ↑↑X.toPresheafedSpace
r : ↑⋯.choose
⊢ Set.range ⇑(((fun x => affineBasisCoverOfAffine ⋯.choose) ⟨x, r⟩.fst).map ⟨x, r⟩.snd).val.base =
    (PrimeSpectrum.basicOpen r).carrier
state_after: no goals
Theorem: Fin.one_succAbove_one
File: Mathlib/Data/Fin/Basic.lean

tactic: simpa only [succ_zero_eq_one, val_zero, zero_succAbove, succ_one_eq_two]
  using succ_succAbove_succ (0 : Fin (n + 2)) (0 : Fin (n + 2))
state_before: n✝ m : ℕ
p : Fin (n✝ + 1)
i j : Fin n✝
n : ℕ
⊢ succAbove 1 1 = 2
state_after: no goals
Theorem: Finset.Iic_mul_Iio_subset'
File: Mathlib/Data/Finset/Pointwise/Interval.lean

tactic: simpa using Set.Iic_mul_Iio_subset' _ _
state_before: α : Type u_1
inst✝⁵ : Mul α
inst✝⁴ : PartialOrder α
inst✝³ : DecidableEq α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝¹ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
inst✝ : LocallyFiniteOrderBot α
a b : α
⊢ ↑(Iic a * Iio b) ⊆ ↑(Iio (a * b))
state_after: no goals
Theorem: Rat.eq_num_of_isInt
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [Rat.isInt, Nat.beq_eq_true_eq] at h
state_before: q✝ a b c q : ℚ
h : q.isInt = true
⊢ q = ↑q.num
state_after: q✝ a b c q : ℚ
h : q.den = 1
⊢ q = ↑q.num

tactic: exact (Rat.coe_int_num_of_den_eq_one h).symm
state_before: q✝ a b c q : ℚ
h : q.den = 1
⊢ q = ↑q.num
state_after: no goals
Theorem: BoundedContinuousFunction.coe_zsmulRec
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: rw [zsmulRec, Int.ofNat_eq_coe, coe_nsmul, natCast_zsmul]
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
n : ℕ
⊢ ⇑(zsmulRec (fun x x_1 => x • x_1) (Int.ofNat n) f) = Int.ofNat n • ⇑f
state_after: no goals

tactic: rw [zsmulRec, negSucc_zsmul, coe_neg, coe_nsmul]
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
n : ℕ
⊢ ⇑(zsmulRec (fun x x_1 => x • x_1) (Int.negSucc n) f) = Int.negSucc n • ⇑f
state_after: no goals
Theorem: List.prod_join
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: induction l <;> [rfl; simp only [*, List.join, map, prod_append, prod_cons]]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List (List M)
⊢ l.join.prod = (map prod l).prod
state_after: no goals
Theorem: Matrix.mulVecLin_one
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: ext
state_before: R : Type u_1
inst✝² : CommSemiring R
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝¹ : Fintype n
inst✝ : DecidableEq n
⊢ mulVecLin 1 = LinearMap.id
state_after: case h.h.h
R : Type u_1
inst✝² : CommSemiring R
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝¹ : Fintype n
inst✝ : DecidableEq n
i✝ x✝ : n
⊢ (mulVecLin 1 ∘ₗ single i✝) 1 x✝ = (LinearMap.id ∘ₗ single i✝) 1 x✝

tactic: simp [Matrix.one_apply, Pi.single_apply]
state_before: case h.h.h
R : Type u_1
inst✝² : CommSemiring R
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝¹ : Fintype n
inst✝ : DecidableEq n
i✝ x✝ : n
⊢ (mulVecLin 1 ∘ₗ single i✝) 1 x✝ = (LinearMap.id ∘ₗ single i✝) 1 x✝
state_after: no goals
Theorem: Submonoid.mem_sup
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

tactic: simp only [ge_iff_le, sup_eq_range, mem_mrange, coprod_apply, coe_subtype, Prod.exists,
  Subtype.exists, exists_prop]
state_before: M : Type u_1
A : Type u_2
B : Type u_3
N : Type u_4
inst✝ : CommMonoid N
s t : Submonoid N
x : N
⊢ x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x
state_after: no goals
Theorem: Isometry.map_hausdorffMeasure
File: Mathlib/MeasureTheory/Measure/Hausdorff.lean

tactic: ext1 s hs
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
inst✝³ : MeasurableSpace X
inst✝² : BorelSpace X
inst✝¹ : MeasurableSpace Y
inst✝ : BorelSpace Y
f : X → Y
d : ℝ
hf : Isometry f
hd : 0 ≤ d ∨ Surjective f
⊢ Measure.map f μH[d] = μH[d].restrict (range f)
state_after: case h
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
inst✝³ : MeasurableSpace X
inst✝² : BorelSpace X
inst✝¹ : MeasurableSpace Y
inst✝ : BorelSpace Y
f : X → Y
d : ℝ
hf : Isometry f
hd : 0 ≤ d ∨ Surjective f
s : Set Y
hs : MeasurableSet s
⊢ (Measure.map f μH[d]) s = (μH[d].restrict (range f)) s

tactic: rw [map_apply hf.continuous.measurable hs, Measure.restrict_apply hs,
  hf.hausdorffMeasure_preimage hd]
state_before: case h
ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
inst✝³ : MeasurableSpace X
inst✝² : BorelSpace X
inst✝¹ : MeasurableSpace Y
inst✝ : BorelSpace Y
f : X → Y
d : ℝ
hf : Isometry f
hd : 0 ≤ d ∨ Surjective f
s : Set Y
hs : MeasurableSet s
⊢ (Measure.map f μH[d]) s = (μH[d].restrict (range f)) s
state_after: no goals
Theorem: Nat.digitsAux_def
File: Mathlib/Data/Nat/Digits.lean

tactic: cases n
state_before: n✝ b : ℕ
h : 2 ≤ b
n : ℕ
w : 0 < n
⊢ b.digitsAux h n = n % b :: b.digitsAux h (n / b)
state_after: case zero
n b : ℕ
h : 2 ≤ b
w : 0 < 0
⊢ b.digitsAux h 0 = 0 % b :: b.digitsAux h (0 / b)

case succ
n b : ℕ
h : 2 ≤ b
n✝ : ℕ
w : 0 < n✝ + 1
⊢ b.digitsAux h (n✝ + 1) = (n✝ + 1) % b :: b.digitsAux h ((n✝ + 1) / b)

tactic: cases w
state_before: case zero
n b : ℕ
h : 2 ≤ b
w : 0 < 0
⊢ b.digitsAux h 0 = 0 % b :: b.digitsAux h (0 / b)
state_after: no goals

tactic: rw [digitsAux]
state_before: case succ
n b : ℕ
h : 2 ≤ b
n✝ : ℕ
w : 0 < n✝ + 1
⊢ b.digitsAux h (n✝ + 1) = (n✝ + 1) % b :: b.digitsAux h ((n✝ + 1) / b)
state_after: no goals
Theorem: hasFDerivAt_iff_isLittleO_nhds_zero
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [HasFDerivAt, hasFDerivAtFilter_iff_isLittleO, ← map_add_left_nhds_zero x, isLittleO_map]
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
⊢ HasFDerivAt f f' x ↔ (fun h => f (x + h) - f x - f' h) =o[𝓝 0] fun h => h
state_after: 𝕜 : 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
⊢ ((fun x' => f x' - f x - f' (x' - x)) ∘ fun x_1 => x + x_1) =o[𝓝 0] ((fun x' => x' - x) ∘ fun x_1 => x + x_1) ↔
    (fun h => f (x + h) - f x - f' h) =o[𝓝 0] fun h => h
Theorem: LinearMap.pow_mulRight
File: Mathlib/Algebra/Algebra/Bilinear.lean

tactic: simp only [mulRight, ← Algebra.coe_lmul_eq_mul]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
a : A
n : ℕ
⊢ mulRight R a ^ n = mulRight R (a ^ n)
state_after: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
a : A
n : ℕ
⊢ (mul R A).flip a ^ n = (mul R A).flip (a ^ n)

tactic: exact
  LinearMap.coe_injective (((mulRight R a).coe_pow n).symm ▸ mul_right_iterate a n)
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
a : A
n : ℕ
⊢ (mul R A).flip a ^ n = (mul R A).flip (a ^ n)
state_after: no goals
Theorem: Filter.exists_forall_mem_of_hasBasis_mem_blimsup'
File: Mathlib/Order/LiminfLimsup.lean

tactic: obtain ⟨f, hf⟩ := exists_forall_mem_of_hasBasis_mem_blimsup hl hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p✝ : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a : α
l : Filter β
b : ι → Set β
hl : l.HasBasis (fun x => True) b
u : β → Set α
p : β → Prop
x : α
hx : x ∈ blimsup u l p
⊢ ∃ f, ∀ (i : ι), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b i
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p✝ : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a : α
l : Filter β
b : ι → Set β
hl : l.HasBasis (fun x => True) b
u : β → Set α
p : β → Prop
x : α
hx : x ∈ blimsup u l p
f : ↑{i | True} → β
hf : ∀ (i : ↑{i | True}), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b ↑i
⊢ ∃ f, ∀ (i : ι), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b i

tactic: exact ⟨fun i => f ⟨i, trivial⟩, fun i => hf ⟨i, trivial⟩⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p✝ : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a : α
l : Filter β
b : ι → Set β
hl : l.HasBasis (fun x => True) b
u : β → Set α
p : β → Prop
x : α
hx : x ∈ blimsup u l p
f : ↑{i | True} → β
hf : ∀ (i : ↑{i | True}), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b ↑i
⊢ ∃ f, ∀ (i : ι), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b i
state_after: no goals
Theorem: Pell.is_pell_solution_iff_mem_unitary
File: Mathlib/NumberTheory/Pell.lean

tactic: rw [← norm_eq_one_iff_mem_unitary, norm_def, sq, sq, ← mul_assoc]
state_before: d : ℤ
a : ℤ√d
⊢ a.re ^ 2 - d * a.im ^ 2 = 1 ↔ a ∈ unitary (ℤ√d)
state_after: no goals
Theorem: Nat.dist_add_add_left
File: Mathlib/Data/Nat/Dist.lean

tactic: rw [add_comm k n, add_comm k m]
state_before: k n m : ℕ
⊢ (k + n).dist (k + m) = n.dist m
state_after: k n m : ℕ
⊢ (n + k).dist (m + k) = n.dist m

tactic: apply dist_add_add_right
state_before: k n m : ℕ
⊢ (n + k).dist (m + k) = n.dist m
state_after: no goals
Theorem: chainClosure_empty
File: Mathlib/Order/Chain.lean

tactic: have : ChainClosure r (⋃₀∅) := ChainClosure.union fun a h => False.rec h
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
⊢ ChainClosure r ∅
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
this : ChainClosure r (⋃₀ ∅)
⊢ ChainClosure r ∅

tactic: simpa using this
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
this : ChainClosure r (⋃₀ ∅)
⊢ ChainClosure r ∅
state_after: no goals
Theorem: Set.image_update_Ico_right
File: Mathlib/Order/Interval/Set/Pi.lean

tactic: simpa using image_update_Ico f i (f i) b
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
b : α i
⊢ update f i '' Ico (f i) b = Ico f (update f i b)
state_after: no goals
Theorem: Complex.integral_exp_neg_mul_rpow
File: Mathlib/MeasureTheory/Integral/Gamma.lean

tactic: convert (integral_rpow_mul_exp_neg_mul_rpow hp (by linarith : (-2:ℝ) < 0)) hb using 1
state_before: p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ ∫ (x : ℂ), rexp (-b * ‖x‖ ^ p) = π * b ^ (-2 / p) * Real.Gamma (2 / p + 1)
state_after: case h.e'_2
p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ ∫ (x : ℂ), rexp (-b * ‖x‖ ^ p) = ∫ (x : ℂ), ‖x‖ ^ 0 * rexp (-b * ‖x‖ ^ p)

case h.e'_3
p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ π * b ^ (-2 / p) * Real.Gamma (2 / p + 1) = 2 * π / p * b ^ (-(0 + 2) / p) * Real.Gamma ((0 + 2) / p)

tactic: linarith
state_before: p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ -2 < 0
state_after: no goals

tactic: simp_rw [norm_eq_abs, rpow_zero, one_mul]
state_before: case h.e'_2
p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ ∫ (x : ℂ), rexp (-b * ‖x‖ ^ p) = ∫ (x : ℂ), ‖x‖ ^ 0 * rexp (-b * ‖x‖ ^ p)
state_after: no goals

tactic: rw [zero_add, Real.Gamma_add_one (div_ne_zero two_ne_zero (by linarith))]
state_before: case h.e'_3
p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ π * b ^ (-2 / p) * Real.Gamma (2 / p + 1) = 2 * π / p * b ^ (-(0 + 2) / p) * Real.Gamma ((0 + 2) / p)
state_after: case h.e'_3
p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ π * b ^ (-2 / p) * (2 / p * Real.Gamma (2 / p)) = 2 * π / p * b ^ (-2 / p) * Real.Gamma (2 / p)

tactic: ring
state_before: case h.e'_3
p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ π * b ^ (-2 / p) * (2 / p * Real.Gamma (2 / p)) = 2 * π / p * b ^ (-2 / p) * Real.Gamma (2 / p)
state_after: no goals

tactic: linarith
state_before: p b : ℝ
hp : 1 ≤ p
hb : 0 < b
⊢ p ≠ 0
state_after: no goals
Theorem: Nat.sub_eq_of_eq_add'
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [h, Nat.add_sub_cancel_left]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : a = b + c
⊢ a - b = c
state_after: no goals
Theorem: CategoryTheory.isDetector_unop_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [IsDetector, IsCodetector, ← isDetecting_unop_iff, Set.singleton_unop]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : Cᵒᵖ
⊢ IsDetector G.unop ↔ IsCodetector G
state_after: no goals
Theorem: measurable_of_re_im
File: Mathlib/MeasureTheory/Function/SpecialFunctions/RCLike.lean

tactic: convert Measurable.add (M := 𝕜) (RCLike.measurable_ofReal.comp hre)
    ((RCLike.measurable_ofReal.comp him).mul_const RCLike.I)
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : RCLike 𝕜
inst✝ : MeasurableSpace α
f : α → 𝕜
μ : MeasureTheory.Measure α
hre : Measurable fun x => RCLike.re (f x)
him : Measurable fun x => RCLike.im (f x)
⊢ Measurable f
state_after: case h.e'_5.h
α : Type u_1
𝕜 : Type u_2
inst✝¹ : RCLike 𝕜
inst✝ : MeasurableSpace α
f : α → 𝕜
μ : MeasureTheory.Measure α
hre : Measurable fun x => RCLike.re (f x)
him : Measurable fun x => RCLike.im (f x)
x✝ : α
⊢ f x✝ = (RCLike.ofReal ∘ fun x => RCLike.re (f x)) x✝ + (RCLike.ofReal ∘ fun x => RCLike.im (f x)) x✝ * RCLike.I

tactic: exact (RCLike.re_add_im _).symm
state_before: case h.e'_5.h
α : Type u_1
𝕜 : Type u_2
inst✝¹ : RCLike 𝕜
inst✝ : MeasurableSpace α
f : α → 𝕜
μ : MeasureTheory.Measure α
hre : Measurable fun x => RCLike.re (f x)
him : Measurable fun x => RCLike.im (f x)
x✝ : α
⊢ f x✝ = (RCLike.ofReal ∘ fun x => RCLike.re (f x)) x✝ + (RCLike.ofReal ∘ fun x => RCLike.im (f x)) x✝ * RCLike.I
state_after: no goals
Theorem: Module.End.IsNilpotent.mapQ
File: Mathlib/RingTheory/Nilpotent/Lemmas.lean

tactic: obtain ⟨k, hk⟩ := hnp
state_before: R : Type u_1
S : Type u_2
x y : R
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : End R M
p : Submodule R M
hp : p ≤ Submodule.comap f p
hnp : IsNilpotent f
⊢ IsNilpotent (p.mapQ p f hp)
state_after: case intro
R : Type u_1
S : Type u_2
x y : R
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : End R M
p : Submodule R M
hp : p ≤ Submodule.comap f p
k : ℕ
hk : f ^ k = 0
⊢ IsNilpotent (p.mapQ p f hp)

tactic: use k
state_before: case intro
R : Type u_1
S : Type u_2
x y : R
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : End R M
p : Submodule R M
hp : p ≤ Submodule.comap f p
k : ℕ
hk : f ^ k = 0
⊢ IsNilpotent (p.mapQ p f hp)
state_after: case h
R : Type u_1
S : Type u_2
x y : R
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : End R M
p : Submodule R M
hp : p ≤ Submodule.comap f p
k : ℕ
hk : f ^ k = 0
⊢ p.mapQ p f hp ^ k = 0

tactic: simp [← p.mapQ_pow, hk]
state_before: case h
R : Type u_1
S : Type u_2
x y : R
M : Type v
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : End R M
p : Submodule R M
hp : p ≤ Submodule.comap f p
k : ℕ
hk : f ^ k = 0
⊢ p.mapQ p f hp ^ k = 0
state_after: no goals
Theorem: Fin.heq_ext_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: subst h
state_before: n m k l : ℕ
h : k = l
i : Fin k
j : Fin l
⊢ HEq i j ↔ ↑i = ↑j
state_after: n m k : ℕ
i j : Fin k
⊢ HEq i j ↔ ↑i = ↑j

tactic: simp [val_eq_val]
state_before: n m k : ℕ
i j : Fin k
⊢ HEq i j ↔ ↑i = ↑j
state_after: no goals
Theorem: MeasureTheory.lintegral_lintegral_mul
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp [lintegral_const_mul'' _ hg, lintegral_mul_const'' _ hf]
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν✝ : Measure α
β : Type u_5
inst✝ : MeasurableSpace β
ν : Measure β
f : α → ℝ≥0∞
g : β → ℝ≥0∞
hf : AEMeasurable f μ
hg : AEMeasurable g ν
⊢ ∫⁻ (x : α), ∫⁻ (y : β), f x * g y ∂ν ∂μ = (∫⁻ (x : α), f x ∂μ) * ∫⁻ (y : β), g y ∂ν
state_after: no goals