1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.div_mem_center
File: Mathlib/Algebra/Group/Center.lean

tactic: rw [div_eq_mul_inv]
state_before: M : Type u_1
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
hb : b ∈ center M
⊢ a / b ∈ center M
state_after: M : Type u_1
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
hb : b ∈ center M
⊢ a * b⁻¹ ∈ center M

tactic: exact mul_mem_center ha (inv_mem_center hb)
state_before: M : Type u_1
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
hb : b ∈ center M
⊢ a * b⁻¹ ∈ center M
state_after: no goals
Theorem: Filter.frequently_or_distrib_right
File: Mathlib/Order/Filter/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : f.NeBot
p : α → Prop
q : Prop
⊢ (∃ᶠ (x : α) in f, p x ∨ q) ↔ (∃ᶠ (x : α) in f, p x) ∨ q
state_after: no goals
Theorem: Matrix.toMvPolynomial_mul
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

tactic: simp only [toMvPolynomial, mul_apply, map_sum, Finset.sum_comm (γ := o), bind₁, aeval,
  AlgHom.coe_mk, coe_eval₂Hom, eval₂_monomial, algebraMap_apply, Algebra.id.map_eq_id,
  RingHom.id_apply, C_apply, pow_zero, Finsupp.prod_single_index, pow_one, Finset.mul_sum,
  monomial_mul, zero_add]
