1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsAdjoinRoot.eval₂_repr_eq_eval₂_of_map_eq
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: rw [eq_comm, ← sub_eq_zero, ← h.map_repr z, ← map_sub, h.map_eq_zero_iff] at hzw
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : S
w : R[X]
hzw : h.map w = z
⊢ eval₂ i x (h.repr z) = eval₂ i x w
state_after: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : S
w : R[X]
hzw : f ∣ h.repr z - w
⊢ eval₂ i x (h.repr z) = eval₂ i x w

tactic: obtain ⟨y, hy⟩ := hzw
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : S
w : R[X]
hzw : f ∣ h.repr z - w
⊢ eval₂ i x (h.repr z) = eval₂ i x w
state_after: case intro
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : S
w y : R[X]
hy : h.repr z - w = f * y
⊢ eval₂ i x (h.repr z) = eval₂ i x w

tactic: rw [← sub_eq_zero, ← eval₂_sub, hy, eval₂_mul, hx, zero_mul]
state_before: case intro
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
T : Type u_1
inst✝ : CommRing T
i : R →+* T
x : T
hx : eval₂ i x f = 0
h : IsAdjoinRoot S f
z : S
w y : R[X]
hy : h.repr z - w = f * y
⊢ eval₂ i x (h.repr z) = eval₂ i x w
state_after: no goals
Theorem: Fin.le_val_last
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [Fin.natCast_eq_last]
state_before: n m : ℕ
i : Fin (n + 1)
⊢ i ≤ ↑n
state_after: n m : ℕ
i : Fin (n + 1)
⊢ i ≤ last n

tactic: exact Fin.le_last i
state_before: n m : ℕ
i : Fin (n + 1)
⊢ i ≤ last n
state_after: no goals
Theorem: ProbabilityTheory.kernel.fst_zero
File: Mathlib/Probability/Kernel/Composition.lean

tactic: simp [fst]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
δ : Type u_4
mδ : MeasurableSpace δ
γ : Type u_5
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
⊢ fst 0 = 0
state_after: no goals
Theorem: Finset.not_mem_sdiff_of_not_mem_left
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∉ s
⊢ a ∉ s \ t
state_after: no goals
Theorem: MeasureTheory.upcrossingsBefore_le
File: Mathlib/Probability/Martingale/Upcrossing.lean

tactic: by_cases hN : N = 0
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
N n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
⊢ upcrossingsBefore a b f N ω ≤ N
state_after: case pos
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
N n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
hN : N = 0
⊢ upcrossingsBefore a b f N ω ≤ N

case neg
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
N n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
hN : ¬N = 0
⊢ upcrossingsBefore a b f N ω ≤ N

tactic: subst hN
state_before: case pos
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
N n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
hN : N = 0
⊢ upcrossingsBefore a b f N ω ≤ N
state_after: case pos
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
⊢ upcrossingsBefore a b f 0 ω ≤ 0

tactic: rw [upcrossingsBefore_zero]
state_before: case pos
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
⊢ upcrossingsBefore a b f 0 ω ≤ 0
state_after: no goals

tactic: refine csSup_le ⟨0, zero_lt_iff.2 hN⟩ fun n (hn : _ < N) => ?_
state_before: case neg
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
N n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
hN : ¬N = 0
⊢ upcrossingsBefore a b f N ω ≤ N
state_after: case neg
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
N n✝ m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
hN : ¬N = 0
n : ℕ
hn : upperCrossingTime a b f N n ω < N
⊢ n ≤ N

tactic: by_contra hnN
state_before: case neg
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
N n✝ m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
hN : ¬N = 0
n : ℕ
hn : upperCrossingTime a b f N n ω < N
⊢ n ≤ N
state_after: case neg
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
N n✝ m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
hN : ¬N = 0
n : ℕ
hn : upperCrossingTime a b f N n ω < N
hnN : ¬n ≤ N
⊢ False

