ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.IsSeparableContraction.dvd_degree'
File: Mathlib/RingTheory/Polynomial/SeparableDegree.lean

Proof steps:
state_before: F : Type u_1
inst✝ : CommSemiring F
q : ℕ
f : F[X]
hf✝ : HasSeparableContraction q f
g : F[X]
hf : IsSeparableContraction q f g
⊢ ∃ m, g.natDegree * q ^ m = f.natDegree
state_after: case intro
F : Type u_1
inst✝ : CommSemiring F
q : ℕ
g : F[X]
m : ℕ
hf✝ : HasSeparableContraction q ((expand F (q ^ m)) g)
hf : IsSeparableContraction q ((expand F (q ^ m)) g) g
⊢ ∃ m_1, g.natDegree * q ^ m_1 = ((expand F (q ^ m)) g).natDegree
tactic: obtain ⟨m, rfl⟩ := hf.2
state_before: case intro
F : Type u_1
inst✝ : CommSemiring F
q : ℕ
g : F[X]
m : ℕ
hf✝ : HasSeparableContraction q ((expand F (q ^ m)) g)
hf : IsSeparableContraction q ((expand F (q ^ m)) g) g
⊢ ∃ m_1, g.natDegree * q ^ m_1 = ((expand F (q ^ m)) g).natDegree
state_after: case h
F : Type u_1
inst✝ : CommSemiring F
q : ℕ
g : F[X]
m : ℕ
hf✝ : HasSeparableContraction q ((expand F (q ^ m)) g)
hf : IsSeparableContraction q ((expand F (q ^ m)) g) g
⊢ g.natDegree * q ^ m = ((expand F (q ^ m)) g).natDegree
tactic: use m
state_before: case h
F : Type u_1
inst✝ : CommSemiring F
q : ℕ
g : F[X]
m : ℕ
hf✝ : HasSeparableContraction q ((expand F (q ^ m)) g)
hf : IsSeparableContraction q ((expand F (q ^ m)) g) g
⊢ g.natDegree * q ^ m = ((expand F (q ^ m)) g).natDegree
state_after: no goals
tactic: rw [natDegree_expand]
Theorem: EReal.mul_pos
File: Mathlib/Data/Real/EReal.lean

Proof steps:
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: induction a
Theorem: Set.Finite.toFinset_range
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
inst✝¹ : DecidableEq α
inst✝ : Fintype β
f : β → α
h : (range f).Finite
⊢ h.toFinset = Finset.image f Finset.univ
state_after: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
inst✝¹ : DecidableEq α
inst✝ : Fintype β
f : β → α
h : (range f).Finite
a✝ : α
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ Finset.image f Finset.univ
tactic: ext
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : s.Finite
ht : t.Finite
inst✝¹ : DecidableEq α
inst✝ : Fintype β
f : β → α
h : (range f).Finite
a✝ : α
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ Finset.image f Finset.univ
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Lp.simpleFunc.zero_toSimpleFunc
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
⊢ ↑(toSimpleFunc 0) =ᶠ[ae μ] 0
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
a✝¹ : α
h₁ : ↑(toSimpleFunc 0) a✝¹ = ↑↑↑0 a✝¹
a✝ : ↑↑0 a✝¹ = 0 a✝¹
⊢ ↑(toSimpleFunc 0) a✝¹ = 0 a✝¹
tactic: filter_upwards [toSimpleFunc_eq_toFun (0 : Lp.simpleFunc E p μ),
    Lp.coeFn_zero E 1 μ] with _ h₁ _
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
a✝¹ : α
h₁ : ↑(toSimpleFunc 0) a✝¹ = ↑↑↑0 a✝¹
a✝ : ↑↑0 a✝¹ = 0 a✝¹
⊢ ↑(toSimpleFunc 0) a✝¹ = 0 a✝¹
state_after: no goals
tactic: rwa [h₁]
Theorem: Finite.card_pos_iff
File: Mathlib/Data/Finite/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
⊢ 0 < Nat.card α ↔ Nonempty α
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
this : Fintype α
⊢ 0 < Nat.card α ↔ Nonempty α
tactic: haveI := Fintype.ofFinite α
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
this : Fintype α
⊢ 0 < Nat.card α ↔ Nonempty α
state_after: no goals
tactic: rw [Nat.card_eq_fintype_card, Fintype.card_pos_iff]
Theorem: Filter.Eventually.diag_of_prod_right
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
⊢ (∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x) → ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
h : ∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x
⊢ ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)
tactic: intro h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
h : ∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x
⊢ ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
h : ∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x
t : α → Prop
ht : ∀ᶠ (x : α) in f, t x
s : γ × γ → Prop
hs : ∀ᶠ (y : γ × γ) in g ×ˢ g, s y
hst : ∀ {x : α}, t x → ∀ {y : γ × γ}, s y → p (x, y)
⊢ ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)
tactic: obtain ⟨t, ht, s, hs, hst⟩ := eventually_prod_iff.1 h
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t✝ : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter γ
p : α × γ × γ → Prop
h : ∀ᶠ (x : α × γ × γ) in f ×ˢ g ×ˢ g, p x
t : α → Prop
ht : ∀ᶠ (x : α) in f, t x
s : γ × γ → Prop
hs : ∀ᶠ (y : γ × γ) in g ×ˢ g, s y
hst : ∀ {x : α}, t x → ∀ {y : γ × γ}, s y → p (x, y)
⊢ ∀ᶠ (x : α × γ) in f ×ˢ g, p (x.1, x.2, x.2)
state_after: no goals
tactic: exact (ht.prod_mk hs.diag_of_prod).mono fun x hx => by simp only [hst hx.1 hx.2]
Theorem: Matrix.mul_self_mul_conjTranspose_eq_zero
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : Fintype p
inst✝⁴ : PartialOrder R
inst✝³ : NonUnitalRing R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : NoZeroDivisors R
A : Matrix m n R
B : Matrix p m R
⊢ B * (A * Aᴴ) = 0 ↔ B * A = 0
state_after: no goals
tactic: rw [← conjTranspose_eq_zero, conjTranspose_mul, conjTranspose_mul, conjTranspose_conjTranspose,
    self_mul_conjTranspose_mul_eq_zero, ← conjTranspose_mul, conjTranspose_eq_zero]
