ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Module.finite_of_rank_eq_nat
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
⊢ Finite R M
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
⊢ Finite R M
tactic: nontriviality R
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
⊢ Finite R M
state_after: case intro.mk
R : Type u
M M₁ : Type v
M' : Type v'
ι✝ : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
ι : Type v
b : Basis ι R M
⊢ Finite R M
tactic: obtain ⟨⟨ι, b⟩⟩ := Module.Free.exists_basis (R := R) (M := M)
state_before: case intro.mk
R : Type u
M M₁ : Type v
M' : Type v'
ι✝ : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
ι : Type v
b : Basis ι R M
⊢ Finite R M
state_after: case intro.mk
R : Type u
M M₁ : Type v
M' : Type v'
ι✝ : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
ι : Type v
b : Basis ι R M
this : _root_.Finite ι
⊢ Finite R M
tactic: have := mk_lt_aleph0_iff.mp <|
    b.linearIndependent.cardinal_le_rank |>.trans_eq h |>.trans_lt <| nat_lt_aleph0 n
state_before: case intro.mk
R : Type u
M M₁ : Type v
M' : Type v'
ι✝ : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Free R M
n : ℕ
h : Module.rank R M = ↑n
a✝ : Nontrivial R
ι : Type v
b : Basis ι R M
this : _root_.Finite ι
⊢ Finite R M
state_after: no goals
tactic: exact Module.Finite.of_basis b
Theorem: Polynomial.IsSplittingField.mul
File: Mathlib/FieldTheory/SplittingField/IsSplittingField.lean

Proof steps:
state_before: F : Type u
K : Type v
L : Type w
inst✝⁸ : Field K
inst✝⁷ : Field L
inst✝⁶ : Field F
inst✝⁵ : Algebra K L
inst✝⁴ : Algebra F K
inst✝³ : Algebra F L
inst✝² : IsScalarTower F K L
f g : F[X]
hf : f ≠ 0
hg : g ≠ 0
inst✝¹ : IsSplittingField F K f
inst✝ : IsSplittingField K L (Polynomial.map (algebraMap F K) g)
⊢ Algebra.adjoin F ((f * g).rootSet L) = ⊤
state_after: no goals
tactic: rw [rootSet, aroots_mul (mul_ne_zero hf hg),
      Multiset.toFinset_add, Finset.coe_union, Algebra.adjoin_union_eq_adjoin_adjoin,
      aroots_def, aroots_def, IsScalarTower.algebraMap_eq F K L, ← map_map,
      roots_map (algebraMap K L) ((splits_id_iff_splits <| algebraMap F K).2 <| splits K f),
      Multiset.toFinset_map, Finset.coe_image, Algebra.adjoin_algebraMap, ← rootSet, adjoin_rootSet,
      Algebra.map_top, IsScalarTower.adjoin_range_toAlgHom, ← map_map, ← rootSet, adjoin_rootSet,
      Subalgebra.restrictScalars_top]
Theorem: StrictMonoOn.continuousWithinAt_right_of_exists_between
File: Mathlib/Topology/Order/MonotoneContinuity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : OrderTopology α
inst✝² : LinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
s : Set α
a : α
h_mono : StrictMonoOn f s
hs : s ∈ 𝓝[≥] a
hfs : ∀ b > f a, ∃ c ∈ s, f c ∈ Ioc (f a) b
⊢ ContinuousWithinAt f (Ici a) a
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : OrderTopology α
inst✝² : LinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
s : Set α
a : α
h_mono : StrictMonoOn f s
hs : s ∈ 𝓝[≥] a
hfs : ∀ b > f a, ∃ c ∈ s, f c ∈ Ioc (f a) b
ha : a ∈ Ici a
⊢ ContinuousWithinAt f (Ici a) a
tactic: have ha : a ∈ Ici a := left_mem_Ici
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : OrderTopology α
inst✝² : LinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
s : Set α
a : α
h_mono : StrictMonoOn f s
hs : s ∈ 𝓝[≥] a
hfs : ∀ b > f a, ∃ c ∈ s, f c ∈ Ioc (f a) b
ha : a ∈ Ici a
⊢ ContinuousWithinAt f (Ici a) a
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : OrderTopology α
inst✝² : LinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
s : Set α
a : α
h_mono : StrictMonoOn f s
hs : s ∈ 𝓝[≥] a
hfs : ∀ b > f a, ∃ c ∈ s, f c ∈ Ioc (f a) b
ha : a ∈ Ici a
has : a ∈ s
⊢ ContinuousWithinAt f (Ici a) a
tactic: have has : a ∈ s := mem_of_mem_nhdsWithin ha hs
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : OrderTopology α
inst✝² : LinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
s : Set α
a : α
h_mono : StrictMonoOn f s
hs : s ∈ 𝓝[≥] a
hfs : ∀ b > f a, ∃ c ∈ s, f c ∈ Ioc (f a) b
ha : a ∈ Ici a
has : a ∈ s
⊢ ContinuousWithinAt f (Ici a) a
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : OrderTopology α
inst✝² : LinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
s : Set α
a : α
h_mono : StrictMonoOn f s
hs : s ∈ 𝓝[≥] a
hfs : ∀ b > f a, ∃ c ∈ s, f c ∈ Ioc (f a) b
ha : a ∈ Ici a
has : a ∈ s
b : β
hb : b < f a
⊢ ∀ᶠ (b_1 : α) in 𝓝[≥] a, b < f b_1

