tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.integral_zero
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.871391
𝕜 : Type ?u.871394
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f g : α → E
m : MeasurableSpace α
μ : Measure α
⊢ (∫ (x : α), 0 ∂μ) = 0

tactic: exact setToFun_zero (dominatedFinMeasAdditive_weightedSMul μ)
state_before: α : Type u_2
E : Type u_1
F : Type ?u.871391
𝕜 : Type ?u.871394
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f g : α → E
m : MeasurableSpace α
μ : Measure α
⊢ (if hf : Integrable fun x => 0 then ↑L1.integralCLM (Integrable.toL1 (fun x => 0) hf) else 0) = 0
Theorem: Multiset.toList_eq_singleton_iff
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← perm_singleton, ← coe_eq_coe, coe_toList, coe_singleton]
state_before: α : Type u_1
β : Type ?u.31600
γ : Type ?u.31603
a : α
m : Multiset α
⊢ toList m = [a] ↔ m = {a}
Theorem: Finset.map_cast_heq
File: Mathlib/Data/Finset/Image.lean

tactic: subst h
state_before: α✝ : Type ?u.17749
β✝ : Type ?u.17752
γ : Type ?u.17755
f : α✝ ↪ β✝
s✝ : Finset α✝
α β : Type u_1
h : α = β
s : Finset α
⊢ HEq (map (Equiv.toEmbedding (Equiv.cast h)) s) s

tactic: simp
state_before: α✝ : Type ?u.17749
β : Type ?u.17752
γ : Type ?u.17755
f : α✝ ↪ β
s✝ : Finset α✝
α : Type u_1
s : Finset α
⊢ HEq (map (Equiv.toEmbedding (Equiv.cast (_ : α = α))) s) s
Theorem: Nat.descFactorial_eq_zero_iff_lt
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: simp only [descFactorial_zero, Nat.one_ne_zero, Nat.not_lt_zero]
state_before: n : ℕ
⊢ descFactorial n 0 = 0 ↔ n < 0

tactic: rw [descFactorial_succ, mul_eq_zero, descFactorial_eq_zero_iff_lt, lt_succ_iff,
  tsub_eq_zero_iff_le, lt_iff_le_and_ne, or_iff_left_iff_imp, and_imp]
state_before: n k : ℕ
⊢ descFactorial n (succ k) = 0 ↔ n < succ k

tactic: exact fun h _ => h
state_before: n k : ℕ
⊢ n ≤ k → n ≠ k → n ≤ k
Theorem: String.revFind_of_valid
File: Std/Data/String/Lemmas.lean

tactic: simpa using revFindAux_of_valid p s.1.reverse []
state_before: p : Char → Bool
s : String
⊢ revFind s p =
    Option.map (fun x => { byteIdx := utf8Len x }) (List.tail? (List.dropWhile (fun x => !p x) (List.reverse s.data)))
Theorem: unitInterval.one_minus_le_one
File: Mathlib/Topology/UnitInterval.lean

tactic: simpa using x.2.1
state_before: x : ↑I
⊢ 1 - ↑x ≤ 1
Theorem: Set.Countable.image
File: Mathlib/Data/Set/Countable.lean

tactic: rw [image_eq_range]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : Set.Countable s
f : α → β
⊢ Set.Countable (f '' s)

tactic: haveI := hs.to_subtype
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : Set.Countable s
f : α → β
⊢ Set.Countable (range fun x => f ↑x)

tactic: apply countable_range
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hs : Set.Countable s
f : α → β
this : Countable ↑s
⊢ Set.Countable (range fun x => f ↑x)
Theorem: Array.get_set_eq
File: Std/Data/Array/Lemmas.lean

tactic: simp [i.2]
state_before: α : Type ?u.14725
a : Array α
i : Fin (size a)
v : α
⊢ i.val < size (set a i v)

tactic: simp only [set, getElem_eq_data_get, List.get_set_eq]
state_before: α : Type u_1
a : Array α
i : Fin (size a)
v : α
⊢ (set a i v)[i.val] = v
Theorem: Bool.coe_true
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: simp
state_before: ⊢ (true = true) = True
Theorem: SimpleGraph.Preconnected.ofBoxProdLeft
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

