ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LinearMap.range_le_ker_iff
File: Mathlib/Algebra/Module/Submodule/Range.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_11
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
g : M₂ →ₛₗ[τ₂₃] M₃
h : g.comp f = 0
x : M₂
hx : x ∈ range f
y : M
hy : f y = x
⊢ g x = 0
state_after: no goals
tactic: rw [← hy, ← comp_apply, h, zero_apply]
Theorem: MeasureTheory.WithDensityᵥEq.congr_ae
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
h : f =ᶠ[ae μ] g
⊢ μ.withDensityᵥ f = μ.withDensityᵥ g
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
h : f =ᶠ[ae μ] g
hf : Integrable f μ
⊢ μ.withDensityᵥ f = μ.withDensityᵥ g

case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
h : f =ᶠ[ae μ] g
hf : ¬Integrable f μ
⊢ μ.withDensityᵥ f = μ.withDensityᵥ g
tactic: by_cases hf : Integrable f μ
Theorem: Units.inv_mul_of_eq
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
h : ↑u = a
⊢ ↑u⁻¹ * a = 1
state_after: no goals
tactic: rw [← h, u.inv_mul]
Theorem: Cubic.b_eq_three_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ φ P.b = φ P.a * -(x + y + z)
state_after: no goals
tactic: injection eq_sum_three_roots ha h3
Theorem: Set.iUnion_eq_range_sigma
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : α → Set β
⊢ ⋃ i, s i = range fun a => ↑a.snd
state_after: no goals
tactic: simp [Set.ext_iff]
Theorem: Finset.erase_sdiff_erase
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hab : a ≠ b
hb : b ∈ s
⊢ s.erase a \ s.erase b = {b}
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hab : a ≠ b
hb : b ∈ s
a✝ : α
⊢ a✝ ∈ s.erase a \ s.erase b ↔ a✝ ∈ {b}
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hab : a ≠ b
hb : b ∈ s
a✝ : α
⊢ a✝ ∈ s.erase a \ s.erase b ↔ a✝ ∈ {b}
state_after: no goals
tactic: aesop
Theorem: Set.not_nonempty_iff_eq_empty
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
⊢ ¬s.Nonempty ↔ s = ∅
state_after: no goals
tactic: simp only [Set.Nonempty, not_exists, eq_empty_iff_forall_not_mem]
Theorem: Continuous.strictMono_of_inj
File: Mathlib/Topology/Order/IntermediateValue.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹⁰ : ConditionallyCompleteLinearOrder α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : OrderTopology α
inst✝⁷ : ConditionallyCompleteLinearOrder β
inst✝⁶ : TopologicalSpace β
inst✝⁵ : OrderTopology β
inst✝⁴ : Nonempty γ
inst✝³ : DenselyOrdered α
a b : α
δ : Type u_1
inst✝² : LinearOrder δ
inst✝¹ : TopologicalSpace δ
inst✝ : OrderClosedTopology δ
f : α → δ
hf_c : Continuous f
hf_i : Injective f
⊢ StrictMono f ∨ StrictAnti f
state_after: α : Type u
β : Type v
γ : Type w
inst✝¹⁰ : ConditionallyCompleteLinearOrder α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : OrderTopology α
inst✝⁷ : ConditionallyCompleteLinearOrder β
inst✝⁶ : TopologicalSpace β
inst✝⁵ : OrderTopology β
inst✝⁴ : Nonempty γ
inst✝³ : DenselyOrdered α
a b : α
δ : Type u_1
inst✝² : LinearOrder δ
inst✝¹ : TopologicalSpace δ
inst✝ : OrderClosedTopology δ
f : α → δ
hf_c : Continuous f
hf_i : Injective f
H : ∀ {c d : α}, c < d → StrictMono f ∨ StrictAnti f
⊢ StrictMono f ∨ StrictAnti f
tactic: have H {c d : α} (hcd : c < d) : StrictMono f ∨ StrictAnti f :=
    (hf_c.continuousOn.strictMonoOn_of_injOn_Icc' hcd.le hf_i.injOn).imp
      (hf_c.strictMonoOn_of_inj_rigidity hf_i hcd)
      (hf_c.strictMonoOn_of_inj_rigidity (δ := δᵒᵈ) hf_i hcd)
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹⁰ : ConditionallyCompleteLinearOrder α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : OrderTopology α
inst✝⁷ : ConditionallyCompleteLinearOrder β
inst✝⁶ : TopologicalSpace β
inst✝⁵ : OrderTopology β
inst✝⁴ : Nonempty γ
inst✝³ : DenselyOrdered α
a b : α
δ : Type u_1
inst✝² : LinearOrder δ
inst✝¹ : TopologicalSpace δ
inst✝ : OrderClosedTopology δ
f : α → δ
hf_c : Continuous f
hf_i : Injective f
H : ∀ {c d : α}, c < d → StrictMono f ∨ StrictAnti f
⊢ StrictMono f ∨ StrictAnti f
state_after: case pos
α : Type u
β : Type v
γ : Type w
inst✝¹⁰ : ConditionallyCompleteLinearOrder α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : OrderTopology α
inst✝⁷ : ConditionallyCompleteLinearOrder β
inst✝⁶ : TopologicalSpace β
inst✝⁵ : OrderTopology β
inst✝⁴ : Nonempty γ
inst✝³ : DenselyOrdered α
a b : α
δ : Type u_1
inst✝² : LinearOrder δ
inst✝¹ : TopologicalSpace δ
inst✝ : OrderClosedTopology δ
f : α → δ
hf_c : Continuous f
hf_i : Injective f
H : ∀ {c d : α}, c < d → StrictMono f ∨ StrictAnti f
hn : Nonempty α
⊢ StrictMono f ∨ StrictAnti f

case neg
α : Type u
β : Type v
γ : Type w
inst✝¹⁰ : ConditionallyCompleteLinearOrder α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : OrderTopology α
inst✝⁷ : ConditionallyCompleteLinearOrder β
inst✝⁶ : TopologicalSpace β
inst✝⁵ : OrderTopology β
inst✝⁴ : Nonempty γ
inst✝³ : DenselyOrdered α
a b : α
δ : Type u_1
inst✝² : LinearOrder δ
inst✝¹ : TopologicalSpace δ
inst✝ : OrderClosedTopology δ
f : α → δ
hf_c : Continuous f
hf_i : Injective f
H : ∀ {c d : α}, c < d → StrictMono f ∨ StrictAnti f
hn : ¬Nonempty α
⊢ StrictMono f ∨ StrictAnti f
tactic: by_cases hn : Nonempty α
Theorem: finSuccEquiv'_above
File: Mathlib/Logic/Equiv/Fin.lean

Proof steps:
state_before: m✝ n : ℕ
i : Fin (n + 1)
m : Fin n
h : i ≤ m.castSucc
⊢ (finSuccEquiv' i) m.succ = some m
state_after: no goals
tactic: rw [← Fin.succAbove_of_le_castSucc _ _ h, finSuccEquiv'_succAbove]
Theorem: Polynomial.natDegree_sub_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
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
tactic: simpa only [← natDegree_neg q] using natDegree_add_le p (-q)
Theorem: HasProd.prod_range_mul
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
k : ℕ
h : HasProd (fun n => f (n + k)) m
⊢ HasProd f ((∏ i ∈ range k, f i) * m)
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
k : ℕ
h : HasProd (fun n => f (n + k)) m
⊢ HasProd (f ∘ Subtype.val) m
tactic: refine ((range k).hasProd f).mul_compl ?_
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
k : ℕ
h : HasProd (fun n => f (n + k)) m
⊢ HasProd (f ∘ Subtype.val) m
state_after: no goals
tactic: rwa [← (notMemRangeEquiv k).symm.hasProd_iff]
Theorem: ENNReal.tsum_const_eq_top_of_ne_zero
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α✝ → ℝ≥0∞
α : Type u_4
inst✝ : Infinite α
c : ℝ≥0∞
hc : c ≠ 0
⊢ ∑' (x : α), c = ⊤
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α✝ → ℝ≥0∞
α : Type u_4
inst✝ : Infinite α
c : ℝ≥0∞
hc : c ≠ 0
A : Tendsto (fun n => ↑n * c) atTop (𝓝 (⊤ * c))
⊢ ∑' (x : α), c = ⊤
tactic: have A : Tendsto (fun n : ℕ => (n : ℝ≥0∞) * c) atTop (𝓝 (∞ * c)) := by
    apply ENNReal.Tendsto.mul_const tendsto_nat_nhds_top
    simp only [true_or_iff, top_ne_zero, Ne, not_false_iff]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α✝ → ℝ≥0∞
α : Type u_4
inst✝ : Infinite α
c : ℝ≥0∞
hc : c ≠ 0
A : Tendsto (fun n => ↑n * c) atTop (𝓝 (⊤ * c))
⊢ ∑' (x : α), c = ⊤
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α✝ → ℝ≥0∞
α : Type u_4
inst✝ : Infinite α
c : ℝ≥0∞
hc : c ≠ 0
A : Tendsto (fun n => ↑n * c) atTop (𝓝 (⊤ * c))
B : ∀ (n : ℕ), ↑n * c ≤ ∑' (x : α), c
⊢ ∑' (x : α), c = ⊤
tactic: have B : ∀ n : ℕ, (n : ℝ≥0∞) * c ≤ ∑' _ : α, c := fun n => by
    rcases Infinite.exists_subset_card_eq α n with ⟨s, hs⟩
    simpa [hs] using @ENNReal.sum_le_tsum α (fun _ => c) s
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f g : α✝ → ℝ≥0∞
α : Type u_4
inst✝ : Infinite α
c : ℝ≥0∞
hc : c ≠ 0
A : Tendsto (fun n => ↑n * c) atTop (𝓝 (⊤ * c))
B : ∀ (n : ℕ), ↑n * c ≤ ∑' (x : α), c
⊢ ∑' (x : α), c = ⊤
state_after: no goals
tactic: simpa [hc] using le_of_tendsto' A B
Theorem: Orientation.kahler_rotation_right
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
θ : Real.Angle
⊢ (o.kahler x) ((o.rotation θ) y) = ↑θ.expMapCircle * (o.kahler x) y
state_after: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
θ : Real.Angle
⊢ ↑θ.cos * (o.kahler x) y + ↑θ.sin * (I * (o.kahler x) y) = (↑θ.cos + ↑θ.sin * I) * (o.kahler x) y
tactic: simp only [o.rotation_apply, map_add, LinearMap.map_smulₛₗ, RingHom.id_apply, real_smul,
    kahler_rightAngleRotation_right, Real.Angle.coe_expMapCircle]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
θ : Real.Angle
⊢ ↑θ.cos * (o.kahler x) y + ↑θ.sin * (I * (o.kahler x) y) = (↑θ.cos + ↑θ.sin * I) * (o.kahler x) y
state_after: no goals
tactic: ring
Theorem: Multiset.noncommSum_eq_card_nsmul
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
s : Multiset α
comm : {x | x ∈ s}.Pairwise Commute
m : α
h : ∀ x ∈ s, x = m
⊢ s.noncommProd comm = m ^ card s
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
m : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ ⟦a✝⟧, x = m
⊢ noncommProd ⟦a✝⟧ comm = m ^ card ⟦a✝⟧
tactic: induction s using Quotient.inductionOn
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
m : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ ⟦a✝⟧, x = m
⊢ noncommProd ⟦a✝⟧ comm = m ^ card ⟦a✝⟧
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
m : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ a✝, x = m
⊢ a✝.prod = m ^ a✝.length
tactic: simp only [quot_mk_to_coe, noncommProd_coe, coe_card, mem_coe] at *
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
m : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ a✝, x = m
⊢ a✝.prod = m ^ a✝.length
state_after: no goals
tactic: exact List.prod_eq_pow_card _ m h
Theorem: CategoryTheory.OplaxMonoidalFunctor.right_unitality_hom
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : OplaxMonoidalFunctor C D
X : C
⊢ F.δ X (𝟙_ C) ≫ F.obj X ◁ F.η ≫ (ρ_ (F.obj X)).hom = F.map (ρ_ X).hom
state_after: no goals
tactic: rw [← Category.assoc, ← Iso.eq_comp_inv, F.right_unitality, ← Category.assoc,
    ← F.toFunctor.map_comp, Iso.hom_inv_id, F.toFunctor.map_id, id_comp]
Theorem: smul_nonpos_iff_pos_imp_nonpos
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
a : α
b : β
⊢ a • b ≤ 0 ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a)
state_after: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
a : α
b : β
⊢ (0 < a → 0 ≤ -b) ∧ (0 < -b → 0 ≤ a) ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a)
tactic: rw [← neg_nonneg, ← smul_neg, smul_nonneg_iff_pos_imp_nonneg]
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
a : α
b : β
⊢ (0 < a → 0 ≤ -b) ∧ (0 < -b → 0 ≤ a) ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a)
state_after: no goals
tactic: simp only [neg_pos, neg_nonneg]
Theorem: div_lt_one_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
⊢ a / b < 1 ↔ 0 < b ∧ a < b ∨ b = 0 ∨ b < 0 ∧ b < a
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
⊢ a / b < 1 ↔ 0 < b ∧ a < b ∨ b = 0 ∨ b < 0 ∧ b < a

