tasksource/leandojo huggingface dataset:
Theorem: BoxIntegral.Box.splitLower_le
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: simp
state_before: ι : Type u_1
M : Type ?u.2864
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ ↑(splitLower I i x) ⊆ ↑↑I
Theorem: LowerSet.map_Iio
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.118391
ι : Sort ?u.118394
κ : ι → Sort ?u.118399
inst✝¹ : Preorder α
inst✝ : Preorder β
s : LowerSet α
a✝ b : α
f : α ≃o β
a : α
⊢ ↑(map f) (Iio a) = Iio (↑f a)

tactic: simp
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type ?u.118391
ι : Sort ?u.118394
κ : ι → Sort ?u.118399
inst✝¹ : Preorder α
inst✝ : Preorder β
s : LowerSet α
a✝ b : α
f : α ≃o β
a : α
x✝ : β
⊢ x✝ ∈ ↑(↑(map f) (Iio a)) ↔ x✝ ∈ ↑(Iio (↑f a))
Theorem: Nat.size_zero
File: Mathlib/Data/Nat/Size.lean

tactic: simp [size]
state_before: ⊢ size 0 = 0
Theorem: eq_of_le_of_inf_le_of_sup_le
File: Mathlib/Order/ModularLattice.lean

tactic: rw [inf_comm, @inf_comm _ _ z]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z : α
hxy : x ≤ y
hinf : y ⊓ z ≤ x ⊓ z
hsup : y ⊔ z ≤ x ⊔ z
h : y ≤ x ⊔ z
⊢ z ⊓ y ≤ z ⊓ x

tactic: exact hinf
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z : α
hxy : x ≤ y
hinf : y ⊓ z ≤ x ⊓ z
hsup : y ⊔ z ≤ x ⊔ z
h : y ≤ x ⊔ z
⊢ y ⊓ z ≤ x ⊓ z
Theorem: BoxIntegral.Box.biUnion_coe_eq_coe
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: induction I using WithBot.recBotCoe <;> simp [WithBot.coe_eq_coe]
state_before: ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
I : WithBot (Box ι)
⊢ (⋃ (J : Box ι) (_ : ↑J = I), ↑J) = ↑I
Theorem: iSup_iSup_eq_right
File: Mathlib/Order/CompleteLattice.lean

tactic: rintro rfl
state_before: α : Type u_2
β : Type u_1
β₂ : Type ?u.98007
γ : Type ?u.98010
ι : Sort ?u.98013
ι' : Sort ?u.98016
κ : ι → Sort ?u.98021
κ' : ι' → Sort ?u.98026
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b✝ : α
b : β
f : (x : β) → b = x → α
c : β
⊢ ∀ (j : b = c), f c j ≤ f b (_ : b = b)

tactic: rfl
state_before: α : Type u_2
β : Type u_1
β₂ : Type ?u.98007
γ : Type ?u.98010
ι : Sort ?u.98013
ι' : Sort ?u.98016
κ : ι → Sort ?u.98021
κ' : ι' → Sort ?u.98026
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b✝ : α
b : β
f : (x : β) → b = x → α
⊢ f b (_ : b = b) ≤ f b (_ : b = b)
Theorem: LipschitzWith.comp_memℒp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: intro a
state_before: α✝ : Type ?u.961798
E✝ : Type ?u.961801
F✝ : Type ?u.961804
G : Type ?u.961807
m m0 : MeasurableSpace α✝
p : ℝ≥0∞
q : ℝ
μ✝ ν : MeasureTheory.Measure α✝
inst✝⁵ : NormedAddCommGroup E✝
inst✝⁴ : NormedAddCommGroup F✝
inst✝³ : NormedAddCommGroup G
g✝ : E✝ → F✝
c : ℝ≥0
α : Type u_1
E : Type u_2
F : Type u_3
K : ℝ≥0
inst✝² : MeasurableSpace α
μ : MeasureTheory.Measure α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f : α → E
g : E → F
hg : LipschitzWith K g
g0 : g 0 = 0
hL : Memℒp f p
⊢ ∀ (x : α), ‖g (f x)‖ ≤ ↑K * ‖f x‖