tactic: exact hn.ne (upperCrossingTime_eq_of_bound_le hab (not_le.1 hnN).le)
state_before: case neg
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f✝ : ℕ → Ω → ℝ
N n✝ m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
hab : a < b
hN : ¬N = 0
n : ℕ
hn : upperCrossingTime a b f N n ω < N
hnN : ¬n ≤ N
⊢ False
state_after: no goals
Theorem: Polynomial.natDegree_sub_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: simpa only [← natDegree_neg q] using natDegree_add_le p (-q)
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
⊢ (p - q).natDegree ≤ max p.natDegree q.natDegree
state_after: no goals
Theorem: List.insertNth_injective
File: Mathlib/Data/List/InsertNth.lean

tactic: induction' n with n IH
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
n : ℕ
x : α
⊢ Injective (insertNth n x)
state_after: case zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a x : α
⊢ Injective (insertNth 0 x)

case succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a x : α
n : ℕ
IH : Injective (insertNth n x)
⊢ Injective (insertNth (n + 1) x)

tactic: have : insertNth 0 x = cons x := funext fun _ => rfl
state_before: case zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a x : α
⊢ Injective (insertNth 0 x)
state_after: case zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a x : α
this : insertNth 0 x = cons x
⊢ Injective (insertNth 0 x)

tactic: simp [this]
state_before: case zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a x : α
this : insertNth 0 x = cons x
⊢ Injective (insertNth 0 x)
state_after: no goals

tactic: rintro (_ | ⟨a, as⟩) (_ | ⟨b, bs⟩) h <;> simpa [IH.eq_iff] using h
state_before: case succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a x : α
n : ℕ
IH : Injective (insertNth n x)
⊢ Injective (insertNth (n + 1) x)
state_after: no goals
Theorem: CauSeq.mul_equiv_zero
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: simpa
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
g f : CauSeq β abv
hf : f ≈ 0
this : (f - 0).LimZero
⊢ f.LimZero
state_after: no goals

tactic: simpa
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
g f : CauSeq β abv
hf : f ≈ 0
this✝ : (f - 0).LimZero
this : (g * f).LimZero
⊢ (g * f - 0).LimZero
state_after: no goals
Theorem: EReal.coe_ennreal_mul
File: Mathlib/Data/Real/EReal.lean

tactic: rw [mul_comm, coe_ennreal_top_mul, EReal.mul_comm, coe_ennreal_top]
state_before: x : ℝ≥0
⊢ ↑(↑x * ⊤) = ↑↑x * ↑⊤
state_after: no goals

tactic: simp only [← ENNReal.coe_mul, coe_nnreal_eq_coe_real, NNReal.coe_mul, EReal.coe_mul]
state_before: x y : ℝ≥0
⊢ ↑(↑x * ↑y) = ↑↑x * ↑↑y
state_after: no goals
Theorem: LieModule.coe_weightSpaceOf_zero
File: Mathlib/Algebra/Lie/Weights/Basic.lean

tactic: simp [weightSpaceOf, Module.End.maxGenEigenspace]
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ ↑(weightSpaceOf M 0 x) = ⨆ k, LinearMap.ker ((toEnd R L M) x ^ k)
state_after: no goals
Theorem: CategoryTheory.Functor.essImage.unit_isIso
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

tactic: rwa [isIso_unit_app_iff_mem_essImage]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
A : C
h : A ∈ i.essImage
⊢ IsIso ((reflectorAdjunction i).unit.app A)
state_after: no goals
Theorem: CategoryTheory.Limits.HasImage.uniq
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp [w]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : X ⟶ Y
inst✝ : HasImage f
F' : MonoFactorisation f
l : image f ⟶ F'.I
w : l ≫ F'.m = image.ι f
⊢ l ≫ F'.m = image.lift F' ≫ F'.m
state_after: no goals
Theorem: LinearMap.toMatrix₂_apply
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: simp only [LinearMap.toMatrix₂, LinearEquiv.trans_apply, LinearMap.toMatrix₂'_apply,
  LinearEquiv.trans_apply, LinearMap.toMatrix₂'_apply, LinearEquiv.arrowCongr_apply,
  Basis.equivFun_symm_stdBasis, LinearEquiv.refl_apply]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