case refine_2
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : OrderTopology α
inst✝² : LinearOrder β
inst✝¹ : TopologicalSpace β
inst✝ : OrderTopology β
f : α → β
s : Set α
a : α
h_mono : StrictMonoOn f s
hs : s ∈ 𝓝[≥] a
hfs : ∀ b > f a, ∃ c ∈ s, f c ∈ Ioc (f a) b
ha : a ∈ Ici a
has : a ∈ s
b : β
hb : b > f a
⊢ ∀ᶠ (b_1 : α) in 𝓝[≥] a, f b_1 < b
tactic: refine tendsto_order.2 ⟨fun b hb => ?_, fun b hb => ?_⟩
Theorem: Valuation.map_eq_of_sub_lt
File: Mathlib/RingTheory/Valuation/Basic.lean

Proof steps:
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (y - x) < v x
⊢ v y = v x
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (y - x) < v x
this : v (y - x + x) = max (v (y - x)) (v x)
⊢ v y = v x
tactic: have := Valuation.map_add_of_distinct_val v (ne_of_gt h).symm
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (y - x) < v x
this : v (y - x + x) = max (v (y - x)) (v x)
⊢ v y = v x
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (y - x) < v x
this : v (y - x + x) = v x
⊢ v y = v x
tactic: rw [max_eq_right (le_of_lt h)] at this
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v (y - x) < v x
this : v (y - x + x) = v x
⊢ v y = v x
state_after: no goals
tactic: simpa using this
Theorem: Filter.zero_smul_filter
File: Mathlib/Order/Filter/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
f : Filter α
g : Filter β
hg : g.NeBot
s : Set β
hs : s ∈ g
⊢ (fun x => 0 • x) '' s ∈ 0
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
f : Filter α
g : Filter β
hg : g.NeBot
s : Set β
hs : s ∈ g
⊢ {0} ∈ 0
tactic: simp_rw [zero_smul, (hg.nonempty_of_mem hs).image_const]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝² : Zero α
inst✝¹ : Zero β
inst✝ : SMulWithZero α β
f : Filter α
g : Filter β
hg : g.NeBot
s : Set β
hs : s ∈ g
⊢ {0} ∈ 0
state_after: no goals
tactic: exact zero_mem_zero
Theorem: ENNReal.ofReal_sub
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
⊢ ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q
state_after: case inl
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
h : p ≤ q
⊢ ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q

