tasksource/leandojo huggingface dataset:
Theorem: String.back_eq
File: Std/Data/String/Lemmas.lean

tactic: match s, s.1.eq_nil_or_concat with
| ⟨_⟩, .inl rfl => rfl
| ⟨_⟩, .inr ⟨cs, c, rfl⟩ => simp [back, prev_of_valid, get_of_valid]
state_before: s : String
⊢ back s = List.getLastD s.data default

tactic: rfl
state_before: s : String
⊢ back { data := [] } = List.getLastD { data := [] }.data default

tactic: simp [back, prev_of_valid, get_of_valid]
state_before: s : String
cs : List Char
c : Char
⊢ back { data := cs ++ [c] } = List.getLastD { data := cs ++ [c] }.data default
Theorem: MeasureTheory.Integrable.exists_hasCompactSupport_integral_sub_le
File: Mathlib/MeasureTheory/Function/ContinuousMapDense.lean

tactic: simp only [← memℒp_one_iff_integrable, ← snorm_one_eq_lintegral_nnnorm, ← ENNReal.ofReal_one]
  at hf ⊢
state_before: α : Type u_1
inst✝⁷ : MeasurableSpace α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : NormalSpace α
inst✝⁴ : BorelSpace α
E : Type u_2
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : NormedSpace ℝ E
inst✝¹ : LocallyCompactSpace α
inst✝ : Measure.Regular μ
f : α → E
hf : Integrable f
ε : ℝ
hε : 0 < ε
⊢ ∃ g, HasCompactSupport g ∧ (∫ (x : α), ‖f x - g x‖ ∂μ) ≤ ε ∧ Continuous g ∧ Integrable g

tactic: simpa using hf.exists_hasCompactSupport_integral_rpow_sub_le zero_lt_one hε
state_before: α : Type u_1
inst✝⁷ : MeasurableSpace α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : NormalSpace α
inst✝⁴ : BorelSpace α
E : Type u_2
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : NormedSpace ℝ E
inst✝¹ : LocallyCompactSpace α
inst✝ : Measure.Regular μ
f : α → E
ε : ℝ
hε : 0 < ε
hf : Memℒp f (ENNReal.ofReal 1)
⊢ ∃ g, HasCompactSupport g ∧ (∫ (x : α), ‖f x - g x‖ ∂μ) ≤ ε ∧ Continuous g ∧ Memℒp g (ENNReal.ofReal 1)
Theorem: Submodule.Quotient.nontrivial_of_lt_top
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: obtain ⟨x, _, not_mem_s⟩ := SetLike.exists_of_lt h
state_before: R : Type u_2
M : Type u_1
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : p < ⊤
⊢ Nontrivial (M ⧸ p)

tactic: refine' ⟨⟨mk x, 0, _⟩⟩
state_before: case intro.intro
R : Type u_2
M : Type u_1
r : R
x✝ y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : p < ⊤
x : M
left✝ : x ∈ ⊤
not_mem_s : ¬x ∈ p
⊢ Nontrivial (M ⧸ p)