state_before: m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
M : Matrix m n R
N : Matrix n o R
i : m
⊢ (M * N).toMvPolynomial i = (bind₁ N.toMvPolynomial) (M.toMvPolynomial i)
state_after: no goals
Theorem: Finset.filter_or
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [mem_filter, mem_union, and_or_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
x✝ : α
⊢ x✝ ∈ filter (fun a => p a ∨ q a) s ↔ x✝ ∈ filter p s ∪ filter q s
state_after: no goals
Theorem: Finset.trop_inf
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: convert Multiset.trop_inf (s.val.map f)
state_before: R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → R
⊢ trop (s.inf f) = ∑ i ∈ s, trop (f i)
state_after: case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → R
⊢ ∑ i ∈ s, trop (f i) = (Multiset.map trop (Multiset.map f s.val)).sum

tactic: simp only [Multiset.map_map, Function.comp_apply]
state_before: case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → R
⊢ ∑ i ∈ s, trop (f i) = (Multiset.map trop (Multiset.map f s.val)).sum
state_after: case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → R
⊢ ∑ i ∈ s, trop (f i) = (Multiset.map (fun i => trop (f i)) s.val).sum

tactic: rfl
state_before: case h.e'_3
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Finset S
f : S → R
⊢ ∑ i ∈ s, trop (f i) = (Multiset.map (fun i => trop (f i)) s.val).sum
state_after: no goals
Theorem: SetTheory.PGame.lt_or_equiv_or_gt_or_fuzzy
File: Mathlib/SetTheory/Game/PGame.lean

tactic: cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
state_before: xl xr : Type u
x y : PGame
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y
state_after: case inl.inl
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

case inl.inr
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : x ⧏ y
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

case inr.inl
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

case inr.inr
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

tactic: right
state_before: case inl.inl
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y
state_after: case inl.inl.h
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x ≈ y ∨ y < x ∨ x ‖ y

tactic: left
state_before: case inl.inl.h
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x ≈ y ∨ y < x ∨ x ‖ y
state_after: case inl.inl.h.h
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x ≈ y

tactic: exact ⟨h₁, h₂⟩
state_before: case inl.inl.h.h
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x ≈ y
state_after: no goals

tactic: left
state_before: case inl.inr
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : x ⧏ y
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y
state_after: case inl.inr.h
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : x ⧏ y
⊢ x < y

tactic: exact ⟨h₁, h₂⟩
state_before: case inl.inr.h
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : x ⧏ y
⊢ x < y
state_after: no goals

tactic: right
state_before: case inr.inl
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y
state_after: case inr.inl.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ x ≈ y ∨ y < x ∨ x ‖ y

tactic: right
state_before: case inr.inl.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ x ≈ y ∨ y < x ∨ x ‖ y
state_after: case inr.inl.h.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ y < x ∨ x ‖ y

tactic: left
state_before: case inr.inl.h.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ y < x ∨ x ‖ y
state_after: case inr.inl.h.h.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ y < x

tactic: exact ⟨h₂, h₁⟩
state_before: case inr.inl.h.h.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ y < x
state_after: no goals

tactic: right
state_before: case inr.inr
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y
state_after: case inr.inr.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x ≈ y ∨ y < x ∨ x ‖ y

tactic: right
state_before: case inr.inr.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x ≈ y ∨ y < x ∨ x ‖ y
state_after: case inr.inr.h.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ y < x ∨ x ‖ y

tactic: right
state_before: case inr.inr.h.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ y < x ∨ x ‖ y
state_after: case inr.inr.h.h.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x ‖ y

tactic: exact ⟨h₂, h₁⟩
state_before: case inr.inr.h.h.h
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x ‖ y
state_after: no goals
Theorem: NonUnitalSubring.mem_bot
File: Mathlib/RingTheory/NonUnitalSubring/Basic.lean

tactic: rw [coe_bot, Set.mem_singleton_iff]
state_before: F : Type w
R : Type u
S : Type v
T : Type u_1
inst✝⁴ : NonUnitalNonAssocRing R
inst✝³ : NonUnitalNonAssocRing S
inst✝² : NonUnitalNonAssocRing T
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
g : S →ₙ+* T
f : R →ₙ+* S
x : R
⊢ x ∈ ↑⊥ ↔ x = 0
state_after: no goals
Theorem: MeasureTheory.IsSetRing.inter_mem
File: Mathlib/MeasureTheory/SetSemiring.lean

tactic: rw [← diff_diff_right_self]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetRing C
hs : s ∈ C
ht : t ∈ C
⊢ s ∩ t ∈ C
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetRing C
hs : s ∈ C
ht : t ∈ C
⊢ s \ (s \ t) ∈ C

tactic: exact hC.diff_mem hs (hC.diff_mem hs ht)
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetRing C
hs : s ∈ C
ht : t ∈ C
⊢ s \ (s \ t) ∈ C
state_after: no goals
Theorem: List.maximum_eq_coe_iff
File: Mathlib/Data/List/MinMax.lean

tactic: rw [maximum, ← WithBot.some_eq_coe, argmax_eq_some_iff]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ l.maximum = ↑m ↔ m ∈ l ∧ ∀ (a : α), a ∈ l → a ≤ m
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ (m ∈ l ∧ (∀ (a : α), a ∈ l → id a ≤ id m) ∧ ∀ (a : α), a ∈ l → id m ≤ id a → indexOf m l ≤ indexOf a l) ↔
    m ∈ l ∧ ∀ (a : α), a ∈ l → a ≤ m

tactic: simp only [id_eq, and_congr_right_iff, and_iff_left_iff_imp]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ (m ∈ l ∧ (∀ (a : α), a ∈ l → id a ≤ id m) ∧ ∀ (a : α), a ∈ l → id m ≤ id a → indexOf m l ≤ indexOf a l) ↔
    m ∈ l ∧ ∀ (a : α), a ∈ l → a ≤ m
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ m ∈ l → (∀ (a : α), a ∈ l → a ≤ m) → ∀ (a : α), a ∈ l → m ≤ a → indexOf m l ≤ indexOf a l

tactic: intro _ h a hal hma
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ m ∈ l → (∀ (a : α), a ∈ l → a ≤ m) → ∀ (a : α), a ∈ l → m ≤ a → indexOf m l ≤ indexOf a l
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a✝¹ m : α
a✝ : m ∈ l
h : ∀ (a : α), a ∈ l → a ≤ m
a : α
hal : a ∈ l
hma : m ≤ a
⊢ indexOf m l ≤ indexOf a l

tactic: rw [_root_.le_antisymm hma (h a hal)]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a✝¹ m : α
a✝ : m ∈ l
h : ∀ (a : α), a ∈ l → a ≤ m
a : α
hal : a ∈ l
hma : m ≤ a
⊢ indexOf m l ≤ indexOf a l
state_after: no goals
Theorem: LieSubmodule.range_incl
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
⊢ N.incl.range = N
state_after: no goals
Theorem: Int.sum_div
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: obtain rfl | hn := eq_or_ne n 0
state_before: ι✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι✝ → Type u_5
s✝ s₁ s₂ : Finset ι✝
i : ι✝
a : α
f✝ g : ι✝ → α
ι : Type u_6
s : Finset ι
f : ι → ℤ
n : ℤ
hf : ∀ i ∈ s, n ∣ f i
⊢ (∑ i ∈ s, f i) / n = ∑ i ∈ s, f i / n
state_after: case inl
ι✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι✝ → Type u_5
s✝ s₁ s₂ : Finset ι✝
i : ι✝
a : α
f✝ g : ι✝ → α
ι : Type u_6
s : Finset ι
f : ι → ℤ
hf : ∀ i ∈ s, 0 ∣ f i
⊢ (∑ i ∈ s, f i) / 0 = ∑ i ∈ s, f i / 0

case inr
ι✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι✝ → Type u_5
s✝ s₁ s₂ : Finset ι✝
i : ι✝
a : α
f✝ g : ι✝ → α
ι : Type u_6
s : Finset ι
f : ι → ℤ
n : ℤ
hf : ∀ i ∈ s, n ∣ f i
hn : n ≠ 0
⊢ (∑ i ∈ s, f i) / n = ∑ i ∈ s, f i / n

tactic: rw [Int.ediv_eq_iff_eq_mul_left hn (dvd_sum hf), sum_mul]
state_before: case inr
ι✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι✝ → Type u_5
s✝ s₁ s₂ : Finset ι✝
i : ι✝
a : α
f✝ g : ι✝ → α
ι : Type u_6
s : Finset ι
f : ι → ℤ
n : ℤ
hf : ∀ i ∈ s, n ∣ f i
hn : n ≠ 0
⊢ (∑ i ∈ s, f i) / n = ∑ i ∈ s, f i / n
state_after: case inr
ι✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι✝ → Type u_5
s✝ s₁ s₂ : Finset ι✝
i : ι✝
a : α
f✝ g : ι✝ → α
ι : Type u_6
s : Finset ι
f : ι → ℤ
n : ℤ
hf : ∀ i ∈ s, n ∣ f i
hn : n ≠ 0
⊢ ∑ i ∈ s, f i = ∑ i ∈ s, f i / n * n

tactic: refine sum_congr rfl fun s hs ↦ ?_
state_before: case inr
ι✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι✝ → Type u_5
s✝ s₁ s₂ : Finset ι✝
i : ι✝
a : α
f✝ g : ι✝ → α
ι : Type u_6
s : Finset ι
f : ι → ℤ
n : ℤ
hf : ∀ i ∈ s, n ∣ f i
hn : n ≠ 0
⊢ ∑ i ∈ s, f i = ∑ i ∈ s, f i / n * n
state_after: case inr
ι✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι✝ → Type u_5
s✝¹ s₁ s₂ : Finset ι✝
i : ι✝
a : α
f✝ g : ι✝ → α
ι : Type u_6
s✝ : Finset ι
f : ι → ℤ
n : ℤ
hf : ∀ i ∈ s✝, n ∣ f i
hn : n ≠ 0
s : ι
hs : s ∈ s✝
⊢ f s = f s / n * n

tactic: rw [Int.ediv_mul_cancel (hf _ hs)]
state_before: case inr
ι✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι✝ → Type u_5
s✝¹ s₁ s₂ : Finset ι✝
i : ι✝
a : α
f✝ g : ι✝ → α
ι : Type u_6
s✝ : Finset ι
f : ι → ℤ
n : ℤ
hf : ∀ i ∈ s✝, n ∣ f i
hn : n ≠ 0
s : ι
hs : s ∈ s✝
⊢ f s = f s / n * n
state_after: no goals

tactic: simp
state_before: case inl
ι✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι✝ → Type u_5
s✝ s₁ s₂ : Finset ι✝
i : ι✝
a : α
f✝ g : ι✝ → α
ι : Type u_6
s : Finset ι
f : ι → ℤ
hf : ∀ i ∈ s, 0 ∣ f i
⊢ (∑ i ∈ s, f i) / 0 = ∑ i ∈ s, f i / 0
state_after: no goals
Theorem: List.toFinset.ext_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [Finset.ext_iff, mem_toFinset]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a✝ : α
a b : List α
⊢ a.toFinset = b.toFinset ↔ ∀ (x : α), x ∈ a ↔ x ∈ b
state_after: no goals
Theorem: Equiv.semiconj_conj
File: Mathlib/Logic/Equiv/Basic.lean

tactic: simp
state_before: α₁ : Type u_1
β₁ : Type u_2
e : α₁ ≃ β₁
f✝ : α₁ → α₁ → α₁
f : α₁ → α₁
x : α₁
⊢ e (f x) = e.conj f (e x)
state_after: no goals
Theorem: Bifunctor.comp_fst
File: Mathlib/Control/Bifunctor.lean

tactic: simp [fst, bimap_bimap]
state_before: F : Type u₀ → Type u₁ → Type u₂
inst✝¹ : Bifunctor F
inst✝ : LawfulBifunctor F
α₀ α₁ α₂ : Type u₀
β : Type u₁
f : α₀ → α₁
f' : α₁ → α₂
x : F α₀ β
⊢ fst f' (fst f x) = fst (f' ∘ f) x
state_after: no goals
Theorem: Basis.tensorProduct_apply'
File: Mathlib/LinearAlgebra/TensorProduct/Basis.lean

