tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Measure.restrict_iUnion_le
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: intro t ht
state_before: α : Type u_2
β : Type ?u.360947
γ : Type ?u.360950
δ : Type ?u.360953
ι : Type u_1
R : Type ?u.360959
R' : Type ?u.360962
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : Countable ι
s : ι → Set α
⊢ restrict μ (⋃ (i : ι), s i) ≤ sum fun i => restrict μ (s i)

tactic: suffices μ (⋃ i, t ∩ s i) ≤ ∑' i, μ (t ∩ s i) by simpa [ht, inter_iUnion]
state_before: α : Type u_2
β : Type ?u.360947
γ : Type ?u.360950
δ : Type ?u.360953
ι : Type u_1
R : Type ?u.360959
R' : Type ?u.360962
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
t : Set α
ht : MeasurableSet t
⊢ ↑↑(restrict μ (⋃ (i : ι), s i)) t ≤ ↑↑(sum fun i => restrict μ (s i)) t

tactic: apply measure_iUnion_le
state_before: α : Type u_2
β : Type ?u.360947
γ : Type ?u.360950
δ : Type ?u.360953
ι : Type u_1
R : Type ?u.360959
R' : Type ?u.360962
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
t : Set α
ht : MeasurableSet t
⊢ ↑↑μ (⋃ (i : ι), t ∩ s i) ≤ ∑' (i : ι), ↑↑μ (t ∩ s i)

tactic: simpa [ht, inter_iUnion]
state_before: α : Type u_2
β : Type ?u.360947
γ : Type ?u.360950
δ : Type ?u.360953
ι : Type u_1
R : Type ?u.360959
R' : Type ?u.360962
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
t : Set α
ht : MeasurableSet t
this : ↑↑μ (⋃ (i : ι), t ∩ s i) ≤ ∑' (i : ι), ↑↑μ (t ∩ s i)
⊢ ↑↑(restrict μ (⋃ (i : ι), s i)) t ≤ ↑↑(sum fun i => restrict μ (s i)) t
Theorem: expNegInvGlue.tendsto_polynomial_inv_mul_zero
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: simp only [expNegInvGlue, mul_ite, mul_zero]
state_before: p : ℝ[X]
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * expNegInvGlue x) (𝓝 0) (𝓝 0)

tactic: refine tendsto_const_nhds.if ?_
state_before: p : ℝ[X]
⊢ Tendsto (fun x => if x ≤ 0 then 0 else Polynomial.eval x⁻¹ p * exp (-x⁻¹)) (𝓝 0) (𝓝 0)

tactic: simp only [not_le]
state_before: p : ℝ[X]
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * exp (-x⁻¹)) (𝓝 0 ⊓ 𝓟 {x | ¬x ≤ 0}) (𝓝 0)

tactic: have : Tendsto (fun x ↦ p.eval x⁻¹ / exp x⁻¹) (𝓝[>] 0) (𝓝 0) :=
  p.tendsto_div_exp_atTop.comp tendsto_inv_zero_atTop
state_before: p : ℝ[X]
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * exp (-x⁻¹)) (𝓝 0 ⊓ 𝓟 {x | 0 < x}) (𝓝 0)

tactic: refine this.congr' <| mem_of_superset self_mem_nhdsWithin fun x hx ↦ ?_
state_before: p : ℝ[X]
this : Tendsto (fun x => Polynomial.eval x⁻¹ p / exp x⁻¹) (𝓝[Ioi 0] 0) (𝓝 0)
⊢ Tendsto (fun x => Polynomial.eval x⁻¹ p * exp (-x⁻¹)) (𝓝 0 ⊓ 𝓟 {x | 0 < x}) (𝓝 0)

tactic: simp [expNegInvGlue, hx.out.not_le, exp_neg, div_eq_mul_inv]
state_before: p : ℝ[X]
this : Tendsto (fun x => Polynomial.eval x⁻¹ p / exp x⁻¹) (𝓝[Ioi 0] 0) (𝓝 0)
x : ℝ
hx : x ∈ {x | 0 < x}
⊢ x ∈ {x | (fun x => Polynomial.eval x⁻¹ p / exp x⁻¹ = (fun x => Polynomial.eval x⁻¹ p * exp (-x⁻¹)) x) x}
Theorem: MeasureTheory.Lp.coeFn_le
File: Mathlib/MeasureTheory/Function/LpOrder.lean

