1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: FirstOrder.Language.DirectLimit.Equiv_isup_symm_inclusion_apply
File: Mathlib/ModelTheory/DirectLimit.lean

tactic: apply (Equiv_iSup S).injective
state_before: L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : Nonempty ι
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
M : Type u_1
N : Type u_2
inst✝¹ : L.Structure M
inst✝ : L.Structure N
S : ι →o L.Substructure M
i : ι
x : ↥(S i)
⊢ (Equiv_iSup S).symm ((Substructure.inclusion ⋯) x) =
    (of L ι (fun x => ↥(S x)) (fun x x_1 h => Substructure.inclusion ⋯) i) x
state_after: case a
L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : Nonempty ι
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
M : Type u_1
N : Type u_2
inst✝¹ : L.Structure M
inst✝ : L.Structure N
S : ι →o L.Substructure M
i : ι
x : ↥(S i)
⊢ (Equiv_iSup S) ((Equiv_iSup S).symm ((Substructure.inclusion ⋯) x)) =
    (Equiv_iSup S) ((of L ι (fun x => ↥(S x)) (fun x x_1 h => Substructure.inclusion ⋯) i) x)

tactic: simp only [Equiv.apply_symm_apply]
state_before: case a
L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : Nonempty ι
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
M : Type u_1
N : Type u_2
inst✝¹ : L.Structure M
inst✝ : L.Structure N
S : ι →o L.Substructure M
i : ι
x : ↥(S i)
⊢ (Equiv_iSup S) ((Equiv_iSup S).symm ((Substructure.inclusion ⋯) x)) =
    (Equiv_iSup S) ((of L ι (fun x => ↥(S x)) (fun x x_1 h => Substructure.inclusion ⋯) i) x)
state_after: case a
L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : Nonempty ι
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
M : Type u_1
N : Type u_2
inst✝¹ : L.Structure M
inst✝ : L.Structure N
S : ι →o L.Substructure M
i : ι
x : ↥(S i)
⊢ (Substructure.inclusion ⋯) x =
    (Equiv_iSup S) ((of L ι (fun x => ↥(S x)) (fun x x_1 h => Substructure.inclusion ⋯) i) x)

tactic: rfl
state_before: case a
L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : Nonempty ι
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
M : Type u_1
N : Type u_2
inst✝¹ : L.Structure M
inst✝ : L.Structure N
S : ι →o L.Substructure M
i : ι
x : ↥(S i)
⊢ (Substructure.inclusion ⋯) x =
    (Equiv_iSup S) ((of L ι (fun x => ↥(S x)) (fun x x_1 h => Substructure.inclusion ⋯) i) x)
state_after: no goals
Theorem: Monotone.map_sup
File: Mathlib/Order/Lattice.lean

tactic: simp only [h, hf h, sup_of_le_right]
state_before: α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : SemilatticeSup β
f : α → β
hf : Monotone f
x y : α
h : x ≤ y
⊢ f (x ⊔ y) = f x ⊔ f y
state_after: no goals

tactic: simp only [h, hf h, sup_of_le_left]
state_before: α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : SemilatticeSup β
f : α → β
hf : Monotone f
x y : α
h : y ≤ x
⊢ f (x ⊔ y) = f x ⊔ f y
state_after: no goals
Theorem: RatFunc.map_apply
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: rw [← num_div_denom f, map_apply_div_ne_zero, num_div_denom f]
state_before: K : Type u
inst✝⁴ : Field K
R : Type u_1
F : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F K[X] R[X]
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
f : RatFunc K
⊢ (map φ hφ) f = (algebraMap R[X] (RatFunc R)) (φ f.num) / (algebraMap R[X] (RatFunc R)) (φ f.denom)
state_after: case hq
K : Type u
inst✝⁴ : Field K
R : Type u_1
F : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F K[X] R[X]
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
f : RatFunc K
⊢ f.denom ≠ 0