case inr
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
h : q ≤ p
⊢ ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q
tactic: obtain h | h := le_total p q
state_before: case inr
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
h : q ≤ p
⊢ ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q
state_after: case inr
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
h : q ≤ p
⊢ ENNReal.ofReal (p - q) + ENNReal.ofReal q = ENNReal.ofReal p
tactic: refine ENNReal.eq_sub_of_add_eq ofReal_ne_top ?_
state_before: case inr
a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hq : 0 ≤ q
h : q ≤ p
⊢ ENNReal.ofReal (p - q) + ENNReal.ofReal q = ENNReal.ofReal p
state_after: no goals
tactic: rw [← ofReal_add (sub_nonneg_of_le h) hq, sub_add_cancel]
Theorem: _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_add
File: Mathlib/RingTheory/WittVector/Basic.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
x y : 𝕎 R
⊢ WittVector.ghostFun (x + y) = WittVector.ghostFun x + WittVector.ghostFun y
state_after: no goals
tactic: ghost_fun_tac X 0 + X 1, ![x.coeff, y.coeff]
Theorem: IsCompact.closure_subset_measurableSet
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
γ₂ : Type u_4
δ : Type u_5
ι : Sort y
s✝ t u : Set α
inst✝¹³ : TopologicalSpace α
inst✝¹² : MeasurableSpace α
inst✝¹¹ : OpensMeasurableSpace α
inst✝¹⁰ : TopologicalSpace β
inst✝⁹ : MeasurableSpace β
inst✝⁸ : OpensMeasurableSpace β
inst✝⁷ : TopologicalSpace γ
inst✝⁶ : MeasurableSpace γ
inst✝⁵ : BorelSpace γ
inst✝⁴ : TopologicalSpace γ₂
inst✝³ : MeasurableSpace γ₂
inst✝² : BorelSpace γ₂
inst✝¹ : MeasurableSpace δ
inst✝ : R1Space γ
K s : Set γ
hK : IsCompact K
hs : MeasurableSet s
hKs : K ⊆ s
⊢ closure K ⊆ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
γ₂ : Type u_4
δ : Type u_5
ι : Sort y
s✝ t u : Set α
inst✝¹³ : TopologicalSpace α
inst✝¹² : MeasurableSpace α
inst✝¹¹ : OpensMeasurableSpace α
inst✝¹⁰ : TopologicalSpace β
inst✝⁹ : MeasurableSpace β
inst✝⁸ : OpensMeasurableSpace β
inst✝⁷ : TopologicalSpace γ
inst✝⁶ : MeasurableSpace γ
inst✝⁵ : BorelSpace γ
inst✝⁴ : TopologicalSpace γ₂
inst✝³ : MeasurableSpace γ₂
inst✝² : BorelSpace γ₂
inst✝¹ : MeasurableSpace δ
inst✝ : R1Space γ
K s : Set γ
hK : IsCompact K
hs : MeasurableSet s
hKs : K ⊆ s
⊢ ∀ i ∈ K, {y | Inseparable i y} ⊆ s
tactic: rw [hK.closure_eq_biUnion_inseparable, iUnion₂_subset_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
γ₂ : Type u_4
δ : Type u_5
ι : Sort y
s✝ t u : Set α
inst✝¹³ : TopologicalSpace α
inst✝¹² : MeasurableSpace α
inst✝¹¹ : OpensMeasurableSpace α
inst✝¹⁰ : TopologicalSpace β
inst✝⁹ : MeasurableSpace β
inst✝⁸ : OpensMeasurableSpace β
inst✝⁷ : TopologicalSpace γ
inst✝⁶ : MeasurableSpace γ
inst✝⁵ : BorelSpace γ
inst✝⁴ : TopologicalSpace γ₂
inst✝³ : MeasurableSpace γ₂
inst✝² : BorelSpace γ₂
inst✝¹ : MeasurableSpace δ
inst✝ : R1Space γ
K s : Set γ
hK : IsCompact K
hs : MeasurableSet s
hKs : K ⊆ s
⊢ ∀ i ∈ K, {y | Inseparable i y} ⊆ s
state_after: no goals
tactic: exact fun x hx y hy ↦ (hy.mem_measurableSet_iff hs).1 (hKs hx)
Theorem: Quiver.Path.reverse_reverse
File: Mathlib/Combinatorics/Quiver/Symmetric.lean

Proof steps:
state_before: U : Type u_1
V : Type u_2
W : Type u_3
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h : HasInvolutiveReverse V
a b : V
p : Path a b
⊢ p.reverse.reverse = p
state_after: case nil
U : Type u_1
V : Type u_2
W : Type u_3
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h : HasInvolutiveReverse V
a b : V
⊢ nil.reverse.reverse = nil

case cons
U : Type u_1
V : Type u_2
W : Type u_3
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h✝ : HasInvolutiveReverse V
a b b✝ c✝ : V
a✝¹ : Path a b✝
a✝ : b✝ ⟶ c✝
h : a✝¹.reverse.reverse = a✝¹
⊢ (a✝¹.cons a✝).reverse.reverse = a✝¹.cons a✝
tactic: induction' p with _ _ _ _ h
Theorem: EReal.coe_real_ereal_eq_coe_toNNReal_sub_coe_toNNReal
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : ℝ
⊢ ↑x = ↑↑x.toNNReal - ↑↑(-x).toNNReal
state_after: case inl
x : ℝ
h : 0 ≤ x
⊢ ↑x = ↑↑x.toNNReal - ↑↑(-x).toNNReal

case inr
x : ℝ
h : x ≤ 0
⊢ ↑x = ↑↑x.toNNReal - ↑↑(-x).toNNReal
tactic: rcases le_total 0 x with (h | h)
Theorem: Irrational.add_cases
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
x y : ℝ
⊢ Irrational (x + y) → Irrational x ∨ Irrational y
state_after: q : ℚ
x y : ℝ
⊢ x + y ∉ Set.range Rat.cast → x ∉ Set.range Rat.cast ∨ y ∉ Set.range Rat.cast
tactic: delta Irrational
state_before: q : ℚ
x y : ℝ
⊢ x + y ∉ Set.range Rat.cast → x ∉ Set.range Rat.cast ∨ y ∉ Set.range Rat.cast
state_after: q : ℚ
x y : ℝ
⊢ x ∈ Set.range Rat.cast ∧ y ∈ Set.range Rat.cast → x + y ∈ Set.range Rat.cast
tactic: contrapose!
state_before: q : ℚ
x y : ℝ
⊢ x ∈ Set.range Rat.cast ∧ y ∈ Set.range Rat.cast → x + y ∈ Set.range Rat.cast
state_after: case intro.intro.intro
q rx ry : ℚ
⊢ ↑rx + ↑ry ∈ Set.range Rat.cast
tactic: rintro ⟨⟨rx, rfl⟩, ⟨ry, rfl⟩⟩
state_before: case intro.intro.intro
q rx ry : ℚ
⊢ ↑rx + ↑ry ∈ Set.range Rat.cast
state_after: no goals
tactic: exact ⟨rx + ry, cast_add rx ry⟩
Theorem: interval_average_eq_div
File: Mathlib/MeasureTheory/Integral/IntervalAverage.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → ℝ
a b : ℝ
⊢ ⨍ (x : ℝ) in a..b, f x = (∫ (x : ℝ) in a..b, f x) / (b - a)
state_after: no goals
tactic: rw [interval_average_eq, smul_eq_mul, div_eq_inv_mul]
Theorem: derangements.Equiv.RemoveNone.fiber_none
File: Mathlib/Combinatorics/Derangements/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
⊢ fiber none = ∅
state_after: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
⊢ ∀ (x : Perm α), x ∉ fiber none
tactic: rw [Set.eq_empty_iff_forall_not_mem]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
⊢ ∀ (x : Perm α), x ∉ fiber none
state_after: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
f : Perm α
hyp : f ∈ fiber none
⊢ False
tactic: intro f hyp
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
f : Perm α
hyp : f ∈ fiber none
⊢ False
state_after: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
f : Perm α
hyp : ∃ F ∈ derangements (Option α), F none = none ∧ removeNone F = f
⊢ False
tactic: rw [RemoveNone.mem_fiber] at hyp
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
f : Perm α
hyp : ∃ F ∈ derangements (Option α), F none = none ∧ removeNone F = f
⊢ False
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
f : Perm α
F : Perm (Option α)
F_derangement : F ∈ derangements (Option α)
F_none : F none = none
right✝ : removeNone F = f
⊢ False
tactic: rcases hyp with ⟨F, F_derangement, F_none, _⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
f : Perm α
F : Perm (Option α)
F_derangement : F ∈ derangements (Option α)
F_none : F none = none
right✝ : removeNone F = f
⊢ False
state_after: no goals
tactic: exact F_derangement none F_none
Theorem: Polynomial.coeff_natTrailingDegree_eq_zero
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p.coeff p.natTrailingDegree = 0 ↔ p = 0
state_after: case mp
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p.coeff p.natTrailingDegree = 0 → p = 0

case mpr
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p = 0 → p.coeff p.natTrailingDegree = 0
tactic: constructor
Theorem: inseparable_pi
File: Mathlib/Topology/Inseparable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f✝ g✝ : X → Y
f g : (i : ι) → π i
⊢ (f ~ᵢ g) ↔ ∀ (i : ι), f i ~ᵢ g i
state_after: no goals
tactic: simp only [Inseparable, nhds_pi, funext_iff, pi_inj]
Theorem: IntermediateField.card_algHom_adjoin_integral
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝⁴ : Field F
E : Type u_2
inst✝³ : Field E
inst✝² : Algebra F E
α : E
K : Type u
inst✝¹ : Field K
inst✝ : Algebra F K
h : IsIntegral F α
h_sep : IsSeparable F α
h_splits : Splits (algebraMap F K) (minpoly F α)
⊢ Fintype.card (↥F⟮α⟯ →ₐ[F] K) = (minpoly F α).natDegree
state_after: case h_sep
F : Type u_1
inst✝⁴ : Field F
E : Type u_2
inst✝³ : Field E
inst✝² : Algebra F E
α : E
K : Type u
inst✝¹ : Field K
inst✝ : Algebra F K
h : IsIntegral F α
h_sep : IsSeparable F α
h_splits : Splits (algebraMap F K) (minpoly F α)
⊢ (minpoly F α).Separable
tactic: rw [AlgHom.card_of_powerBasis] <;>
    simp only [IsSeparable, adjoin.powerBasis_dim, adjoin.powerBasis_gen, minpoly_gen, h_splits]
state_before: case h_sep
F : Type u_1
inst✝⁴ : Field F
E : Type u_2
inst✝³ : Field E
inst✝² : Algebra F E
α : E
K : Type u
inst✝¹ : Field K
inst✝ : Algebra F K
h : IsIntegral F α
h_sep : IsSeparable F α
h_splits : Splits (algebraMap F K) (minpoly F α)
⊢ (minpoly F α).Separable
state_after: no goals
tactic: exact h_sep
Theorem: IsCompact.exists_isOpen_closure_subset
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K U : Set X
hK : IsCompact K
hU : U ∈ 𝓝ˢ K
⊢ ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K U : Set X
hK : IsCompact K
hU : U ∈ 𝓝ˢ K
hd : Disjoint (𝓝ˢ K) (𝓝ˢ Uᶜ)
⊢ ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U
tactic: have hd : Disjoint (𝓝ˢ K) (𝓝ˢ Uᶜ) := by
    simpa [hK.disjoint_nhdsSet_left, disjoint_nhds_nhdsSet,
      ← subset_interior_iff_mem_nhdsSet] using hU
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K U : Set X
hK : IsCompact K
hU : U ∈ 𝓝ˢ K
hd : Disjoint (𝓝ˢ K) (𝓝ˢ Uᶜ)
⊢ ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U
state_after: case intro.intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K U : Set X
hK : IsCompact K
hU : U ∈ 𝓝ˢ K
hd : Disjoint (𝓝ˢ K) (𝓝ˢ Uᶜ)
V : Set X
hVo : IsOpen V
hKV : K ⊆ V
W : Set X
hVW : Disjoint V W
hW : IsOpen W
hUW : Uᶜ ⊆ W
⊢ ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U
tactic: rcases ((hasBasis_nhdsSet _).disjoint_iff (hasBasis_nhdsSet _)).1 hd
    with ⟨V, ⟨hVo, hKV⟩, W, ⟨hW, hUW⟩, hVW⟩
state_before: case intro.intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K U : Set X
hK : IsCompact K
hU : U ∈ 𝓝ˢ K
hd : Disjoint (𝓝ˢ K) (𝓝ˢ Uᶜ)
V : Set X
hVo : IsOpen V
hKV : K ⊆ V
W : Set X
hVW : Disjoint V W
hW : IsOpen W
hUW : Uᶜ ⊆ W
⊢ ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U
state_after: case intro.intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K U : Set X
hK : IsCompact K
hU : U ∈ 𝓝ˢ K
hd : Disjoint (𝓝ˢ K) (𝓝ˢ Uᶜ)
V : Set X
hVo : IsOpen V
hKV : K ⊆ V
W : Set X
hVW : Disjoint V W
hW : IsOpen W
hUW : Uᶜ ⊆ W
⊢ closure V ⊆ Wᶜ
tactic: refine ⟨V, hVo, hKV, Subset.trans ?_ (compl_subset_comm.1 hUW)⟩
state_before: case intro.intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s K U : Set X
hK : IsCompact K
hU : U ∈ 𝓝ˢ K
hd : Disjoint (𝓝ˢ K) (𝓝ˢ Uᶜ)
V : Set X
hVo : IsOpen V
hKV : K ⊆ V
W : Set X
hVW : Disjoint V W
hW : IsOpen W
hUW : Uᶜ ⊆ W
⊢ closure V ⊆ Wᶜ
state_after: no goals
tactic: exact closure_minimal hVW.subset_compl_right hW.isClosed_compl
Theorem: IntermediateField.Lifts.exists_lift_of_splits
File: Mathlib/FieldTheory/Extension.lean

Proof steps:
state_before: F : Type u_1
E : Type u_2
K : Type u_3
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
x : Lifts F E K
s : E
h1 : IsIntegral F s
h2 : Splits (algebraMap F K) (minpoly F s)
⊢ Splits (x.emb.comp (algebraMap F ↥x.carrier)) (minpoly F s)
state_after: no goals
tactic: rwa [← x.emb.comp_algebraMap] at h2
Theorem: SimpleGraph.set_walk_self_length_zero_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkCounting.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
⊢ {p | p.length = 0} = {Walk.nil}
state_after: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
p : G.Walk u u
⊢ p ∈ {p | p.length = 0} ↔ p ∈ {Walk.nil}
tactic: ext p
state_before: case h
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u : V
p : G.Walk u u
⊢ p ∈ {p | p.length = 0} ↔ p ∈ {Walk.nil}
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Comma.post_map_right
File: Mathlib/CategoryTheory/Comma/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝⁷ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁶ : Category.{v₂, u₂} B
T : Type u₃
inst✝⁵ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝⁴ : Category.{?u.158446, u_1} A'
inst✝³ : Category.{?u.158450, u_2} B'
inst✝² : Category.{?u.158454, u_3} T'
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝¹ : Category.{v₄, u₄} C
D : Type u₅
inst✝ : Category.{v₅, u₅} D
L : A ⥤ T
R : B ⥤ T
F : T ⥤ C
X✝ Y✝ : Comma L R
f : X✝ ⟶ Y✝
⊢ (L ⋙ F).map f.left ≫ ((fun X => { left := X.left, right := X.right, hom := F.map X.hom }) Y✝).hom =
    ((fun X => { left := X.left, right := X.right, hom := F.map X.hom }) X✝).hom ≫ (R ⋙ F).map f.right
state_after: no goals
tactic: simp only [Functor.comp_map, ← F.map_comp, f.w]
Theorem: cmpLE_eq_cmp
File: Mathlib/Order/Compare.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
inst✝³ : Preorder α
inst✝² : IsTotal α fun x x_1 => x ≤ x_1
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x < x_1
x y : α
⊢ cmpLE x y = cmp x y
state_after: case neg
α✝ : Type u_1
β : Type u_2
α : Type u_3
inst✝³ : Preorder α
inst✝² : IsTotal α fun x x_1 => x ≤ x_1
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x < x_1
x y : α
xy : ¬x ≤ y
yx : ¬y ≤ x
⊢ False
tactic: by_cases xy : x ≤ y <;> by_cases yx : y ≤ x <;> simp [cmpLE, lt_iff_le_not_le, *, cmp, cmpUsing]
state_before: case neg
α✝ : Type u_1
β : Type u_2
α : Type u_3
inst✝³ : Preorder α
inst✝² : IsTotal α fun x x_1 => x ≤ x_1
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : DecidableRel fun x x_1 => x < x_1
x y : α
xy : ¬x ≤ y
yx : ¬y ≤ x
⊢ False
state_after: no goals
tactic: cases not_or_of_not xy yx (total_of _ _ _)