tactic: simp [Basis.tensorProduct]
state_before: R : Type u_1
S : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁸ : CommSemiring R
inst✝⁷ : Semiring S
inst✝⁶ : Algebra R S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : Module S M
inst✝² : IsScalarTower R S M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
b : Basis ι R M
c : Basis κ R N
i : ι × κ
⊢ (b.tensorProduct c) i = b i.1 ⊗ₜ[R] c i.2
state_after: no goals
Theorem: CategoryTheory.CostructuredArrow.isSeparating_proj_preimage
File: Mathlib/CategoryTheory/Generator.lean

tactic: refine fun X Y f g hfg => ext _ _ (h𝒢 _ _ fun G hG h => ?_)
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S : C ⥤ D
T : D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢
⊢ IsSeparating ((proj S T).obj ⁻¹' 𝒢)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S : C ⥤ D
T : D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢
X Y : CostructuredArrow S T
f g : X ⟶ Y
hfg : ∀ G ∈ (proj S T).obj ⁻¹' 𝒢, ∀ (h : G ⟶ X), h ≫ f = h ≫ g
G : C
hG : G ∈ 𝒢
h : G ⟶ X.left
⊢ h ≫ f.left = h ≫ g.left

tactic: exact congr_arg CommaMorphism.left (hfg (mk (S.map h ≫ X.hom)) hG (homMk h rfl))
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S : C ⥤ D
T : D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢
X Y : CostructuredArrow S T
f g : X ⟶ Y
hfg : ∀ G ∈ (proj S T).obj ⁻¹' 𝒢, ∀ (h : G ⟶ X), h ≫ f = h ≫ g
G : C
hG : G ∈ 𝒢
h : G ⟶ X.left
⊢ h ≫ f.left = h ≫ g.left
state_after: no goals
Theorem: SignType.mul_comm
File: Mathlib/Data/Sign.lean

tactic: rintro ⟨⟩ ⟨⟩ <;> rfl
state_before: ⊢ ∀ (a b : SignType), a * b = b * a
state_after: no goals
Theorem: DFinsupp.neLocus_self_sub_right
File: Mathlib/Data/DFinsupp/NeLocus.lean

tactic: rw [sub_eq_add_neg, neLocus_self_add_right, support_neg]
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ f.neLocus (f - g) = g.support
state_after: no goals
Theorem: Subgroup.map_eq_bot_iff_of_injective
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: rw [map_eq_bot_iff, f.ker_eq_bot_iff.mpr hf, le_bot_iff]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
H : Subgroup G
f : G →* N
hf : Injective ⇑f
⊢ map f H = ⊥ ↔ H = ⊥
state_after: no goals
Theorem: List.set_eq_modifyNth
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
a : α
l : List α
⊢ l.set 0 a = modifyNth (fun x => a) 0 l
state_after: no goals
Theorem: Finset.diag_union
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨i, j⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
⊢ (s ∪ t).diag = s.diag ∪ t.diag
state_after: case a.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
i j : α
⊢ (i, j) ∈ (s ∪ t).diag ↔ (i, j) ∈ s.diag ∪ t.diag

tactic: simp only [mem_diag, mem_union, or_and_right]
state_before: case a.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
i j : α
⊢ (i, j) ∈ (s ∪ t).diag ↔ (i, j) ∈ s.diag ∪ t.diag
state_after: no goals
Theorem: Nat.bit_ne_zero_iff
File: Mathlib/Data/Nat/Bitwise.lean

tactic: simpa only [not_and, Bool.not_eq_false] using (@bit_eq_zero n b).not
state_before: n : ℕ
b : Bool
⊢ bit b n ≠ 0 ↔ n = 0 → b = true
state_after: no goals
Theorem: Fin.preimage_insertNth_Icc_of_not_mem
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp only [mem_preimage, insertNth_mem_Icc, hx, false_and_iff, mem_empty_iff_false]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
i : Fin (n + 1)
x : α i
q₁ q₂ : (j : Fin (n + 1)) → α j
hx : x ∉ Icc (q₁ i) (q₂ i)
p : (j : Fin n) → α (i.succAbove j)
⊢ p ∈ i.insertNth x ⁻¹' Icc q₁ q₂ ↔ p ∈ ∅
state_after: no goals
Theorem: LinearMap.finrank_range_add_finrank_ker
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← f.quotKerEquivRange.finrank_eq]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V₂
⊢ finrank K ↥(range f) + finrank K ↥(ker f) = finrank K V
state_after: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V₂
⊢ finrank K (V ⧸ ker f) + finrank K ↥(ker f) = finrank K V