tactic: exact denom_ne_zero _
state_before: case hq
K : Type u
inst✝⁴ : Field K
R : Type u_1
F : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F K[X] R[X]
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
f : RatFunc K
⊢ f.denom ≠ 0
state_after: no goals
Theorem: List.lookmap_congr
File: Mathlib/Data/List/Basic.lean

tactic: cases' forall_mem_cons.1 H with H₁ H₂
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f✝ f g : α → Option α
a : α
l : List α
H : ∀ (a_1 : α), a_1 ∈ a :: l → f a_1 = g a_1
⊢ lookmap f (a :: l) = lookmap g (a :: l)
state_after: case intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f✝ f g : α → Option α
a : α
l : List α
H : ∀ (a_1 : α), a_1 ∈ a :: l → f a_1 = g a_1
H₁ : f a = g a
H₂ : ∀ (x : α), x ∈ l → f x = g x
⊢ lookmap f (a :: l) = lookmap g (a :: l)

tactic: cases' h : g a with b
state_before: case intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f✝ f g : α → Option α
a : α
l : List α
H : ∀ (a_1 : α), a_1 ∈ a :: l → f a_1 = g a_1
H₁ : f a = g a
H₂ : ∀ (x : α), x ∈ l → f x = g x
⊢ lookmap f (a :: l) = lookmap g (a :: l)
state_after: case intro.none
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f✝ f g : α → Option α
a : α
l : List α
H : ∀ (a_1 : α), a_1 ∈ a :: l → f a_1 = g a_1
H₁ : f a = g a
H₂ : ∀ (x : α), x ∈ l → f x = g x
h : g a = none
⊢ lookmap f (a :: l) = lookmap g (a :: l)

case intro.some
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f✝ f g : α → Option α
a : α
l : List α
H : ∀ (a_1 : α), a_1 ∈ a :: l → f a_1 = g a_1
H₁ : f a = g a
H₂ : ∀ (x : α), x ∈ l → f x = g x
b : α
h : g a = some b
⊢ lookmap f (a :: l) = lookmap g (a :: l)

tactic: simp [h, H₁.trans h, lookmap_congr H₂]
state_before: case intro.none
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f✝ f g : α → Option α
a : α
l : List α
H : ∀ (a_1 : α), a_1 ∈ a :: l → f a_1 = g a_1
H₁ : f a = g a
H₂ : ∀ (x : α), x ∈ l → f x = g x
h : g a = none
⊢ lookmap f (a :: l) = lookmap g (a :: l)
state_after: no goals

tactic: simp [lookmap_cons_some _ _ h, lookmap_cons_some _ _ (H₁.trans h)]
state_before: case intro.some
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f✝ f g : α → Option α
a : α
l : List α
H : ∀ (a_1 : α), a_1 ∈ a :: l → f a_1 = g a_1
H₁ : f a = g a
H₂ : ∀ (x : α), x ∈ l → f x = g x
b : α
h : g a = some b
⊢ lookmap f (a :: l) = lookmap g (a :: l)
state_after: no goals
Theorem: EReal.add_pos
File: Mathlib/Data/Real/EReal.lean

tactic: induction a
state_before: a b : EReal
ha : 0 < a
hb : 0 < b
⊢ 0 < a + b
state_after: case h_bot
b : EReal
hb : 0 < b
ha : 0 < ⊥
⊢ 0 < ⊥ + b

case h_real
b : EReal
hb : 0 < b
a✝ : ℝ
ha : 0 < ↑a✝
⊢ 0 < ↑a✝ + b

case h_top
b : EReal
hb : 0 < b
ha : 0 < ⊤
⊢ 0 < ⊤ + b

tactic: exfalso
state_before: case h_bot
b : EReal
hb : 0 < b
ha : 0 < ⊥
⊢ 0 < ⊥ + b
state_after: case h_bot
b : EReal
hb : 0 < b
ha : 0 < ⊥
⊢ False

tactic: exact not_lt_bot ha
state_before: case h_bot
b : EReal
hb : 0 < b
ha : 0 < ⊥
⊢ False
state_after: no goals

