ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Filter.tendsto_pure
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : α → β
a : Filter α
b : β
⊢ Tendsto f a (pure b) ↔ ∀ᶠ (x : α) in a, f x = b
state_after: no goals
tactic: simp only [Tendsto, le_pure_iff, mem_map', mem_singleton_iff, Filter.Eventually]
Theorem: Finset.eq_prod_range_div
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
M : Type u_6
inst✝ : CommGroup M
f : ℕ → M
n : ℕ
⊢ f n = f 0 * ∏ i ∈ range n, f (i + 1) / f i
state_after: no goals
tactic: rw [prod_range_div, mul_div_cancel]
Theorem: Fermat42.exists_pos_odd_minimal
File: Mathlib/NumberTheory/FLT/Four.lean

Proof steps:
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0
state_after: case intro.intro.intro.intro
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0
tactic: obtain ⟨a0, b0, c0, hf, hc⟩ := exists_odd_minimal h
state_before: case intro.intro.intro.intro
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0
state_after: case intro.intro.intro.intro.inl
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
h1 : 0 < c0
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0

case intro.intro.intro.intro.inr.inl
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
h1 : 0 = c0
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0

case intro.intro.intro.intro.inr.inr
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hc : a0 % 2 = 1
h1 : c0 < 0
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1 ∧ 0 < c0
tactic: rcases lt_trichotomy 0 c0 with (h1 | h1 | h1)
Theorem: CategoryTheory.isCoseparating_iff_mono
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
𝒢 : Set C
inst✝ : ∀ (A : C), HasProduct fun f => ↑f.fst
⊢ IsCoseparating 𝒢 ↔ ∀ (A : C), Mono (Pi.lift Sigma.snd)
state_after: case refine_1
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
𝒢 : Set C
inst✝ : ∀ (A : C), HasProduct fun f => ↑f.fst
h : IsCoseparating 𝒢
A Z✝ : C
u v : Z✝ ⟶ A
huv : u ≫ Pi.lift Sigma.snd = v ≫ Pi.lift Sigma.snd
G : C
hG : G ∈ 𝒢
f : A ⟶ G
⊢ u ≫ f = v ≫ f

case refine_2
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
𝒢 : Set C
inst✝ : ∀ (A : C), HasProduct fun f => ↑f.fst
h : ∀ (A : C), Mono (Pi.lift Sigma.snd)
X Y : C
f g : X ⟶ Y
hh : ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
⊢ f = g
tactic: refine ⟨fun h A => ⟨fun u v huv => h _ _ fun G hG f => ?_⟩, fun h X Y f g hh => ?_⟩
Theorem: Rat.toNNRat_pos
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: p q : ℚ
⊢ 0 < q.toNNRat ↔ 0 < q
state_after: no goals
tactic: simp [toNNRat, ← coe_lt_coe]
Theorem: CategoryTheory.Limits.Cofork.app_zero_eq_comp_π_left
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
s : Cofork f g
⊢ s.ι.app zero = f ≫ s.π
state_after: no goals
tactic: rw [← s.app_one_eq_π, ← s.w left, parallelPair_map_left]
Theorem: ZNum.ofInt'_eq
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
n : ℕ
⊢ ofInt' -[n+1] = ↑-[n+1]
state_after: α : Type u_1
n : ℕ
⊢ (↑(n + 1)).toZNumNeg = -↑(n + 1)
tactic: show Num.toZNumNeg (n + 1 : ℕ) = -(n + 1 : ℕ)
state_before: α : Type u_1
n : ℕ
⊢ (↑(n + 1)).toZNumNeg = -↑(n + 1)
state_after: α : Type u_1
n : ℕ
⊢ (↑n).toZNum.succ = (↑n).succ
tactic: rw [← neg_inj, neg_neg, Nat.cast_succ, Num.add_one, Num.zneg_toZNumNeg, Num.toZNum_succ,
      Nat.cast_succ, ZNum.add_one]
state_before: α : Type u_1
n : ℕ
⊢ (↑n).toZNum.succ = (↑n).succ
state_after: no goals
tactic: rfl
Theorem: TensorAlgebra.lift_ι_apply
File: Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : M →ₗ[R] A
x : M
⊢ ((lift R) f) ((ι R) x) = f x
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : M →ₗ[R] A
x : M
⊢ ((lift R) f) ((ι R) x) = (((lift R) f).toLinearMap ∘ₗ ι R) x
tactic: conv_rhs => rw [← ι_comp_lift f]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : M →ₗ[R] A
x : M
⊢ ((lift R) f) ((ι R) x) = (((lift R) f).toLinearMap ∘ₗ ι R) x
state_after: no goals
tactic: rfl
Theorem: Submodule.smul_mem_span_smul
File: Mathlib/Algebra/Algebra/Tower.lean

Proof steps:
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid A
inst✝³ : Module R S
inst✝² : Module S A
inst✝¹ : Module R A
inst✝ : IsScalarTower R S A
s : Set S
hs : span R s = ⊤
t : Set A
k : S
x : A
hx : x ∈ span R t
⊢ k • x ∈ span R (s • t)
state_after: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid A
inst✝³ : Module R S
inst✝² : Module S A
inst✝¹ : Module R A
inst✝ : IsScalarTower R S A
s : Set S
hs : span R s = ⊤
t : Set A
k : S
x : A
hx : x ∈ span R t
⊢ k • x ∈ restrictScalars R (span S t)
tactic: rw [span_smul_of_span_eq_top hs]
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid A
inst✝³ : Module R S
inst✝² : Module S A
inst✝¹ : Module R A
inst✝ : IsScalarTower R S A
s : Set S
hs : span R s = ⊤
t : Set A
k : S
x : A
hx : x ∈ span R t
⊢ k • x ∈ restrictScalars R (span S t)
state_after: no goals
tactic: exact (span S t).smul_mem k (span_le_restrictScalars R S t hx)
Theorem: inTangentCoordinates_model_space
File: Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H : Type u_4
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝⁸ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_6
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : SmoothManifoldWithCorners I M
M' : Type u_7
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
N : Type u_9
f : N → H
g : N → H'
ϕ : N → E →L[𝕜] E'
x₀ : N
⊢ inTangentCoordinates I I' f g ϕ x₀ = ϕ
state_after: no goals
tactic: simp (config := { unfoldPartialApp := true }) only [inTangentCoordinates,
    inCoordinates_tangent_bundle_core_model_space]
Theorem: BoxIntegral.Prepartition.iUnion_disjUnion
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
h : Disjoint π₁.iUnion π₂.iUnion
⊢ (π₁.disjUnion π₂ h).iUnion = π₁.iUnion ∪ π₂.iUnion
state_after: no goals
tactic: simp [disjUnion, Prepartition.iUnion, iUnion_or, iUnion_union_distrib]
Theorem: SimplicialObject.Splitting.ιSummand_comp_d_comp_πSummand_eq_zero
File: Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
j k : ℕ
A : IndexSet (op [j])
hA : ¬A.EqId
⊢ (s.cofan (op [j])).inj A ≫ K[X].d j k ≫ s.πSummand (IndexSet.id (op [k])) = 0
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
j k : ℕ
A : IndexSet (op [j])
hA : ¬Mono A.e
⊢ (s.cofan (op [j])).inj A ≫ K[X].d j k ≫ s.πSummand (IndexSet.id (op [k])) = 0
tactic: rw [A.eqId_iff_mono] at hA
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
j k : ℕ
A : IndexSet (op [j])
hA : ¬Mono A.e
⊢ (s.cofan (op [j])).inj A ≫ K[X].d j k ≫ s.πSummand (IndexSet.id (op [k])) = 0
state_after: no goals
tactic: rw [← assoc, ← s.comp_PInfty_eq_zero_iff, assoc, ← PInfty.comm j k, s.cofan_inj_eq, assoc,
    degeneracy_comp_PInfty_assoc X j A.e hA, zero_comp, comp_zero]
Theorem: SimpleGraph.dotProduct_mulVec_degMatrix
File: Mathlib/Combinatorics/SimpleGraph/LapMatrix.lean

Proof steps:
state_before: V : Type u_1
R : Type u_2
inst✝³ : Fintype V
inst✝² : DecidableEq V
G : SimpleGraph V
inst✝¹ : DecidableRel G.Adj
inst✝ : CommRing R
x : V → R
⊢ x ⬝ᵥ degMatrix R G *ᵥ x = ∑ i : V, ↑(G.degree i) * x i * x i
state_after: no goals
tactic: simp only [dotProduct, degMatrix, mulVec_diagonal, ← mul_assoc, mul_comm]
Theorem: Bool.ofNat_le_ofNat
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: n m : Nat
h : n ≤ m
⊢ ofNat n ≤ ofNat m
state_after: n m : Nat
h : n ≤ m
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
tactic: simp only [ofNat, ne_eq, _root_.decide_not]
state_before: n m : Nat
h : n ≤ m
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
state_after: no goals
tactic: cases Nat.decEq n 0 with
  | isTrue hn => rw [_root_.decide_eq_true hn]; exact Bool.false_le _
  | isFalse hn =>
    cases Nat.decEq m 0 with
    | isFalse hm => rw [_root_.decide_eq_false hm]; exact Bool.le_true _
    | isTrue hm => subst hm; have h := Nat.le_antisymm h (Nat.zero_le n); contradiction
Theorem: CategoryTheory.Limits.kernelComparison_comp_kernel_map
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map f ≫ G.map q = G.map p ≫ G.map g
state_after: no goals
tactic: rw [← G.map_comp, hpq, G.map_comp]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (kernel.ι f) ≫ G.map f = 0
state_after: no goals
tactic: rw [← G.map_comp, kernel.condition, G.map_zero]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (kernel.ι g) ≫ G.map g = 0
state_after: no goals
tactic: rw [← G.map_comp, kernel.condition, G.map_zero]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (kernel.ι f) ≫ G.map p = G.map (kernel.map f g p q hpq) ≫ G.map (kernel.ι g)
state_after: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (kernel.ι f ≫ p) = G.map (kernel.map f g p q hpq ≫ kernel.ι g)
tactic: simp only [← G.map_comp]
state_before: C : Type u
inst✝⁸ : Category.{v, u} C
inst✝⁷ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
inst✝⁵ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁴ : G.PreservesZeroMorphisms
X' Y' : C
inst✝³ : HasKernel f
inst✝² : HasKernel (G.map f)
g : X' ⟶ Y'
inst✝¹ : HasKernel g
inst✝ : HasKernel (G.map g)
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map (kernel.ι f ≫ p) = G.map (kernel.map f g p q hpq ≫ kernel.ι g)
state_after: no goals
tactic: exact G.congr_map (kernel.lift_ι _ _ _).symm
Theorem: Matrix.isUnit_iff_isUnit_det
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
⊢ IsUnit A ↔ IsUnit A.det
state_after: no goals
tactic: simp only [← nonempty_invertible_iff_isUnit, (invertibleEquivDetInvertible A).nonempty_congr]
Theorem: IsAntichain.ordConnected
File: Mathlib/Order/Interval/Set/OrdConnected.lean

Proof steps:
state_before: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x✝ y✝ : α
hs : IsAntichain (fun x x_1 => x ≤ x_1) s
x : α
hx : x ∈ s
y : α
hy : y ∈ s
z : α
hz : z ∈ Icc x y
⊢ z ∈ s
state_after: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x✝ y : α
hs : IsAntichain (fun x x_1 => x ≤ x_1) s
x : α
hx : x ∈ s
z : α
hy : x ∈ s
hz : z ∈ Icc x x
⊢ z ∈ s
tactic: obtain rfl := hs.eq hx hy (hz.1.trans hz.2)
state_before: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x✝ y : α
hs : IsAntichain (fun x x_1 => x ≤ x_1) s
x : α
hx : x ∈ s
z : α
hy : x ∈ s
hz : z ∈ Icc x x
⊢ z ∈ s
state_after: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x✝ y : α
hs : IsAntichain (fun x x_1 => x ≤ x_1) s
x : α
hx : x ∈ s
z : α
hy : x ∈ s
hz : z = x
⊢ z ∈ s
tactic: rw [Icc_self, mem_singleton_iff] at hz
state_before: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x✝ y : α
hs : IsAntichain (fun x x_1 => x ≤ x_1) s
x : α
hx : x ∈ s
z : α
hy : x ∈ s
hz : z = x
⊢ z ∈ s
state_after: no goals
tactic: rwa [hz]
Theorem: CategoryTheory.MorphismProperty.map_le_iff
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
P : MorphismProperty C
F : C ⥤ D
Q : MorphismProperty D
inst✝ : Q.RespectsIso
⊢ P.map F ≤ Q ↔ P ≤ Q.inverseImage F
state_after: case mp
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
P : MorphismProperty C
F : C ⥤ D
Q : MorphismProperty D
inst✝ : Q.RespectsIso
⊢ P.map F ≤ Q → P ≤ Q.inverseImage F

case mpr
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
P : MorphismProperty C
F : C ⥤ D
Q : MorphismProperty D
inst✝ : Q.RespectsIso
⊢ P ≤ Q.inverseImage F → P.map F ≤ Q
tactic: constructor
Theorem: Profinite.NobelingProof.Products.lt_iff_lex_lt
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l m : Products I
⊢ l < m ↔ List.Lex (fun x x_1 => x < x_1) ↑l ↑m
state_after: case mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
m : Products I
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ ⟨val✝, property✝⟩ < m ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝, property✝⟩ ↑m
tactic: cases l
state_before: case mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
m : Products I
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ ⟨val✝, property✝⟩ < m ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝, property✝⟩ ↑m
state_after: case mk.mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
val✝¹ : List I
property✝¹ : List.Chain' (fun x x_1 => x > x_1) val✝¹
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ ⟨val✝¹, property✝¹⟩ < ⟨val✝, property✝⟩ ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝¹, property✝¹⟩ ↑⟨val✝, property✝⟩
tactic: cases m
state_before: case mk.mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
val✝¹ : List I
property✝¹ : List.Chain' (fun x x_1 => x > x_1) val✝¹
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ ⟨val✝¹, property✝¹⟩ < ⟨val✝, property✝⟩ ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝¹, property✝¹⟩ ↑⟨val✝, property✝⟩
state_after: case mk.mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
val✝¹ : List I
property✝¹ : List.Chain' (fun x x_1 => x > x_1) val✝¹
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ val✝¹ < val✝ ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝¹, property✝¹⟩ ↑⟨val✝, property✝⟩
tactic: rw [Subtype.mk_lt_mk]
state_before: case mk.mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
val✝¹ : List I
property✝¹ : List.Chain' (fun x x_1 => x > x_1) val✝¹
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ val✝¹ < val✝ ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝¹, property✝¹⟩ ↑⟨val✝, property✝⟩
state_after: no goals
tactic: exact Iff.rfl
Theorem: Quiver.Path.toList_injective
File: Mathlib/Combinatorics/Quiver/Path.lean

Proof steps:
state_before: V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a c : V
p : Path a c
f : c ⟶ a
h : nil.toList = (p.cons f).toList
⊢ nil = p.cons f
state_after: no goals
tactic: cases h
state_before: V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a c : V
p : Path a c
f : c ⟶ a
h : (p.cons f).toList = nil.toList
⊢ p.cons f = nil
state_after: no goals
tactic: cases h
state_before: V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a x✝ c : V
p : Path a c
f : c ⟶ x✝
t : V
C : Path a t
D : t ⟶ x✝
h : (p.cons f).toList = (C.cons D).toList
⊢ p.cons f = C.cons D
state_after: V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a x✝ c : V
p : Path a c
f : c ⟶ x✝
t : V
C : Path a t
D : t ⟶ x✝
h : c = t ∧ p.toList = C.toList
⊢ p.cons f = C.cons D
tactic: simp only [toList, List.cons.injEq] at h
state_before: V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a x✝ c : V
p : Path a c
f : c ⟶ x✝
t : V
C : Path a t
D : t ⟶ x✝
h : c = t ∧ p.toList = C.toList
⊢ p.cons f = C.cons D
state_after: case intro
V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a x✝ c : V
p : Path a c
f : c ⟶ x✝
C : Path a c
D : c ⟶ x✝
hAC : p.toList = C.toList
⊢ p.cons f = C.cons D
tactic: obtain ⟨rfl, hAC⟩ := h
state_before: case intro
V : Type u
inst✝¹ : Quiver V
a✝ b c✝ d : V
inst✝ : ∀ (a b : V), Subsingleton (a ⟶ b)
a x✝ c : V
p : Path a c
f : c ⟶ x✝
C : Path a c
D : c ⟶ x✝
hAC : p.toList = C.toList
⊢ p.cons f = C.cons D
state_after: no goals
tactic: simp [toList_injective _ _ hAC, eq_iff_true_of_subsingleton]
Theorem: AddMonoid.Coprod.range_lift
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝² : Group G
inst✝¹ : Group H
K : Type u_3
inst✝ : Group K
f : G →* K
g : H →* K
⊢ (lift f g).range = f.range ⊔ g.range
state_after: no goals
tactic: simp [range_eq]
Theorem: Finsupp.neLocus_neg
File: Mathlib/Data/Finsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ (-f).neLocus g = f.neLocus (-g)
state_after: no goals
tactic: rw [← neLocus_neg_neg, neg_neg]
Theorem: Real.rpow_lt_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hxy : x < y
hz : 0 < z
⊢ x ^ z < y ^ z
state_after: x y z : ℝ
n : ℕ
hx : 0 = x ∨ 0 < x
hxy : x < y
hz : 0 < z
⊢ x ^ z < y ^ z
tactic: rw [le_iff_eq_or_lt] at hx
state_before: x y z : ℝ
n : ℕ
hx : 0 = x ∨ 0 < x
hxy : x < y
hz : 0 < z
⊢ x ^ z < y ^ z
state_after: case inl
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 = x
⊢ x ^ z < y ^ z

case inr
x y z : ℝ
n : ℕ
hxy : x < y
hz : 0 < z
hx : 0 < x
⊢ x ^ z < y ^ z
tactic: cases' hx with hx hx
Theorem: MeasureTheory.TendstoInMeasure.exists_seq_tendstoInMeasure_atTop
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
⊢ ∃ ns, TendstoInMeasure μ (fun n => f (ns n)) atTop g
state_after: case intro
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
ns : ℕ → ι
h_tendsto_ns : Tendsto ns atTop u
⊢ ∃ ns, TendstoInMeasure μ (fun n => f (ns n)) atTop g
tactic: obtain ⟨ns, h_tendsto_ns⟩ : ∃ ns : ℕ → ι, Tendsto ns atTop u := exists_seq_tendsto u
state_before: case intro
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
ns : ℕ → ι
h_tendsto_ns : Tendsto ns atTop u
⊢ ∃ ns, TendstoInMeasure μ (fun n => f (ns n)) atTop g
state_after: no goals
tactic: exact ⟨ns, fun ε hε => (hfg ε hε).comp h_tendsto_ns⟩
Theorem: MeasureTheory.SimpleFunc.const_lintegral
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
⊢ (const α c).lintegral μ = c * μ univ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
⊢ ∑ x ∈ (const α c).range, x * μ (↑(const α c) ⁻¹' {x}) = c * μ univ
tactic: rw [lintegral]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
⊢ ∑ x ∈ (const α c).range, x * μ (↑(const α c) ⁻¹' {x}) = c * μ univ
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
h✝ : IsEmpty α
⊢ ∑ x ∈ (const α c).range, x * μ (↑(const α c) ⁻¹' {x}) = c * μ univ

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
h✝ : Nonempty α
⊢ ∑ x ∈ (const α c).range, x * μ (↑(const α c) ⁻¹' {x}) = c * μ univ
tactic: cases isEmpty_or_nonempty α
Theorem: HasStrictFDerivAt.smul_const
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁵ : NormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
𝕜' : Type u_6
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : E → 𝕜'
c' : E →L[𝕜] 𝕜'
hc : HasStrictFDerivAt c c' x
f : F
⊢ HasStrictFDerivAt (fun y => c y • f) (c'.smulRight f) x
state_after: no goals
tactic: simpa only [smul_zero, zero_add] using hc.smul (hasStrictFDerivAt_const f x)