1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Behrend.exp_four_lt
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

tactic: rw [show (64 : ℝ) = 2 ^ ((6 : ℕ) : ℝ) by rw [rpow_natCast]; norm_num1,
  ← lt_log_iff_exp_lt (rpow_pos_of_pos zero_lt_two _), log_rpow zero_lt_two, ← div_lt_iff']
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ rexp 4 < 64
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 4 / ↑6 < log 2

α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 0 < ↑6

tactic: rw [rpow_natCast]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 64 = 2 ^ ↑6
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 64 = 2 ^ 6

tactic: norm_num1
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 64 = 2 ^ 6
state_after: no goals

tactic: exact log_two_gt_d9.trans_le' (by norm_num1)
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 4 / ↑6 < log 2
state_after: no goals

tactic: norm_num1
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 4 / ↑6 ≤ 0.6931471803
state_after: no goals

tactic: norm_num
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 0 < ↑6
state_after: no goals
Theorem: CFilter.ofEquiv_val
File: Mathlib/Data/Analysis/Filter.lean

tactic: cases F
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
inst✝ : PartialOrder α
F✝ : CFilter α σ
E : σ ≃ τ
F : CFilter α σ
a : τ
⊢ (ofEquiv E F).f a = F.f (E.symm a)
state_after: case mk
α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
inst✝ : PartialOrder α
F : CFilter α σ
E : σ ≃ τ
a : τ
f✝ : σ → α
pt✝ : σ
inf✝ : σ → σ → σ
inf_le_left✝ : ∀ (a b : σ), f✝ (inf✝ a b) ≤ f✝ a
inf_le_right✝ : ∀ (a b : σ), f✝ (inf✝ a b) ≤ f✝ b
⊢ (ofEquiv E { f := f✝, pt := pt✝, inf := inf✝, inf_le_left := inf_le_left✝, inf_le_right := inf_le_right✝ }).f a =
    { f := f✝, pt := pt✝, inf := inf✝, inf_le_left := inf_le_left✝, inf_le_right := inf_le_right✝ }.f (E.symm a)

tactic: rfl
state_before: case mk
α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
inst✝ : PartialOrder α
F : CFilter α σ
E : σ ≃ τ
a : τ
f✝ : σ → α
pt✝ : σ
inf✝ : σ → σ → σ
inf_le_left✝ : ∀ (a b : σ), f✝ (inf✝ a b) ≤ f✝ a
inf_le_right✝ : ∀ (a b : σ), f✝ (inf✝ a b) ≤ f✝ b
⊢ (ofEquiv E { f := f✝, pt := pt✝, inf := inf✝, inf_le_left := inf_le_left✝, inf_le_right := inf_le_right✝ }).f a =
    { f := f✝, pt := pt✝, inf := inf✝, inf_le_left := inf_le_left✝, inf_le_right := inf_le_right✝ }.f (E.symm a)
state_after: no goals
Theorem: List.Lex.ne_iff
File: Mathlib/Data/List/Lex.lean

tactic: classical
exact Decidable.List.Lex.ne_iff H
state_before: α : Type u
l₁ l₂ : List α
H : l₁.length ≤ l₂.length
⊢ Lex (fun x x_1 => x ≠ x_1) l₁ l₂ ↔ l₁ ≠ l₂
state_after: no goals

tactic: exact Decidable.List.Lex.ne_iff H
state_before: α : Type u
l₁ l₂ : List α
H : l₁.length ≤ l₂.length
⊢ Lex (fun x x_1 => x ≠ x_1) l₁ l₂ ↔ l₁ ≠ l₂
state_after: no goals
Theorem: eval₂_minpolyDiv_self
File: Mathlib/FieldTheory/Minpoly/MinpolyDiv.lean

tactic: apply eval₂_minpolyDiv_of_eval₂_eq_zero
state_before: R : Type u_2
K : Type ?u.44014
L : Type ?u.44017
S : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
inst✝⁴ : Algebra K L
x✝ : S
hx : IsIntegral R x✝
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
inst✝¹ : IsDomain T
inst✝ : DecidableEq T
x : S
σ₁ σ₂ : S →ₐ[R] T
⊢ eval₂ (↑σ₁) (σ₂ x) (minpolyDiv R x) = if σ₁ x = σ₂ x then σ₁ ((aeval x) (derivative (minpoly R x))) else 0
state_after: case hy
R : Type u_2
K : Type ?u.44014
L : Type ?u.44017
S : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
inst✝⁴ : Algebra K L
x✝ : S
hx : IsIntegral R x✝
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
inst✝¹ : IsDomain T
inst✝ : DecidableEq T
x : S
σ₁ σ₂ : S →ₐ[R] T
⊢ eval₂ ((↑σ₁).comp (algebraMap R S)) (σ₂ x) (minpoly R x) = 0

tactic: rw [AlgHom.comp_algebraMap, ← σ₂.comp_algebraMap, ← eval₂_map, ← RingHom.coe_coe, eval₂_hom,
  eval_map, ← aeval_def, minpoly.aeval, map_zero]
state_before: case hy
R : Type u_2
K : Type ?u.44014
L : Type ?u.44017
S : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : CommRing S
inst✝⁵ : Algebra R S
inst✝⁴ : Algebra K L
x✝ : S
hx : IsIntegral R x✝
T : Type u_1
inst✝³ : CommRing T
inst✝² : Algebra R T
inst✝¹ : IsDomain T
inst✝ : DecidableEq T
x : S
σ₁ σ₂ : S →ₐ[R] T
⊢ eval₂ ((↑σ₁).comp (algebraMap R S)) (σ₂ x) (minpoly R x) = 0
state_after: no goals
Theorem: Cardinal.mul_eq_max'
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rcases aleph0_le_mul_iff.mp h with ⟨ha, hb, ha' | hb'⟩
state_before: a b : Cardinal.{u_1}
h : ℵ₀ ≤ a * b
⊢ a * b = max a b
state_after: case intro.intro.inl
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a * b
ha : a ≠ 0
hb : b ≠ 0
ha' : ℵ₀ ≤ a
⊢ a * b = max a b

case intro.intro.inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a * b
ha : a ≠ 0
hb : b ≠ 0
hb' : ℵ₀ ≤ b
⊢ a * b = max a b

tactic: exact mul_eq_max_of_aleph0_le_left ha' hb
state_before: case intro.intro.inl
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a * b
ha : a ≠ 0
hb : b ≠ 0
ha' : ℵ₀ ≤ a
⊢ a * b = max a b
state_after: no goals

tactic: exact mul_eq_max_of_aleph0_le_right ha hb'
state_before: case intro.intro.inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a * b
ha : a ≠ 0
hb : b ≠ 0
hb' : ℵ₀ ≤ b
⊢ a * b = max a b
state_after: no goals
Theorem: PNat.eq_one_of_lt_two
File: Mathlib/Data/PNat/Prime.lean

tactic: intro h
state_before: n : ℕ+
⊢ n < 2 → n = 1
state_after: n : ℕ+
h : n < 2
⊢ n = 1

tactic: apply le_antisymm
state_before: n : ℕ+
h : n < 2
⊢ n = 1
state_after: case a
n : ℕ+
h : n < 2
⊢ n ≤ 1

case a
n : ℕ+
h : n < 2
⊢ 1 ≤ n

tactic: swap
state_before: case a
n : ℕ+
h : n < 2
⊢ n ≤ 1

case a
n : ℕ+
h : n < 2
⊢ 1 ≤ n
state_after: case a
n : ℕ+
h : n < 2
⊢ 1 ≤ n

case a
n : ℕ+
h : n < 2
⊢ n ≤ 1

tactic: apply PNat.one_le
state_before: case a
n : ℕ+
h : n < 2
⊢ 1 ≤ n
state_after: no goals

tactic: exact PNat.lt_add_one_iff.1 h
state_before: case a
n : ℕ+
h : n < 2
⊢ n ≤ 1
state_after: no goals
Theorem: ModuleCat.Derivation.desc_d
File: Mathlib/Algebra/Category/ModuleCat/Differentials/Basic.lean

tactic: letI := f.toAlgebra
state_before: A B : CommRingCat
f : A ⟶ B
M : ModuleCat ↑B
D : M.Derivation f
b : ↑B
⊢ D.desc (CommRingCat.KaehlerDifferential.d b) = D.d b
state_after: A B : CommRingCat
f : A ⟶ B
M : ModuleCat ↑B
D : M.Derivation f
b : ↑B
this : Algebra ↑A ↑B := RingHom.toAlgebra f
⊢ D.desc (CommRingCat.KaehlerDifferential.d b) = D.d b

tactic: letI := Module.compHom M f
state_before: A B : CommRingCat
f : A ⟶ B
M : ModuleCat ↑B
D : M.Derivation f
b : ↑B
this : Algebra ↑A ↑B := RingHom.toAlgebra f
⊢ D.desc (CommRingCat.KaehlerDifferential.d b) = D.d b
state_after: A B : CommRingCat
f : A ⟶ B
M : ModuleCat ↑B
D : M.Derivation f
b : ↑B
this✝ : Algebra ↑A ↑B := RingHom.toAlgebra f
this : Module ↑A ↑M := Module.compHom (↑M) f
⊢ D.desc (CommRingCat.KaehlerDifferential.d b) = D.d b

tactic: apply D.liftKaehlerDifferential_comp_D
state_before: A B : CommRingCat
f : A ⟶ B
M : ModuleCat ↑B
D : M.Derivation f
b : ↑B
this✝ : Algebra ↑A ↑B := RingHom.toAlgebra f
this : Module ↑A ↑M := Module.compHom (↑M) f
⊢ D.desc (CommRingCat.KaehlerDifferential.d b) = D.d b
state_after: no goals
Theorem: List.unzip_zip_left
File: Mathlib/Data/List/Zip.lean

tactic: rw [eq_nil_of_length_eq_zero (Nat.eq_zero_of_le_zero h)]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
h : l₁.length ≤ [].length
⊢ (l₁.zip []).unzip.1 = l₁
state_after: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
h : l₁.length ≤ [].length
⊢ ([].zip []).unzip.1 = []

tactic: rfl
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l₁ : List α
h : l₁.length ≤ [].length
⊢ ([].zip []).unzip.1 = []
state_after: no goals

tactic: simp only [zip_cons_cons, unzip_cons, unzip_zip_left (le_of_succ_le_succ h)]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
a : α
l₁ : List α
b : β
l₂ : List β
h : (a :: l₁).length ≤ (b :: l₂).length
⊢ ((a :: l₁).zip (b :: l₂)).unzip.1 = a :: l₁
state_after: no goals
Theorem: CoxeterSystem.rightInvSeq_reverse
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

tactic: simp [leftInvSeq_eq_reverse_rightInvSeq_reverse]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ cs.rightInvSeq ω.reverse = (cs.leftInvSeq ω).reverse
state_after: no goals
Theorem: disjoint_principal_nhdsSet
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [disjoint_principal_left, ← subset_interior_iff_mem_nhdsSet, interior_compl,
  subset_compl_iff_disjoint_left]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
⊢ Disjoint (𝓟 s) (𝓝ˢ t) ↔ Disjoint (closure s) t
state_after: no goals
Theorem: List.getElem_eq_iff
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp only [get_eq_getElem, get?_eq_getElem?, getElem?_eq_some]
state_before: α : Type u_1
x : α
l : List α
n : Nat
h : n < l.length
⊢ l[n] = x ↔ l[n]? = some x
state_after: α : Type u_1
x : α
l : List α
n : Nat
h : n < l.length
⊢ l[n] = x ↔ ∃ h, l[n] = x

tactic: exact ⟨fun w => ⟨h, w⟩, fun h => h.2⟩
state_before: α : Type u_1
x : α
l : List α
n : Nat
h : n < l.length
⊢ l[n] = x ↔ ∃ h, l[n] = x
state_after: no goals
Theorem: HasDerivAt.lhopital_zero_nhds
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: apply @lhopital_zero_nhds' _ _ _ f' _ g' <;>
  (first | apply eventually_nhdsWithin_of_eventually_nhds |
    apply tendsto_nhdsWithin_of_tendsto_nhds) <;> assumption
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[≠] a) l
state_after: no goals

