1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ContextFreeRule.Rewrites.exists_parts
File: Mathlib/Computability/ContextFreeGrammar.lean

tactic: induction hyp with
| head s =>
  use [], s
  simp
| cons x _ ih =>
  rcases ih with ⟨p', q', rfl, rfl⟩
  use x :: p', q'
  simp
state_before: T : Type uT
N : Type uN
r : ContextFreeRule T N
u v : List (Symbol T N)
hyp : r.Rewrites u v
⊢ ∃ p q, u = p ++ [Symbol.nonterminal r.input] ++ q ∧ v = p ++ r.output ++ q
state_after: no goals

tactic: use [], s
state_before: case head
T : Type uT
N : Type uN
r : ContextFreeRule T N
u v s : List (Symbol T N)
⊢ ∃ p q, Symbol.nonterminal r.input :: s = p ++ [Symbol.nonterminal r.input] ++ q ∧ r.output ++ s = p ++ r.output ++ q
state_after: case h
T : Type uT
N : Type uN
r : ContextFreeRule T N
u v s : List (Symbol T N)
⊢ Symbol.nonterminal r.input :: s = [] ++ [Symbol.nonterminal r.input] ++ s ∧ r.output ++ s = [] ++ r.output ++ s

tactic: simp
state_before: case h
T : Type uT
N : Type uN
r : ContextFreeRule T N
u v s : List (Symbol T N)
⊢ Symbol.nonterminal r.input :: s = [] ++ [Symbol.nonterminal r.input] ++ s ∧ r.output ++ s = [] ++ r.output ++ s
state_after: no goals

tactic: rcases ih with ⟨p', q', rfl, rfl⟩
state_before: case cons
T : Type uT
N : Type uN
r : ContextFreeRule T N
u v : List (Symbol T N)
x : Symbol T N
s₁✝ s₂✝ : List (Symbol T N)
hrs✝ : r.Rewrites s₁✝ s₂✝
ih : ∃ p q, s₁✝ = p ++ [Symbol.nonterminal r.input] ++ q ∧ s₂✝ = p ++ r.output ++ q
⊢ ∃ p q, x :: s₁✝ = p ++ [Symbol.nonterminal r.input] ++ q ∧ x :: s₂✝ = p ++ r.output ++ q
state_after: case cons.intro.intro.intro
T : Type uT
N : Type uN
r : ContextFreeRule T N
u v : List (Symbol T N)
x : Symbol T N
p' q' : List (Symbol T N)
hrs✝ : r.Rewrites (p' ++ [Symbol.nonterminal r.input] ++ q') (p' ++ r.output ++ q')
⊢ ∃ p q,
    x :: (p' ++ [Symbol.nonterminal r.input] ++ q') = p ++ [Symbol.nonterminal r.input] ++ q ∧
      x :: (p' ++ r.output ++ q') = p ++ r.output ++ q

tactic: use x :: p', q'
state_before: case cons.intro.intro.intro
T : Type uT
N : Type uN
r : ContextFreeRule T N
u v : List (Symbol T N)
x : Symbol T N
p' q' : List (Symbol T N)
hrs✝ : r.Rewrites (p' ++ [Symbol.nonterminal r.input] ++ q') (p' ++ r.output ++ q')
⊢ ∃ p q,
    x :: (p' ++ [Symbol.nonterminal r.input] ++ q') = p ++ [Symbol.nonterminal r.input] ++ q ∧
      x :: (p' ++ r.output ++ q') = p ++ r.output ++ q
state_after: case h
T : Type uT
N : Type uN
r : ContextFreeRule T N
u v : List (Symbol T N)
x : Symbol T N
p' q' : List (Symbol T N)
hrs✝ : r.Rewrites (p' ++ [Symbol.nonterminal r.input] ++ q') (p' ++ r.output ++ q')
⊢ x :: (p' ++ [Symbol.nonterminal r.input] ++ q') = x :: p' ++ [Symbol.nonterminal r.input] ++ q' ∧
    x :: (p' ++ r.output ++ q') = x :: p' ++ r.output ++ q'

tactic: simp
state_before: case h
T : Type uT
N : Type uN
r : ContextFreeRule T N
u v : List (Symbol T N)
x : Symbol T N
p' q' : List (Symbol T N)
hrs✝ : r.Rewrites (p' ++ [Symbol.nonterminal r.input] ++ q') (p' ++ r.output ++ q')
⊢ x :: (p' ++ [Symbol.nonterminal r.input] ++ q') = x :: p' ++ [Symbol.nonterminal r.input] ++ q' ∧
    x :: (p' ++ r.output ++ q') = x :: p' ++ r.output ++ q'