tactic: rw [← Subtype.coe_le_coe, ← AEEqFun.coeFn_le]
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f g : { x // x ∈ Lp E p }
⊢ ↑↑f ≤ᵐ[μ] ↑↑g ↔ f ≤ g
Theorem: Finset.fold_min_lt
File: Mathlib/Data/Finset/Fold.lean

tactic: show _ > _ ↔ _
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.67307
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c : β
⊢ fold min b f s < c ↔ b < c ∨ ∃ x, x ∈ s ∧ f x < c

tactic: apply fold_op_rel_iff_or
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.67307
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c : β
⊢ c > fold min b f s ↔ b < c ∨ ∃ x, x ∈ s ∧ f x < c

tactic: intro x y z
state_before: case hr
α : Type u_2
β : Type u_1
γ : Type ?u.67307
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c : β
⊢ ∀ {x y z : β}, x > min y z ↔ x > y ∨ x > z

tactic: show _ < _ ↔ _
state_before: case hr
α : Type u_2
β : Type u_1
γ : Type ?u.67307
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c x y z : β
⊢ x > min y z ↔ x > y ∨ x > z

tactic: exact min_lt_iff
state_before: case hr
α : Type u_2
β : Type u_1
γ : Type ?u.67307
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
inst✝ : LinearOrder β
c x y z : β
⊢ min y z < x ↔ x > y ∨ x > z
Theorem: LieIdeal.lowerCentralSeries_map_eq
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: have h' : (⊤ : LieIdeal R L).map f = ⊤ := by
  rw [← f.idealRange_eq_map]
  exact f.idealRange_eq_top_of_surjective h
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
k : ℕ
f : L →ₗ⁅R⁆ L'
h : Function.Surjective ↑f
⊢ map f (lowerCentralSeries R L L k) = lowerCentralSeries R L' L' k

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
k : ℕ
f : L →ₗ⁅R⁆ L'
h : Function.Surjective ↑f
h' : map f ⊤ = ⊤
⊢ map f (lowerCentralSeries R L L k) = lowerCentralSeries R L' L' k

tactic: rw [← f.idealRange_eq_map]
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
k : ℕ
f : L →ₗ⁅R⁆ L'
h : Function.Surjective ↑f
⊢ map f ⊤ = ⊤

tactic: exact f.idealRange_eq_top_of_surjective h
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
k : ℕ
f : L →ₗ⁅R⁆ L'
h : Function.Surjective ↑f
⊢ LieHom.idealRange f = ⊤

tactic: simp only [LieModule.lowerCentralSeries_zero]
state_before: case zero
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
h : Function.Surjective ↑f
h' : map f ⊤ = ⊤
⊢ map f (lowerCentralSeries R L L Nat.zero) = lowerCentralSeries R L' L' Nat.zero

tactic: exact h'
state_before: case zero
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
h : Function.Surjective ↑f
h' : map f ⊤ = ⊤
⊢ map f (lowerCentralSeries R L L Nat.zero) = lowerCentralSeries R L' L' Nat.zero

tactic: simp only [LieModule.lowerCentralSeries_succ, LieIdeal.map_bracket_eq f h, ih, h']
state_before: case succ
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
h : Function.Surjective ↑f
h' : map f ⊤ = ⊤
k : ℕ
ih : map f (lowerCentralSeries R L L k) = lowerCentralSeries R L' L' k
⊢ map f (lowerCentralSeries R L L (Nat.succ k)) = lowerCentralSeries R L' L' (Nat.succ k)
Theorem: List.Palindrome.append_reverse
File: Mathlib/Data/List/Palindrome.lean

tactic: apply of_reverse_eq
state_before: α : Type u_1
β : Type ?u.1074
l✝ l : List α
⊢ Palindrome (l ++ reverse l)

tactic: rw [reverse_append, reverse_reverse]
state_before: case a
α : Type u_1
β : Type ?u.1074
l✝ l : List α
⊢ reverse (l ++ reverse l) = l ++ reverse l
Theorem: GradedMonoid.list_prod_ofFn_eq_dProd
File: Mathlib/Algebra/GradedMonoid.lean

tactic: rw [List.ofFn_eq_map, GradedMonoid.list_prod_map_eq_dProd]
state_before: ι : Type u_1
α : Type ?u.51491
A : ι → Type u_2
inst✝¹ : AddMonoid ι
inst✝ : GMonoid A
n : ℕ
f : Fin n → GradedMonoid A
⊢ List.prod (List.ofFn f) =
    mk (List.dProdIndex (List.finRange n) fun i => (f i).fst)
      (List.dProd (List.finRange n) (fun i => (f i).fst) fun i => (f i).snd)
Theorem: MeasureTheory.setToFun_neg
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1458556
G : Type ?u.1458559
𝕜 : Type ?u.1458562
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
f : α → E
⊢ setToFun μ T hT (-f) = -setToFun μ T hT f

tactic: rw [setToFun_eq hT hf, setToFun_eq hT hf.neg, Integrable.toL1_neg,
  (L1.setToL1 hT).map_neg]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1458556
G : Type ?u.1458559
𝕜 : Type ?u.1458562
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
f : α → E
hf : Integrable f
⊢ setToFun μ T hT (-f) = -setToFun μ T hT f

tactic: rw [setToFun_undef hT hf, setToFun_undef hT, neg_zero]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1458556
G : Type ?u.1458559
𝕜 : Type ?u.1458562
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
f : α → E
hf : ¬Integrable f
⊢ setToFun μ T hT (-f) = -setToFun μ T hT f

tactic: rwa [← integrable_neg_iff] at hf
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1458556
G : Type ?u.1458559
𝕜 : Type ?u.1458562
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
f : α → E
hf : ¬Integrable f
⊢ ¬Integrable (-f)
Theorem: TensorProduct.map_smul_right
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: ext
state_before: R : Type u_1
inst✝¹⁸ : CommSemiring R
R' : Type ?u.1007951
inst✝¹⁷ : Monoid R'
R'' : Type ?u.1007957
inst✝¹⁶ : Semiring R''
M : Type u_2
N : Type u_4
P : Type u_3
Q : Type u_5
S : Type ?u.1007975
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid N
inst✝¹³ : AddCommMonoid P
inst✝¹² : AddCommMonoid Q
inst✝¹¹ : AddCommMonoid S
inst✝¹⁰ : Module R M
inst✝⁹ : Module R N
inst✝⁸ : Module R P
inst✝⁷ : Module R Q
inst✝⁶ : Module R S
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type ?u.1009102
Q' : Type ?u.1009105
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
r : R
f : M →ₗ[R] P
g : N →ₗ[R] Q
⊢ map f (r • g) = r • map f g

tactic: simp only [smul_tmul, compr₂_apply, mk_apply, map_tmul, smul_apply, tmul_smul]
state_before: case H.h.h
R : Type u_1
inst✝¹⁸ : CommSemiring R
R' : Type ?u.1007951
inst✝¹⁷ : Monoid R'
R'' : Type ?u.1007957
inst✝¹⁶ : Semiring R''
M : Type u_2
N : Type u_4
P : Type u_3
Q : Type u_5
S : Type ?u.1007975
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid N
inst✝¹³ : AddCommMonoid P
inst✝¹² : AddCommMonoid Q
inst✝¹¹ : AddCommMonoid S
inst✝¹⁰ : Module R M
inst✝⁹ : Module R N
inst✝⁸ : Module R P
inst✝⁷ : Module R Q
inst✝⁶ : Module R S
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type ?u.1009102
Q' : Type ?u.1009105
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
r : R
f : M →ₗ[R] P
g : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ ↑(↑(compr₂ (mk R M N) (map f (r • g))) x✝¹) x✝ = ↑(↑(compr₂ (mk R M N) (r • map f g)) x✝¹) x✝
Theorem: LinearMap.associated_det_comp_equiv
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: refine' LinearMap.associated_det_of_eq_comp (e.trans e'.symm) _ _ _
state_before: R : Type u_2
inst✝⁸ : CommRing R
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2243677
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type ?u.2244219
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
N : Type u_1
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : N →ₗ[R] M
e e' : M ≃ₗ[R] N
⊢ Associated (↑LinearMap.det (comp f ↑e)) (↑LinearMap.det (comp f ↑e'))

tactic: intro x
state_before: R : Type u_2
inst✝⁸ : CommRing R
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2243677
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type ?u.2244219
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
N : Type u_1
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : N →ₗ[R] M
e e' : M ≃ₗ[R] N
⊢ ∀ (x : M), ↑(comp f ↑e) x = ↑(comp f ↑e') (↑(LinearEquiv.trans e (LinearEquiv.symm e')) x)

tactic: simp only [LinearMap.comp_apply, LinearEquiv.coe_coe, LinearEquiv.trans_apply,
  LinearEquiv.apply_symm_apply]
state_before: R : Type u_2
inst✝⁸ : CommRing R
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2243677
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type ?u.2244219
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
N : Type u_1
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : N →ₗ[R] M
e e' : M ≃ₗ[R] N
x : M
⊢ ↑(comp f ↑e) x = ↑(comp f ↑e') (↑(LinearEquiv.trans e (LinearEquiv.symm e')) x)
Theorem: CategoryTheory.Limits.Cofork.app_zero_eq_comp_π_right
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: rw [← s.app_one_eq_π, ← s.w right, parallelPair_map_right]
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
s : Cofork f g
⊢ s.ι.app zero = g ≫ π s
Theorem: LowerSet.coe_iSup
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [iSup, coe_sSup, mem_range, iUnion_exists, iUnion_iUnion_eq']
state_before: α : Type u_1
β : Type ?u.69615
γ : Type ?u.69618
ι : Sort u_2
κ : ι → Sort ?u.69626
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ ↑(⨆ (i : ι), f i) = ⋃ (i : ι), ↑(f i)
Theorem: Fin.cast_addNat_left
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n✝ m✝ n n' m : ℕ
i : Fin n'
h : n' + m = n + m
⊢ ↑(cast h) (↑(addNat m) i) = ↑(addNat m) (↑(cast (_ : n' = n)) i)

tactic: simp
state_before: case h
n✝ m✝ n n' m : ℕ
i : Fin n'
h : n' + m = n + m
⊢ ↑(↑(cast h) (↑(addNat m) i)) = ↑(↑(addNat m) (↑(cast (_ : n' = n)) i))
Theorem: ENNReal.rpow_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases' x with x
state_before: x : ℝ≥0∞
y : ℝ
⊢ x ^ (-y) = (x ^ y)⁻¹

tactic: rcases lt_trichotomy y 0 with (H | H | H) <;>
  simp [top_rpow_of_pos, top_rpow_of_neg, H, neg_pos.mpr]
state_before: case none
y : ℝ
⊢ none ^ (-y) = (none ^ y)⁻¹

tactic: by_cases h : x = 0
state_before: case some
y : ℝ
x : ℝ≥0
⊢ Option.some x ^ (-y) = (Option.some x ^ y)⁻¹

tactic: rcases lt_trichotomy y 0 with (H | H | H) <;>
  simp [h, zero_rpow_of_pos, zero_rpow_of_neg, H, neg_pos.mpr]
state_before: case pos
y : ℝ
x : ℝ≥0
h : x = 0
⊢ Option.some x ^ (-y) = (Option.some x ^ y)⁻¹

tactic: have A : x ^ y ≠ 0 := by simp [h]
state_before: case neg
y : ℝ
x : ℝ≥0
h : ¬x = 0
⊢ Option.some x ^ (-y) = (Option.some x ^ y)⁻¹

tactic: simp [coe_rpow_of_ne_zero h, ← coe_inv A, NNReal.rpow_neg]
state_before: case neg
y : ℝ
x : ℝ≥0
h : ¬x = 0
A : x ^ y ≠ 0
⊢ Option.some x ^ (-y) = (Option.some x ^ y)⁻¹

tactic: simp [h]
state_before: y : ℝ
x : ℝ≥0
h : ¬x = 0
⊢ x ^ y ≠ 0
Theorem: HasDerivAtFilter.sub
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
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 : Filter 𝕜
hf : HasDerivAtFilter f f' x L
hg : HasDerivAtFilter g g' x L
⊢ HasDerivAtFilter (fun x => f x - g x) (f' - g') x L
Theorem: Basis.constr_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp only [constr_def, LinearMap.comp_apply, Finsupp.lmapDomain_apply, Finsupp.total_apply]
state_before: ι : Type u_4
ι' : Type ?u.502339
R : Type u_3
R₂ : Type ?u.502345
K : Type ?u.502348
M : Type u_2
M' : Type u_1
M'' : Type ?u.502357
V : Type u
V' : Type ?u.502362
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
S : Type u_5
inst✝² : Semiring S
inst✝¹ : Module S M'
inst✝ : SMulCommClass R S M'
f : ι → M'
x : M
⊢ ↑(↑(constr b S) f) x = Finsupp.sum (↑b.repr x) fun b a => a • f b

tactic: rw [Finsupp.sum_mapDomain_index] <;> simp [add_smul]
state_before: ι : Type u_4
ι' : Type ?u.502339
R : Type u_3
R₂ : Type ?u.502345
K : Type ?u.502348
M : Type u_2
M' : Type u_1
M'' : Type ?u.502357
V : Type u
V' : Type ?u.502362
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
S : Type u_5
inst✝² : Semiring S
inst✝¹ : Module S M'
inst✝ : SMulCommClass R S M'
f : ι → M'
x : M
⊢ (Finsupp.sum (Finsupp.mapDomain f (↑↑b.repr x)) fun i a => a • id i) = Finsupp.sum (↑b.repr x) fun b a => a • f b
Theorem: Finsupp.prod_filter_index
File: Mathlib/Data/Finsupp/Basic.lean

tactic: classical
  refine' Finset.prod_congr rfl fun x hx => _
  rw [support_filter, Finset.mem_filter] at hx
  rw [filter_apply_pos _ _ hx.2]
state_before: α : Type u_2
β : Type ?u.475516
γ : Type ?u.475519
ι : Type ?u.475522
M : Type u_3
M' : Type ?u.475528
N : Type u_1
P : Type ?u.475534
G : Type ?u.475537
H : Type ?u.475540
R : Type ?u.475543
S : Type ?u.475546
inst✝¹ : Zero M
p : α → Prop
f : α →₀ M
inst✝ : CommMonoid N
g : α → M → N
⊢ prod (filter p f) g = ∏ x in (filter p f).support, g x (↑f x)

tactic: refine' Finset.prod_congr rfl fun x hx => _
state_before: α : Type u_2
β : Type ?u.475516
γ : Type ?u.475519
ι : Type ?u.475522
M : Type u_3
M' : Type ?u.475528
N : Type u_1
P : Type ?u.475534
G : Type ?u.475537
H : Type ?u.475540
R : Type ?u.475543
S : Type ?u.475546
inst✝¹ : Zero M
p : α → Prop
f : α →₀ M
inst✝ : CommMonoid N
g : α → M → N
⊢ prod (filter p f) g = ∏ x in (filter p f).support, g x (↑f x)

tactic: rw [support_filter, Finset.mem_filter] at hx
state_before: α : Type u_2
β : Type ?u.475516
γ : Type ?u.475519
ι : Type ?u.475522
M : Type u_3
M' : Type ?u.475528
N : Type u_1
P : Type ?u.475534
G : Type ?u.475537
H : Type ?u.475540
R : Type ?u.475543
S : Type ?u.475546
inst✝¹ : Zero M
p : α → Prop
f : α →₀ M
inst✝ : CommMonoid N
g : α → M → N
x : α
hx : x ∈ (filter p f).support
⊢ g x (↑(filter p f) x) = g x (↑f x)

tactic: rw [filter_apply_pos _ _ hx.2]
state_before: α : Type u_2
β : Type ?u.475516
γ : Type ?u.475519
ι : Type ?u.475522
M : Type u_3
M' : Type ?u.475528
N : Type u_1
P : Type ?u.475534
G : Type ?u.475537
H : Type ?u.475540
R : Type ?u.475543
S : Type ?u.475546
inst✝¹ : Zero M
p : α → Prop
f : α →₀ M
inst✝ : CommMonoid N
g : α → M → N
x : α
hx : x ∈ f.support ∧ p x
⊢ g x (↑(filter p f) x) = g x (↑f x)
Theorem: CategoryTheory.MonoidalFunctor.map_leftUnitor
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

tactic: simp only [LaxMonoidalFunctor.left_unitality]
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (λ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X) ≫ (inv F.ε ⊗ 𝟙 (F.obj X)) ≫ (λ_ (F.obj X)).hom

tactic: slice_rhs 2 3 =>
  rw [← comp_tensor_id]
  simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (λ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X) ≫
      (inv F.ε ⊗ 𝟙 (F.obj X)) ≫
        (F.ε ⊗ 𝟙 (F.obj X)) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X ≫ F.map (λ_ X).hom

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (λ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X) ≫
      (𝟙 (F.obj (𝟙_ C) ⊗ F.obj X) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X) ≫ F.map (λ_ X).hom
Theorem: Primrec.fin_succ
File: Mathlib/Computability/Primrec.lean

tactic: simp [succ.comp fin_val]
state_before: α : Type ?u.360281
β : Type ?u.360284
γ : Type ?u.360287
σ : Type ?u.360290
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
⊢ Primrec fun a => ↑(Fin.succ a)
Theorem: uniformSpace_eq
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: obtain rfl : u₁ = u₂ := UniformSpace.core_eq h
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.27706
t₁ : TopologicalSpace α
u₁ : UniformSpace.Core α
o₁ : ∀ (s : Set α), IsOpen s ↔ ∀ (x : α), x ∈ s → {p | p.fst = x → p.snd ∈ s} ∈ u₁.uniformity
t₂ : TopologicalSpace α
u₂ : UniformSpace.Core α
o₂ : ∀ (s : Set α), IsOpen s ↔ ∀ (x : α), x ∈ s → {p | p.fst = x → p.snd ∈ s} ∈ u₂.uniformity
h : uniformity α = uniformity α
⊢ UniformSpace.mk' t₁ u₁ o₁ = UniformSpace.mk' t₂ u₂ o₂

tactic: obtain rfl : t₁ = t₂ := topologicalSpace_eq <| funext fun s => by rw [o₁, o₂]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.27706
t₁ : TopologicalSpace α
u₁ : UniformSpace.Core α
o₁ : ∀ (s : Set α), IsOpen s ↔ ∀ (x : α), x ∈ s → {p | p.fst = x → p.snd ∈ s} ∈ u₁.uniformity
t₂ : TopologicalSpace α
o₂ : ∀ (s : Set α), IsOpen s ↔ ∀ (x : α), x ∈ s → {p | p.fst = x → p.snd ∈ s} ∈ u₁.uniformity
h : uniformity α = uniformity α
⊢ UniformSpace.mk' t₁ u₁ o₁ = UniformSpace.mk' t₂ u₁ o₂

tactic: rfl
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.27706
t₁ : TopologicalSpace α
u₁ : UniformSpace.Core α
o₁ o₂ : ∀ (s : Set α), IsOpen s ↔ ∀ (x : α), x ∈ s → {p | p.fst = x → p.snd ∈ s} ∈ u₁.uniformity
h : uniformity α = uniformity α
⊢ UniformSpace.mk' t₁ u₁ o₁ = UniformSpace.mk' t₁ u₁ o₂

tactic: rw [o₁, o₂]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.27706
t₁ : TopologicalSpace α
u₁ : UniformSpace.Core α
o₁ : ∀ (s : Set α), IsOpen s ↔ ∀ (x : α), x ∈ s → {p | p.fst = x → p.snd ∈ s} ∈ u₁.uniformity
t₂ : TopologicalSpace α
o₂ : ∀ (s : Set α), IsOpen s ↔ ∀ (x : α), x ∈ s → {p | p.fst = x → p.snd ∈ s} ∈ u₁.uniformity
h : uniformity α = uniformity α
s : Set α
⊢ IsOpen s = IsOpen s
Theorem: toIcoMod_apply_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod_eq_iff hp, Set.left_mem_Ico]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ toIcoMod hp a (a + p) = a

tactic: exact ⟨lt_add_of_pos_right _ hp, 1, by simp⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a < a + p ∧ ∃ z, a + p = a + z • p

tactic: simp
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a + p = a + 1 • p