tactic: classical
rintro a₁ a₂
obtain ⟨w⟩ := h (a₁, Classical.arbitrary _) (a₂, Classical.arbitrary _)
exact ⟨w.ofBoxProdLeft⟩
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.82005
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty β
h : Preconnected (G □ H)
⊢ Preconnected G

tactic: rintro a₁ a₂
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.82005
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty β
h : Preconnected (G □ H)
⊢ Preconnected G

tactic: obtain ⟨w⟩ := h (a₁, Classical.arbitrary _) (a₂, Classical.arbitrary _)
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.82005
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty β
h : Preconnected (G □ H)
a₁ a₂ : α
⊢ Reachable G a₁ a₂

tactic: exact ⟨w.ofBoxProdLeft⟩
state_before: case intro
α : Type u_2
β : Type u_1
γ : Type ?u.82005
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty β
h : Preconnected (G □ H)
a₁ a₂ : α
w : Walk (G □ H) (a₁, Classical.arbitrary β) (a₂, Classical.arbitrary β)
⊢ Reachable G a₁ a₂
Theorem: convexJoin_empty_right
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp [convexJoin]
state_before: ι : Sort ?u.18687
𝕜 : Type u_2
E : Type u_1
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s✝ t s₁ s₂ t₁ t₂ u : Set E
x y : E
s : Set E
⊢ convexJoin 𝕜 s ∅ = ∅
Theorem: List.permutationsAux2_fst
File: Mathlib/Data/List/Permutation.lean

tactic: simp [permutationsAux2, permutationsAux2_fst t _ _ ys]
state_before: α : Type u_1
β : Type u_2
t : α
ts : List α
r : List β
y : α
ys : List α
f : List α → β
⊢ (permutationsAux2 t ts r (y :: ys) f).fst = y :: ys ++ ts
Theorem: Polynomial.natDegree_list_prod_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: induction' l with hd tl IH
state_before: R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
l : List S[X]
⊢ natDegree (List.prod l) ≤ List.sum (List.map natDegree l)

tactic: simp
state_before: case nil
R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
⊢ natDegree (List.prod []) ≤ List.sum (List.map natDegree [])

tactic: simpa using natDegree_mul_le.trans (add_le_add_left IH _)
state_before: case cons
R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
hd : S[X]
tl : List S[X]
IH : natDegree (List.prod tl) ≤ List.sum (List.map natDegree tl)
⊢ natDegree (List.prod (hd :: tl)) ≤ List.sum (List.map natDegree (hd :: tl))
Theorem: Finset.image₂_right
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_2
α' : Type ?u.69695
β : Type u_1
β' : Type ?u.69701
γ : Type ?u.69704
γ' : Type ?u.69707
δ : Type ?u.69710
δ' : Type ?u.69713
ε : Type ?u.69716
ε' : Type ?u.69719
ζ : Type ?u.69722
ζ' : Type ?u.69725
ν : Type ?u.69728
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq β
h : Finset.Nonempty s
⊢ ↑(image₂ (fun x y => y) s t) = ↑t

tactic: exact image2_right h
state_before: α : Type u_2
α' : Type ?u.69695
β : Type u_1
β' : Type ?u.69701
γ : Type ?u.69704
γ' : Type ?u.69707
δ : Type ?u.69710
δ' : Type ?u.69713
ε : Type ?u.69716
ε' : Type ?u.69719
ζ : Type ?u.69722
ζ' : Type ?u.69725
ν : Type ?u.69728
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
inst✝ : DecidableEq β
h : Finset.Nonempty s
⊢ image2 (fun x y => y) ↑s ↑t = ↑t
Theorem: hasStrictFDerivAt_euclidean
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: rw [← (EuclideanSpace.equiv ι 𝕜).comp_hasStrictFDerivAt_iff, hasStrictFDerivAt_pi']
state_before: 𝕜 : Type u_1
ι : Type u_3
H : Type u_2
inst✝³ : IsROrC 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ HasStrictFDerivAt f f' y ↔ ∀ (i : ι), HasStrictFDerivAt (fun x => f x i) (comp (EuclideanSpace.proj i) f') y