state_after: no goals
Theorem: Polynomial.Monic.mul_natDegree_lt_iff
File: Mathlib/Algebra/Polynomial/Monic.lean

tactic: by_cases hq : q = 0
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : p.Monic
q : R[X]
⊢ (p * q).natDegree < p.natDegree ↔ p ≠ 1 ∧ q = 0
state_after: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : p.Monic
q : R[X]
hq : q = 0
⊢ (p * q).natDegree < p.natDegree ↔ p ≠ 1 ∧ q = 0

case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : p.Monic
q : R[X]
hq : ¬q = 0
⊢ (p * q).natDegree < p.natDegree ↔ p ≠ 1 ∧ q = 0

tactic: suffices 0 < p.natDegree ↔ p.natDegree ≠ 0 by simpa [hq, ← h.natDegree_eq_zero_iff_eq_one]
state_before: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : p.Monic
q : R[X]
hq : q = 0
⊢ (p * q).natDegree < p.natDegree ↔ p ≠ 1 ∧ q = 0
state_after: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : p.Monic
q : R[X]
hq : q = 0
⊢ 0 < p.natDegree ↔ p.natDegree ≠ 0

tactic: exact ⟨fun h => h.ne', fun h => lt_of_le_of_ne (Nat.zero_le _) h.symm⟩
state_before: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : p.Monic
q : R[X]
hq : q = 0
⊢ 0 < p.natDegree ↔ p.natDegree ≠ 0
state_after: no goals

tactic: simpa [hq, ← h.natDegree_eq_zero_iff_eq_one]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : p.Monic
q : R[X]
hq : q = 0
this : 0 < p.natDegree ↔ p.natDegree ≠ 0
⊢ (p * q).natDegree < p.natDegree ↔ p ≠ 1 ∧ q = 0
state_after: no goals