case inr.inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a c d : α
n : ℤ
⊢ a / 0 < 1 ↔ 0 < 0 ∧ a < 0 ∨ 0 = 0 ∨ 0 < 0 ∧ 0 < a

case inr.inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : 0 < b
⊢ a / b < 1 ↔ 0 < b ∧ a < b ∨ b = 0 ∨ b < 0 ∧ b < a
tactic: rcases lt_trichotomy b 0 with (hb | rfl | hb)
Theorem: MeasureTheory.analyticSet_empty
File: Mathlib/MeasureTheory/Constructions/Polish/Basic.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
inst✝ : TopologicalSpace α
⊢ AnalyticSet ∅
state_after: α : Type u_1
ι : Type u_2
inst✝ : TopologicalSpace α
⊢ ∅ = ∅ ∨ ∃ f, Continuous f ∧ range f = ∅
tactic: rw [AnalyticSet]
state_before: α : Type u_1
ι : Type u_2
inst✝ : TopologicalSpace α
⊢ ∅ = ∅ ∨ ∃ f, Continuous f ∧ range f = ∅
state_after: no goals
tactic: exact Or.inl rfl
Theorem: List.filter_sublist
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
⊢ filter p (a :: l) <+ a :: l
state_after: α : Type u_1
p : α → Bool
a : α
l : List α
⊢ (match p a with
    | true => a :: filter p l
    | false => filter p l) <+
    a :: l