Theorem: Real.logb_pow
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
k : ℕ
hx : 0 < x
⊢ logb b (x ^ k) = ↑k * logb b x
state_after: no goals
tactic: rw [← rpow_natCast, logb_rpow_eq_mul_logb_of_pos hx]
Theorem: stronglyMeasurable_iff_measurable_separable
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : PseudoMetrizableSpace β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
⊢ StronglyMeasurable f ↔ Measurable f ∧ IsSeparable (range f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : PseudoMetrizableSpace β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
x✝ : Measurable f ∧ IsSeparable (range f)
Hm : Measurable f
Hsep : IsSeparable (range f)
⊢ StronglyMeasurable f
tactic: refine ⟨fun H ↦ ⟨H.measurable, H.isSeparable_range⟩, fun ⟨Hm, Hsep⟩  ↦ ?_⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : PseudoMetrizableSpace β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
x✝ : Measurable f ∧ IsSeparable (range f)
Hm : Measurable f
Hsep : IsSeparable (range f)
⊢ StronglyMeasurable f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : PseudoMetrizableSpace β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
x✝ : Measurable f ∧ IsSeparable (range f)
Hm : Measurable f
Hsep : IsSeparable (range f)
this : SecondCountableTopology ↑(range f)
⊢ StronglyMeasurable f
tactic: have := Hsep.secondCountableTopology
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : PseudoMetrizableSpace β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
x✝ : Measurable f ∧ IsSeparable (range f)
Hm : Measurable f
Hsep : IsSeparable (range f)
this : SecondCountableTopology ↑(range f)
⊢ StronglyMeasurable f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : PseudoMetrizableSpace β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
x✝ : Measurable f ∧ IsSeparable (range f)
Hm : Measurable f
Hsep : IsSeparable (range f)
this : SecondCountableTopology ↑(range f)
Hm' : StronglyMeasurable (rangeFactorization f)
⊢ StronglyMeasurable f
tactic: have Hm' : StronglyMeasurable (rangeFactorization f) := Hm.subtype_mk.stronglyMeasurable
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : PseudoMetrizableSpace β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
x✝ : Measurable f ∧ IsSeparable (range f)
Hm : Measurable f
Hsep : IsSeparable (range f)
this : SecondCountableTopology ↑(range f)
Hm' : StronglyMeasurable (rangeFactorization f)
⊢ StronglyMeasurable f
state_after: no goals
tactic: exact continuous_subtype_val.comp_stronglyMeasurable Hm'
Theorem: IsUpperSet.add_right
File: Mathlib/Algebra/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : IsUpperSet s
⊢ IsUpperSet (s * t)
state_after: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : IsUpperSet s
⊢ IsUpperSet (t * s)
tactic: rw [mul_comm]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : IsUpperSet s
⊢ IsUpperSet (t * s)
state_after: no goals
tactic: exact hs.mul_left
Theorem: TopCat.coequalizer_isOpen_iff
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
⊢ IsOpen U ↔ IsOpen (⇑(colimit.ι F WalkingParallelPair.one) ⁻¹' U)
state_after: J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
⊢ (∀ (j : WalkingParallelPair), IsOpen (⇑(colimit.ι F j) ⁻¹' U)) ↔ IsOpen (⇑(colimit.ι F WalkingParallelPair.one) ⁻¹' U)
tactic: rw [colimit_isOpen_iff]
state_before: J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
⊢ (∀ (j : WalkingParallelPair), IsOpen (⇑(colimit.ι F j) ⁻¹' U)) ↔ IsOpen (⇑(colimit.ι F WalkingParallelPair.one) ⁻¹' U)
state_after: case mp
J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
⊢ (∀ (j : WalkingParallelPair), IsOpen (⇑(colimit.ι F j) ⁻¹' U)) → IsOpen (⇑(colimit.ι F WalkingParallelPair.one) ⁻¹' U)

case mpr
J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
⊢ IsOpen (⇑(colimit.ι F WalkingParallelPair.one) ⁻¹' U) → ∀ (j : WalkingParallelPair), IsOpen (⇑(colimit.ι F j) ⁻¹' U)
tactic: constructor
Theorem: Finsupp.unique_single_eq_iff
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
a a' : α
b : M
inst✝ : Unique α
b' : M
⊢ single a b = single a' b' ↔ b = b'
state_after: no goals
tactic: rw [Finsupp.unique_ext_iff, Unique.eq_default a, Unique.eq_default a', single_eq_same,
    single_eq_same]
Theorem: Complex.monotone_ofReal
File: Mathlib/Data/Complex/Order.lean

Proof steps:
state_before: ⊢ Monotone ofReal'
state_after: x y : ℝ
hxy : x ≤ y
⊢ ↑x ≤ ↑y
tactic: intro x y hxy
state_before: x y : ℝ
hxy : x ≤ y
⊢ ↑x ≤ ↑y
state_after: no goals
tactic: simp only [ofReal_eq_coe, real_le_real, hxy]
Theorem: SMul.smul_lt_smul_of_lt_of_le
File: Mathlib/Algebra/Order/AddTorsor.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a < b
h₂ : c ≤ d
⊢ a • c < b • d
state_after: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a < b
h₂ : c ≤ d
⊢ a • d < b • d
tactic: refine lt_of_le_of_lt (IsOrderedSMul.smul_le_smul_left c d h₂ a) ?_
state_before: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a < b
h₂ : c ≤ d
⊢ a • d < b • d
state_after: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a < b
h₂ : c ≤ d
⊢ ¬b • d ≤ a • d
tactic: refine lt_of_le_not_le (IsOrderedSMul.smul_le_smul_right a b (le_of_lt h₁) d) ?_
state_before: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a < b
h₂ : c ≤ d
⊢ ¬b • d ≤ a • d
state_after: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a < b
h₂ : c ≤ d
hbad : b • d ≤ a • d
⊢ False
tactic: by_contra hbad
state_before: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a < b
h₂ : c ≤ d
hbad : b • d ≤ a • d
⊢ False
state_after: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a < b
h₂ : c ≤ d
hbad : b • d ≤ a • d
h : b ≤ a
⊢ False
tactic: have h : b ≤ a := IsOrderedCancelSMul.le_of_smul_le_smul_right b a d hbad
state_before: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a < b
h₂ : c ≤ d
hbad : b • d ≤ a • d
h : b ≤ a
⊢ False
state_after: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b ∧ ¬b ≤ a
h₂ : c ≤ d
hbad : b • d ≤ a • d
h : b ≤ a
⊢ False
tactic: rw [@lt_iff_le_not_le] at h₁
state_before: G : Type u_1
P : Type u_2
inst✝³ : Preorder G
inst✝² : Preorder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
a b : G
c d : P
h₁ : a ≤ b ∧ ¬b ≤ a
h₂ : c ≤ d
hbad : b • d ≤ a • d
h : b ≤ a
⊢ False
state_after: no goals
tactic: simp_all only [not_true_eq_false, and_false]
Theorem: List.sublistsLen_one
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ sublistsLen 1 [] = map (fun x => [x]) [].reverse
state_after: no goals
tactic: rw [sublistsLen_succ_nil, reverse_nil, map_nil]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
a : α
s : List α
ih : sublistsLen 1 s = map (fun x => [x]) s.reverse
⊢ sublistsLen 1 (a :: s) = map (fun x => [x]) (a :: s).reverse
state_after: α : Type u
β : Type v
γ : Type w
l : List α
a : α
s : List α
ih : sublistsLen 1 s = map (fun x => [x]) s.reverse
⊢ map (fun x => [x]) s.reverse ++ map (cons a) [[]] = map (fun x => [x]) s.reverse ++ map (fun x => [x]) [a]
tactic: rw [sublistsLen_succ_cons, ih, reverse_cons, map_append, sublistsLen_zero]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
a : α
s : List α
ih : sublistsLen 1 s = map (fun x => [x]) s.reverse
⊢ map (fun x => [x]) s.reverse ++ map (cons a) [[]] = map (fun x => [x]) s.reverse ++ map (fun x => [x]) [a]
state_after: no goals
tactic: rfl
Theorem: List.get_zipWith
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l : List α
l' : List β
i : Fin (zipWith f l l').length
⊢ (zipWith f l l').get i = f (l.get ⟨↑i, ⋯⟩) (l'.get ⟨↑i, ⋯⟩)
state_after: no goals
tactic: simp
Theorem: Matroid.freeOn_restrict
File: Mathlib/Data/Matroid/Constructions.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
h : R ⊆ E
⊢ freeOn E ↾ R = freeOn R
state_after: no goals
tactic: simp [h, eq_freeOn_iff, Subset.rfl]
Theorem: ConvexBody.hausdorffEdist_ne_top
File: Mathlib/Analysis/Convex/Body.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : SeminormedAddCommGroup V
inst✝ : NormedSpace ℝ V
K✝ L✝ K L : ConvexBody V
⊢ EMetric.hausdorffEdist ↑K ↑L ≠ ⊤
state_after: no goals
tactic: apply_rules [Metric.hausdorffEdist_ne_top_of_nonempty_of_bounded, ConvexBody.nonempty,
    ConvexBody.isBounded]
Theorem: List.Ico.bagInter_consecutive
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m l : ℕ
⊢ Ico n m ∩ Ico m l = []
state_after: no goals
tactic: convert inter_consecutive n m l
Theorem: SimpleGraph.Subgraph.deleteEdges_deleteEdges
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s✝ s s' : Set (Sym2 V)
⊢ (G'.deleteEdges s).deleteEdges s' = G'.deleteEdges (s ∪ s')
state_after: no goals
tactic: ext <;> simp [and_assoc, not_or]
Theorem: compl_beattySeq'
File: Mathlib/NumberTheory/Rayleigh.lean

Proof steps:
state_before: r s : ℝ
hrs : r.IsConjExponent s
⊢ {x | ∃ k, beattySeq' r k = x}ᶜ = {x | ∃ k, beattySeq s k = x}
state_after: no goals
tactic: rw [← compl_beattySeq hrs.symm, compl_compl]
Theorem: Filter.le_limsup_iff
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
x : β
h₁ : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h₂ : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
⊢ x ≤ limsup u f ↔ ∀ y < x, ∃ᶠ (a : α) in f, y < u a
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
x : β
h₁ : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h₂ : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : ∀ y < x, ∃ᶠ (a : α) in f, y < u a
⊢ x ≤ limsup u f
tactic: refine ⟨fun h _ h' ↦ frequently_lt_of_lt_limsup h₁ (lt_of_lt_of_le h' h), fun h ↦ ?_⟩
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
x : β
h₁ : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h₂ : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : ∀ y < x, ∃ᶠ (a : α) in f, y < u a
⊢ x ≤ limsup u f
state_after: case pos
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
x : β
h₁ : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h₂ : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : ∀ y < x, ∃ᶠ (a : α) in f, y < u a
h' : ∀ y < x, ∃ z, y < z ∧ z < x
⊢ x ≤ limsup u f

case neg
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
x : β
h₁ : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h₂ : autoParam (IsBoundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : ∀ y < x, ∃ᶠ (a : α) in f, y < u a
h' : ¬∀ y < x, ∃ z, y < z ∧ z < x
⊢ x ≤ limsup u f
tactic: by_cases h' : ∀ y < x, ∃ z, y < z ∧ z < x
Theorem: EReal.preimage_coe_Ioi_bot
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: ⊢ Real.toEReal ⁻¹' Ioi ⊥ = univ
state_after: ⊢ WithBot.some ∘ WithTop.some ⁻¹' Ioi ⊥ = univ
tactic: change (WithBot.some ∘ WithTop.some) ⁻¹' (Ioi ⊥) = _
state_before: ⊢ WithBot.some ∘ WithTop.some ⁻¹' Ioi ⊥ = univ
state_after: ⊢ WithTop.some ⁻¹' (WithBot.some ⁻¹' Ioi ⊥) = univ
tactic: refine preimage_comp.trans ?_
state_before: ⊢ WithTop.some ⁻¹' (WithBot.some ⁻¹' Ioi ⊥) = univ
state_after: no goals
tactic: simp only [WithBot.preimage_coe_Ioi_bot, preimage_univ]
Theorem: Equiv.mul_swap_eq_swap_mul
File: Mathlib/GroupTheory/Perm/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
f : Perm α
x y : α
⊢ f * swap x y = swap (f x) (f y) * f
state_after: no goals
tactic: rw [swap_mul_eq_mul_swap, Perm.inv_apply_self, Perm.inv_apply_self]
Theorem: linearIndependent_iff''
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
⊢ LinearIndependent R v ↔ ∀ (s : Finset ι) (g : ι → R), (∀ i ∉ s, g i = 0) → ∑ i ∈ s, g i • v i = 0 → ∀ (i : ι), g i = 0
state_after: no goals
tactic: classical
  exact linearIndependent_iff'.trans
    ⟨fun H s g hg hv i => if his : i ∈ s then H s g hv i his else hg i his, fun H s g hg i hi => by
      convert
        H s (fun j => if j ∈ s then g j else 0) (fun j hj => if_neg hj)
          (by simp_rw [ite_smul, zero_smul, Finset.sum_extend_by_zero, hg]) i
      exact (if_pos hi).symm⟩
Theorem: List.mk_mem_enum_iff_get?
File: Mathlib/Data/List/Enum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
i : ℕ
x : α
l : List α
⊢ (i, x) ∈ l.enum ↔ l.get? i = some x
state_after: no goals
tactic: simp [enum, mk_mem_enumFrom_iff_le_and_get?_sub]
Theorem: Cardinal.mk_surjective_eq_zero_iff_lift
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: α β : Type u
β' : Type v
⊢ #↑{f | Surjective f} = 0 ↔ lift.{v, u} #α < lift.{u, v} #β' ∨ #α ≠ 0 ∧ #β' = 0
state_after: α β : Type u
β' : Type v
⊢ #↑{f | Surjective f} ≠ 0 ↔ (#α = 0 ∨ ¬#β' = 0) ∧ Nonempty (β' ↪ α)
tactic: rw [← not_iff_not, not_or, not_lt, lift_mk_le', ← Ne, not_and_or, not_ne_iff, and_comm]
state_before: α β : Type u
β' : Type v
⊢ #↑{f | Surjective f} ≠ 0 ↔ (#α = 0 ∨ ¬#β' = 0) ∧ Nonempty (β' ↪ α)
state_after: no goals
tactic: simp_rw [mk_ne_zero_iff, mk_eq_zero_iff, nonempty_coe_sort,
    Set.Nonempty, mem_setOf, exists_surjective_iff, nonempty_fun]
Theorem: completeSpace_iff_ultrafilter
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
⊢ CompleteSpace α ↔ ∀ (l : Ultrafilter α), Cauchy ↑l → ∃ x, ↑l ≤ 𝓝 x
state_after: no goals
tactic: simp [completeSpace_iff_isComplete_univ, isComplete_iff_ultrafilter]
Theorem: _private.Mathlib.NumberTheory.LSeries.HurwitzZetaValues.0.HurwitzZeta.hurwitzZeta_one_sub_two_mul_nat
File: Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean

Proof steps:
state_before: k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ hurwitzZeta (↑x) (1 - 2 * ↑k) =
    -1 / (2 * ↑k) * Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * k)))
state_after: k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ hurwitzZetaOdd (↑x) (1 - 2 * ↑k) = 0
tactic: suffices hurwitzZetaOdd x (1 - 2 * k) = 0 by
    rw [hurwitzZeta, this, add_zero, hurwitzZetaEven_one_sub_two_mul_nat hk hx]
state_before: k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ hurwitzZetaOdd (↑x) (1 - 2 * ↑k) = 0
state_after: case intro
x : ℝ
hx : x ∈ Icc 0 1
k : ℕ
hk : k.succ ≠ 0
⊢ hurwitzZetaOdd (↑x) (1 - 2 * ↑k.succ) = 0
tactic: obtain ⟨k, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hk
state_before: case intro
x : ℝ
hx : x ∈ Icc 0 1
k : ℕ
hk : k.succ ≠ 0
⊢ hurwitzZetaOdd (↑x) (1 - 2 * ↑k.succ) = 0
state_after: no goals
tactic: rw [Nat.cast_succ, show (1 : ℂ) - 2 * (k + 1) = - 2 * k - 1 by ring,
    hurwitzZetaOdd_neg_two_mul_nat_sub_one]