tactic: simp [h.natDegree_mul', hq]
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : p.Monic
q : R[X]
hq : ¬q = 0
⊢ (p * q).natDegree < p.natDegree ↔ p ≠ 1 ∧ q = 0
state_after: no goals
Theorem: SetTheory.PGame.neg_le_zero_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [neg_le_iff, neg_zero]
state_before: xl xr : Type u
x : PGame
⊢ -x ≤ 0 ↔ 0 ≤ x
state_after: no goals
Theorem: LieIdeal.killingForm_eq
File: Mathlib/Algebra/Lie/TraceForm.lean

tactic: simp
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
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
inst✝⁵ : Module.Free R M
inst✝⁴ : Module.Finite R M
inst✝³ : Module.Free R L
inst✝² : Module.Finite R L
I : LieIdeal R L
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
⊢ I ≤ LieSubmodule.idealizer I
state_after: no goals
Theorem: ENNReal.le_of_forall_pos_le_add
File: Mathlib/Data/ENNReal/Basic.lean

tactic: contrapose! h
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : ∀ (ε : ℝ≥0), 0 < ε → b < ⊤ → a ≤ b + ↑ε
⊢ a ≤ b
state_after: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : b < a
⊢ ∃ ε, 0 < ε ∧ b < ⊤ ∧ b + ↑ε < a

tactic: rcases lt_iff_exists_add_pos_lt.1 h with ⟨r, hr0, hr⟩
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : b < a
⊢ ∃ ε, 0 < ε ∧ b < ⊤ ∧ b + ↑ε < a
state_after: case intro.intro
α : Type u_1
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
h : b < a
r : ℝ≥0
hr0 : 0 < r
hr : b + ↑r < a
⊢ ∃ ε, 0 < ε ∧ b < ⊤ ∧ b + ↑ε < a

tactic: exact ⟨r, hr0, h.trans_le le_top, hr⟩
state_before: case intro.intro
α : Type u_1
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
h : b < a
r : ℝ≥0
hr0 : 0 < r
hr : b + ↑r < a
⊢ ∃ ε, 0 < ε ∧ b < ⊤ ∧ b + ↑ε < a
state_after: no goals
Theorem: Nat.prod_range_succ_factorial
File: Mathlib/Data/Nat/Factorial/SuperFactorial.lean

tactic: rw [prod_range_succ, prod_range_succ_factorial n, mul_comm, superFactorial]
state_before: n✝ n : ℕ
⊢ ∏ x ∈ range (n + 1 + 1), x ! = sf n + 1
state_after: no goals
Theorem: IntermediateField.normalClosure_def''
File: Mathlib/FieldTheory/NormalClosure.lean

tactic: refine (normalClosure_def' K).trans (le_antisymm (iSup_le (fun f ↦ ?_)) (iSup_le (fun f ↦ ?_)))
state_before: F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
⊢ normalClosure F (↥K) L = ⨆ f, map (↑f) K
state_after: case refine_1
F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
f : L →ₐ[F] L
⊢ map f K ≤ ⨆ f, map (↑f) K

case refine_2
F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
f : L ≃ₐ[F] L
⊢ map (↑f) K ≤ ⨆ f, map f K

tactic: exact le_iSup_of_le (f.restrictNormal' L)
  (fun b ⟨a, h⟩ ↦ ⟨a, h.1, h.2 ▸ f.restrictNormal_commutes L a⟩)
state_before: case refine_1
F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
f : L →ₐ[F] L
⊢ map f K ≤ ⨆ f, map (↑f) K
state_after: no goals

tactic: exact le_iSup_of_le f le_rfl
state_before: case refine_2
F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
f : L ≃ₐ[F] L
⊢ map (↑f) K ≤ ⨆ f, map f K
state_after: no goals
Theorem: Submodule.mapQ_id
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: rw [comap_id]
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
⊢ p ≤ comap LinearMap.id p
state_after: no goals

tactic: ext
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
h : optParam (p ≤ comap LinearMap.id p) ⋯
⊢ p.mapQ p LinearMap.id h = LinearMap.id
state_after: case h.h
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
h : optParam (p ≤ comap LinearMap.id p) ⋯
x✝ : M
⊢ (p.mapQ p LinearMap.id h ∘ₗ p.mkQ) x✝ = (LinearMap.id ∘ₗ p.mkQ) x✝

tactic: simp
state_before: case h.h
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
h : optParam (p ≤ comap LinearMap.id p) ⋯
x✝ : M
⊢ (p.mapQ p LinearMap.id h ∘ₗ p.mkQ) x✝ = (LinearMap.id ∘ₗ p.mkQ) x✝
state_after: no goals
Theorem: derivWithin_congr
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: unfold derivWithin
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 𝕜
hs : EqOn f₁ f s
hx : f₁ x = f x
⊢ derivWithin f₁ s x = derivWithin f s x
state_after: 𝕜 : 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 𝕜
hs : EqOn f₁ f s
hx : f₁ x = f x
⊢ (fderivWithin 𝕜 f₁ s x) 1 = (fderivWithin 𝕜 f s x) 1

tactic: rw [fderivWithin_congr hs hx]
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 𝕜
hs : EqOn f₁ f s
hx : f₁ x = f x
⊢ (fderivWithin 𝕜 f₁ s x) 1 = (fderivWithin 𝕜 f s x) 1
state_after: no goals
Theorem: Nat.bit1_inj
File: Mathlib/Init/Data/Nat/Lemmas.lean

tactic: simp [Nat.bit1_eq_succ_bit0] at h
state_before: n m : ℕ
h : bit1 n = bit1 m
⊢ (bit0 n).succ = (bit0 m).succ
state_after: n m : ℕ
h : bit0 n = bit0 m
⊢ (bit0 n).succ = (bit0 m).succ

tactic: rw [h]
state_before: n m : ℕ
h : bit0 n = bit0 m
⊢ (bit0 n).succ = (bit0 m).succ
state_after: no goals

tactic: injection this
state_before: n m : ℕ
h : bit1 n = bit1 m
this : (bit0 n).succ = (bit0 m).succ
⊢ bit0 n = bit0 m
state_after: no goals
Theorem: Set.Ico_union_right
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: simpa only [dual_Ioc, dual_Icc] using Ioc_union_left hab.dual
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
hab : a ≤ b
⊢ Ico a b ∪ {b} = Icc a b
state_after: no goals
Theorem: Antitone.map_sSup_le
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [sSup_eq_iSup]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Antitone f
⊢ f (sSup s) ≤ ⨅ a ∈ s, f a
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Antitone f
⊢ f (⨆ a ∈ s, a) ≤ ⨅ a ∈ s, f a

tactic: exact hf.map_iSup₂_le _
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Antitone f
⊢ f (⨆ a ∈ s, a) ≤ ⨅ a ∈ s, f a
state_after: no goals
Theorem: List.diff_erase
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: rw [← diff_cons_right, diff_cons]
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List α
a : α
⊢ (l₁.diff l₂).erase a = (l₁.erase a).diff l₂
state_after: no goals
Theorem: RCLike.abs_im_le_norm
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: rw [mul_self_le_mul_self_iff (abs_nonneg _) (norm_nonneg _), abs_mul_abs_self, mul_self_norm]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ |im z| ≤ ‖z‖
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ im z * im z ≤ normSq z

tactic: apply im_sq_le_normSq
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ im z * im z ≤ normSq z
state_after: no goals
Theorem: Class.ofSet.inj
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: change (x : Class.{u}) z ↔ (y : Class.{u}) z
state_before: x y : ZFSet
h : ↑x = ↑y
z : ZFSet
⊢ z ∈ x ↔ z ∈ y
state_after: x y : ZFSet
h : ↑x = ↑y
z : ZFSet
⊢ ↑x z ↔ ↑y z

tactic: rw [h]
state_before: x y : ZFSet
h : ↑x = ↑y
z : ZFSet
⊢ ↑x z ↔ ↑y z
state_after: no goals
Theorem: Polynomial.binomial_eq_binomial
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: simp_rw [C_mul_X_pow_eq_monomial, ← toFinsupp_inj, toFinsupp_add, toFinsupp_monomial]
state_before: R : Type u
a b : R
m✝ n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
k l m n : ℕ
u v : R
hu : u ≠ 0
hv : v ≠ 0
⊢ C u * X ^ k + C v * X ^ l = C u * X ^ m + C v * X ^ n ↔
    k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u + v = 0 ∧ k = l ∧ m = n
state_after: R : Type u
a b : R
m✝ n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
k l m n : ℕ
u v : R
hu : u ≠ 0
hv : v ≠ 0
⊢ Finsupp.single k u + Finsupp.single l v = Finsupp.single m u + Finsupp.single n v ↔
    k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u + v = 0 ∧ k = l ∧ m = n

tactic: exact Finsupp.single_add_single_eq_single_add_single hu hv
state_before: R : Type u
a b : R
m✝ n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
k l m n : ℕ
u v : R
hu : u ≠ 0
hv : v ≠ 0
⊢ Finsupp.single k u + Finsupp.single l v = Finsupp.single m u + Finsupp.single n v ↔
    k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u + v = 0 ∧ k = l ∧ m = n
state_after: no goals
Theorem: eventuallyEq_zero_nhds
File: Mathlib/Topology/Basic.lean

tactic: rw [← mem_compl_iff, ← interior_compl, mem_interior_iff_mem_nhds, Function.compl_support,
  EventuallyEq, eventually_iff]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
f✝ : X → Y
s : Set X
x : X
y : Y
M₀ : Type u_4
inst✝ : Zero M₀
f : X → M₀
⊢ f =ᶠ[𝓝 x] 0 ↔ x ∉ closure (Function.support f)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
f✝ : X → Y
s : Set X
x : X
y : Y
M₀ : Type u_4
inst✝ : Zero M₀
f : X → M₀
⊢ {x | f x = 0 x} ∈ 𝓝 x ↔ {x | f x = 0} ∈ 𝓝 x

tactic: simp only [Pi.zero_apply]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
f✝ : X → Y
s : Set X
x : X
y : Y
M₀ : Type u_4
inst✝ : Zero M₀
f : X → M₀
⊢ {x | f x = 0 x} ∈ 𝓝 x ↔ {x | f x = 0} ∈ 𝓝 x
state_after: no goals
Theorem: Cardinal.exists_eq_of_iSup_eq_of_not_isSuccLimit
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: subst h
state_before: α β ι : Type u
f : ι → Cardinal.{v}
ω : Cardinal.{v}
hω : ¬IsSuccLimit ω
h : ⨆ i, f i = ω
⊢ ∃ i, f i = ω
state_after: α β ι : Type u
f : ι → Cardinal.{v}
hω : ¬IsSuccLimit (⨆ i, f i)
⊢ ∃ i, f i = ⨆ i, f i

tactic: refine (isLUB_csSup' ?_).exists_of_not_isSuccLimit hω
state_before: α β ι : Type u
f : ι → Cardinal.{v}
hω : ¬IsSuccLimit (⨆ i, f i)
⊢ ∃ i, f i = ⨆ i, f i
state_after: α β ι : Type u
f : ι → Cardinal.{v}
hω : ¬IsSuccLimit (⨆ i, f i)
⊢ BddAbove (range f)

tactic: contrapose! hω with hf
state_before: α β ι : Type u
f : ι → Cardinal.{v}
hω : ¬IsSuccLimit (⨆ i, f i)
⊢ BddAbove (range f)
state_after: α β ι : Type u
f : ι → Cardinal.{v}
hf : ¬BddAbove (range f)
⊢ IsSuccLimit (⨆ i, f i)

tactic: rw [iSup, csSup_of_not_bddAbove hf, csSup_empty]
state_before: α β ι : Type u
f : ι → Cardinal.{v}
hf : ¬BddAbove (range f)
⊢ IsSuccLimit (⨆ i, f i)
state_after: α β ι : Type u
f : ι → Cardinal.{v}
hf : ¬BddAbove (range f)
⊢ IsSuccLimit ⊥

tactic: exact Order.isSuccLimit_bot
state_before: α β ι : Type u
f : ι → Cardinal.{v}
hf : ¬BddAbove (range f)
⊢ IsSuccLimit ⊥
state_after: no goals
Theorem: SetTheory.PGame.add_moveRight_inr
File: Mathlib/SetTheory/Game/PGame.lean

tactic: cases x
state_before: xl xr : Type u
x y : PGame
i : y.RightMoves
⊢ (x + y).moveRight (toRightMovesAdd (Sum.inr i)) = x + y.moveRight i
state_after: case mk
xl xr : Type u
y : PGame
i : y.RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝ β✝ a✝¹ a✝ + y).moveRight (toRightMovesAdd (Sum.inr i)) = mk α✝ β✝ a✝¹ a✝ + y.moveRight i

tactic: cases y
state_before: case mk
xl xr : Type u
y : PGame
i : y.RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝ β✝ a✝¹ a✝ + y).moveRight (toRightMovesAdd (Sum.inr i)) = mk α✝ β✝ a✝¹ a✝ + y.moveRight i
state_after: case mk.mk
xl xr : Type u
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesAdd (Sum.inr i)) =
    mk α✝¹ β✝¹ a✝³ a✝² + (mk α✝ β✝ a✝¹ a✝).moveRight i

tactic: rfl
state_before: case mk.mk
xl xr : Type u
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesAdd (Sum.inr i)) =
    mk α✝¹ β✝¹ a✝³ a✝² + (mk α✝ β✝ a✝¹ a✝).moveRight i