tactic: rw [filter]
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
⊢ (match p a with
    | true => a :: filter p l
    | false => filter p l) <+
    a :: l
state_after: no goals
tactic: split <;> simp [Sublist.cons, Sublist.cons₂, filter_sublist l]
Theorem: ENNReal.limsup_mul_le
File: Mathlib/Order/Filter/ENNReal.lean

Proof steps:
state_before: α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u v : α → ℝ≥0∞
⊢ limsup (u * v) f ≤ limsup (fun x => limsup u f * v x) f
state_after: α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u v : α → ℝ≥0∞
⊢ u * v ≤ᶠ[f] fun x => limsup u f * v x
tactic: refine limsup_le_limsup ?_
state_before: α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u v : α → ℝ≥0∞
⊢ u * v ≤ᶠ[f] fun x => limsup u f * v x
state_after: no goals
tactic: filter_upwards [@eventually_le_limsup _ f _ u] with x hx using mul_le_mul' hx le_rfl
Theorem: CategoryTheory.Localization.SmallHom.mk_id_comp
File: Mathlib/CategoryTheory/Localization/SmallHom.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
D' : Type u₃
inst✝² : Category.{v₃, u₃} D'
X Y Z T : C
inst✝¹ : HasSmallLocalizedHom W X Y
inst✝ : HasSmallLocalizedHom W X X
α : SmallHom W X Y
⊢ (equiv W W.Q) ((mk W (𝟙 X)).comp α) = (equiv W W.Q) α
state_after: no goals
tactic: simp [equiv_comp]
Theorem: Cardinal.mul_eq_right
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b : Cardinal.{u_1}
hb : ℵ₀ ≤ b
ha : a ≤ b
ha' : a ≠ 0
⊢ a * b = b
state_after: no goals
tactic: rw [mul_comm, mul_eq_left hb ha ha']
Theorem: odd_add_self_one'
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n : ℕ
⊢ Odd (a + (a + 1))
state_after: no goals
tactic: simp [← add_assoc]
Theorem: TopologicalSpace.Opens.openEmbedding_of_le
File: Mathlib/Topology/Sets/Opens.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
U V : Opens α
i : U ≤ V
⊢ IsOpen (range (inclusion ⋯))
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
U V : Opens α
i : U ≤ V
⊢ IsOpen {x | ↑x ∈ ↑U}
tactic: rw [Set.range_inclusion i]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
U V : Opens α
i : U ≤ V
⊢ IsOpen {x | ↑x ∈ ↑U}
state_after: no goals
tactic: exact U.isOpen.preimage continuous_subtype_val
Theorem: Equiv.Perm.IsThreeCycle.isCycle
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
h : σ.IsThreeCycle
⊢ σ.IsCycle
state_after: no goals
tactic: rw [← card_cycleType_eq_one, h.cycleType, card_singleton]
Theorem: Set.monotone_or_antitone_iff_uIcc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ Monotone f ∨ Antitone f ↔ ∀ (a b c : α), c ∈ [[a, b]] → f c ∈ [[f a, f b]]
state_after: case mp
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ Monotone f ∨ Antitone f → ∀ (a b c : α), c ∈ [[a, b]] → f c ∈ [[f a, f b]]

case mpr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ (∀ (a b c : α), c ∈ [[a, b]] → f c ∈ [[f a, f b]]) → Monotone f ∨ Antitone f
tactic: constructor
state_before: case mpr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ (∀ (a b c : α), c ∈ [[a, b]] → f c ∈ [[f a, f b]]) → Monotone f ∨ Antitone f
state_after: case mpr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ ¬Monotone f ∧ ¬Antitone f → ∃ a b, ∃ c ∈ [[a, b]], f c ∉ [[f a, f b]]
tactic: contrapose!
state_before: case mpr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ ¬Monotone f ∧ ¬Antitone f → ∃ a b, ∃ c ∈ [[a, b]], f c ∉ [[f a, f b]]
state_after: case mpr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ (∃ a b c, a ≤ b ∧ b ≤ c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)) → ∃ a b, ∃ c ∈ [[a, b]], f c ∉ [[f a, f b]]
tactic: rw [not_monotone_not_antitone_iff_exists_le_le]
state_before: case mpr
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ (∃ a b c, a ≤ b ∧ b ≤ c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)) → ∃ a b, ∃ c ∈ [[a, b]], f c ∉ [[f a, f b]]
state_after: case mpr.intro.intro.intro.intro.intro.inl.intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ d x a b c : α
hab : a ≤ b
hbc : b ≤ c
hfab : f a < f b
hfcb : f c < f b
⊢ ∃ a b, ∃ c ∈ [[a, b]], f c ∉ [[f a, f b]]