tactic: exact Submodule.finrank_quotient_add_finrank _
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V₂
⊢ finrank K (V ⧸ ker f) + finrank K ↥(ker f) = finrank K V
state_after: no goals
Theorem: hasFDerivAtFilter_iff_hasDerivAtFilter
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simp [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 L₁ L₂ : Filter 𝕜
f' : 𝕜 →L[𝕜] F
⊢ HasFDerivAtFilter f f' x L ↔ HasDerivAtFilter f (f' 1) x L
state_after: no goals
Theorem: Rat.mk_eq_mkRat
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: simp [mk_eq_normalize, normalize_eq_mkRat]
state_before: num : Int
den : Nat
nz : den ≠ 0
c : num.natAbs.Coprime den
⊢ { num := num, den := den, den_nz := nz, reduced := c } = mkRat num den
state_after: no goals
Theorem: OreLocalization.mul_inv
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: simp [oreDiv_mul_char (s : R) s' s' s 1 1 (by simp)]
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.96987
inst✝ : MulAction R X
s s' : ↥S
⊢ ↑s /ₒ s' * (↑s' /ₒ s) = 1
state_after: no goals

tactic: simp
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.96987
inst✝ : MulAction R X
s s' : ↥S
⊢ ↑1 * ↑s = 1 * ↑s
state_after: no goals
Theorem: Int.le_iff_eq_or_lt
File: Mathlib/Data/Int/Defs.lean