tactic: induction b
state_before: case h_real
b : EReal
hb : 0 < b
a✝ : ℝ
ha : 0 < ↑a✝
⊢ 0 < ↑a✝ + b
state_after: case h_real.h_bot
a✝ : ℝ
ha : 0 < ↑a✝
hb : 0 < ⊥
⊢ 0 < ↑a✝ + ⊥

case h_real.h_real
a✝¹ : ℝ
ha : 0 < ↑a✝¹
a✝ : ℝ
hb : 0 < ↑a✝
⊢ 0 < ↑a✝¹ + ↑a✝

case h_real.h_top
a✝ : ℝ
ha : 0 < ↑a✝
hb : 0 < ⊤
⊢ 0 < ↑a✝ + ⊤

tactic: exfalso
state_before: case h_real.h_bot
a✝ : ℝ
ha : 0 < ↑a✝
hb : 0 < ⊥
⊢ 0 < ↑a✝ + ⊥
state_after: case h_real.h_bot
a✝ : ℝ
ha : 0 < ↑a✝
hb : 0 < ⊥
⊢ False

tactic: exact not_lt_bot hb
state_before: case h_real.h_bot
a✝ : ℝ
ha : 0 < ↑a✝
hb : 0 < ⊥
⊢ False
state_after: no goals

tactic: norm_cast at *
state_before: case h_real.h_real
a✝¹ : ℝ
ha : 0 < ↑a✝¹
a✝ : ℝ
hb : 0 < ↑a✝
⊢ 0 < ↑a✝¹ + ↑a✝
state_after: case h_real.h_real
a✝¹ a✝ : ℝ
ha : 0 < a✝¹
hb : 0 < a✝
⊢ 0 < a✝¹ + a✝

tactic: exact Left.add_pos ha hb
state_before: case h_real.h_real
a✝¹ a✝ : ℝ
ha : 0 < a✝¹
hb : 0 < a✝
⊢ 0 < a✝¹ + a✝
state_after: no goals

tactic: exact add_top_of_ne_bot (bot_lt_zero.trans ha).ne' ▸ hb
state_before: case h_real.h_top
a✝ : ℝ
ha : 0 < ↑a✝
hb : 0 < ⊤
⊢ 0 < ↑a✝ + ⊤
state_after: no goals