tactic: rfl
state_before: 𝕜 : Type u_1
ι : Type u_3
H : Type u_2
inst✝³ : IsROrC 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ (∀ (i : ι),
      HasStrictFDerivAt (fun x => (↑(EuclideanSpace.equiv ι 𝕜) ∘ f) x i)
        (comp (proj i) (comp (↑(EuclideanSpace.equiv ι 𝕜)) f')) y) ↔
    ∀ (i : ι), HasStrictFDerivAt (fun x => f x i) (comp (EuclideanSpace.proj i) f') y
Theorem: Finset.prod_lt_prod_of_nonempty'
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: apply prod_lt_prod'
state_before: ι : Type u_1
α : Type ?u.128549
β : Type ?u.128552
M : Type u_2
N : Type ?u.128558
G : Type ?u.128561
k : Type ?u.128564
R : Type ?u.128567
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
hs : Finset.Nonempty s
Hlt : ∀ (i : ι), i ∈ s → f i < g i
⊢ ∏ i in s, f i < ∏ i in s, g i

tactic: cases' hs with i hi
state_before: case Hlt
ι : Type u_1
α : Type ?u.128549
β : Type ?u.128552
M : Type u_2
N : Type ?u.128558
G : Type ?u.128561
k : Type ?u.128564
R : Type ?u.128567
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
hs : Finset.Nonempty s
Hlt : ∀ (i : ι), i ∈ s → f i < g i
⊢ ∃ i, i ∈ s ∧ f i < g i

tactic: exact ⟨i, hi, Hlt i hi⟩
state_before: case Hlt.intro
ι : Type u_1
α : Type ?u.128549
β : Type ?u.128552
M : Type u_2
N : Type ?u.128558
G : Type ?u.128561
k : Type ?u.128564
R : Type ?u.128567
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
Hlt : ∀ (i : ι), i ∈ s → f i < g i
i : ι
hi : i ∈ s
⊢ ∃ i, i ∈ s ∧ f i < g i

tactic: intro i hi
state_before: case Hle
ι : Type u_1
α : Type ?u.128549
β : Type ?u.128552
M : Type u_2
N : Type ?u.128558
G : Type ?u.128561
k : Type ?u.128564
R : Type ?u.128567
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
hs : Finset.Nonempty s
Hlt : ∀ (i : ι), i ∈ s → f i < g i
⊢ ∀ (i : ι), i ∈ s → f i ≤ g i

tactic: apply le_of_lt (Hlt i hi)
state_before: case Hle
ι : Type u_1
α : Type ?u.128549
β : Type ?u.128552
M : Type u_2
N : Type ?u.128558
G : Type ?u.128561
k : Type ?u.128564
R : Type ?u.128567
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
hs : Finset.Nonempty s
Hlt : ∀ (i : ι), i ∈ s → f i < g i
i : ι
hi : i ∈ s
⊢ f i ≤ g i
Theorem: Polynomial.coeff_pow_of_natDegree_le
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: induction' m with m hm
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
pn : natDegree p ≤ n
⊢ coeff (p ^ m) (n * m) = coeff p n ^ m

tactic: simp
state_before: case zero
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
pn : natDegree p ≤ n
⊢ coeff (p ^ Nat.zero) (n * Nat.zero) = coeff p n ^ Nat.zero

tactic: rw [pow_succ', pow_succ', ← hm, Nat.mul_succ, coeff_mul_of_natDegree_le _ pn]
state_before: case succ
R : Type u
S : Type v
ι : Type w
a b : R
m✝ n : ℕ
inst✝ : Semiring R
p q r : R[X]
pn : natDegree p ≤ n
m : ℕ
hm : coeff (p ^ m) (n * m) = coeff p n ^ m
⊢ coeff (p ^ Nat.succ m) (n * Nat.succ m) = coeff p n ^ Nat.succ m

tactic: refine' natDegree_pow_le.trans (le_trans _ (mul_comm _ _).le)
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m✝ n : ℕ
inst✝ : Semiring R
p q r : R[X]
pn : natDegree p ≤ n
m : ℕ
hm : coeff (p ^ m) (n * m) = coeff p n ^ m
⊢ natDegree (p ^ m) ≤ n * m

tactic: exact mul_le_mul_of_nonneg_left pn m.zero_le
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m✝ n : ℕ
inst✝ : Semiring R
p q r : R[X]
pn : natDegree p ≤ n
m : ℕ
hm : coeff (p ^ m) (n * m) = coeff p n ^ m
⊢ m * natDegree p ≤ m * n
Theorem: NormedAddGroupHom.isQuotientQuotient
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: simpa [S.ker_normedMk] using quotient_norm_mk_eq _ m
state_before: M : Type u_1
N : Type ?u.464490
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
⊢ ‖↑(AddSubgroup.normedMk S) m‖ = sInf ((fun m_1 => ‖m + m_1‖) '' ↑(ker (AddSubgroup.normedMk S)))
Theorem: OrderTop.upperBounds_univ
File: Mathlib/Order/Bounds/Basic.lean

tactic: rw [isGreatest_univ.upperBounds_eq, Ici_top]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝³ : Preorder α
inst✝² : Preorder β
s t : Set α
a b : α
inst✝¹ : PartialOrder γ
inst✝ : OrderTop γ
⊢ upperBounds univ = {⊤}
Theorem: Dfinsupp.card_Ioc
File: Mathlib/Data/Dfinsupp/Interval.lean

tactic: rw [card_Ioc_eq_card_Icc_sub_one, card_Icc]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : (i : ι) → DecidableEq (α i)
inst✝² : (i : ι) → PartialOrder (α i)
inst✝¹ : (i : ι) → Zero (α i)
inst✝ : (i : ι) → LocallyFiniteOrder (α i)
f g : Π₀ (i : ι), α i
⊢ card (Ioc f g) = ∏ i in support f ∪ support g, card (Icc (↑f i) (↑g i)) - 1
Theorem: ProbabilityTheory.kernel.set_integral_restrict
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [restrict_apply, Measure.restrict_restrict' hs]
state_before: α : Type u_3
β : Type u_2
ι : Type ?u.1446410
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
s t✝ : Set β
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : β → E
a : α
hs : MeasurableSet s
t : Set β
⊢ (∫ (x : β) in t, f x ∂↑(kernel.restrict κ hs) a) = ∫ (x : β) in t ∩ s, f x ∂↑κ a
Theorem: Nat.mem_factors_mul_left
File: Mathlib/Data/Nat/Factors.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: p a b : ℕ
hpa : p ∈ factors a
hb : b ≠ 0
⊢ p ∈ factors (a * b)

tactic: apply (mem_factors_mul ha hb).2 (Or.inl hpa)
state_before: case inr
p a b : ℕ
hpa : p ∈ factors a
hb : b ≠ 0
ha : a ≠ 0
⊢ p ∈ factors (a * b)

tactic: simp at hpa
state_before: case inl
p b : ℕ
hb : b ≠ 0
hpa : p ∈ factors 0
⊢ p ∈ factors (0 * b)
Theorem: Set.pow_subset_pow
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [pow_zero]
state_before: F : Type ?u.52486
α : Type u_1
β : Type ?u.52492
γ : Type ?u.52495
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ s ^ 0 ⊆ t ^ 0

tactic: exact Subset.rfl
state_before: F : Type ?u.52486
α : Type u_1
β : Type ?u.52492
γ : Type ?u.52495
inst✝ : Monoid α
s t : Set α
a : α
m n : ℕ
hst : s ⊆ t
⊢ 1 ⊆ t ^ 0

tactic: rw [pow_succ]
state_before: F : Type ?u.52486
α : Type u_1
β : Type ?u.52492
γ : Type ?u.52495
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ (n + 1) ⊆ t ^ (n + 1)

tactic: exact mul_subset_mul hst (pow_subset_pow hst _)
state_before: F : Type ?u.52486
α : Type u_1
β : Type ?u.52492
γ : Type ?u.52495
inst✝ : Monoid α
s t : Set α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s * s ^ n ⊆ t ^ (n + 1)
Theorem: Polynomial.nextCoeffUp_C_eq_zero
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: rw [nextCoeffUp]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
c : R
⊢ nextCoeffUp (↑C c) = 0

tactic: simp
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
c : R
⊢ (if natTrailingDegree (↑C c) = 0 then 0 else coeff (↑C c) (natTrailingDegree (↑C c) + 1)) = 0
Theorem: CategoryTheory.Adjunction.leftAdjointUniq_trans_app
File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

tactic: rw [← leftAdjointUniq_trans adj1 adj2 adj3]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' F'' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
adj3 : F'' ⊣ G
x : C
⊢ (leftAdjointUniq adj1 adj2).hom.app x ≫ (leftAdjointUniq adj2 adj3).hom.app x = (leftAdjointUniq adj1 adj3).hom.app x

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' F'' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
adj3 : F'' ⊣ G
x : C
⊢ (leftAdjointUniq adj1 adj2).hom.app x ≫ (leftAdjointUniq adj2 adj3).hom.app x =
    ((leftAdjointUniq adj1 adj2).hom ≫ (leftAdjointUniq adj2 adj3).hom).app x
Theorem: Submonoid.dense_induction
File: Mathlib/GroupTheory/Submonoid/Basic.lean

tactic: have : ∀ x ∈ closure s, p x := fun x hx => closure_induction hx Hs H1 Hmul
state_before: M : Type u_1
N : Type ?u.25831
A : Type ?u.25834
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
Hs : ∀ (x : M), x ∈ s → p x
H1 : p 1
Hmul : ∀ (x y : M), p x → p y → p (x * y)
⊢ p x

tactic: simpa [hs] using this x
state_before: M : Type u_1
N : Type ?u.25831
A : Type ?u.25834
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
p : M → Prop
x : M
s : Set M
hs : closure s = ⊤
Hs : ∀ (x : M), x ∈ s → p x
H1 : p 1
Hmul : ∀ (x y : M), p x → p y → p (x * y)
this : ∀ (x : M), x ∈ closure s → p x
⊢ p x
Theorem: Matrix.cons_eq_zero_iff
File: Mathlib/Data/Fin/VecNotation.lean

tactic: convert congr_arg vecTail h
state_before: α : Type u
m n o : ℕ
m' : Type ?u.78559
n' : Type ?u.78562
o' : Type ?u.78565
inst✝ : Zero α
v : Fin n → α
x : α
h : vecCons x v = 0
⊢ v = 0

tactic: simp [hx, hv]
state_before: α : Type u
m n o : ℕ
m' : Type ?u.78559
n' : Type ?u.78562
o' : Type ?u.78565
inst✝ : Zero α
v : Fin n → α
x : α
x✝ : x = 0 ∧ v = 0
hx : x = 0
hv : v = 0
⊢ vecCons x v = 0
Theorem: List.append_concat
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.25691
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
a : α
l₁ l₂ : List α
⊢ l₁ ++ concat l₂ a = concat (l₁ ++ l₂) a
Theorem: OrthonormalBasis.det_eq_neg_det_of_opposite_orientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

tactic: rw [e.toBasis.det.eq_smul_basis_det f.toBasis]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
h : Basis.orientation (OrthonormalBasis.toBasis e) ≠ Basis.orientation (OrthonormalBasis.toBasis f)
⊢ Basis.det (OrthonormalBasis.toBasis e) = -Basis.det (OrthonormalBasis.toBasis f)

tactic: simp [e.det_to_matrix_orthonormalBasis_of_opposite_orientation f h,
  neg_one_smul ℝ (M := AlternatingMap ℝ E ℝ ι)]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
h : Basis.orientation (OrthonormalBasis.toBasis e) ≠ Basis.orientation (OrthonormalBasis.toBasis f)
⊢ ↑(Basis.det (OrthonormalBasis.toBasis e)) ↑(OrthonormalBasis.toBasis f) • Basis.det (OrthonormalBasis.toBasis f) =
    -Basis.det (OrthonormalBasis.toBasis f)
Theorem: Int.exists_unique_equiv
File: Mathlib/Data/Int/ModEq.lean

tactic: have : a % b < |b| := emod_lt _ (ne_of_gt hb)
state_before: m n a✝ b✝ c d a b : ℤ
hb : 0 < b
⊢ a % b < b

tactic: rwa [abs_of_pos hb] at this
state_before: m n a✝ b✝ c d a b : ℤ
hb : 0 < b
this : a % b < abs b
⊢ a % b < b

tactic: simp [ModEq]
state_before: m n a✝ b✝ c d a b : ℤ
hb : 0 < b
⊢ a % b ≡ a [ZMOD b]
Theorem: Cardinal.not_countable_real
File: Mathlib/Data/Real/Cardinality.lean

tactic: rw [← le_aleph0_iff_set_countable, not_le, mk_univ_real]
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ ¬Set.Countable Set.univ

tactic: apply cantor
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
⊢ ℵ₀ < 𝔠
Theorem: CategoryTheory.Limits.spanExt_inv_app_right
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [spanExt]
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).inv.app WalkingSpan.right = iZ.inv
Theorem: Subgroup.nilpotencyClass_le
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: repeat rw [← lowerCentralSeries_length_eq_nilpotencyClass]
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
hG : Group.IsNilpotent G
⊢ nilpotencyClass { x // x ∈ H } ≤ nilpotencyClass G

tactic: refine @Nat.find_mono _ _ (Classical.decPred _) (Classical.decPred _) ?_ _ _
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
hG : Group.IsNilpotent G
⊢ Nat.find (_ : ∃ n, lowerCentralSeries { x // x ∈ H } n = ⊥) ≤ Nat.find (_ : ∃ n, lowerCentralSeries G n = ⊥)

tactic: intro n hG
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
hG : Group.IsNilpotent G
⊢ ∀ (n : ℕ), lowerCentralSeries G n = ⊥ → lowerCentralSeries { x // x ∈ H } n = ⊥

tactic: have := lowerCentralSeries_map_subtype_le H n
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
hG✝ : Group.IsNilpotent G
n : ℕ
hG : lowerCentralSeries G n = ⊥
⊢ lowerCentralSeries { x // x ∈ H } n = ⊥

tactic: simp only [hG, SetLike.le_def, mem_map, forall_apply_eq_imp_iff₂, exists_imp] at this
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
hG✝ : Group.IsNilpotent G
n : ℕ
hG : lowerCentralSeries G n = ⊥
this : map (Subgroup.subtype H) (lowerCentralSeries { x // x ∈ H } n) ≤ lowerCentralSeries G n
⊢ lowerCentralSeries { x // x ∈ H } n = ⊥

tactic: exact eq_bot_iff.mpr fun x hx => Subtype.ext (this x ⟨hx, rfl⟩)
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
hG✝ : Group.IsNilpotent G
n : ℕ
hG : lowerCentralSeries G n = ⊥
this :
  ∀ ⦃x : G⦄ (x_1 : { x // x ∈ H }), x_1 ∈ lowerCentralSeries { x // x ∈ H } n ∧ ↑(Subgroup.subtype H) x_1 = x → x ∈ ⊥
⊢ lowerCentralSeries { x // x ∈ H } n = ⊥

tactic: rw [← lowerCentralSeries_length_eq_nilpotencyClass]
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : Subgroup G
hG : Group.IsNilpotent G
⊢ Nat.find (_ : ∃ n, lowerCentralSeries { x // x ∈ H } n = ⊥) ≤ Nat.find (_ : ∃ n, lowerCentralSeries G n = ⊥)
Theorem: MeasureTheory.Measure.toSignedMeasure_congr
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: congr
state_before: α : Type u_1
β : Type ?u.135192
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
h : μ = ν
⊢ toSignedMeasure μ = toSignedMeasure ν
Theorem: HasDerivAtFilter.neg
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simpa using h.neg.hasDerivAtFilter
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 𝕜
h : HasDerivAtFilter f f' x L
⊢ HasDerivAtFilter (fun x => -f x) (-f') x L
Theorem: Polynomial.ne_zero_of_degree_ge_degree
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rwa [Ne.def, Polynomial.degree_eq_bot]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.466413
hpq : degree p ≤ degree q
hp : p ≠ 0
⊢ degree p ≠ ⊥