tactic: rw [Int.le_antisymm_iff, Int.lt_iff_le_not_le, ← and_or_left]
state_before: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a ≤ b ↔ a = b ∨ a < b
state_after: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a ≤ b ↔ a ≤ b ∧ (b ≤ a ∨ ¬b ≤ a)

tactic: simp [em]
state_before: a✝ b✝ c✝ d m n a b c : ℤ
⊢ a ≤ b ↔ a ≤ b ∧ (b ≤ a ∨ ¬b ≤ a)
state_after: no goals
Theorem: RingSubgroupsBasis.nonarchimedean
File: Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean

tactic: letI := hB.topology
state_before: A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
⊢ NonarchimedeanRing A
state_after: A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := hB.topology
⊢ NonarchimedeanRing A

tactic: constructor
state_before: A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := hB.topology
⊢ NonarchimedeanRing A
state_after: case is_nonarchimedean
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := hB.topology
⊢ ∀ U ∈ 𝓝 0, ∃ V, ↑V ⊆ U

tactic: intro U hU
state_before: case is_nonarchimedean
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := hB.topology
⊢ ∀ U ∈ 𝓝 0, ∃ V, ↑V ⊆ U
state_after: case is_nonarchimedean
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := hB.topology
U : Set A
hU : U ∈ 𝓝 0
⊢ ∃ V, ↑V ⊆ U

