tasksource/leandojo huggingface dataset:
Theorem: Multiset.countp_le_of_le
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa [countp_eq_card_filter] using card_le_of_le (filter_le_filter p h)
state_before: α : Type u_1
β : Type ?u.311172
γ : Type ?u.311175
p : α → Prop
inst✝ : DecidablePred p
s t : Multiset α
h : s ≤ t
⊢ countp p s ≤ countp p t
Theorem: map_int_cast_smul
File: Mathlib/Algebra/Module/Basic.lean

tactic: simp only [← zsmul_eq_smul_cast, map_zsmul]
state_before: α : Type ?u.166374
R✝ : Type ?u.166377
k : Type ?u.166380
S✝ : Type ?u.166383
M : Type u_1
M₂ : Type u_2
M₃ : Type ?u.166392
ι : Type ?u.166395
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M₂
F : Type u_3
inst✝⁴ : AddMonoidHomClass F M M₂
f : F
R : Type u_4
S : Type u_5
inst✝³ : Ring R
inst✝² : Ring S
inst✝¹ : Module R M
inst✝ : Module S M₂
x : ℤ
a : M
⊢ ↑f (↑x • a) = ↑x • ↑f a
Theorem: iterate_pred_toZ
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: rw [toZ_of_lt hi, neg_neg, Int.toNat_coe_nat]
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i✝ i : ι
hi : i < i0
⊢ (pred^[Int.toNat (-toZ i0 i)]) i0 = i

tactic: exact Nat.find_spec (exists_pred_iterate_of_le hi.le)
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i✝ i : ι
hi : i < i0
⊢ (pred^[Nat.find (_ : ∃ n, (pred^[n]) i0 = i)]) i0 = i
Theorem: Multiset.add_sigma
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [Multiset.sigma]
state_before: α : Type u_1
β : Type ?u.70742
γ : Type ?u.70745
δ : Type ?u.70748
σ : α → Type u_2
a : α
s✝ : Multiset α
t✝ : (a : α) → Multiset (σ a)
s t : Multiset α
u : (a : α) → Multiset (σ a)
⊢ Multiset.sigma (s + t) u = Multiset.sigma s u + Multiset.sigma t u
Theorem: sign_cases_of_C_mul_pow_nonneg
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: have : 0 ≤ C := by simpa only [pow_zero, mul_one] using h 0
state_before: α : Type ?u.305323
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedSemiring R
C r : R
h : ∀ (n : ℕ), 0 ≤ C * r ^ n
⊢ C = 0 ∨ 0 < C ∧ 0 ≤ r

tactic: refine' this.eq_or_lt.elim (fun h => Or.inl h.symm) fun hC => Or.inr ⟨hC, _⟩
state_before: α : Type ?u.305323
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedSemiring R
C r : R
h : ∀ (n : ℕ), 0 ≤ C * r ^ n
this : 0 ≤ C
⊢ C = 0 ∨ 0 < C ∧ 0 ≤ r

tactic: refine' nonneg_of_mul_nonneg_right _ hC
state_before: α : Type ?u.305323
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedSemiring R
C r : R
h : ∀ (n : ℕ), 0 ≤ C * r ^ n
this : 0 ≤ C
hC : 0 < C
⊢ 0 ≤ r

tactic: simpa only [pow_one] using h 1
state_before: α : Type ?u.305323
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedSemiring R
C r : R
h : ∀ (n : ℕ), 0 ≤ C * r ^ n
this : 0 ≤ C
hC : 0 < C
⊢ 0 ≤ C * r

tactic: simpa only [pow_zero, mul_one] using h 0
state_before: α : Type ?u.305323
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedSemiring R
C r : R
h : ∀ (n : ℕ), 0 ≤ C * r ^ n
⊢ 0 ≤ C
Theorem: Ordnode.Sized.size_eq_zero
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases t <;> [simp;simp [ht.1]]
state_before: α : Type u_1
t : Ordnode α
ht : Sized t
⊢ size t = 0 ↔ t = nil
Theorem: Int.zpow_pred_clog_lt_self
File: Mathlib/Data/Int/Log.lean