M : Type u_4
M₁ : Type u_5
M₂ : Type u_6
M₁' : Type u_7
M₂' : Type u_8
n : Type u_9
m : Type u_10
n' : Type u_11
m' : Type u_12
ι : Type u_13
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : Module R M₁
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
B : M₁ →ₗ[R] M₂ →ₗ[R] R
i : n
j : m
⊢ (toMatrix₂ b₁ b₂) B i j = (B (b₁ i)) (b₂ j)
state_after: no goals
Theorem: Matrix.fromBlocks_add
File: Mathlib/Data/Matrix/Block.lean

tactic: ext i j
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝ : Add α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
A' : Matrix n l α
B' : Matrix n m α
C' : Matrix o l α
D' : Matrix o m α
⊢ fromBlocks A B C D + fromBlocks A' B' C' D' = fromBlocks (A + A') (B + B') (C + C') (D + D')
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝ : Add α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
A' : Matrix n l α
B' : Matrix n m α
C' : Matrix o l α
D' : Matrix o m α
i : n ⊕ o
j : l ⊕ m
⊢ (fromBlocks A B C D + fromBlocks A' B' C' D') i j = fromBlocks (A + A') (B + B') (C + C') (D + D') i j

tactic: rcases i with ⟨⟩ <;> rcases j with ⟨⟩ <;> rfl
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝ : Add α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
A' : Matrix n l α
B' : Matrix n m α
C' : Matrix o l α
D' : Matrix o m α
i : n ⊕ o
j : l ⊕ m
⊢ (fromBlocks A B C D + fromBlocks A' B' C' D') i j = fromBlocks (A + A') (B + B') (C + C') (D + D') i j
state_after: no goals
Theorem: Action.leftDual_ρ
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

tactic: rw [← SingleObj.inv_as_inv]
state_before: V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ (ᘁX).ρ h = ᘁX.ρ h⁻¹
state_after: V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ (ᘁX).ρ h = ᘁX.ρ (inv h)

case x
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ SingleObj H.1

case y
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ SingleObj H.1

tactic: rfl
state_before: V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ (ᘁX).ρ h = ᘁX.ρ (inv h)

case x
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ SingleObj H.1

case y
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : LeftRigidCategory V
h : ↑H
⊢ SingleObj H.1
state_after: no goals
Theorem: Nat.coprime_self_sub_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [Coprime, Coprime, gcd_self_sub_left h]
state_before: m n : ℕ
h : m ≤ n
⊢ (n - m).Coprime n ↔ m.Coprime n
state_after: no goals
Theorem: ZMod.isQuadratic_χ₄
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: unfold MulChar.IsQuadratic
state_before: ⊢ χ₄.IsQuadratic
state_after: ⊢ ∀ (a : ZMod 4), χ₄ a = 0 ∨ χ₄ a = 1 ∨ χ₄ a = -1

tactic: decide
state_before: ⊢ ∀ (a : ZMod 4), χ₄ a = 0 ∨ χ₄ a = 1 ∨ χ₄ a = -1
state_after: no goals
Theorem: Finset.eq_of_veq
File: Mathlib/Data/Finset/Basic.lean

tactic: cases h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
nodup✝¹ : s.Nodup
t : Multiset α
nodup✝ : t.Nodup
h : { val := s, nodup := nodup✝¹ }.val = { val := t, nodup := nodup✝ }.val
⊢ { val := s, nodup := nodup✝¹ } = { val := t, nodup := nodup✝ }
state_after: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
nodup✝¹ nodup✝ : s.Nodup
⊢ { val := s, nodup := nodup✝¹ } = { val := s, nodup := nodup✝ }

tactic: rfl
state_before: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
nodup✝¹ nodup✝ : s.Nodup
⊢ { val := s, nodup := nodup✝¹ } = { val := s, nodup := nodup✝ }
state_after: no goals
Theorem: Rat.pow_def
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [Nat.pow_eq_zero]
state_before: q✝ q : ℚ
n : ℕ
⊢ q.den ^ n ≠ 0
state_after: no goals

tactic: rw [Int.natAbs_pow]
state_before: q✝ q : ℚ
n : ℕ
⊢ (q.num ^ n).natAbs.Coprime (q.den ^ n)
state_after: q✝ q : ℚ
n : ℕ
⊢ (q.num.natAbs ^ n).Coprime (q.den ^ n)