tactic: simpa [g0] using hg.norm_sub_le (f a) 0
state_before: α✝ : Type ?u.961798
E✝ : Type ?u.961801
F✝ : Type ?u.961804
G : Type ?u.961807
m m0 : MeasurableSpace α✝
p : ℝ≥0∞
q : ℝ
μ✝ ν : MeasureTheory.Measure α✝
inst✝⁵ : NormedAddCommGroup E✝
inst✝⁴ : NormedAddCommGroup F✝
inst✝³ : NormedAddCommGroup G
g✝ : E✝ → F✝
c : ℝ≥0
α : Type u_1
E : Type u_2
F : Type u_3
K : ℝ≥0
inst✝² : MeasurableSpace α
μ : MeasureTheory.Measure α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f : α → E
g : E → F
hg : LipschitzWith K g
g0 : g 0 = 0
hL : Memℒp f p
a : α
⊢ ‖g (f a)‖ ≤ ↑K * ‖f a‖
Theorem: nonneg_and_nonneg_or_nonpos_and_nonpos_of_mul_nnonneg
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: refine' Decidable.or_iff_not_and_not.2 _
state_before: α : Type u
β : Type ?u.94554
inst✝ : LinearOrderedSemiring α
a b c d : α
hab : 0 ≤ a * b
⊢ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0

tactic: simp only [not_and, not_le]
state_before: α : Type u
β : Type ?u.94554
inst✝ : LinearOrderedSemiring α
a b c d : α
hab : 0 ≤ a * b
⊢ ¬(¬(0 ≤ a ∧ 0 ≤ b) ∧ ¬(a ≤ 0 ∧ b ≤ 0))

tactic: intro ab nab
state_before: α : Type u
β : Type ?u.94554
inst✝ : LinearOrderedSemiring α
a b c d : α
hab : 0 ≤ a * b
⊢ (0 ≤ a → b < 0) → ¬(a ≤ 0 → 0 < b)

tactic: apply not_lt_of_le hab _
state_before: α : Type u
β : Type ?u.94554
inst✝ : LinearOrderedSemiring α
a b c d : α
hab : 0 ≤ a * b
ab : 0 ≤ a → b < 0
nab : a ≤ 0 → 0 < b
⊢ False

tactic: rcases lt_trichotomy 0 a with (ha | ha | ha)
state_before: α : Type u
β : Type ?u.94554
inst✝ : LinearOrderedSemiring α
a b c d : α
hab : 0 ≤ a * b
ab : 0 ≤ a → b < 0
nab : a ≤ 0 → 0 < b
⊢ a * b < 0

tactic: exact mul_neg_of_pos_of_neg ha (ab ha.le)
state_before: case inl
α : Type u
β : Type ?u.94554
inst✝ : LinearOrderedSemiring α
a b c d : α
hab : 0 ≤ a * b
ab : 0 ≤ a → b < 0
nab : a ≤ 0 → 0 < b
ha : 0 < a
⊢ a * b < 0

tactic: subst ha
state_before: case inr.inl
α : Type u
β : Type ?u.94554
inst✝ : LinearOrderedSemiring α
a b c d : α
hab : 0 ≤ a * b
ab : 0 ≤ a → b < 0
nab : a ≤ 0 → 0 < b
ha : 0 = a
⊢ a * b < 0

tactic: exact ((ab le_rfl).asymm (nab le_rfl)).elim
state_before: case inr.inl
α : Type u
β : Type ?u.94554
inst✝ : LinearOrderedSemiring α
b c d : α
hab : 0 ≤ 0 * b
ab : 0 ≤ 0 → b < 0
nab : 0 ≤ 0 → 0 < b
⊢ 0 * b < 0

tactic: exact mul_neg_of_neg_of_pos ha (nab ha.le)
state_before: case inr.inr
α : Type u
β : Type ?u.94554
inst✝ : LinearOrderedSemiring α
a b c d : α
hab : 0 ≤ a * b
ab : 0 ≤ a → b < 0
nab : a ≤ 0 → 0 < b
ha : a < 0
⊢ a * b < 0
Theorem: Multiset.card_Ioo
File: Mathlib/Data/Multiset/Interval.lean