tactic: simpa using not_mem_s
state_before: case intro.intro
R : Type u_2
M : Type u_1
r : R
x✝ y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : p < ⊤
x : M
left✝ : x ∈ ⊤
not_mem_s : ¬x ∈ p
⊢ mk x ≠ 0
Theorem: Ordinal.infinite_pigeonhole_set
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: cases' infinite_pigeonhole_card f θ hθ h₁ h₂ with a ha
state_before: α✝ : Type ?u.111380
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal
hθ : θ ≤ (#↑s)
h₁ : ℵ₀ ≤ θ
h₂ : (#α) < cof (ord θ)
⊢ ∃ a t h, θ ≤ (#↑t) ∧ ∀ ⦃x : β⦄ (hx : x ∈ t), f { val := x, property := (_ : x ∈ s) } = a

tactic: refine' ⟨a, { x | ∃ h, f ⟨x, h⟩ = a }, _, _, _⟩
state_before: case intro
α✝ : Type ?u.111380
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal
hθ : θ ≤ (#↑s)
h₁ : ℵ₀ ≤ θ
h₂ : (#α) < cof (ord θ)
a : α
ha : θ ≤ (#↑(f ⁻¹' {a}))
⊢ ∃ a t h, θ ≤ (#↑t) ∧ ∀ ⦃x : β⦄ (hx : x ∈ t), f { val := x, property := (_ : x ∈ s) } = a

tactic: rintro x ⟨_, hx'⟩
state_before: case intro.refine'_3
α✝ : Type ?u.111380
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal
hθ : θ ≤ (#↑s)
h₁ : ℵ₀ ≤ θ
h₂ : (#α) < cof (ord θ)
a : α
ha : θ ≤ (#↑(f ⁻¹' {a}))
⊢ ∀ ⦃x : β⦄ (hx : x ∈ {x | ∃ h, f { val := x, property := h } = a}), f { val := x, property := (_ : x ∈ s) } = a

tactic: exact hx'
state_before: case intro.refine'_3.intro
α✝ : Type ?u.111380
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal
hθ : θ ≤ (#↑s)
h₁ : ℵ₀ ≤ θ
h₂ : (#α) < cof (ord θ)
a : α
ha : θ ≤ (#↑(f ⁻¹' {a}))
x : β
w✝ : x ∈ s
hx' : f { val := x, property := w✝ } = a
⊢ f { val := x, property := (_ : x ∈ s) } = a

tactic: rintro x ⟨hx, _⟩
state_before: case intro.refine'_1
α✝ : Type ?u.111380
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal
hθ : θ ≤ (#↑s)
h₁ : ℵ₀ ≤ θ
h₂ : (#α) < cof (ord θ)
a : α
ha : θ ≤ (#↑(f ⁻¹' {a}))
⊢ {x | ∃ h, f { val := x, property := h } = a} ⊆ s

tactic: exact hx
state_before: case intro.refine'_1.intro
α✝ : Type ?u.111380
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal
hθ : θ ≤ (#↑s)
h₁ : ℵ₀ ≤ θ
h₂ : (#α) < cof (ord θ)
a : α
ha : θ ≤ (#↑(f ⁻¹' {a}))
x : β
hx : x ∈ s
h✝ : f { val := x, property := hx } = a
⊢ x ∈ s

tactic: refine'
  ha.trans
    (ge_of_eq <|
      Quotient.sound ⟨Equiv.trans _ (Equiv.subtypeSubtypeEquivSubtypeExists _ _).symm⟩)
state_before: case intro.refine'_2
α✝ : Type ?u.111380
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal
hθ : θ ≤ (#↑s)
h₁ : ℵ₀ ≤ θ
h₂ : (#α) < cof (ord θ)
a : α
ha : θ ≤ (#↑(f ⁻¹' {a}))
⊢ θ ≤ (#↑{x | ∃ h, f { val := x, property := h } = a})

tactic: simp only [coe_eq_subtype, mem_singleton_iff, mem_preimage, mem_setOf_eq]
state_before: case intro.refine'_2
α✝ : Type ?u.111380
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal
hθ : θ ≤ (#↑s)
h₁ : ℵ₀ ≤ θ
h₂ : (#α) < cof (ord θ)
a : α
ha : θ ≤ (#↑(f ⁻¹' {a}))
⊢ ↑{x | ∃ h, f { val := x, property := h } = a} ≃ { a_1 // ∃ h, { val := a_1, property := h } ∈ f ⁻¹' {a} }

tactic: rfl
state_before: case intro.refine'_2
α✝ : Type ?u.111380
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal
hθ : θ ≤ (#↑s)
h₁ : ℵ₀ ≤ θ
h₂ : (#α) < cof (ord θ)
a : α
ha : θ ≤ (#↑(f ⁻¹' {a}))
⊢ { x // ∃ h, f { val := x, property := h } = a } ≃ { a_1 // ∃ h, f { val := a_1, property := (_ : a_1 ∈ s) } = a }
Theorem: ContinuousLinearEquiv.comp_right_differentiable_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: simp only [← differentiableOn_univ, ← iso.comp_right_differentiableOn_iff, preimage_univ]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_3
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.181173
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : F → G
⊢ Differentiable 𝕜 (f ∘ ↑iso) ↔ Differentiable 𝕜 f
Theorem: intervalIntegral.inv_smul_integral_comp_div_sub
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_div_sub]
state_before: ι : Type ?u.14938809
𝕜 : Type ?u.14938812
E : Type u_1
F : Type ?u.14938818
A : Type ?u.14938821
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c✝ d✝ : ℝ
f : ℝ → E
c d : ℝ
⊢ (c⁻¹ • ∫ (x : ℝ) in a..b, f (x / c - d)) = ∫ (x : ℝ) in a / c - d..b / c - d, f x
Theorem: Nat.sInf_empty
File: Mathlib/Data/Nat/Lattice.lean

tactic: rw [sInf_eq_zero]
state_before: ⊢ sInf ∅ = 0

tactic: right
state_before: ⊢ 0 ∈ ∅ ∨ ∅ = ∅

tactic: rfl
state_before: case h

⊢ ∅ = ∅
Theorem: Dfinsupp.support_mk'_subset
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simpa using (Finset.mem_filter.1 H).1
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : (i : ι) → β i
s : Multiset ι
h : ∀ (i : ι), i ∈ s ∨ f i = 0
i : ι
H : i ∈ support { toFun := f, support' := Trunc.mk { val := s, property := h } }
⊢ i ∈ Multiset.toFinset (Multiset.toFinset s).val
Theorem: Num.cmp_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: have := PosNum.cmp_to_nat a b
state_before: α : Type ?u.226784
a b : PosNum
⊢ Ordering.casesOn (cmp (pos a) (pos b)) (↑(pos a) < ↑(pos b)) (pos a = pos b) (↑(pos b) < ↑(pos a))

tactic: revert this
state_before: α : Type ?u.226784
a b : PosNum
this : Ordering.casesOn (PosNum.cmp a b) (↑a < ↑b) (a = b) (↑b < ↑a)
⊢ Ordering.casesOn (cmp (pos a) (pos b)) (↑(pos a) < ↑(pos b)) (pos a = pos b) (↑(pos b) < ↑(pos a))

tactic: dsimp [cmp]
state_before: α : Type ?u.226784
a b : PosNum
⊢ Ordering.casesOn (PosNum.cmp a b) (↑a < ↑b) (a = b) (↑b < ↑a) →
    Ordering.casesOn (cmp (pos a) (pos b)) (↑(pos a) < ↑(pos b)) (pos a = pos b) (↑(pos b) < ↑(pos a))

tactic: cases PosNum.cmp a b
state_before: α : Type ?u.226784
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) (PosNum.cmp a b) →
    Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) (PosNum.cmp a b)

tactic: exacts [id, congr_arg pos, id]
state_before: case lt
α : Type ?u.226784
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) Ordering.lt → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) Ordering.lt

case eq
α : Type ?u.226784
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) Ordering.eq → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) Ordering.eq

case gt
α : Type ?u.226784
a b : PosNum
⊢ Ordering.rec (↑a < ↑b) (a = b) (↑b < ↑a) Ordering.gt → Ordering.rec (↑a < ↑b) (pos a = pos b) (↑b < ↑a) Ordering.gt
Theorem: List.replaceF_cons_of_none
File: Std/Data/List/Lemmas.lean

tactic: simp [replaceF_cons, h]
state_before: α : Type u_1
a : α
l : List α
p : α → Option α
h : p a = none
⊢ replaceF p (a :: l) = a :: replaceF p l
Theorem: Primrec.list_length
File: Mathlib/Computability/Primrec.lean

tactic: dsimp
state_before: α : Type u_1
β : Type ?u.315388
γ : Type ?u.315391
σ : Type ?u.315394
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List α
⊢ List.foldr (fun b s => (fun a b => Nat.succ (a, b).snd.snd) (l, b, s).fst (l, b, s).snd) 0 (id l) = List.length l

tactic: induction l <;> simp [*]
state_before: α : Type u_1
β : Type ?u.315388
γ : Type ?u.315391
σ : Type ?u.315394
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List α
⊢ List.foldr (fun b s => Nat.succ s) 0 l = List.length l
Theorem: Cubic.natDegree_of_a_eq_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: simpa only [of_a_eq_zero ha] using natDegree_quadratic_le
state_before: R : Type u_1
S : Type ?u.587971
F : Type ?u.587974
K : Type ?u.587977
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
⊢ natDegree (toPoly P) ≤ 2
Theorem: Nonneg.toNonneg_lt
File: Mathlib/Algebra/Order/Nonneg/Ring.lean

tactic: cases' a with a ha
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : { x // 0 ≤ x }
b : α
⊢ a < toNonneg b ↔ ↑a < b

tactic: simp [toNonneg, ha.not_lt]
state_before: case mk
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
b a : α
ha : 0 ≤ a
⊢ { val := a, property := ha } < toNonneg b ↔ ↑{ val := a, property := ha } < b
Theorem: FormalMultilinearSeries.coeff_iterate_fslope
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

tactic: induction k generalizing p with
| zero => rfl
| succ k ih => simp [ih, add_assoc]
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
p : FormalMultilinearSeries 𝕜 𝕜 E
n✝ k n : ℕ
⊢ coeff ((fslope^[k]) p) n = coeff p (n + k)

tactic: rfl
state_before: case zero
𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n✝ n : ℕ
p : FormalMultilinearSeries 𝕜 𝕜 E
⊢ coeff ((fslope^[Nat.zero]) p) n = coeff p (n + Nat.zero)

tactic: simp [ih, add_assoc]
state_before: case succ
𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n✝ n k : ℕ
ih : ∀ {p : FormalMultilinearSeries 𝕜 𝕜 E}, coeff ((fslope^[k]) p) n = coeff p (n + k)
p : FormalMultilinearSeries 𝕜 𝕜 E
⊢ coeff ((fslope^[Nat.succ k]) p) n = coeff p (n + Nat.succ k)
Theorem: AffineSubspace.subsingleton_of_subsingleton_span_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: obtain ⟨p, hp⟩ := AffineSubspace.nonempty_of_affineSpan_eq_top k V P h₂
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : Set.Subsingleton s
h₂ : affineSpan k s = ⊤
⊢ Subsingleton P

tactic: have : s = {p} := Subset.antisymm (fun q hq => h₁ hq hp) (by simp [hp])
state_before: case intro
k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : Set.Subsingleton s
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
⊢ Subsingleton P

tactic: rw [this, ← AffineSubspace.ext_iff, AffineSubspace.coe_affineSpan_singleton,
  AffineSubspace.top_coe, eq_comm, ← subsingleton_iff_singleton (mem_univ _)] at h₂
state_before: case intro
k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : Set.Subsingleton s
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P

tactic: exact subsingleton_of_univ_subsingleton h₂
state_before: case intro
k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : Set.Subsingleton s
p : P
h₂ : Set.Subsingleton univ
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P

tactic: simp [hp]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : Set.Subsingleton s
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
⊢ {p} ⊆ s
Theorem: Set.Icc_union_Icc
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: cases' le_or_lt a b with hab hab <;> cases' le_or_lt c d with hcd hcd <;>
  simp only [min_eq_left, min_eq_right, max_eq_left, max_eq_right, min_eq_left_of_lt,
    min_eq_right_of_lt, max_eq_left_of_lt, max_eq_right_of_lt, hab, hcd] at h₁ h₂
state_before: α : Type u_1
β : Type ?u.150639
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : min a b < max c d
h₂ : min c d < max a b
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

tactic: all_goals simp [*, min_eq_left_of_lt, max_eq_left_of_lt, min_eq_right_of_lt, max_eq_right_of_lt]
state_before: case inl.inr
α : Type u_1
β : Type ?u.150639
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : d < c
h₁ : a < c
h₂ : d < b
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

case inr.inl
α : Type u_1
β : Type ?u.150639
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
hcd : c ≤ d
h₁ : b < d
h₂ : c < a
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

case inr.inr
α : Type u_1
β : Type ?u.150639
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
hcd : d < c
h₁ : b < c
h₂ : d < a
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

tactic: exact Icc_union_Icc' h₂.le h₁.le
state_before: case inl.inl
α : Type u_1
β : Type ?u.150639
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : c ≤ d
h₁ : a < d
h₂ : c < b
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)

tactic: simp [*, min_eq_left_of_lt, max_eq_left_of_lt, min_eq_right_of_lt, max_eq_right_of_lt]
state_before: case inr.inr
α : Type u_1
β : Type ?u.150639
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b < a
hcd : d < c
h₁ : b < c
h₂ : d < a
⊢ Icc a b ∪ Icc c d = Icc (min a c) (max b d)
Theorem: FreeGroup.Red.not_step_nil
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: generalize h' : [] = L'
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ ¬Step [] L

tactic: intro h
state_before: α : Type u
L L₁ L₂ L₃ L₄ L' : List (α × Bool)
h' : [] = L'
⊢ ¬Step L' L

tactic: cases' h with L₁ L₂
state_before: α : Type u
L L₁ L₂ L₃ L₄ L' : List (α × Bool)
h' : [] = L'
h : Step L' L
⊢ False

tactic: simp [List.nil_eq_append] at h'
state_before: case not
α : Type u
L₁✝ L₂✝ L₃ L₄ L₁ L₂ : List (α × Bool)
x✝ : α
b✝ : Bool
h' : [] = L₁ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂
⊢ False
Theorem: BilinForm.zero_right
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [← @zero_smul R _ _ _ _ (0 : M), smul_right, MulZeroClass.zero_mul]
state_before: R : Type u_1
M : Type u_2
inst✝¹⁴ : Semiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type ?u.42555
M₁ : Type ?u.42558
inst✝¹¹ : Ring R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
R₂ : Type ?u.43167
M₂ : Type ?u.43170
inst✝⁸ : CommSemiring R₂
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
R₃ : Type ?u.43357
M₃ : Type ?u.43360
inst✝⁵ : CommRing R₃
inst✝⁴ : AddCommGroup M₃
inst✝³ : Module R₃ M₃
V : Type ?u.43948
K : Type ?u.43951
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
x : M
⊢ bilin B x 0 = 0
Theorem: IsPrimitiveRoot.zero
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: simpa [zero_pow_eq, show ∀ p, ¬p → False ↔ p from @Classical.not_not] using hl
state_before: M : Type ?u.2595779
N : Type ?u.2595782
G : Type ?u.2595785
R : Type ?u.2595788
S : Type ?u.2595791
F : Type ?u.2595794
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l✝ : ℕ
M₀ : Type u_1
inst✝¹ : CommMonoidWithZero M₀
inst✝ : Nontrivial M₀
l : ℕ
hl : 0 ^ l = 1
⊢ 0 ∣ l
Theorem: Real.cos_sub_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [sub_eq_add_neg, cos_add]
state_before: x : ℝ
⊢ cos (x - π / 2) = sin x
Theorem: iSup_sigma
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [iSup_le_iff, Sigma.forall]
state_before: α : Type u_3
β : Type u_2
β₂ : Type ?u.164848
γ : Type ?u.164851
ι : Sort ?u.164854
ι' : Sort ?u.164857
κ : ι → Sort ?u.164862
κ' : ι' → Sort ?u.164867
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
p : β → Type u_1
f : Sigma p → α
c : α
⊢ (⨆ (x : Sigma p), f x) ≤ c ↔ (⨆ (i : β) (j : p i), f { fst := i, snd := j }) ≤ c
Theorem: Order.succ_top
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [succ_eq_iff_isMax, isMax_iff_eq_top]
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b : α
inst✝ : OrderTop α
⊢ succ ⊤ = ⊤
Theorem: List.dropLast_cons_of_ne_nil
File: Mathlib/Data/List/Basic.lean

tactic: simp [h]
state_before: ι : Type ?u.198075
α✝ : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
x : α
l : List α
h : l ≠ []
⊢ dropLast (x :: l) = x :: dropLast l
Theorem: Set.preimage_div_const_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp only [div_eq_mul_inv, preimage_mul_const_uIcc (inv_ne_zero ha), inv_inv]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a : α
ha : a ≠ 0
b c : α
⊢ (fun x => x / a) ⁻¹' [[b, c]] = [[b * a, c * a]]
Theorem: Complex.div_re
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [div_eq_mul_inv, mul_assoc, sub_eq_add_neg]
state_before: z w : ℂ
⊢ (z / w).re = z.re * w.re / ↑normSq w + z.im * w.im / ↑normSq w
Theorem: CategoryTheory.Limits.CokernelCofork.condition
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: rw [Cofork.condition, zero_comp]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
s : CokernelCofork f
⊢ f ≫ Cofork.π s = 0
Theorem: Filter.nhds_atTop
File: Mathlib/Topology/Filter.lean

tactic: simp only [atTop, nhds_iInf, nhds_principal]
state_before: ι : Sort ?u.19779
α : Type u_1
β : Type ?u.19785
X : Type ?u.19788
Y : Type ?u.19791
inst✝ : Preorder α
⊢ 𝓝 atTop = ⨅ (x : α), 𝓟 (Iic (𝓟 (Ici x)))
Theorem: QuaternionAlgebra.smul_coe
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [coe_mul, coe_mul_eq_smul]
state_before: S : Type ?u.288486
T : Type ?u.288489
R : Type u_1
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ x • ↑y = ↑(x * y)
Theorem: Complex.exp_ofReal_mul_I_re
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [exp_mul_I, cos_ofReal_re]
state_before: x✝ y : ℂ
x : ℝ
⊢ (exp (↑x * I)).re = Real.cos x
Theorem: symmDiff_eq_bot
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [symmDiff, sup_eq_bot_iff, sdiff_eq_bot_iff, le_antisymm_iff]
state_before: ι : Type ?u.19057
α : Type u_1
β : Type ?u.19063
π : ι → Type ?u.19068
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
⊢ a ∆ b = ⊥ ↔ a = b
Theorem: CategoryTheory.Bicategory.triangle_assoc_comp_right_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp [← cancel_mono (f ◁ (λ_ g).hom)]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (ρ_ f).inv ▷ g ≫ (α_ f (𝟙 b) g).hom = f ◁ (λ_ g).inv
Theorem: Irreducible.dvd_symm
File: Mathlib/Algebra/Associated.lean

tactic: rintro ⟨q', rfl⟩
state_before: α : Type u_1
β : Type ?u.86920
γ : Type ?u.86923
δ : Type ?u.86926
inst✝ : Monoid α
p q : α
hp : Irreducible p
hq : Irreducible q
⊢ p ∣ q → q ∣ p

tactic: rw [IsUnit.mul_right_dvd (Or.resolve_left (of_irreducible_mul hq) hp.not_unit)]
state_before: case intro
α : Type u_1
β : Type ?u.86920
γ : Type ?u.86923
δ : Type ?u.86926
inst✝ : Monoid α
p : α
hp : Irreducible p
q' : α
hq : Irreducible (p * q')
⊢ p * q' ∣ p
Theorem: Rel.card_interedges_finpartition_left
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: classical
simp_rw [← P.biUnion_parts, interedges_biUnion_left, id.def]
rw [card_biUnion]
exact fun x hx y hy h ↦ interedges_disjoint_left r (P.disjoint hx hy h) _
state_before: 𝕜 : Type ?u.21732
ι : Type ?u.21735
κ : Type ?u.21738
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField 𝕜
r : α → β → Prop
inst✝¹ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝ : DecidableEq α
P : Finpartition s
t : Finset β
⊢ card (interedges r s t) = ∑ a in P.parts, card (interedges r a t)

tactic: simp_rw [← P.biUnion_parts, interedges_biUnion_left, id.def]
state_before: 𝕜 : Type ?u.21732
ι : Type ?u.21735
κ : Type ?u.21738
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField 𝕜
r : α → β → Prop
inst✝¹ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝ : DecidableEq α
P : Finpartition s
t : Finset β
⊢ card (interedges r s t) = ∑ a in P.parts, card (interedges r a t)

tactic: rw [card_biUnion]
state_before: 𝕜 : Type ?u.21732
ι : Type ?u.21735
κ : Type ?u.21738
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField 𝕜
r : α → β → Prop
inst✝¹ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝ : DecidableEq α
P : Finpartition s
t : Finset β
⊢ card (Finset.biUnion P.parts fun a => interedges r a t) = ∑ a in P.parts, card (interedges r a t)

tactic: exact fun x hx y hy h ↦ interedges_disjoint_left r (P.disjoint hx hy h) _
state_before: 𝕜 : Type ?u.21732
ι : Type ?u.21735
κ : Type ?u.21738
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField 𝕜
r : α → β → Prop
inst✝¹ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝ : DecidableEq α
P : Finpartition s
t : Finset β
⊢ ∀ (x : Finset α), x ∈ P.parts → ∀ (y : Finset α), y ∈ P.parts → x ≠ y → Disjoint (interedges r x t) (interedges r y t)
Theorem: Set.Finite.sUnion
File: Mathlib/Data/Set/Finite.lean

tactic: cases hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set (Set α)
hs : Set.Finite s
H : ∀ (t : Set α), t ∈ s → Set.Finite t
⊢ Set.Finite (⋃₀ s)

tactic: haveI := fun i : s => (H i i.2).to_subtype
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set (Set α)
H : ∀ (t : Set α), t ∈ s → Set.Finite t
a✝ : Fintype ↑s
⊢ Set.Finite (⋃₀ s)

tactic: apply toFinite
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set (Set α)
H : ∀ (t : Set α), t ∈ s → Set.Finite t
a✝ : Fintype ↑s
this : ∀ (i : ↑s), Finite ↑↑i
⊢ Set.Finite (⋃₀ s)
Theorem: Function.IsPeriodicPt.comp
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [IsPeriodicPt, hco.comp_iterate]
state_before: α : Type u_1
β : Type ?u.3017
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
hco : Commute f g
hf : IsPeriodicPt f n x
hg : IsPeriodicPt g n x
⊢ IsPeriodicPt (f ∘ g) n x

tactic: exact IsFixedPt.comp hf hg
state_before: α : Type u_1
β : Type ?u.3017
f fa : α → α
fb : β → β
x y : α
m n : ℕ
g : α → α
hco : Commute f g
hf : IsPeriodicPt f n x
hg : IsPeriodicPt g n x
⊢ IsFixedPt (f^[n] ∘ g^[n]) x
Theorem: neg_pow_bit0
File: Mathlib/Algebra/GroupPower/Ring.lean

tactic: rw [pow_bit0', neg_mul_neg, pow_bit0']
state_before: R : Type u_1
S : Type ?u.105410
M : Type ?u.105413
inst✝¹ : Monoid R
inst✝ : HasDistribNeg R
a : R
n : ℕ
⊢ (-a) ^ bit0 n = a ^ bit0 n