state_after: no goals
Theorem: Polynomial.Gal.ext
File: Mathlib/FieldTheory/PolynomialGaloisGroup.lean

tactic: refine
  AlgEquiv.ext fun x =>
    (AlgHom.mem_equalizer σ.toAlgHom τ.toAlgHom x).mp
      ((SetLike.ext_iff.mp ?_ x).mpr Algebra.mem_top)
state_before: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
σ τ : p.Gal
h : ∀ x ∈ p.rootSet p.SplittingField, σ x = τ x
⊢ σ = τ
state_after: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
σ τ : p.Gal
h : ∀ x ∈ p.rootSet p.SplittingField, σ x = τ x
x : p.SplittingField
⊢ (↑σ).equalizer ↑τ = ⊤

tactic: rwa [eq_top_iff, ← SplittingField.adjoin_rootSet, Algebra.adjoin_le_iff]
state_before: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
σ τ : p.Gal
h : ∀ x ∈ p.rootSet p.SplittingField, σ x = τ x
x : p.SplittingField
⊢ (↑σ).equalizer ↑τ = ⊤
state_after: no goals
Theorem: MeasureTheory.smulInvariantMeasure_map
File: Mathlib/MeasureTheory/Group/Action.lean

tactic: rw [preimage_preimage]
state_before: G : Type u
M✝ : Type v
α✝ : Type w
s : Set α✝
M : Type uM
N : Type uN
α : Type uα
β : Type uβ
inst✝⁷ : MeasurableSpace M
inst✝⁶ : MeasurableSpace N
inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : SMul M α
inst✝² : SMul M β
inst✝¹ : MeasurableSMul M β
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
f : α → β
hsmul : ∀ (m : M) (a : α), f (m • a) = m • f a
hf : Measurable f
m : M
S : Set β
hS : MeasurableSet S
⊢ μ (f ⁻¹' ((fun x => m • x) ⁻¹' S)) = μ ((fun x => m • f x) ⁻¹' S)
state_after: no goals

tactic: simp_rw [hsmul]
state_before: G : Type u
M✝ : Type v
α✝ : Type w
s : Set α✝
M : Type uM
N : Type uN
α : Type uα
β : Type uβ
inst✝⁷ : MeasurableSpace M
inst✝⁶ : MeasurableSpace N
inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : SMul M α
inst✝² : SMul M β
inst✝¹ : MeasurableSMul M β
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
f : α → β
hsmul : ∀ (m : M) (a : α), f (m • a) = m • f a
hf : Measurable f
m : M
S : Set β
hS : MeasurableSet S
⊢ μ ((fun x => m • f x) ⁻¹' S) = μ ((fun x => f (m • x)) ⁻¹' S)
state_after: no goals

tactic: rw [← preimage_preimage]
state_before: G : Type u
M✝ : Type v
α✝ : Type w
s : Set α✝
M : Type uM
N : Type uN
α : Type uα
β : Type uβ
inst✝⁷ : MeasurableSpace M
inst✝⁶ : MeasurableSpace N
inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : SMul M α
inst✝² : SMul M β
inst✝¹ : MeasurableSMul M β
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
f : α → β
hsmul : ∀ (m : M) (a : α), f (m • a) = m • f a
hf : Measurable f
m : M
S : Set β
hS : MeasurableSet S
⊢ μ ((fun x => f (m • x)) ⁻¹' S) = μ ((fun x => m • x) ⁻¹' (f ⁻¹' S))
state_after: no goals

tactic: rw [SMulInvariantMeasure.measure_preimage_smul m (hS.preimage hf)]
state_before: G : Type u
M✝ : Type v
α✝ : Type w
s : Set α✝
M : Type uM
N : Type uN
α : Type uα
β : Type uβ
inst✝⁷ : MeasurableSpace M
inst✝⁶ : MeasurableSpace N
inst✝⁵ : MeasurableSpace α
inst✝⁴ : MeasurableSpace β
inst✝³ : SMul M α
inst✝² : SMul M β
inst✝¹ : MeasurableSMul M β
μ : Measure α
inst✝ : SMulInvariantMeasure M α μ
f : α → β
hsmul : ∀ (m : M) (a : α), f (m • a) = m • f a
hf : Measurable f
m : M
S : Set β
hS : MeasurableSet S
⊢ μ ((fun x => m • x) ⁻¹' (f ⁻¹' S)) = μ (f ⁻¹' S)
state_after: no goals
Theorem: Finset.erase_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a✝ b a : α
⊢ {a}.erase a = ∅
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a✝ b a x : α
⊢ x ∈ {a}.erase a ↔ x ∈ ∅

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a✝ b a x : α
⊢ x ∈ {a}.erase a ↔ x ∈ ∅
state_after: no goals
Theorem: Sum.LiftRel.isLeft_congr
File: Mathlib/Data/Sum/Basic.lean

tactic: cases h <;> rfl
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
h : LiftRel r s x y
⊢ x.isLeft = true ↔ y.isLeft = true
state_after: no goals
Theorem: LinearIsometry.re_apply_eq_re
File: Mathlib/Analysis/Complex/Isometry.lean

tactic: apply LinearIsometry.re_apply_eq_re_of_add_conj_eq
state_before: f : ℂ →ₗᵢ[ℝ] ℂ
h : f 1 = 1
z : ℂ
⊢ (f z).re = z.re
state_after: case h₃
f : ℂ →ₗᵢ[ℝ] ℂ
h : f 1 = 1
z : ℂ
⊢ ∀ (z : ℂ), z + (starRingEnd ℂ) z = f z + (starRingEnd ℂ) (f z)

tactic: intro z
state_before: case h₃
f : ℂ →ₗᵢ[ℝ] ℂ
h : f 1 = 1
z : ℂ
⊢ ∀ (z : ℂ), z + (starRingEnd ℂ) z = f z + (starRingEnd ℂ) (f z)
state_after: case h₃
f : ℂ →ₗᵢ[ℝ] ℂ
h : f 1 = 1
z✝ z : ℂ
⊢ z + (starRingEnd ℂ) z = f z + (starRingEnd ℂ) (f z)

tactic: apply LinearIsometry.im_apply_eq_im h
state_before: case h₃
f : ℂ →ₗᵢ[ℝ] ℂ
h : f 1 = 1
z✝ z : ℂ
⊢ z + (starRingEnd ℂ) z = f z + (starRingEnd ℂ) (f z)
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.map_addXYZ
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: simp_rw [addXYZ, comp_fin3, map_addX, map_addY, map_addZ]
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
⊢ addXYZ (map W' f) (⇑f ∘ P) (⇑f ∘ Q) = ⇑f ∘ W'.addXYZ P Q
state_after: no goals