tactic: rw [card_Ioo_eq_card_Icc_sub_two, card_Icc]
state_before: α : Type u_1
β : α → Type ?u.46956
inst✝ : DecidableEq α
f g : Multiset α
⊢ Finset.card (Finset.Ioo f g) = ∏ i in toFinset f ∪ toFinset g, (count i g + 1 - count i f) - 2
Theorem: basis_toMatrix_mul
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: have := basis_toMatrix_mul_linearMap_toMatrix b₃ b₁ b₂ (Matrix.toLin b₃ b₂ A)
state_before: ι : Type u_2
ι' : Type u_5
κ : Type u_1
κ' : Type ?u.448557
R : Type u_3
M : Type u_4
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₂ : Type ?u.448750
M₂ : Type ?u.448753
inst✝⁹ : CommRing R₂
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_6
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝⁴ : Fintype ι'
inst✝³ : Fintype κ
inst✝² : Fintype κ'
inst✝¹ : Fintype ι
inst✝ : DecidableEq κ
b₁ : Basis ι R M
b₂ : Basis ι' R M
b₃ : Basis κ R N
A : Matrix ι' κ R
⊢ Basis.toMatrix b₁ ↑b₂ ⬝ A = ↑(toMatrix b₃ b₁) (↑(toLin b₃ b₂) A)

tactic: rwa [LinearMap.toMatrix_toLin] at this
state_before: ι : Type u_2
ι' : Type u_5
κ : Type u_1
κ' : Type ?u.448557
R : Type u_3
M : Type u_4
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₂ : Type ?u.448750
M₂ : Type ?u.448753
inst✝⁹ : CommRing R₂
inst✝⁸ : AddCommGroup M₂
inst✝⁷ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
N : Type u_6
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
b : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
inst✝⁴ : Fintype ι'
inst✝³ : Fintype κ
inst✝² : Fintype κ'
inst✝¹ : Fintype ι
inst✝ : DecidableEq κ
b₁ : Basis ι R M
b₂ : Basis ι' R M
b₃ : Basis κ R N
A : Matrix ι' κ R
this : Basis.toMatrix b₁ ↑b₂ ⬝ ↑(toMatrix b₃ b₂) (↑(toLin b₃ b₂) A) = ↑(toMatrix b₃ b₁) (↑(toLin b₃ b₂) A)
⊢ Basis.toMatrix b₁ ↑b₂ ⬝ A = ↑(toMatrix b₃ b₁) (↑(toLin b₃ b₂) A)
Theorem: InnerProductSpace.Core.norm_inner_le_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [norm_inner_symm]
state_before: 𝕜 : Type u_1
E : Type ?u.854474
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ‖inner x y‖ * ‖inner x y‖ = ‖inner x y‖ * ‖inner y x‖

tactic: simp only [inner_self_eq_norm_mul_norm]
state_before: 𝕜 : Type u_1
E : Type ?u.854474
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ↑re (inner x x) * ↑re (inner y y) = ‖x‖ * ‖y‖ * (‖x‖ * ‖y‖)

tactic: ring
state_before: 𝕜 : Type u_1
E : Type ?u.854474
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ‖x‖ * ‖x‖ * (‖y‖ * ‖y‖) = ‖x‖ * ‖y‖ * (‖x‖ * ‖y‖)
Theorem: Polynomial.eq_of_monic_of_dvd_of_natDegree_le
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: convert eq_leadingCoeff_mul_of_monic_of_dvd_of_natDegree_le hp hdiv hdeg
state_before: R✝ : Type u
S : Type v
T : Type w
a b : R✝
n : ℕ
inst✝² : CommRing R✝
inst✝¹ : IsDomain R✝
p✝ q✝ : R✝[X]
R : Type u_1
inst✝ : CommRing R
p q : R[X]
hp : Monic p
hq : Monic q
hdiv : p ∣ q
hdeg : natDegree q ≤ natDegree p
⊢ q = p

tactic: rw [hq.leadingCoeff, C_1, one_mul]
state_before: case h.e'_3
R✝ : Type u
S : Type v
T : Type w
a b : R✝
n : ℕ
inst✝² : CommRing R✝
inst✝¹ : IsDomain R✝
p✝ q✝ : R✝[X]
R : Type u_1
inst✝ : CommRing R
p q : R[X]
hp : Monic p
hq : Monic q
hdiv : p ∣ q
hdeg : natDegree q ≤ natDegree p
⊢ p = ↑C (leadingCoeff q) * p
Theorem: Submodule.map_inr
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext ⟨x, y⟩
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.295441
M₆ : Type ?u.295444
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (inr R M M₂) q = prod ⊥ q