tactic: first | apply eventually_nhdsWithin_of_eventually_nhds |
 apply tendsto_nhdsWithin_of_tendsto_nhds
state_before: case hdiv
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ Tendsto (fun x => f' x / g' x) (𝓝[≠] a) l
state_after: case hdiv.h
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ Tendsto (fun x => f' x / g' x) (𝓝 a) l

tactic: apply eventually_nhdsWithin_of_eventually_nhds
state_before: case hg'
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ ∀ᶠ (x : ℝ) in 𝓝[≠] a, g' x ≠ 0
state_after: case hg'.h
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0

tactic: apply tendsto_nhdsWithin_of_tendsto_nhds
state_before: case hdiv
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ Tendsto (fun x => f' x / g' x) (𝓝[≠] a) l
state_after: case hdiv.h
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ Tendsto (fun x => f' x / g' x) (𝓝 a) l
Theorem: continuousWithinAt_congr_nhds
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [ContinuousWithinAt, h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s t : Set α
x : α
h : 𝓝[s] x = 𝓝[t] x
⊢ ContinuousWithinAt f s x ↔ ContinuousWithinAt f t x
state_after: no goals
Theorem: AlgebraicTopology.DoldKan.P_f_idem
File: Mathlib/AlgebraicTopology/DoldKan/Projections.lean

tactic: rcases n with (_|n)
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ (P q).f n ≫ (P q).f n = (P q).f n
state_after: case zero
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ (P q).f 0 ≫ (P q).f 0 = (P q).f 0

case succ
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ (P q).f (n + 1) ≫ (P q).f (n + 1) = (P q).f (n + 1)

tactic: rw [P_f_0_eq q, comp_id]
state_before: case zero
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ (P q).f 0 ≫ (P q).f 0 = (P q).f 0
state_after: no goals

tactic: exact (HigherFacesVanish.of_P q n).comp_P_eq_self
state_before: case succ
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
⊢ (P q).f (n + 1) ≫ (P q).f (n + 1) = (P q).f (n + 1)
state_after: no goals
Theorem: Nat.ModEq.mul_left'
File: Mathlib/Data/Nat/ModEq.lean

tactic: unfold ModEq at *
state_before: m n a b c✝ d c : ℕ
h : a ≡ b [MOD n]
⊢ c * a ≡ c * b [MOD c * n]
state_after: m n a b c✝ d c : ℕ
h : a % n = b % n
⊢ c * a % (c * n) = c * b % (c * n)

tactic: rw [mul_mod_mul_left, mul_mod_mul_left, h]
state_before: m n a b c✝ d c : ℕ
h : a % n = b % n
⊢ c * a % (c * n) = c * b % (c * n)
state_after: no goals
Theorem: Finset.Nonempty.csSup_mem
File: Mathlib/Order/ConditionallyCompleteLattice/Finset.lean

tactic: rw [h.csSup_eq_max']
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : ConditionallyCompleteLinearOrder α
s✝ t : Set α
a b : α
s : Finset α
h : s.Nonempty
⊢ sSup ↑s ∈ s
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : ConditionallyCompleteLinearOrder α
s✝ t : Set α
a b : α
s : Finset α
h : s.Nonempty
⊢ s.max' h ∈ s

tactic: exact s.max'_mem _
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : ConditionallyCompleteLinearOrder α
s✝ t : Set α
a b : α
s : Finset α
h : s.Nonempty
⊢ s.max' h ∈ s
state_after: no goals
Theorem: Subgroup.map_eq_comap_of_inverse
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: rw [coe_map, coe_comap, Set.image_eq_preimage_of_inverse hl hr]
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
f✝ f : G →* N
g : N →* G
hl : LeftInverse ⇑g ⇑f
hr : Function.RightInverse ⇑g ⇑f
H : Subgroup G
⊢ ↑(map f H) = ↑(comap g H)
state_after: no goals
Theorem: DiscreteQuotient.toSetoid_injective
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: congr
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
toSetoid✝¹ : Setoid X
isOpen_setOf_rel✝¹ : ∀ (x : X), IsOpen (setOf (toSetoid✝¹.Rel x))
toSetoid✝ : Setoid X
isOpen_setOf_rel✝ : ∀ (x : X), IsOpen (setOf (toSetoid✝.Rel x))
x✝ :
  { toSetoid := toSetoid✝¹, isOpen_setOf_rel := isOpen_setOf_rel✝¹ }.toSetoid =
    { toSetoid := toSetoid✝, isOpen_setOf_rel := isOpen_setOf_rel✝ }.toSetoid
⊢ { toSetoid := toSetoid✝¹, isOpen_setOf_rel := isOpen_setOf_rel✝¹ } =
    { toSetoid := toSetoid✝, isOpen_setOf_rel := isOpen_setOf_rel✝ }
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Pullback.t'_fst_fst_fst
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

tactic: simp only [t', Category.assoc, pullbackSymmetry_hom_comp_fst_assoc,
  pullbackRightPullbackFstIso_inv_snd_fst_assoc, pullback.lift_fst_assoc, t_fst_fst,
  pullbackRightPullbackFstIso_hom_fst_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ pullback.fst ≫ pullback.fst ≫ pullback.fst = pullback.fst ≫ pullback.snd
state_after: no goals
Theorem: Set.relatively_discrete_of_finite
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [← einfsep_pos]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : EMetricSpace α
x y z : α
s t : Set α
C : ℝ≥0∞
sC : Set ℝ≥0∞
inst✝ : Finite ↑s
⊢ ∃ C > 0, ∀ x ∈ s, ∀ y ∈ s, x ≠ y → C ≤ edist x y
state_after: α : Type u_1
β : Type u_2
inst✝¹ : EMetricSpace α
x y z : α
s t : Set α
C : ℝ≥0∞
sC : Set ℝ≥0∞
inst✝ : Finite ↑s
⊢ 0 < s.einfsep

tactic: exact einfsep_pos_of_finite
state_before: α : Type u_1
β : Type u_2
inst✝¹ : EMetricSpace α
x y z : α
s t : Set α
C : ℝ≥0∞
sC : Set ℝ≥0∞
inst✝ : Finite ↑s
⊢ 0 < s.einfsep
state_after: no goals
Theorem: List.formPerm_eq_one_iff
File: Mathlib/GroupTheory/Perm/List.lean

tactic: cases' l with hd tl
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
hl : l.Nodup
⊢ l.formPerm = 1 ↔ l.length ≤ 1
state_after: case nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x : α
hl : [].Nodup
⊢ [].formPerm = 1 ↔ [].length ≤ 1

case cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
⊢ (hd :: tl).formPerm = 1 ↔ (hd :: tl).length ≤ 1

tactic: simp
state_before: case nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x : α
hl : [].Nodup
⊢ [].formPerm = 1 ↔ [].length ≤ 1
state_after: no goals

tactic: rw [← formPerm_apply_mem_eq_self_iff _ hl hd (mem_cons_self _ _)]
state_before: case cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
⊢ (hd :: tl).formPerm = 1 ↔ (hd :: tl).length ≤ 1
state_after: case cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
⊢ (hd :: tl).formPerm = 1 ↔ (hd :: tl).formPerm hd = hd

tactic: constructor
state_before: case cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
⊢ (hd :: tl).formPerm = 1 ↔ (hd :: tl).formPerm hd = hd
state_after: case cons.mp
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
⊢ (hd :: tl).formPerm = 1 → (hd :: tl).formPerm hd = hd

case cons.mpr
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
⊢ (hd :: tl).formPerm hd = hd → (hd :: tl).formPerm = 1

tactic: simp (config := { contextual := true })
state_before: case cons.mp
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
⊢ (hd :: tl).formPerm = 1 → (hd :: tl).formPerm hd = hd
state_after: no goals

tactic: intro h
state_before: case cons.mpr
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
⊢ (hd :: tl).formPerm hd = hd → (hd :: tl).formPerm = 1
state_after: case cons.mpr
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
h : (hd :: tl).formPerm hd = hd
⊢ (hd :: tl).formPerm = 1

tactic: simp only [(hd :: tl).formPerm_apply_mem_eq_self_iff hl hd (mem_cons_self hd tl),
  add_le_iff_nonpos_left, length, nonpos_iff_eq_zero, length_eq_zero] at h
state_before: case cons.mpr
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
h : (hd :: tl).formPerm hd = hd
⊢ (hd :: tl).formPerm = 1
state_after: case cons.mpr
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
h : tl = []
⊢ (hd :: tl).formPerm = 1

tactic: simp [h]
state_before: case cons.mpr
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
h : tl = []
⊢ (hd :: tl).formPerm = 1
state_after: no goals
Theorem: Matrix.natCast_kronecker_natCast
File: Mathlib/Data/Matrix/Kronecker.lean

tactic: simp_rw [← Nat.cast_mul]
state_before: R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝² : NonAssocSemiring α
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
a b : ℕ
⊢ (diagonal fun mn => ↑a * ↑b) = ↑(a * b)
state_after: R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝² : NonAssocSemiring α
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
a b : ℕ
⊢ (diagonal fun mn => ↑(a * b)) = ↑(a * b)

tactic: rfl
state_before: R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝² : NonAssocSemiring α
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
a b : ℕ
⊢ (diagonal fun mn => ↑(a * b)) = ↑(a * b)
state_after: no goals
Theorem: PartialEquiv.mem_symm_trans_source
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: rwa [mem_preimage, PartialEquiv.symm_symm, e.left_inv he]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e'✝ : PartialEquiv β γ
e' : PartialEquiv α γ
x : α
he : x ∈ e.source
he' : x ∈ e'.source
⊢ ↑e x ∈ ↑e.symm.symm.symm ⁻¹' e'.source
state_after: no goals
Theorem: LinearOrder.supClosed
File: Mathlib/Order/SupClosed.lean

tactic: cases le_total a b <;> simp [*]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrder α
s : Set α
a : α
ha : a ∈ s
b : α
hb : b ∈ s
⊢ a ⊔ b ∈ s
state_after: no goals
Theorem: Finset.le_card_add_mul_mulEnergy
File: Mathlib/Combinatorics/Additive/Energy.lean

tactic: rw [filter_eq_self.2, card_product, mul_pow]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ s.card ^ 2 * t.card ^ 2 =
    (filter
          (fun x =>
            match x with
            | (a, b) => a * b ∈ s * t)
          (s ×ˢ t)).card ^
      2
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ ∀ x ∈ s ×ˢ t,
    match x with
    | (a, b) => a * b ∈ s * t

tactic: aesop (add unsafe mul_mem_mul)
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ ∀ x ∈ s ×ˢ t,
    match x with
    | (a, b) => a * b ∈ s * t
state_after: no goals
Theorem: variationOnFromTo.eq_left_iff
File: Mathlib/Analysis/BoundedVariation.lean

tactic: simp only [← variationOnFromTo.add hf ha hb hc, self_eq_add_right]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f✝ : α → E
s✝ : Set α
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
⊢ variationOnFromTo f s a b = variationOnFromTo f s a c ↔ variationOnFromTo f s b c = 0
state_after: no goals
Theorem: MeasureTheory.JordanDecomposition.real_smul_posPart_nonneg
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: rw [real_smul_def, ← smul_posPart, if_pos hr]
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ
hr : 0 ≤ r
⊢ (r • j).posPart = r.toNNReal • j.posPart
state_after: no goals