tactic: exact q.reduced.pow _ _
state_before: q✝ q : ℚ
n : ℕ
⊢ (q.num.natAbs ^ n).Coprime (q.den ^ n)
state_after: no goals
Theorem: Sym2.gameAdd_iff
File: Mathlib/Order/GameAdd.lean

tactic: rintro ⟨_, _⟩ ⟨_, _⟩
state_before: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a : α
b : β
⊢ ∀ {x y : α × α}, GameAdd rα (Sym2.mk x) (Sym2.mk y) ↔ Prod.GameAdd rα rα x y ∨ Prod.GameAdd rα rα x.swap y
state_after: case mk.mk
α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a : α
b : β
fst✝¹ snd✝¹ fst✝ snd✝ : α
⊢ GameAdd rα s(fst✝¹, snd✝¹) s(fst✝, snd✝) ↔
    Prod.GameAdd rα rα (fst✝¹, snd✝¹) (fst✝, snd✝) ∨ Prod.GameAdd rα rα (fst✝¹, snd✝¹).swap (fst✝, snd✝)

tactic: rfl
state_before: case mk.mk
α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a : α
b : β
fst✝¹ snd✝¹ fst✝ snd✝ : α
⊢ GameAdd rα s(fst✝¹, snd✝¹) s(fst✝, snd✝) ↔
    Prod.GameAdd rα rα (fst✝¹, snd✝¹) (fst✝, snd✝) ∨ Prod.GameAdd rα rα (fst✝¹, snd✝¹).swap (fst✝, snd✝)
state_after: no goals
Theorem: List.reduceOption_cons_of_none
File: Mathlib/Data/List/ReduceOption.lean

tactic: simp only [reduceOption, filterMap, id]
state_before: α : Type u_1
β : Type u_2
l : List (Option α)
⊢ (none :: l).reduceOption = l.reduceOption
state_after: no goals
Theorem: Primrec.of_equiv_symm_iff
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_1
β✝ : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β✝
inst✝ : Primcodable σ
β : Type u_4
e : β ≃ α
f : σ → α
this : Primcodable β := Primcodable.ofEquiv α e
h : Primrec fun a => e.symm (f a)
a : σ
⊢ e (e.symm (f a)) = f a
state_after: no goals
Theorem: norm_div_rev
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [dist_eq_norm_div] using dist_comm a b
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ ‖a / b‖ = ‖b / a‖
state_after: no goals
Theorem: CategoryTheory.Limits.isIso_π_of_isInitial
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: ext
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u
inst✝¹ : Category.{v, u} J
j : J
I : IsInitial j
F : J ⥤ C
inst✝ : HasLimit F
⊢ limit.π F j ≫ limit.lift F (coneOfDiagramInitial I F) = 𝟙 (limit F)
state_after: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u
inst✝¹ : Category.{v, u} J
j : J
I : IsInitial j
F : J ⥤ C
inst✝ : HasLimit F
j✝ : J
⊢ (limit.π F j ≫ limit.lift F (coneOfDiagramInitial I F)) ≫ limit.π F j✝ = 𝟙 (limit F) ≫ limit.π F j✝

tactic: simp
state_before: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u
inst✝¹ : Category.{v, u} J
j : J
I : IsInitial j
F : J ⥤ C
inst✝ : HasLimit F
j✝ : J
⊢ (limit.π F j ≫ limit.lift F (coneOfDiagramInitial I F)) ≫ limit.π F j✝ = 𝟙 (limit F) ≫ limit.π F j✝
state_after: no goals

tactic: simp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
J : Type u
inst✝¹ : Category.{v, u} J
j : J
I : IsInitial j
F : J ⥤ C
inst✝ : HasLimit F
⊢ limit.lift F (coneOfDiagramInitial I F) ≫ limit.π F j = 𝟙 (F.obj j)
state_after: no goals
Theorem: AnalyticAt.order_eq_top_iff
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

tactic: unfold order
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
⊢ hf.order = ⊤ ↔ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0
state_after: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
⊢ (if h : ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0 then ⊤ else ↑⋯.choose) = ⊤ ↔ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0