tactic: simp [and_left_comm, eq_comm, and_comm]
state_before: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.295441
M₆ : Type ?u.295444
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ map (inr R M M₂) q ↔ (x, y) ∈ prod ⊥ q
Theorem: Nat.totient_eq_mul_prod_factors
File: Mathlib/Data/Nat/Totient.lean

tactic: by_cases hn : n = 0
state_before: n : ℕ
⊢ ↑(φ n) = ↑n * ∏ p in List.toFinset (factors n), (1 - (↑p)⁻¹)

tactic: have hn' : (n : ℚ) ≠ 0 := by simp [hn]
state_before: case neg
n : ℕ
hn : ¬n = 0
⊢ ↑(φ n) = ↑n * ∏ p in List.toFinset (factors n), (1 - (↑p)⁻¹)

tactic: have hpQ : (∏ p in n.factors.toFinset, (p : ℚ)) ≠ 0 := by
  rw [← cast_prod, cast_ne_zero, ← zero_lt_iff, ← prod_factorization_eq_prod_factors]
  exact prod_pos fun p hp => pos_of_mem_factorization hp
state_before: case neg
n : ℕ
hn : ¬n = 0
hn' : ↑n ≠ 0
⊢ ↑(φ n) = ↑n * ∏ p in List.toFinset (factors n), (1 - (↑p)⁻¹)

tactic: simp only [totient_eq_div_factors_mul n, prod_prime_factors_dvd n, cast_mul, cast_prod,
  cast_div_charZero, mul_comm_div, mul_right_inj' hn', div_eq_iff hpQ, ← prod_mul_distrib]
state_before: case neg
n : ℕ
hn : ¬n = 0
hn' : ↑n ≠ 0
hpQ : ∏ p in List.toFinset (factors n), ↑p ≠ 0
⊢ ↑(φ n) = ↑n * ∏ p in List.toFinset (factors n), (1 - (↑p)⁻¹)

tactic: refine' prod_congr rfl fun p hp => _
state_before: case neg
n : ℕ
hn : ¬n = 0
hn' : ↑n ≠ 0
hpQ : ∏ p in List.toFinset (factors n), ↑p ≠ 0
⊢ ∏ i in List.toFinset (factors n), ↑(i - 1) = ∏ x in List.toFinset (factors n), (1 - (↑x)⁻¹) * ↑x

tactic: have hp := pos_of_mem_factors (List.mem_toFinset.mp hp)
state_before: case neg
n : ℕ
hn : ¬n = 0
hn' : ↑n ≠ 0
hpQ : ∏ p in List.toFinset (factors n), ↑p ≠ 0
p : ℕ
hp : p ∈ List.toFinset (factors n)
⊢ ↑(p - 1) = (1 - (↑p)⁻¹) * ↑p

tactic: have hp' : (p : ℚ) ≠ 0 := cast_ne_zero.mpr hp.ne.symm
state_before: case neg
n : ℕ
hn : ¬n = 0
hn' : ↑n ≠ 0
hpQ : ∏ p in List.toFinset (factors n), ↑p ≠ 0
p : ℕ
hp✝ : p ∈ List.toFinset (factors n)
hp : 0 < p
⊢ ↑(p - 1) = (1 - (↑p)⁻¹) * ↑p

