1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.Countable.isLindelof_sUnion
File: Mathlib/Topology/Compactness/Lindelof.lean

tactic: rw [sUnion_eq_biUnion]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hf : S.Countable
hc : ∀ s ∈ S, IsLindelof s
⊢ IsLindelof (⋃₀ S)
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hf : S.Countable
hc : ∀ s ∈ S, IsLindelof s
⊢ IsLindelof (⋃ i ∈ S, i)

tactic: exact hf.isLindelof_biUnion hc
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hf : S.Countable
hc : ∀ s ∈ S, IsLindelof s
⊢ IsLindelof (⋃ i ∈ S, i)
state_after: no goals
Theorem: Finmap.insert_singleton_eq
File: Mathlib/Data/Finmap.lean

tactic: simp only [singleton, Finmap.insert_toFinmap, AList.insert_singleton_eq]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b b' : β a
⊢ insert a b (singleton a b') = singleton a b
state_after: no goals
Theorem: Set.ncard_le_ncard_of_injOn
File: Mathlib/Data/Set/Card.lean

tactic: have hle := encard_le_encard_of_injOn hf f_inj
state_before: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : InjOn f s
ht : autoParam t.Finite _auto✝
⊢ s.ncard ≤ t.ncard
state_after: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : InjOn f s
ht : autoParam t.Finite _auto✝
hle : s.encard ≤ t.encard
⊢ s.ncard ≤ t.ncard

tactic: to_encard_tac
state_before: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : InjOn f s
ht : autoParam t.Finite _auto✝
hle : s.encard ≤ t.encard
⊢ s.ncard ≤ t.ncard
state_after: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : InjOn f s
ht : autoParam t.Finite _auto✝
hle : s.encard ≤ t.encard
⊢ ↑s.ncard ≤ ↑t.ncard

tactic: rwa [ht.cast_ncard_eq, (ht.finite_of_encard_le hle).cast_ncard_eq]
state_before: α : Type u_1
β : Type u_2
s t✝ : Set α
f✝ : α → β
t : Set β
f : α → β
hf : ∀ a ∈ s, f a ∈ t
f_inj : InjOn f s
ht : autoParam t.Finite _auto✝
hle : s.encard ≤ t.encard
⊢ ↑s.ncard ≤ ↑t.ncard
state_after: no goals
Theorem: Module.End.IsSemisimple_smul_iff
File: Mathlib/LinearAlgebra/Semisimple.lean

tactic: simp [isSemisimple_iff, Submodule.comap_smul f (h := ht)]
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
K : Type u_3
inst✝¹ : Field K
inst✝ : Module K M
f g : End K M
t : K
ht : t ≠ 0
⊢ (t • f).IsSemisimple ↔ f.IsSemisimple
state_after: no goals
Theorem: HurwitzZeta.evenKernel_eq_cosKernel_of_zero
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

tactic: ext1 x
state_before: ⊢ evenKernel 0 = cosKernel 0
state_after: case h
x : ℝ
⊢ evenKernel 0 x = cosKernel 0 x

tactic: simp only [← QuotientAddGroup.mk_zero, ← ofReal_inj, evenKernel_def, ofReal_zero, sq, mul_zero,
  zero_mul, Complex.exp_zero, one_mul, cosKernel_def]
state_before: case h
x : ℝ
⊢ evenKernel 0 x = cosKernel 0 x
state_after: no goals
Theorem: gauge_zero'
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: ext x
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a : ℝ
⊢ gauge 0 = 0
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
⊢ gauge 0 x = 0 x

tactic: rw [gauge_def']
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
⊢ gauge 0 x = 0 x
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
⊢ sInf {r | r ∈ Ioi 0 ∧ r⁻¹ • x ∈ 0} = 0 x

tactic: obtain rfl | hx := eq_or_ne x 0
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
⊢ sInf {r | r ∈ Ioi 0 ∧ r⁻¹ • x ∈ 0} = 0 x
state_after: case h.inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a : ℝ
⊢ sInf {r | r ∈ Ioi 0 ∧ r⁻¹ • 0 ∈ 0} = 0 0

case h.inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
hx : x ≠ 0
⊢ sInf {r | r ∈ Ioi 0 ∧ r⁻¹ • x ∈ 0} = 0 x

tactic: simp only [csInf_Ioi, mem_zero, Pi.zero_apply, eq_self_iff_true, sep_true, smul_zero]
state_before: case h.inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a : ℝ
⊢ sInf {r | r ∈ Ioi 0 ∧ r⁻¹ • 0 ∈ 0} = 0 0
state_after: no goals

tactic: simp only [mem_zero, Pi.zero_apply, inv_eq_zero, smul_eq_zero]
state_before: case h.inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
hx : x ≠ 0
⊢ sInf {r | r ∈ Ioi 0 ∧ r⁻¹ • x ∈ 0} = 0 x
state_after: case h.inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
hx : x ≠ 0
⊢ sInf {r | r ∈ Ioi 0 ∧ (r = 0 ∨ x = 0)} = 0

tactic: convert Real.sInf_empty
state_before: case h.inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
hx : x ≠ 0
⊢ sInf {r | r ∈ Ioi 0 ∧ (r = 0 ∨ x = 0)} = 0
state_after: case h.e'_2.h.e'_3
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
hx : x ≠ 0
⊢ {r | r ∈ Ioi 0 ∧ (r = 0 ∨ x = 0)} = ∅

tactic: exact eq_empty_iff_forall_not_mem.2 fun r hr => hr.2.elim (ne_of_gt hr.1) hx
state_before: case h.e'_2.h.e'_3
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
x : E
hx : x ≠ 0
⊢ {r | r ∈ Ioi 0 ∧ (r = 0 ∨ x = 0)} = ∅
state_after: no goals
Theorem: HNNExtension.NormalWord.unitsSMulGroup_snd
File: Mathlib/GroupTheory/HNNExtension.lean

tactic: rcases Int.units_eq_one_or u with rfl | rfl <;> rfl
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
d : TransversalPair G A B
u : ℤˣ
g : G
⊢ (unitsSMulGroup φ d u g).2 = (⋯.equiv g).2
state_after: no goals
Theorem: RegularExpression.map_pow
File: Mathlib/Computability/RegularExpressions.lean

tactic: dsimp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
f : α → β
P : RegularExpression α
⊢ map f (P ^ 0) = map f P ^ 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
f : α → β
P : RegularExpression α
⊢ 1 = map f P ^ 0

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
f : α → β
P : RegularExpression α
⊢ 1 = map f P ^ 0
state_after: no goals
Theorem: List.foldl_ext
File: Mathlib/Data/List/Basic.lean

tactic: induction l generalizing a with
| nil => rfl
| cons hd tl ih =>
  unfold foldl
  rw [ih _ fun a b bin => H a b <| mem_cons_of_mem _ bin, H a hd (mem_cons_self _ _)]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → α
a : α
l : List β
H : ∀ (a : α) (b : β), b ∈ l → f a b = g a b
⊢ foldl f a l = foldl g a l
state_after: no goals

tactic: rfl
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → α
a : α
H : ∀ (a : α) (b : β), b ∈ [] → f a b = g a b
⊢ foldl f a [] = foldl g a []
state_after: no goals

tactic: unfold foldl
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → α
hd : β
tl : List β
ih : ∀ (a : α), (∀ (a : α) (b : β), b ∈ tl → f a b = g a b) → foldl f a tl = foldl g a tl
a : α
H : ∀ (a : α) (b : β), b ∈ hd :: tl → f a b = g a b
⊢ foldl f a (hd :: tl) = foldl g a (hd :: tl)
state_after: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → α
hd : β
tl : List β
ih : ∀ (a : α), (∀ (a : α) (b : β), b ∈ tl → f a b = g a b) → foldl f a tl = foldl g a tl
a : α
H : ∀ (a : α) (b : β), b ∈ hd :: tl → f a b = g a b
⊢ foldl f (f a hd) tl = foldl g (g a hd) tl

tactic: rw [ih _ fun a b bin => H a b <| mem_cons_of_mem _ bin, H a hd (mem_cons_self _ _)]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : α → β → α
hd : β
tl : List β
ih : ∀ (a : α), (∀ (a : α) (b : β), b ∈ tl → f a b = g a b) → foldl f a tl = foldl g a tl
a : α
H : ∀ (a : α) (b : β), b ∈ hd :: tl → f a b = g a b
⊢ foldl f (f a hd) tl = foldl g (g a hd) tl
state_after: no goals
Theorem: pow_mul_pow_eq_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Monoid M
a b c : M
m n : ℕ
x✝ : a * b = 1
⊢ a ^ 0 * b ^ 0 = 1
state_after: no goals

tactic: rw [pow_succ, pow_succ']
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Monoid M
a b c : M
m n✝ n : ℕ
h : a * b = 1
⊢ a ^ n.succ * b ^ n.succ = a ^ n * a * (b * b ^ n)
state_after: no goals

tactic: simp only [mul_assoc]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Monoid M
a b c : M
m n✝ n : ℕ
h : a * b = 1
⊢ a ^ n * a * (b * b ^ n) = a ^ n * (a * b) * b ^ n
state_after: no goals

tactic: simp [h, pow_mul_pow_eq_one]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Monoid M
a b c : M
m n✝ n : ℕ
h : a * b = 1
⊢ a ^ n * (a * b) * b ^ n = 1
state_after: no goals
Theorem: AbsoluteValue.le_sub
File: Mathlib/Algebra/Order/AbsoluteValue.lean

tactic: simpa using abv.add_le (a - b) b
state_before: ι : Type u_1
α : Type u_2
R✝ : Type u_3
S✝ : Type u_4
R : Type u_5
S : Type u_6
inst✝¹ : Ring R
inst✝ : OrderedRing S
abv : AbsoluteValue R S
a b : R
⊢ abv a ≤ abv (a - b) + abv b
state_after: no goals
Theorem: MeasureTheory.Measure.measurable_join
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

tactic: simp only [join_apply hs]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
hs : MeasurableSet s
⊢ Measurable fun b => b.join s
state_after: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
hs : MeasurableSet s
⊢ Measurable fun b => ∫⁻ (μ : Measure α), μ s ∂b

tactic: exact measurable_lintegral (measurable_coe hs)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
hs : MeasurableSet s
⊢ Measurable fun b => ∫⁻ (μ : Measure α), μ s ∂b
state_after: no goals
Theorem: Asymptotics.isBigO_one_nat_atTop_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [norm_one, mul_one]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f : ℕ → E''
⊢ (∃ C, ∀ (x : ℕ), ‖f x‖ ≤ C * ‖1‖) ↔ ∃ C, ∀ (n : ℕ), ‖f n‖ ≤ C
state_after: no goals
Theorem: HasGradientWithinAt.congr
File: Mathlib/Analysis/Calculus/Gradient/Basic.lean

tactic: tauto
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
f₀ f₁ : F → 𝕜
f₀' f₁' x₀ x₁ : F
s₀ s₁ t : Set F
L₀ L₁ : Filter F
h : HasGradientWithinAt f f' s x
hs : ∀ x ∈ s, f₁ x = f x
hx : f₁ x = f x
⊢ s ⊆ s
state_after: no goals
Theorem: Class.eq_univ_of_powerset_subset
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: by_contra! hnA
state_before: A : Class
hA : A.powerset ⊆ A
⊢ ∀ (x : ZFSet), A x
state_after: A : Class
hA : A.powerset ⊆ A
hnA : ∃ x, ¬A x
⊢ False

tactic: exact
  WellFounded.min_mem ZFSet.mem_wf _ hnA
    (hA fun x hx =>
      Classical.not_not.1 fun hB =>
        WellFounded.not_lt_min ZFSet.mem_wf _ hnA hB <| coe_apply.1 hx)
state_before: A : Class
hA : A.powerset ⊆ A
hnA : ∃ x, ¬A x
⊢ False
state_after: no goals
Theorem: IsMulFreimanIso.subset
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

tactic: refine hf.map_prod_eq_map_prod (fun a ha ↦ hA (hsA ha)) (fun a ha ↦ hA (htA ha)) hs ht
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hA : A₁ ⊆ A₂
hf : IsMulFreimanIso n A₂ B₂ f
hf' : BijOn f A₁ B₁
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A₁
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A₁
hs : card s = n
ht : card t = n
⊢ (map f s).prod = (map f t).prod ↔ s.prod = t.prod
state_after: no goals
Theorem: Real.IsConjExponent.mul_eq_add
File: Mathlib/Data/Real/ConjExponents.lean

tactic: simpa only [sub_mul, sub_eq_iff_eq_add, one_mul] using h.sub_one_mul_conj
state_before: a b p q : ℝ
h : p.IsConjExponent q
⊢ p * q = p + q
state_after: no goals
Theorem: AlgebraicGeometry.PresheafedSpace.ext
File: Mathlib/Geometry/RingedSpace/PresheafedSpace.lean

tactic: rw [w]
state_before: C : Type u_1
inst✝ : Category.{?u.17443, u_1} C
X Y : PresheafedSpace C
α β : X ⟶ Y
w : α.base = β.base
⊢ (Opens.map α.base).op = (Opens.map β.base).op
state_after: no goals
Theorem: CategoryTheory.Adjunction.homEquiv_naturality_left
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: rw [← Equiv.eq_symm_apply]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ (adj.homEquiv X' Y) (F.map f ≫ g) = f ≫ (adj.homEquiv X Y) g
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = (adj.homEquiv X' Y).symm (f ≫ (adj.homEquiv X Y) g)

tactic: simp only [Equiv.symm_apply_apply,eq_self_iff_true,homEquiv_naturality_left_symm]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = (adj.homEquiv X' Y).symm (f ≫ (adj.homEquiv X Y) g)
state_after: no goals
Theorem: List.Ico.trichotomy
File: Mathlib/Data/List/Intervals.lean

tactic: by_cases h₁ : n < a
state_before: n a b : ℕ
⊢ n < a ∨ b ≤ n ∨ n ∈ Ico a b
state_after: case pos
n a b : ℕ
h₁ : n < a
⊢ n < a ∨ b ≤ n ∨ n ∈ Ico a b

case neg
n a b : ℕ
h₁ : ¬n < a
⊢ n < a ∨ b ≤ n ∨ n ∈ Ico a b

tactic: left
state_before: case pos
n a b : ℕ
h₁ : n < a
⊢ n < a ∨ b ≤ n ∨ n ∈ Ico a b
state_after: case pos.h
n a b : ℕ
h₁ : n < a
⊢ n < a

tactic: exact h₁
state_before: case pos.h
n a b : ℕ
h₁ : n < a
⊢ n < a
state_after: no goals

tactic: right
state_before: case neg
n a b : ℕ
h₁ : ¬n < a
⊢ n < a ∨ b ≤ n ∨ n ∈ Ico a b
state_after: case neg.h
n a b : ℕ
h₁ : ¬n < a
⊢ b ≤ n ∨ n ∈ Ico a b

tactic: by_cases h₂ : n ∈ Ico a b
state_before: case neg.h
n a b : ℕ
h₁ : ¬n < a
⊢ b ≤ n ∨ n ∈ Ico a b
state_after: case pos
n a b : ℕ
h₁ : ¬n < a
h₂ : n ∈ Ico a b
⊢ b ≤ n ∨ n ∈ Ico a b

case neg
n a b : ℕ
h₁ : ¬n < a
h₂ : n ∉ Ico a b
⊢ b ≤ n ∨ n ∈ Ico a b

tactic: right
state_before: case pos
n a b : ℕ
h₁ : ¬n < a
h₂ : n ∈ Ico a b
⊢ b ≤ n ∨ n ∈ Ico a b
state_after: case pos.h
n a b : ℕ
h₁ : ¬n < a
h₂ : n ∈ Ico a b
⊢ n ∈ Ico a b

tactic: exact h₂
state_before: case pos.h
n a b : ℕ
h₁ : ¬n < a
h₂ : n ∈ Ico a b
⊢ n ∈ Ico a b
state_after: no goals

tactic: left
state_before: case neg
n a b : ℕ
h₁ : ¬n < a
h₂ : n ∉ Ico a b
⊢ b ≤ n ∨ n ∈ Ico a b
state_after: case neg.h
n a b : ℕ
h₁ : ¬n < a
h₂ : n ∉ Ico a b
⊢ b ≤ n

tactic: simp only [Ico.mem, not_and, not_lt] at *
state_before: case neg.h
n a b : ℕ
h₁ : ¬n < a
h₂ : n ∉ Ico a b
⊢ b ≤ n
state_after: case neg.h
n a b : ℕ
h₁ : a ≤ n
h₂ : a ≤ n → b ≤ n
⊢ b ≤ n

tactic: exact h₂ h₁
state_before: case neg.h
n a b : ℕ
h₁ : a ≤ n
h₂ : a ≤ n → b ≤ n
⊢ b ≤ n
state_after: no goals
Theorem: Nat.sqrt_le'
File: Mathlib/Data/Nat/Defs.lean

tactic: simpa [Nat.pow_two] using sqrt_le n
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
⊢ n.sqrt ^ 2 ≤ n
state_after: no goals
Theorem: AddCommGroup.DirectLimit.map_comp
File: Mathlib/Algebra/DirectLimit.lean

tactic: rw [AddMonoidHom.comp_assoc, hg₁ i, ← AddMonoidHom.comp_assoc, hg₂ i,
  AddMonoidHom.comp_assoc]
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : DecidableEq ι
inst✝⁴ : (i : ι) → AddCommGroup (G i)
f : (i j : ι) → i ≤ j → G i →+ G j
P : Type u₁
inst✝³ : AddCommGroup P
g : (i : ι) → G i →+ P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x
G' : ι → Type v'
inst✝² : (i : ι) → AddCommGroup (G' i)
f' : (i j : ι) → i ≤ j → G' i →+ G' j
G'' : ι → Type v''
inst✝¹ : (i : ι) → AddCommGroup (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →+ G'' j
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
g₁ : (i : ι) → G i →+ G' i
g₂ : (i : ι) → G' i →+ G'' i
hg₁ : ∀ (i j : ι) (h : i ≤ j), (g₁ j).comp (f i j h) = (f' i j h).comp (g₁ i)
hg₂ : ∀ (i j : ι) (h : i ≤ j), (g₂ j).comp (f' i j h) = (f'' i j h).comp (g₂ i)
i j : ι
h : i ≤ j
⊢ ((fun i => (g₂ i).comp (g₁ i)) j).comp (f i j h) = (f'' i j h).comp ((fun i => (g₂ i).comp (g₁ i)) i)
state_after: no goals

tactic: simp
state_before: R : Type u
inst✝⁷ : Ring R
ι : Type v
inst✝⁶ : Preorder ι
G : ι → Type w
inst✝⁵ : DecidableEq ι
inst✝⁴ : (i : ι) → AddCommGroup (G i)
f : (i j : ι) → i ≤ j → G i →+ G j
P : Type u₁
inst✝³ : AddCommGroup P
g✝ : (i : ι) → G i →+ P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g✝ j) ((f i j hij) x) = (g✝ i) x
G' : ι → Type v'
inst✝² : (i : ι) → AddCommGroup (G' i)
f' : (i j : ι) → i ≤ j → G' i →+ G' j
G'' : ι → Type v''
inst✝¹ : (i : ι) → AddCommGroup (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →+ G'' j
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
g₁ : (i : ι) → G i →+ G' i
g₂ : (i : ι) → G' i →+ G'' i
hg₁ : ∀ (i j : ι) (h : i ≤ j), (g₁ j).comp (f i j h) = (f' i j h).comp (g₁ i)
hg₂ : ∀ (i j : ι) (h : i ≤ j), (g₂ j).comp (f' i j h) = (f'' i j h).comp (g₂ i)
x : DirectLimit G f
x✝ : Nonempty ι
i : ι
g : G i
⊢ ((map g₂ hg₂).comp (map g₁ hg₁)) ((of G f i) g) = (map (fun i => (g₂ i).comp (g₁ i)) ⋯) ((of G f i) g)
state_after: no goals
Theorem: NumberField.mixedEmbedding.norm_eq_zero_iff'
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

tactic: obtain ⟨a, rfl⟩ := hx
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : ({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)
hx : x ∈ Set.range ⇑(mixedEmbedding K)
⊢ mixedEmbedding.norm x = 0 ↔ x = 0
state_after: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
a : K
⊢ mixedEmbedding.norm ((mixedEmbedding K) a) = 0 ↔ (mixedEmbedding K) a = 0

tactic: rw [norm_eq_norm, Rat.cast_abs, abs_eq_zero, Rat.cast_eq_zero, Algebra.norm_eq_zero_iff,
  map_eq_zero]
state_before: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
a : K
⊢ mixedEmbedding.norm ((mixedEmbedding K) a) = 0 ↔ (mixedEmbedding K) a = 0
state_after: no goals
Theorem: WithBot.sum_eq_bot_iff
File: Mathlib/Algebra/BigOperators/WithTop.lean

tactic: induction s using Finset.cons_induction <;> simp [*]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : AddCommMonoid α
inst✝ : LT α
s : Finset ι
f : ι → WithBot α
⊢ ∑ i ∈ s, f i = ⊥ ↔ ∃ i ∈ s, f i = ⊥
state_after: no goals
Theorem: Filter.exists_singleton_mem_of_mem_of_forall_separating
File: Mathlib/Order/Filter/CountableSeparatingOn.lean

tactic: rcases s.eq_empty_or_nonempty with rfl | hne
state_before: α : Type u_1
β : Type u_2
l : Filter α
inst✝² : CountableInterFilter l
f g : α → β
inst✝¹ : Nonempty α
p : Set α → Prop
s : Set α
inst✝ : HasCountableSeparatingOn α p s
hs : s ∈ l
hl : ∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l
⊢ ∃ a, {a} ∈ l
state_after: case inl
α : Type u_1
β : Type u_2
l : Filter α
inst✝² : CountableInterFilter l
f g : α → β
inst✝¹ : Nonempty α
p : Set α → Prop
hl : ∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l
inst✝ : HasCountableSeparatingOn α p ∅
hs : ∅ ∈ l
⊢ ∃ a, {a} ∈ l

case inr
α : Type u_1
β : Type u_2
l : Filter α
inst✝² : CountableInterFilter l
f g : α → β
inst✝¹ : Nonempty α
p : Set α → Prop
s : Set α
inst✝ : HasCountableSeparatingOn α p s
hs : s ∈ l
hl : ∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l
hne : s.Nonempty
⊢ ∃ a, {a} ∈ l

tactic: exact ‹Nonempty α›.elim fun a ↦ ⟨a, mem_of_superset hs (empty_subset _)⟩
state_before: case inl
α : Type u_1
β : Type u_2
l : Filter α
inst✝² : CountableInterFilter l
f g : α → β
inst✝¹ : Nonempty α
p : Set α → Prop
hl : ∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l
inst✝ : HasCountableSeparatingOn α p ∅
hs : ∅ ∈ l
⊢ ∃ a, {a} ∈ l
state_after: no goals

tactic: exact (exists_mem_singleton_mem_of_mem_of_nonempty_of_forall_separating p hs hne hl).imp fun _ ↦
  And.right
state_before: case inr
α : Type u_1
β : Type u_2
l : Filter α
inst✝² : CountableInterFilter l
f g : α → β
inst✝¹ : Nonempty α
p : Set α → Prop
s : Set α
inst✝ : HasCountableSeparatingOn α p s
hs : s ∈ l
hl : ∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l
hne : s.Nonempty
⊢ ∃ a, {a} ∈ l
state_after: no goals
Theorem: Multiset.sym2_mono
File: Mathlib/Data/Multiset/Sym.lean

tactic: refine Quotient.inductionOn₂ m m' (fun xs ys h => ?_) h
state_before: α : Type u_1
m m' : Multiset α
h : m ≤ m'
⊢ m.sym2 ≤ m'.sym2
state_after: α : Type u_1
m m' : Multiset α
h✝ : m ≤ m'
xs ys : List α
h : ⟦xs⟧ ≤ ⟦ys⟧
⊢ Multiset.sym2 ⟦xs⟧ ≤ Multiset.sym2 ⟦ys⟧

tactic: suffices xs <+~ ys from this.sym2
state_before: α : Type u_1
m m' : Multiset α
h✝ : m ≤ m'
xs ys : List α
h : ⟦xs⟧ ≤ ⟦ys⟧
⊢ Multiset.sym2 ⟦xs⟧ ≤ Multiset.sym2 ⟦ys⟧
state_after: α : Type u_1
m m' : Multiset α
h✝ : m ≤ m'
xs ys : List α
h : ⟦xs⟧ ≤ ⟦ys⟧
⊢ xs <+~ ys

tactic: simpa only [quot_mk_to_coe, coe_le, sym2_coe] using h
state_before: α : Type u_1
m m' : Multiset α
h✝ : m ≤ m'
xs ys : List α
h : ⟦xs⟧ ≤ ⟦ys⟧
⊢ xs <+~ ys
state_after: no goals
Theorem: Tropical.add_eq_left_iff
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: rw [trop_add_def, trop_eq_iff_eq_untrop, ← untrop_le_iff, min_eq_left_iff]
state_before: R : Type u
inst✝ : LinearOrder R
x y : Tropical R
⊢ x + y = x ↔ x ≤ y
state_after: no goals
Theorem: Sym.card_sym_eq_choose
File: Mathlib/Data/Sym/Card.lean

tactic: rw [card_sym_eq_multichoose, Nat.multichoose_eq]
state_before: α✝ : Type u_1
β : Type u_2
n : ℕ
α : Type u_3
inst✝¹ : Fintype α
k : ℕ
inst✝ : Fintype (Sym α k)
⊢ Fintype.card (Sym α k) = (Fintype.card α + k - 1).choose k
state_after: no goals
Theorem: LinearMap.isNilpotent_mulLeft_iff
File: Mathlib/RingTheory/Nilpotent/Lemmas.lean

tactic: constructor <;> rintro ⟨n, hn⟩ <;> use n <;>
    simp only [mulLeft_eq_zero_iff, pow_mulLeft] at hn ⊢ <;>
  exact hn
state_before: R : Type u_1
S : Type u_2
x y : R
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
⊢ IsNilpotent (mulLeft R a) ↔ IsNilpotent a
state_after: no goals
Theorem: BooleanRing.inf_comm
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: ring
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : α
⊢ a * b = b * a
state_after: no goals
Theorem: Rat.zero_divInt
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: cases n <;> simp [divInt]
state_before: n : Int
⊢ 0 /. n = 0
state_after: no goals