tactic: split_ifs with h
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
⊢ (if h : ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0 then ⊤ else ↑⋯.choose) = ⊤ ↔ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0
state_after: case pos
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
h : ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0
⊢ ⊤ = ⊤ ↔ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0

case neg
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
h : ¬∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0
⊢ ↑⋯.choose = ⊤ ↔ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0

tactic: rwa [eq_self, true_iff]
state_before: case pos
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
h : ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0
⊢ ⊤ = ⊤ ↔ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0
state_after: no goals

tactic: simpa only [ne_eq, ENat.coe_ne_top, false_iff] using h
state_before: case neg
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
h : ¬∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0
⊢ ↑⋯.choose = ⊤ ↔ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0
state_after: no goals
Theorem: finAddFlip_apply_natAdd
File: Mathlib/Logic/Equiv/Fin.lean

tactic: simp [finAddFlip]
state_before: m✝ n : ℕ
k : Fin n
m : ℕ
⊢ finAddFlip (Fin.natAdd m k) = Fin.castAdd m k
state_after: no goals
Theorem: CategoryTheory.CosimplicialObject.δ_comp_σ_self
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.δ i.castSucc ≫ X.σ i = 𝟙 (X.obj [n])
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.map (SimplexCategory.δ i.castSucc) ≫ X.map (SimplexCategory.σ i) = 𝟙 (X.obj [n])

tactic: simp only [← X.map_comp, SimplexCategory.δ_comp_σ_self, X.map_id]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.map (SimplexCategory.δ i.castSucc) ≫ X.map (SimplexCategory.σ i) = 𝟙 (X.obj [n])
state_after: no goals
Theorem: Set.nonempty_of_encard_ne_zero
File: Mathlib/Data/Set/Card.lean

tactic: rwa [nonempty_iff_ne_empty, Ne, ← encard_eq_zero]
state_before: α : Type u_1
β : Type u_2
s t : Set α
h : s.encard ≠ 0
⊢ s.Nonempty
state_after: no goals
Theorem: nhdsSet_le_iff
File: Mathlib/Topology/Separation.lean

tactic: refine ⟨?_, fun h => monotone_nhdsSet h⟩
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
⊢ 𝓝ˢ s ≤ 𝓝ˢ t ↔ s ⊆ t
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
⊢ 𝓝ˢ s ≤ 𝓝ˢ t → s ⊆ t

tactic: simp_rw [Filter.le_def]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
⊢ 𝓝ˢ s ≤ 𝓝ˢ t → s ⊆ t
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
⊢ (∀ x ∈ 𝓝ˢ t, x ∈ 𝓝ˢ s) → s ⊆ t

tactic: intro h x hx
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
⊢ (∀ x ∈ 𝓝ˢ t, x ∈ 𝓝ˢ s) → s ⊆ t
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
h : ∀ x ∈ 𝓝ˢ t, x ∈ 𝓝ˢ s
x : X
hx : x ∈ s
⊢ x ∈ t

tactic: specialize h {x}ᶜ
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
h : ∀ x ∈ 𝓝ˢ t, x ∈ 𝓝ˢ s
x : X
hx : x ∈ s
⊢ x ∈ t
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
x : X
hx : x ∈ s
h : {x}ᶜ ∈ 𝓝ˢ t → {x}ᶜ ∈ 𝓝ˢ s
⊢ x ∈ t

tactic: simp_rw [compl_singleton_mem_nhdsSet_iff] at h
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
x : X
hx : x ∈ s
h : {x}ᶜ ∈ 𝓝ˢ t → {x}ᶜ ∈ 𝓝ˢ s
⊢ x ∈ t
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
x : X
hx : x ∈ s
h : x ∉ t → x ∉ s
⊢ x ∈ t

tactic: by_contra hxt
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
x : X
hx : x ∈ s
h : x ∉ t → x ∉ s
⊢ x ∈ t
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
x : X
hx : x ∈ s
h : x ∉ t → x ∉ s
hxt : x ∉ t
⊢ False

tactic: exact h hxt hx
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
s t : Set X
x : X
hx : x ∈ s
h : x ∉ t → x ∉ s
hxt : x ∉ t
⊢ False
state_after: no goals