tactic: rw [sub_mul, one_mul, mul_comm, mul_inv_cancel hp', cast_pred hp]
state_before: case neg
n : ℕ
hn : ¬n = 0
hn' : ↑n ≠ 0
hpQ : ∏ p in List.toFinset (factors n), ↑p ≠ 0
p : ℕ
hp✝ : p ∈ List.toFinset (factors n)
hp : 0 < p
hp' : ↑p ≠ 0
⊢ ↑(p - 1) = (1 - (↑p)⁻¹) * ↑p

tactic: simp [hn]
state_before: case pos
n : ℕ
hn : n = 0
⊢ ↑(φ n) = ↑n * ∏ p in List.toFinset (factors n), (1 - (↑p)⁻¹)

tactic: simp [hn]
state_before: n : ℕ
hn : ¬n = 0
⊢ ↑n ≠ 0

tactic: rw [← cast_prod, cast_ne_zero, ← zero_lt_iff, ← prod_factorization_eq_prod_factors]
state_before: n : ℕ
hn : ¬n = 0
hn' : ↑n ≠ 0
⊢ ∏ p in List.toFinset (factors n), ↑p ≠ 0

tactic: exact prod_pos fun p hp => pos_of_mem_factorization hp
state_before: n : ℕ
hn : ¬n = 0
hn' : ↑n ≠ 0
⊢ 0 < Finsupp.prod (factorization n) fun p x => p
Theorem: CircleDeg1Lift.coe_pow
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: ext x
state_before: f g : CircleDeg1Lift
n : ℕ
⊢ ↑(f ^ (n + 1)) = ↑f^[n + 1]

tactic: simp [coe_pow n, pow_succ']
state_before: case h
f g : CircleDeg1Lift
n : ℕ
x : ℝ
⊢ ↑(f ^ (n + 1)) x = (↑f^[n + 1]) x
Theorem: Associates.factors_mono
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [eq, factors_mul]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
s t : Associates α
d : Associates α
eq : t = s * d
⊢ factors s ≤ factors t

tactic: exact le_add_of_nonneg_right bot_le
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
s t : Associates α
d : Associates α
eq : t = s * d
⊢ factors s ≤ factors s + factors d
Theorem: strictConcaveOn_of_deriv2_neg
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: rwa [interior_interior]
state_before: E : Type ?u.462295
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.462391
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf'' : ∀ (x : ℝ), x ∈ interior D → (deriv^[2]) f x < 0
⊢ ∀ (x : ℝ), x ∈ interior (interior D) → deriv (deriv f) x < 0
Theorem: Finset.sum_div
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: simp only [div_eq_mul_inv, sum_mul]
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b✝ : β
f✝ g : α → β
inst✝ : DivisionSemiring β
s : Finset α
f : α → β
b : β
⊢ (∑ x in s, f x) / b = ∑ x in s, f x / b
Theorem: Substring.Valid.data_drop
File: Std/Data/String/Lemmas.lean

tactic: simp [(h.drop _).toString, h.toString]
state_before: x✝¹ : Substring
h✝ : Valid x✝¹
x✝ : Nat
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝¹
⊢ (toString (Substring.drop x✝¹ x✝)).data = List.drop x✝ (toString x✝¹).data
Theorem: List.sublistsLenAux_eq
File: Mathlib/Data/List/Sublists.lean

tactic: rw [sublistsLen, ← sublistsLenAux_append]
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
α : Type u_1
β : Type u_2
l : List α
n : ℕ
f : List α → β
r : List β
⊢ sublistsLenAux n l f r = map f (sublistsLen n l) ++ r

tactic: rfl
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
α : Type u_1
β : Type u_2
l : List α
n : ℕ
f : List α → β
r : List β
⊢ sublistsLenAux n l f r = sublistsLenAux n l (f ∘ id) (map f [] ++ r)
Theorem: WithBot.preimage_coe_Ioo_bot
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: simp [← Ioi_inter_Iio]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some ⁻¹' Ioo ⊥ ↑a = Iio a
Theorem: CategoryTheory.CosimplicialObject.δ_comp_σ_succ'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: subst H
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = Fin.succ i
⊢ δ X j ≫ σ X i = 𝟙 (X.obj [n])

tactic: rw [δ_comp_σ_succ]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ δ X (Fin.succ i) ≫ σ X i = 𝟙 (X.obj [n])
Theorem: Int.sub_neg_of_lt
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_right h (-b)
state_before: a b : Int
h : a < b
⊢ a - b < 0

tactic: rwa [Int.add_right_neg] at h
state_before: a b : Int
h✝ : a < b
h : a + -b < b + -b
⊢ a - b < 0
Theorem: HasDerivAt.rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: rw [← hasDerivWithinAt_univ] at *
state_before: f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivAt f f' x
hg : HasDerivAt g g' x
h : 0 < f x
⊢ HasDerivAt (fun x => f x ^ g x) (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) x

tactic: exact hf.rpow hg h
state_before: f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' Set.univ x
hg : HasDerivWithinAt g g' Set.univ x
h : 0 < f x
⊢ HasDerivWithinAt (fun x => f x ^ g x) (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) Set.univ x
Theorem: MvPolynomial.support_monomial
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [←Subsingleton.elim (Classical.decEq R a 0) h]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
h : Decidable (a = 0)
⊢ support (↑(monomial s) a) = if a = 0 then ∅ else {s}

tactic: rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
h : Decidable (a = 0)
⊢ support (↑(monomial s) a) = if a = 0 then ∅ else {s}
Theorem: Matrix.mul_nonsing_inv_cancel_right
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simp [Matrix.mul_assoc, mul_nonsing_inv A h]
state_before: l : Type ?u.200547
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B✝ : Matrix n n α
B : Matrix m n α
h : IsUnit (det A)
⊢ B ⬝ A ⬝ A⁻¹ = B
Theorem: sameRay_neg_smul_right_iff_of_ne
File: Mathlib/LinearAlgebra/Ray.lean

tactic: simp only [sameRay_neg_smul_right_iff, hv, or_false_iff, hr.le_iff_lt]
state_before: R : Type u_2
inst✝³ : LinearOrderedCommRing R
M : Type u_1
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
v : M
r : R
hv : v ≠ 0
hr : r ≠ 0
⊢ SameRay R (-v) (r • v) ↔ r < 0
Theorem: Std.RBNode.setBlack_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: cases t <;> simp [setBlack]
state_before: α : Type u_1
t : RBNode α
⊢ toList (setBlack t) = toList t
Theorem: generateFrom_piiUnionInter_singleton_left
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: refine' le_antisymm (generateFrom_le _) (generateFrom_mono _)
state_before: α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
⊢ generateFrom (piiUnionInter (fun k => {s k}) S) = generateFrom {t | ∃ k, k ∈ S ∧ s k = t}

tactic: rintro _ ⟨I, hI, f, hf, rfl⟩
state_before: case refine'_1
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
⊢ ∀ (t : Set α), t ∈ piiUnionInter (fun k => {s k}) S → MeasurableSet t

tactic: refine' Finset.measurableSet_biInter _ fun m hm => measurableSet_generateFrom _
state_before: case refine'_1.intro.intro.intro.intro
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
I : Finset ι
hI : ↑I ⊆ S
f : ι → Set α
hf : ∀ (x : ι), x ∈ I → f x ∈ (fun k => {s k}) x
⊢ MeasurableSet (⋂ (x : ι) (_ : x ∈ I), f x)

tactic: exact ⟨m, hI hm, (hf m hm).symm⟩
state_before: case refine'_1.intro.intro.intro.intro
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
I : Finset ι
hI : ↑I ⊆ S
f : ι → Set α
hf : ∀ (x : ι), x ∈ I → f x ∈ (fun k => {s k}) x
m : ι
hm : m ∈ I
⊢ f m ∈ {t | ∃ k, k ∈ S ∧ s k = t}

tactic: rintro _ ⟨k, hk, rfl⟩
state_before: case refine'_2
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
⊢ {t | ∃ k, k ∈ S ∧ s k = t} ⊆ piiUnionInter (fun k => {s k}) S

tactic: refine' ⟨{k}, fun m hm => _, s, fun i _ => _, _⟩
state_before: case refine'_2.intro.intro
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
k : ι
hk : k ∈ S
⊢ s k ∈ piiUnionInter (fun k => {s k}) S

tactic: rw [Finset.mem_coe, Finset.mem_singleton] at hm
state_before: case refine'_2.intro.intro.refine'_1
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
k : ι
hk : k ∈ S
m : ι
hm : m ∈ ↑{k}
⊢ m ∈ S

tactic: rwa [hm]
state_before: case refine'_2.intro.intro.refine'_1
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
k : ι
hk : k ∈ S
m : ι
hm : m = k
⊢ m ∈ S

tactic: exact Set.mem_singleton _
state_before: case refine'_2.intro.intro.refine'_2
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
k : ι
hk : k ∈ S
i : ι
x✝ : i ∈ {k}
⊢ s i ∈ (fun k => {s k}) i

tactic: simp only [Finset.mem_singleton, Set.iInter_iInter_eq_left]
state_before: case refine'_2.intro.intro.refine'_3
α : Type u_1
ι : Type u_2
s : ι → Set α
S : Set ι
k : ι
hk : k ∈ S
⊢ s k = ⋂ (x : ι) (_ : x ∈ {k}), s x
Theorem: Real.toNNReal_eq_toNNReal_iff
File: Mathlib/Data/Real/NNReal.lean

tactic: simp [← NNReal.coe_eq, coe_toNNReal, hr, hp]
state_before: r p : ℝ
hr : 0 ≤ r
hp : 0 ≤ p
⊢ toNNReal r = toNNReal p ↔ r = p
Theorem: CategoryTheory.IsPushout.of_isBilimit
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: convert IsPushout.of_is_coproduct' h.isColimit HasZeroObject.zeroIsInitial
state_before: C : Type u₁
inst✝² : Category C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : BinaryBicone.IsBilimit b
⊢ IsPushout 0 0 b.inl b.inr
Theorem: List.pairwise_of_coe_toFinset_pairwise
File: Mathlib/Data/Finset/Pairwise.lean

tactic: rw [coe_toFinset] at hl
state_before: α : Type u_1
ι : Type ?u.6985
ι' : Type ?u.6988
β : Type ?u.6991
inst✝ : DecidableEq α
r : α → α → Prop
l : List α
hl : Set.Pairwise (↑(toFinset l)) r
hn : Nodup l
⊢ Pairwise r l

tactic: exact hn.pairwise_of_set_pairwise hl
state_before: α : Type u_1
ι : Type ?u.6985
ι' : Type ?u.6988
β : Type ?u.6991
inst✝ : DecidableEq α
r : α → α → Prop
l : List α
hl : Set.Pairwise {a | a ∈ l} r
hn : Nodup l
⊢ Pairwise r l
Theorem: Metric.infDist_zero_of_mem_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [← infDist_closure]
state_before: ι : Sort ?u.65043
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
hx : x ∈ closure s
⊢ infDist x s = 0

tactic: exact infDist_zero_of_mem hx
state_before: ι : Sort ?u.65043
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
hx : x ∈ closure s
⊢ infDist x (closure s) = 0
Theorem: Fin.succAbove_lt_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: refine' Iff.intro _ _
state_before: n m : ℕ
p : Fin (n + 1)
i : Fin n
⊢ ↑(succAbove p) i < p ↔ ↑castSucc i < p

tactic: intro h
state_before: case refine'_1
n m : ℕ
p : Fin (n + 1)
i : Fin n
⊢ ↑(succAbove p) i < p → ↑castSucc i < p

tactic: cases' succAbove_lt_ge p i with H H
state_before: case refine'_1
n m : ℕ
p : Fin (n + 1)
i : Fin n
h : ↑(succAbove p) i < p
⊢ ↑castSucc i < p

tactic: exact H
state_before: case refine'_1.inl
n m : ℕ
p : Fin (n + 1)
i : Fin n
h : ↑(succAbove p) i < p
H : ↑castSucc i < p
⊢ ↑castSucc i < p

tactic: rw [succAbove_above _ _ H] at h
state_before: case refine'_1.inr
n m : ℕ
p : Fin (n + 1)
i : Fin n
h : ↑(succAbove p) i < p
H : p ≤ ↑castSucc i
⊢ ↑castSucc i < p

tactic: exact lt_trans (castSucc_lt_succ i) h
state_before: case refine'_1.inr
n m : ℕ
p : Fin (n + 1)
i : Fin n
h : succ i < p
H : p ≤ ↑castSucc i
⊢ ↑castSucc i < p

tactic: intro h
state_before: case refine'_2
n m : ℕ
p : Fin (n + 1)
i : Fin n
⊢ ↑castSucc i < p → ↑(succAbove p) i < p

tactic: rw [succAbove_below _ _ h]
state_before: case refine'_2
n m : ℕ
p : Fin (n + 1)
i : Fin n
h : ↑castSucc i < p
⊢ ↑(succAbove p) i < p

tactic: exact h
state_before: case refine'_2
n m : ℕ
p : Fin (n + 1)
i : Fin n
h : ↑castSucc i < p
⊢ ↑castSucc i < p
Theorem: SimpleGraph.Subgraph.deleteVerts_le
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: constructor <;> simp [Set.diff_subset]
state_before: ι : Sort ?u.270890
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set V
⊢ deleteVerts G' s ≤ G'
Theorem: Ordnode.Valid'.node4L_lemma₅
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: linarith
state_before: α : Type ?u.290553
inst✝ : Preorder α
a b c d : ℕ
lr₂ : 3 * (b + c + 1 + d) ≤ 16 * a + 9
mr₁ : 2 * d ≤ b + c + 1
mm₂ : c ≤ 3 * b
⊢ c + d + 1 ≤ 3 * (a + b + 1)
Theorem: Asymptotics.IsEquivalent.refl
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: rw [IsEquivalent, sub_self]
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ u ~[l] u

tactic: exact isLittleO_zero _ _
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ 0 =o[l] u