tactic: rw [top_add_of_ne_bot (bot_lt_zero.trans hb).ne']
state_before: case h_top
b : EReal
hb : 0 < b
ha : 0 < ⊤
⊢ 0 < ⊤ + b
state_after: case h_top
b : EReal
hb : 0 < b
ha : 0 < ⊤
⊢ 0 < ⊤

tactic: exact ha
state_before: case h_top
b : EReal
hb : 0 < b
ha : 0 < ⊤
⊢ 0 < ⊤
state_after: no goals
Theorem: IsFractionRing.num_mul_den_eq_num_iff_eq
File: Mathlib/RingTheory/Localization/NumDen.lean

tactic: simpa only [mk'_num_den] using eq_mk'_iff_mul_eq.mpr h
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x y : K
h : x * (algebraMap A K) ↑(den A y) = (algebraMap A K) (num A y)
⊢ x = y
state_after: no goals

tactic: rw [h, mk'_num_den]
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x y : K
h : x = y
⊢ x = mk' K (num A y) (den A y)
state_after: no goals
Theorem: LinearMap.isNilRegular_iff_coeff_polyCharpoly_nilRank_ne_zero
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

tactic: rw [IsNilRegular, polyCharpoly_coeff_eval]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
n : Type u_4
ι : Type u_5
ι' : Type u_6
ιM : Type u_7
inst✝¹⁴ : CommRing R
inst✝¹³ : AddCommGroup L
inst✝¹² : Module R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : Module R M
φ : L →ₗ[R] Module.End R M
inst✝⁹ : Fintype ι
inst✝⁸ : Fintype ι'
inst✝⁷ : Fintype ιM
inst✝⁶ : DecidableEq ι
inst✝⁵ : DecidableEq ι'
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
b : Basis ι R L
inst✝² : Module.Finite R L
inst✝¹ : Module.Free R L
inst✝ : Nontrivial R
x : L
⊢ φ.IsNilRegular x ↔ (MvPolynomial.eval ⇑(b.repr x)) ((φ.polyCharpoly b).coeff φ.nilRank) ≠ 0
state_after: no goals
Theorem: Real.sqrt_lt_sqrt_iff_of_pos
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [Real.sqrt, Real.sqrt, NNReal.coe_lt_coe, NNReal.sqrt_lt_sqrt, toNNReal_lt_toNNReal_iff hy]
state_before: x y : ℝ
hy : 0 < y
⊢ √x < √y ↔ x < y
state_after: no goals
Theorem: Cardinal.mk_preimage_of_injective_of_subset_range
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: convert mk_preimage_of_injective_of_subset_range_lift.{u, u} f s h h2 using 1 <;> rw [lift_id]
state_before: α β : Type u
c : Cardinal.{?u.230365}
f : α → β
s : Set β
h : Injective f
h2 : s ⊆ range f
⊢ #↑(f ⁻¹' s) = #↑s
state_after: no goals
Theorem: Submodule.comap_zero
File: Mathlib/Algebra/Module/Submodule/Map.lean

tactic: simp
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : Module R M
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p p' : Submodule R M
q q' : Submodule R₂ M₂
x : M
σ₂₁ : R₂ →+* R
inst✝³ : RingHomInvPair σ₁₂ σ₂₁
inst✝² : RingHomInvPair σ₂₁ σ₁₂
F : Type u_9
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
⊢ ∀ (x : M), x ∈ comap 0 q ↔ x ∈ ⊤
state_after: no goals
Theorem: iter_deriv_pow
File: Mathlib/Analysis/Calculus/Deriv/ZPow.lean

tactic: simp only [← zpow_natCast, iter_deriv_zpow, Int.cast_natCast]
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m : ℤ
n : ℕ
x : 𝕜
k : ℕ
⊢ deriv^[k] (fun x => x ^ n) x = (∏ i ∈ Finset.range k, (↑n - ↑i)) * x ^ (n - k)
state_after: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m : ℤ
n : ℕ
x : 𝕜
k : ℕ
⊢ (∏ x ∈ Finset.range k, (↑n - ↑x)) * x ^ (↑n - ↑k) = (∏ i ∈ Finset.range k, (↑n - ↑i)) * x ^ ↑(n - k)

tactic: rcases le_or_lt k n with hkn | hnk
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m : ℤ
n : ℕ
x : 𝕜
k : ℕ
⊢ (∏ x ∈ Finset.range k, (↑n - ↑x)) * x ^ (↑n - ↑k) = (∏ i ∈ Finset.range k, (↑n - ↑i)) * x ^ ↑(n - k)
state_after: case inl
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m : ℤ
n : ℕ
x : 𝕜
k : ℕ
hkn : k ≤ n
⊢ (∏ x ∈ Finset.range k, (↑n - ↑x)) * x ^ (↑n - ↑k) = (∏ i ∈ Finset.range k, (↑n - ↑i)) * x ^ ↑(n - k)

case inr
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m : ℤ
n : ℕ
x : 𝕜
k : ℕ
hnk : n < k
⊢ (∏ x ∈ Finset.range k, (↑n - ↑x)) * x ^ (↑n - ↑k) = (∏ i ∈ Finset.range k, (↑n - ↑i)) * x ^ ↑(n - k)

tactic: rw [Int.ofNat_sub hkn]
state_before: case inl
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m : ℤ
n : ℕ
x : 𝕜
k : ℕ
hkn : k ≤ n
⊢ (∏ x ∈ Finset.range k, (↑n - ↑x)) * x ^ (↑n - ↑k) = (∏ i ∈ Finset.range k, (↑n - ↑i)) * x ^ ↑(n - k)
state_after: no goals

tactic: have : (∏ i ∈ Finset.range k, (n - i : 𝕜)) = 0 :=
  Finset.prod_eq_zero (Finset.mem_range.2 hnk) (sub_self _)
state_before: case inr
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m : ℤ
n : ℕ
x : 𝕜
k : ℕ
hnk : n < k
⊢ (∏ x ∈ Finset.range k, (↑n - ↑x)) * x ^ (↑n - ↑k) = (∏ i ∈ Finset.range k, (↑n - ↑i)) * x ^ ↑(n - k)
state_after: case inr
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m : ℤ
n : ℕ
x : 𝕜
k : ℕ
hnk : n < k
this : ∏ i ∈ Finset.range k, (↑n - ↑i) = 0
⊢ (∏ x ∈ Finset.range k, (↑n - ↑x)) * x ^ (↑n - ↑k) = (∏ i ∈ Finset.range k, (↑n - ↑i)) * x ^ ↑(n - k)

tactic: simp only [this, zero_mul]
state_before: case inr
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m : ℤ
n : ℕ
x : 𝕜
k : ℕ
hnk : n < k
this : ∏ i ∈ Finset.range k, (↑n - ↑i) = 0
⊢ (∏ x ∈ Finset.range k, (↑n - ↑x)) * x ^ (↑n - ↑k) = (∏ i ∈ Finset.range k, (↑n - ↑i)) * x ^ ↑(n - k)
state_after: no goals
Theorem: closure_union
File: Mathlib/Topology/Basic.lean

tactic: simp [closure_eq_compl_interior_compl, compl_inter]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ closure (s ∪ t) = closure s ∪ closure t
state_after: no goals
Theorem: IsWellOrderLimitElement.bot_lt
File: Mathlib/Order/IsWellOrderLimitElement.lean

tactic: obtain h|h := eq_or_lt_of_le (@bot_le _ _ _ a)
state_before: α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
a : α
ha : IsWellOrderLimitElement a
inst✝ : OrderBot α
⊢ ⊥ < a
state_after: case inl
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
a : α
ha : IsWellOrderLimitElement a
inst✝ : OrderBot α
h : ⊥ = a
⊢ ⊥ < a

case inr
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
a : α
ha : IsWellOrderLimitElement a
inst✝ : OrderBot α
h : ⊥ < a
⊢ ⊥ < a

tactic: exact (IsWellOrderLimitElement.neq_bot a h.symm).elim
state_before: case inl
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
a : α
ha : IsWellOrderLimitElement a
inst✝ : OrderBot α
h : ⊥ = a
⊢ ⊥ < a
state_after: no goals

tactic: exact h
state_before: case inr
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
a : α
ha : IsWellOrderLimitElement a
inst✝ : OrderBot α
h : ⊥ < a
⊢ ⊥ < a
state_after: no goals
Theorem: Path.trans_prod_eq_prod_trans
File: Mathlib/Topology/Connected/PathConnected.lean

tactic: ext t <;>
unfold Path.trans <;>
simp only [Path.coe_mk_mk, Path.prod_coe, Function.comp_apply] <;>
split_ifs <;>
rfl
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
a₁ a₂ a₃ : X
b₁ b₂ b₃ : Y
γ₁ : Path a₁ a₂
δ₁ : Path a₂ a₃
γ₂ : Path b₁ b₂
δ₂ : Path b₂ b₃
⊢ (γ₁.prod γ₂).trans (δ₁.prod δ₂) = (γ₁.trans δ₁).prod (γ₂.trans δ₂)
state_after: no goals
Theorem: Substring.ValidFor.atEnd
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [Substring.atEnd, Pos.ext_iff, Nat.add_left_cancel_iff]
state_before: l m r : List Char
p : Nat
⊢ { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.atEnd
        { byteIdx := p } =
      true ↔
    p = utf8Len m
state_after: no goals
Theorem: Finset.Nonempty.zero_div
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simpa [mem_div] using hs
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : GroupWithZero α
s t : Finset α
hs : s.Nonempty
⊢ 0 ⊆ 0 / s
state_after: no goals
Theorem: Fintype.eval_image_piFinset_const
File: Mathlib/Data/Fintype/Pi.lean

tactic: obtain rfl | ht := t.eq_empty_or_nonempty
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
β : Type u_4
inst✝ : DecidableEq β
t : Finset β
a : α
⊢ image (fun f => f a) (piFinset fun _i => t) = t
state_after: case inl
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
β : Type u_4
inst✝ : DecidableEq β
a : α
⊢ image (fun f => f a) (piFinset fun _i => ∅) = ∅

case inr
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
β : Type u_4
inst✝ : DecidableEq β
t : Finset β
a : α
ht : t.Nonempty
⊢ image (fun f => f a) (piFinset fun _i => t) = t

tactic: haveI : Nonempty α := ⟨a⟩
state_before: case inl
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
β : Type u_4
inst✝ : DecidableEq β
a : α
⊢ image (fun f => f a) (piFinset fun _i => ∅) = ∅
state_after: case inl
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
β : Type u_4
inst✝ : DecidableEq β
a : α
this : Nonempty α
⊢ image (fun f => f a) (piFinset fun _i => ∅) = ∅

tactic: simp
state_before: case inl
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
β : Type u_4
inst✝ : DecidableEq β
a : α
this : Nonempty α
⊢ image (fun f => f a) (piFinset fun _i => ∅) = ∅
state_after: no goals

tactic: exact eval_image_piFinset (fun _ ↦ t) a fun _ _ ↦ ht
state_before: case inr
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
β : Type u_4
inst✝ : DecidableEq β
t : Finset β
a : α
ht : t.Nonempty
⊢ image (fun f => f a) (piFinset fun _i => t) = t
state_after: no goals
Theorem: affineIndependent_of_ne_of_not_mem_of_mem_of_mem
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: rw [← affineIndependent_equiv (Equiv.swap (0 : Fin 3) 2)]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : p₁ ∉ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k ![p₁, p₂, p₃]
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : p₁ ∉ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 0 2))

tactic: convert affineIndependent_of_ne_of_mem_of_mem_of_not_mem hp₂p₃.symm hp₃ hp₂ hp₁ using 1
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : p₁ ∉ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 0 2))
state_after: case h.e'_9
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : p₁ ∉ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ ![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 0 2) = ![p₃, p₂, p₁]