tactic: rw [← neg_log_inv_eq_clog, ← neg_add', zpow_neg, inv_lt _ hr]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
⊢ ↑b ^ (clog b r - 1) < r

tactic: exact lt_zpow_succ_log_self hb _
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
⊢ r⁻¹ < ↑b ^ (log b r⁻¹ + 1)

tactic: exact zpow_pos_of_pos (Nat.cast_pos.mpr <| zero_le_one.trans_lt hb) _
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hb : 1 < b
hr : 0 < r
⊢ 0 < ↑b ^ (log b r⁻¹ + 1)
Theorem: MultilinearMap.map_update_sum
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: induction' t using Finset.induction with a t has ih h
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁹ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : AddCommMonoid M'
inst✝⁵ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝⁴ : (i : ι) → Module R (M₁ i)
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
f f' : MultilinearMap R M₁ M₂
α✝ : ι → Type ?u.279373
g✝ : (i : ι) → α✝ i → M₁ i
A : (i : ι) → Finset (α✝ i)
α : Type u_1
inst✝ : DecidableEq ι
t : Finset α
i : ι
g : α → M₁ i
m : (i : ι) → M₁ i
⊢ ↑f (update m i (∑ a in t, g a)) = ∑ a in t, ↑f (update m i (g a))

tactic: simp
state_before: case empty
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁹ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : AddCommMonoid M'
inst✝⁵ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝⁴ : (i : ι) → Module R (M₁ i)
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
f f' : MultilinearMap R M₁ M₂
α✝ : ι → Type ?u.279373
g✝ : (i : ι) → α✝ i → M₁ i
A : (i : ι) → Finset (α✝ i)
α : Type u_1
inst✝ : DecidableEq ι
i : ι
g : α → M₁ i
m : (i : ι) → M₁ i
⊢ ↑f (update m i (∑ a in ∅, g a)) = ∑ a in ∅, ↑f (update m i (g a))

tactic: simp [Finset.sum_insert has, ih]
state_before: case insert
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁹ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : AddCommMonoid M'
inst✝⁵ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝⁴ : (i : ι) → Module R (M₁ i)
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
f f' : MultilinearMap R M₁ M₂
α✝ : ι → Type ?u.279373
g✝ : (i : ι) → α✝ i → M₁ i
A : (i : ι) → Finset (α✝ i)
α : Type u_1
inst✝ : DecidableEq ι
i : ι
g : α → M₁ i
m : (i : ι) → M₁ i
a : α
t : Finset α
has : ¬a ∈ t
ih : ↑f (update m i (∑ a in t, g a)) = ∑ a in t, ↑f (update m i (g a))
⊢ ↑f (update m i (∑ a in insert a t, g a)) = ∑ a in insert a t, ↑f (update m i (g a))
Theorem: HomologicalComplex.dFrom_comp_xNextIso
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: simp [C.dFrom_eq r]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j : ι
r : ComplexShape.Rel c i j
⊢ dFrom C i ≫ (xNextIso C r).hom = d C i j
Theorem: IsSelfAdjoint.isStarNormal
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [Commute, SemiconjBy, hx.star_eq]
state_before: R : Type u_1
A : Type ?u.25400
inst✝¹ : Semigroup R
inst✝ : StarSemigroup R
x : R
hx : IsSelfAdjoint x
⊢ Commute (star x) x
Theorem: Polynomial.cyclotomic'_one
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: simp only [cyclotomic', Finset.prod_singleton, RingHom.map_one,
  IsPrimitiveRoot.primitiveRoots_one]
state_before: R✝ : Type ?u.33472
inst✝³ : CommRing R✝
inst✝² : IsDomain R✝
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
⊢ cyclotomic' 1 R = X - 1
Theorem: Int.abs_le_one_iff
File: Mathlib/Data/Int/Order/Basic.lean

tactic: rw [le_iff_lt_or_eq, abs_lt_one_iff, abs_eq (zero_le_one' ℤ)]
state_before: a : ℤ
⊢ abs a ≤ 1 ↔ a = 0 ∨ a = 1 ∨ a = -1
Theorem: SimpleGraph.Walk.start_mem_support
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: cases p <;> simp
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ u ∈ support p
Theorem: SimpleGraph.isUniform_one
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

tactic: intro s' hs' t' ht' hs ht
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
⊢ IsUniform G 1 s t

tactic: rw [mul_one] at hs ht
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
s' : Finset α
hs' : s' ⊆ s
t' : Finset α
ht' : t' ⊆ t
hs : ↑(card s) * 1 ≤ ↑(card s')
ht : ↑(card t) * 1 ≤ ↑(card t')
⊢ abs (↑(edgeDensity G s' t') - ↑(edgeDensity G s t)) < 1

tactic: rw [eq_of_subset_of_card_le hs' (Nat.cast_le.1 hs),
  eq_of_subset_of_card_le ht' (Nat.cast_le.1 ht), sub_self, abs_zero]
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
s' : Finset α
hs' : s' ⊆ s
t' : Finset α
ht' : t' ⊆ t
hs : ↑(card s) ≤ ↑(card s')
ht : ↑(card t) ≤ ↑(card t')
⊢ abs (↑(edgeDensity G s' t') - ↑(edgeDensity G s t)) < 1

tactic: exact zero_lt_one
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
s' : Finset α
hs' : s' ⊆ s
t' : Finset α
ht' : t' ⊆ t
hs : ↑(card s) ≤ ↑(card s')
ht : ↑(card t) ≤ ↑(card t')
⊢ 0 < 1
Theorem: symmDiff_eq_right
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_comm, symmDiff_eq_left]
state_before: ι : Type ?u.76655
α : Type u_1
β : Type ?u.76661
π : ι → Type ?u.76666
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ b = b ↔ a = ⊥
Theorem: Dfinsupp.toLex_monotone
File: Mathlib/Data/Dfinsupp/Lex.lean

tactic: intro a b h
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : LinearOrder ι
inst✝ : (i : ι) → PartialOrder (α i)
⊢ Monotone ↑toLex

tactic: refine' le_of_lt_or_eq (or_iff_not_imp_right.2 fun hne ↦ _)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : LinearOrder ι
inst✝ : (i : ι) → PartialOrder (α i)
a b : Π₀ (i : ι), α i
h : a ≤ b
⊢ ↑toLex a ≤ ↑toLex b

tactic: classical
exact ⟨Finset.min' _ (nonempty_neLocus_iff.2 hne),
  fun j hj ↦ not_mem_neLocus.1 fun h ↦ (Finset.min'_le _ _ h).not_lt hj,
  (h _).lt_of_ne (mem_neLocus.1 <| Finset.min'_mem _ _)⟩
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : LinearOrder ι
inst✝ : (i : ι) → PartialOrder (α i)
a b : Π₀ (i : ι), α i
h : a ≤ b
hne : ¬↑toLex a = ↑toLex b
⊢ ↑toLex a < ↑toLex b

tactic: exact ⟨Finset.min' _ (nonempty_neLocus_iff.2 hne),
  fun j hj ↦ not_mem_neLocus.1 fun h ↦ (Finset.min'_le _ _ h).not_lt hj,
  (h _).lt_of_ne (mem_neLocus.1 <| Finset.min'_mem _ _)⟩
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : LinearOrder ι
inst✝ : (i : ι) → PartialOrder (α i)
a b : Π₀ (i : ι), α i
h : a ≤ b
hne : ¬↑toLex a = ↑toLex b
⊢ ↑toLex a < ↑toLex b
Theorem: Set.image_image2_distrib_left
File: Mathlib/Data/Set/NAry.lean

tactic: rw [image_id']
state_before: α : Type u_3
α' : Type u_5
β : Type u_4
β' : Type ?u.44956
γ : Type u_2
γ' : Type ?u.44962
δ : Type u_1
δ' : Type ?u.44968
ε : Type ?u.44971
ε' : Type ?u.44974
ζ : Type ?u.44977
ζ' : Type ?u.44980
ν : Type ?u.44983
f f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
g : γ → δ
f' : α' → β → δ
g' : α → α'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g' a) b
⊢ image2 f' ((fun a => g' a) '' s) ((fun b => b) '' t) = image2 f' (g' '' s) t
Theorem: LinearOrderedField.smul_Iic
File: Mathlib/Algebra/Order/Pointwise.lean

tactic: ext x
state_before: α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
⊢ r • Iic a = Iic (r • a)

tactic: simp only [mem_smul_set, smul_eq_mul, mem_Iio]
state_before: case h
α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ x ∈ r • Iic a ↔ x ∈ Iic (r • a)

tactic: constructor
state_before: case h
α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, y ∈ Iic a ∧ r * y = x) ↔ x ∈ Iic (r * a)

tactic: rintro ⟨a_w, a_h_left, rfl⟩
state_before: case h.mp
α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, y ∈ Iic a ∧ r * y = x) → x ∈ Iic (r * a)

tactic: exact (mul_le_mul_left hr).mpr a_h_left
state_before: case h.mp.intro.intro
α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
a_w : K
a_h_left : a_w ∈ Iic a
⊢ r * a_w ∈ Iic (r * a)

tactic: rintro h
state_before: case h.mpr
α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ x ∈ Iic (r * a) → ∃ y, y ∈ Iic a ∧ r * y = x

tactic: use x / r
state_before: case h.mpr
α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : x ∈ Iic (r * a)
⊢ ∃ y, y ∈ Iic a ∧ r * y = x

tactic: constructor
state_before: case h.mpr
α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : x ∈ Iic (r * a)
⊢ x / r ∈ Iic a ∧ r * (x / r) = x

tactic: exact (div_le_iff' hr).mpr h
state_before: case h.mpr.left
α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : x ∈ Iic (r * a)
⊢ x / r ∈ Iic a

case h.mpr.right
α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : x ∈ Iic (r * a)
⊢ r * (x / r) = x

tactic: exact mul_div_cancel' _ (ne_of_gt hr)
state_before: case h.mpr.right
α : Type ?u.66941
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : x ∈ Iic (r * a)
⊢ r * (x / r) = x
Theorem: LieSubmodule.comap_incl_self
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp [← LieSubmodule.coe_toSubmodule_eq_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
⊢ comap (incl N) N = ⊤
Theorem: Nat.coprime.eq_one_of_dvd
File: Std/Data/Nat/Gcd.lean

tactic: rw [← H.gcd_eq_one, gcd_eq_left d]
state_before: k m : Nat
H : coprime k m
d : k ∣ m
⊢ k = 1
Theorem: Finset.card_eq_three
File: Mathlib/Data/Finset/Card.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.62214
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ card s = 3 ↔ ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z}

tactic: rw [card_eq_succ]
state_before: case mp
α : Type u_1
β : Type ?u.62214
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ card s = 3 → ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z}

tactic: simp_rw [card_eq_two]
state_before: case mp
α : Type u_1
β : Type ?u.62214
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ (∃ a t, ¬a ∈ t ∧ insert a t = s ∧ card t = 2) → ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z}

tactic: rintro ⟨a, _, abc, rfl, b, c, bc, rfl⟩
state_before: case mp
α : Type u_1
β : Type ?u.62214
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ (∃ a t, ¬a ∈ t ∧ insert a t = s ∧ ∃ x y, x ≠ y ∧ t = {x, y}) → ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z}

tactic: rw [mem_insert, mem_singleton, not_or] at abc
state_before: case mp.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.62214
t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
a b c : α
bc : b ≠ c
abc : ¬a ∈ {b, c}
⊢ ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ {a, b, c} = {x, y, z}

tactic: exact ⟨a, b, c, abc.1, abc.2, bc, rfl⟩
state_before: case mp.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.62214
t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
a b c : α
bc : b ≠ c
abc : ¬a = b ∧ ¬a = c
⊢ ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ {a, b, c} = {x, y, z}

tactic: rintro ⟨x, y, z, xy, xz, yz, rfl⟩
state_before: case mpr
α : Type u_1
β : Type ?u.62214
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ (∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z}) → card s = 3

tactic: simp only [xy, xz, yz, mem_insert, card_insert_of_not_mem, not_false_iff, mem_singleton,
  or_self_iff, card_singleton]
state_before: case mpr.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.62214
t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
x y z : α
xy : x ≠ y
xz : x ≠ z
yz : y ≠ z
⊢ card {x, y, z} = 3
Theorem: Vector.id_traverse
File: Mathlib/Data/Vector/Basic.lean

tactic: rintro ⟨x, rfl⟩
state_before: n : ℕ
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
⊢ ∀ (x : Vector α n), Vector.traverse pure x = x

tactic: dsimp [Vector.traverse, cast]
state_before: case mk
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : List α
⊢ Vector.traverse pure { val := x, property := (_ : List.length x = List.length x) } =
    { val := x, property := (_ : List.length x = List.length x) }

tactic: induction' x with x xs IH
state_before: case mk
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : List α
⊢ Vector.traverseAux pure x = { val := x, property := (_ : List.length x = List.length x) }

tactic: simp! [IH]
state_before: case mk.cons
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : α
xs : List α
IH : Vector.traverseAux pure xs = { val := xs, property := (_ : List.length xs = List.length xs) }
⊢ Vector.traverseAux pure (x :: xs) =
    { val := x :: xs, property := (_ : List.length (x :: xs) = List.length (x :: xs)) }

tactic: rfl
state_before: case mk.cons
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
x : α
xs : List α
IH : Vector.traverseAux pure xs = { val := xs, property := (_ : List.length xs = List.length xs) }
⊢ (Seq.seq (cons x) fun x => { val := xs, property := (_ : List.length xs = List.length xs) }) =
    { val := x :: xs, property := (_ : List.length (x :: xs) = List.length (x :: xs)) }

tactic: rfl
state_before: case mk.nil
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β : Type u
⊢ Vector.traverseAux pure [] = { val := [], property := (_ : List.length [] = List.length []) }
Theorem: Nat.Primrec.prec1
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: f : ℕ → ℕ
m : ℕ
hf : Nat.Primrec f
n : ℕ
⊢ unpaired (fun z n => Nat.rec m (fun y IH => f (unpair (Nat.pair z (Nat.pair y IH))).snd) n) (Nat.pair 0 (id n)) =
    Nat.rec m (fun y IH => f (Nat.pair y IH)) n
Theorem: Bornology.isBounded_compl_iff
File: Mathlib/Topology/Bornology/Basic.lean

tactic: rw [isBounded_def, isCobounded_def, compl_compl]
state_before: ι : Type ?u.3987
α : Type u_1
β : Type ?u.3993
inst✝ : Bornology α
s t : Set α
x : α
⊢ IsBounded (sᶜ) ↔ IsCobounded s
Theorem: Polynomial.eval_multiset_prod_X_sub_C_derivative
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: nth_rw 1 [← Multiset.cons_erase hr]
state_before: R : Type u
S✝ : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
S : Multiset R
r : R
hr : r ∈ S
⊢ eval r (↑derivative (Multiset.prod (Multiset.map (fun a => X - ↑C a) S))) =
    Multiset.prod (Multiset.map (fun a => r - a) (Multiset.erase S r))

tactic: have := (evalRingHom r).map_multiset_prod (Multiset.map (fun a => X - C a) (S.erase r))
state_before: R : Type u
S✝ : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
S : Multiset R
r : R
hr : r ∈ S
⊢ eval r (↑derivative (Multiset.prod (Multiset.map (fun a => X - ↑C a) (r ::ₘ Multiset.erase S r)))) =
    Multiset.prod (Multiset.map (fun a => r - a) (Multiset.erase S r))

tactic: simpa using this
state_before: R : Type u
S✝ : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
S : Multiset R
r : R
hr : r ∈ S
this :
  ↑(evalRingHom r) (Multiset.prod (Multiset.map (fun a => X - ↑C a) (Multiset.erase S r))) =
    Multiset.prod (Multiset.map (↑(evalRingHom r)) (Multiset.map (fun a => X - ↑C a) (Multiset.erase S r)))
⊢ eval r (↑derivative (Multiset.prod (Multiset.map (fun a => X - ↑C a) (r ::ₘ Multiset.erase S r)))) =
    Multiset.prod (Multiset.map (fun a => r - a) (Multiset.erase S r))
Theorem: zero_eq_bit0
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: rw [eq_comm]
state_before: R : Type u_1
inst✝² : NonAssocSemiring R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a✝ a : R
⊢ 0 = bit0 a ↔ a = 0

tactic: exact bit0_eq_zero
state_before: R : Type u_1
inst✝² : NonAssocSemiring R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a✝ a : R
⊢ bit0 a = 0 ↔ a = 0
Theorem: Int.gcd_least_linear
File: Mathlib/Data/Int/GCD.lean

tactic: simp_rw [← gcd_dvd_iff]
state_before: a b : ℤ
ha : a ≠ 0
⊢ IsLeast {n | 0 < n ∧ ∃ x y, ↑n = a * x + b * y} (gcd a b)

tactic: constructor
state_before: a b : ℤ
ha : a ≠ 0
⊢ IsLeast {n | 0 < n ∧ gcd a b ∣ n} (gcd a b)

tactic: simpa [and_true_iff, dvd_refl, Set.mem_setOf_eq] using gcd_pos_of_ne_zero_left b ha
state_before: case left
a b : ℤ
ha : a ≠ 0
⊢ gcd a b ∈ {n | 0 < n ∧ gcd a b ∣ n}

tactic: simp only [lowerBounds, and_imp, Set.mem_setOf_eq]
state_before: case right
a b : ℤ
ha : a ≠ 0
⊢ gcd a b ∈ lowerBounds {n | 0 < n ∧ gcd a b ∣ n}

tactic: exact fun n hn_pos hn => Nat.le_of_dvd hn_pos hn
state_before: case right
a b : ℤ
ha : a ≠ 0
⊢ ∀ ⦃a_1 : ℕ⦄, 0 < a_1 → gcd a b ∣ a_1 → gcd a b ≤ a_1
Theorem: Ideal.Filtration.Stable.exists_pow_smul_eq_of_ge
File: Mathlib/RingTheory/Filtration.lean

tactic: obtain ⟨n₀, hn₀⟩ := h.exists_pow_smul_eq
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
⊢ ∃ n₀, ∀ (n : ℕ), n ≥ n₀ → N F n = I ^ (n - n₀) • N F n₀

tactic: use n₀
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
n₀ : ℕ
hn₀ : ∀ (k : ℕ), N F (n₀ + k) = I ^ k • N F n₀
⊢ ∃ n₀, ∀ (n : ℕ), n ≥ n₀ → N F n = I ^ (n - n₀) • N F n₀

tactic: intro n hn
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
n₀ : ℕ
hn₀ : ∀ (k : ℕ), N F (n₀ + k) = I ^ k • N F n₀
⊢ ∀ (n : ℕ), n ≥ n₀ → N F n = I ^ (n - n₀) • N F n₀

tactic: convert hn₀ (n - n₀)
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
n₀ : ℕ
hn₀ : ∀ (k : ℕ), N F (n₀ + k) = I ^ k • N F n₀
n : ℕ
hn : n ≥ n₀
⊢ N F n = I ^ (n - n₀) • N F n₀

tactic: rw [add_comm, tsub_add_cancel_of_le hn]
state_before: case h.e'_2.h.e'_8
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
n₀ : ℕ
hn₀ : ∀ (k : ℕ), N F (n₀ + k) = I ^ k • N F n₀
n : ℕ
hn : n ≥ n₀
⊢ n = n₀ + (n - n₀)
Theorem: hasDerivAt_sqrt_mul_log
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: convert (hasDerivAt_sqrt hx).mul (hasDerivAt_log hx) using 1
state_before: x : ℝ
hx : x ≠ 0
⊢ HasDerivAt (fun x => sqrt x * log x) ((2 + log x) / (2 * sqrt x)) x

tactic: rw [add_div, div_mul_right (sqrt x) two_ne_zero, ← div_eq_mul_inv, sqrt_div_self', add_comm,
  div_eq_mul_one_div, mul_comm]
state_before: case h.e'_7
x : ℝ
hx : x ≠ 0
⊢ (2 + log x) / (2 * sqrt x) = 1 / (2 * sqrt x) * log x + sqrt x * x⁻¹
Theorem: selfZpow_neg_coe_nat
File: Mathlib/RingTheory/Localization/Away/Basic.lean

tactic: simp [selfZpow_of_nonpos _ _ (neg_nonpos.mpr (Int.coe_nat_nonneg d))]
state_before: R : Type u_2
inst✝³ : CommRing R
x : R
B : Type u_1
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℕ
⊢ selfZpow x B (-↑d) = mk' B 1 (Submonoid.pow x d)
Theorem: Complex.normSq_sub
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [sub_eq_add_neg, normSq_add]
state_before: z w : ℂ
⊢ ↑normSq (z - w) = ↑normSq z + ↑normSq w - 2 * (z * ↑(starRingEnd ℂ) w).re

tactic: simp only [RingHom.map_neg, mul_neg, neg_re, normSq_neg]
state_before: z w : ℂ
⊢ ↑normSq z + ↑normSq (-w) + 2 * (z * ↑(starRingEnd ℂ) (-w)).re =
    ↑normSq z + ↑normSq w - 2 * (z * ↑(starRingEnd ℂ) w).re

tactic: ring
state_before: z w : ℂ
⊢ ↑normSq z + ↑normSq w + -(2 * (z * ↑(starRingEnd ℂ) w).re) = ↑normSq z + ↑normSq w - 2 * (z * ↑(starRingEnd ℂ) w).re