case mpr.intro.intro.intro.intro.intro.inr.intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ d x a b c : α
hab : a ≤ b
hbc : b ≤ c
hfba : f b < f a
hfbc : f b < f c
⊢ ∃ a b, ∃ c ∈ [[a, b]], f c ∉ [[f a, f b]]
tactic: rintro ⟨a, b, c, hab, hbc, ⟨hfab, hfcb⟩ | ⟨hfba, hfbc⟩⟩
Theorem: List.Perm.prod_eq'
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ l₁.prod = l₂.prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ ∀ x ∈ l₁, ∀ y ∈ l₁, ∀ (z : M), z * x * y = z * y * x
tactic: refine h.foldl_eq' ?_ _
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ ∀ x ∈ l₁, ∀ y ∈ l₁, ∀ (z : M), z * x * y = z * y * x
state_after: case H
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ Symmetric fun x y => ∀ (z : M), z * x * y = z * y * x

case H₁
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ ∀ x ∈ l₁, ∀ (z : M), z * x * x = z * x * x

case H₂
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
h : l₁ ~ l₂
hc : Pairwise Commute l₁
⊢ Pairwise (fun x y => ∀ (z : M), z * x * y = z * y * x) l₁
tactic: apply Pairwise.forall_of_forall
Theorem: Set.prod_eq_empty_iff
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅
state_after: no goals
tactic: simp only [not_nonempty_iff_eq_empty.symm, prod_nonempty_iff, not_and_or]