tactic: obtain ⟨i, -, hi : (B i : Set A) ⊆ U⟩ := hB.hasBasis_nhds_zero.mem_iff.mp hU
state_before: case is_nonarchimedean
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := hB.topology
U : Set A
hU : U ∈ 𝓝 0
⊢ ∃ V, ↑V ⊆ U
state_after: case is_nonarchimedean.intro.intro
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := hB.topology
U : Set A
hU : U ∈ 𝓝 0
i : ι
hi : ↑(B i) ⊆ U
⊢ ∃ V, ↑V ⊆ U

tactic: exact ⟨hB.openAddSubgroup i, hi⟩
state_before: case is_nonarchimedean.intro.intro
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
this : TopologicalSpace A := hB.topology
U : Set A
hU : U ∈ 𝓝 0
i : ι
hi : ↑(B i) ⊆ U
⊢ ∃ V, ↑V ⊆ U
state_after: no goals
Theorem: mfderivWithin_of_mem_nhds
File: Mathlib/Geometry/Manifold/MFDeriv/Basic.lean

tactic: rw [← mfderivWithin_univ, ← univ_inter s, mfderivWithin_inter h]
state_before: 𝕜 : Type u_1
inst✝¹⁵ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁴ : NormedAddCommGroup E
inst✝¹³ : NormedSpace 𝕜 E
H : Type u_3
inst✝¹² : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝¹¹ : TopologicalSpace M
inst✝¹⁰ : ChartedSpace H M
E' : Type u_5
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝⁷ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : ChartedSpace H' M'
E'' : Type u_8
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : NormedSpace 𝕜 E''
H'' : Type u_9
inst✝² : TopologicalSpace H''
I'' : ModelWithCorners 𝕜 E'' H''
M'' : Type u_10
inst✝¹ : TopologicalSpace M''
inst✝ : ChartedSpace H'' M''
f f₀ f₁ : M → M'
x : M
s t : Set M
g : M' → M''
u : Set M'
Is : SmoothManifoldWithCorners I M
I's : SmoothManifoldWithCorners I' M'
I''s : SmoothManifoldWithCorners I'' M''
f' f₀' f₁' : TangentSpace I x →L[𝕜] TangentSpace I' (f x)
g' : TangentSpace I' (f x) →L[𝕜] TangentSpace I'' (g (f x))
h : s ∈ 𝓝 x
⊢ mfderivWithin I I' f s x = mfderiv I I' f x
state_after: no goals
Theorem: left_inv_eq_right_inv
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [← one_mul c, ← hba, mul_assoc, hac, mul_one b]
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a b c : M
m n : ℕ
hba : b * a = 1
hac : a * c = 1
⊢ b = c
state_after: no goals
Theorem: Rat.mul_add
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [Rat.mul_comm, Rat.add_mul, Rat.mul_comm, Rat.mul_comm c a]
state_before: q a b c : ℚ
⊢ a * (b + c) = a * b + a * c
state_after: no goals
Theorem: GradedRing.proj_recompose
File: Mathlib/RingTheory/GradedAlgebra/Basic.lean

tactic: rw [GradedRing.proj_apply, decompose_symm_of, Equiv.apply_symm_apply]
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁷ : DecidableEq ι
inst✝⁶ : AddMonoid ι
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a : ⨁ (i : ι), ↥(𝒜 i)
i : ι
⊢ (proj 𝒜 i) ((decompose 𝒜).symm a) = (decompose 𝒜).symm ((of (fun i => ↥(𝒜 i)) i) (a i))
state_after: no goals