tactic: ext x
state_before: case h.e'_9
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : p₁ ∉ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ ![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 0 2) = ![p₃, p₂, p₁]
state_after: case h.e'_9.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : p₁ ∉ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
x : Fin 3
⊢ (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 0 2)) x = ![p₃, p₂, p₁] x

tactic: fin_cases x <;> rfl
state_before: case h.e'_9.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : p₁ ∉ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
x : Fin 3
⊢ (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 0 2)) x = ![p₃, p₂, p₁] x
state_after: no goals
Theorem: Polynomial.trailingDegree_eq_iff_natTrailingDegree_eq_of_pos
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

tactic: rw [natTrailingDegree, ENat.toNat_eq_iff hn]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hn : n ≠ 0
⊢ p.trailingDegree = ↑n ↔ p.natTrailingDegree = n
state_after: no goals
Theorem: Equiv.Perm.partition_eq_of_isConj
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [isConj_iff_cycleType_eq]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
⊢ IsConj σ τ ↔ σ.partition = τ.partition
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
⊢ σ.cycleType = τ.cycleType ↔ σ.partition = τ.partition

tactic: refine ⟨fun h => ?_, fun h => ?_⟩
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
⊢ σ.cycleType = τ.cycleType ↔ σ.partition = τ.partition
state_after: case refine_1
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : σ.cycleType = τ.cycleType
⊢ σ.partition = τ.partition

case refine_2
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : σ.partition = τ.partition
⊢ σ.cycleType = τ.cycleType

tactic: rw [Nat.Partition.ext_iff, parts_partition, parts_partition, ← sum_cycleType, ← sum_cycleType,
  h]
state_before: case refine_1
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : σ.cycleType = τ.cycleType
⊢ σ.partition = τ.partition
state_after: no goals

tactic: rw [← filter_parts_partition_eq_cycleType, ← filter_parts_partition_eq_cycleType, h]
state_before: case refine_2
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
h : σ.partition = τ.partition
⊢ σ.cycleType = τ.cycleType
state_after: no goals