ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.right_le_pair
File: Mathlib/Data/Nat/Pairing.lean

Proof steps:
state_before: a b : ℕ
⊢ b ≤ pair a b
state_after: case pos
a b : ℕ
h : a < b
⊢ b ≤ pair a b

case neg
a b : ℕ
h : ¬a < b
⊢ b ≤ pair a b
tactic: by_cases h : a < b
Theorem: List.reduceOption_concat
File: Mathlib/Data/List/ReduceOption.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : List (Option α)
x : Option α
⊢ (l.concat x).reduceOption = l.reduceOption ++ x.toList
state_after: case nil
α : Type u_1
β : Type u_2
x : Option α
⊢ ([].concat x).reduceOption = [].reduceOption ++ x.toList

case cons
α : Type u_1
β : Type u_2
hd : Option α
tl : List (Option α)
hl : ∀ (x : Option α), (tl.concat x).reduceOption = tl.reduceOption ++ x.toList
x : Option α
⊢ ((hd :: tl).concat x).reduceOption = (hd :: tl).reduceOption ++ x.toList
tactic: induction' l with hd tl hl generalizing x
Theorem: div_div_eq_mul_div
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
⊢ a / (b / c) = a * c / b
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.splitEpiOfIdempotentOfIsColimitCofork_section_
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
X : C
f : X ⟶ X
hf : f ≫ f = f
c : Cofork (𝟙 X) f
i : IsColimit c
⊢ 𝟙 X ≫ f = f ≫ f
state_after: no goals
tactic: simp [hf]
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f✝ g : X✝ ⟶ Y
X : C
f : X ⟶ X
hf : f ≫ f = f
c : Cofork (𝟙 X) f
i : IsColimit c
⊢ i.desc (Cofork.ofπ f ⋯) ≫ c.π = 𝟙 (((Functor.const WalkingParallelPair).obj c.pt).obj one)
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f✝ g : X✝ ⟶ Y
X : C
f : X ⟶ X
hf : f ≫ f = f
c : Cofork (𝟙 X) f
i : IsColimit c
this : Epi c.π := epi_of_isColimit_cofork i
⊢ i.desc (Cofork.ofπ f ⋯) ≫ c.π = 𝟙 (((Functor.const WalkingParallelPair).obj c.pt).obj one)
tactic: letI := epi_of_isColimit_cofork i
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f✝ g : X✝ ⟶ Y
X : C
f : X ⟶ X
hf : f ≫ f = f
c : Cofork (𝟙 X) f
i : IsColimit c
this : Epi c.π := epi_of_isColimit_cofork i
⊢ i.desc (Cofork.ofπ f ⋯) ≫ c.π = 𝟙 (((Functor.const WalkingParallelPair).obj c.pt).obj one)
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f✝ g : X✝ ⟶ Y
X : C
f : X ⟶ X
hf : f ≫ f = f
c : Cofork (𝟙 X) f
i : IsColimit c
this : Epi c.π := epi_of_isColimit_cofork i
⊢ 𝟙 X ≫ c.π = c.π
tactic: rw [← cancel_epi_id c.π, ← Category.assoc, Cofork.IsColimit.π_desc, Cofork.π_ofπ, ←
      c.condition]
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f✝ g : X✝ ⟶ Y
X : C
f : X ⟶ X
hf : f ≫ f = f
c : Cofork (𝟙 X) f
i : IsColimit c
this : Epi c.π := epi_of_isColimit_cofork i
⊢ 𝟙 X ≫ c.π = c.π
state_after: no goals
tactic: exact Category.id_comp _
Theorem: Nat.le_nth_of_lt_nth_succ
File: Mathlib/Data/Nat/Nth.lean

Proof steps:
state_before: p : ℕ → Prop
k a : ℕ
h : a < nth p (k + 1)
ha : p a
⊢ a ≤ nth p k
state_after: case inl
p : ℕ → Prop
k a : ℕ
h : a < nth p (k + 1)
ha : p a
hf : (setOf p).Finite
⊢ a ≤ nth p k

case inr
p : ℕ → Prop
k a : ℕ
h : a < nth p (k + 1)
ha : p a
hf : (setOf p).Infinite
⊢ a ≤ nth p k
tactic: cases' (setOf p).finite_or_infinite with hf hf
Theorem: mem_minimals_iff_forall_lt_not_mem'
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a b x : α
rlt : α → α → Prop
inst✝ : IsNonstrictStrictOrder α r rlt
⊢ x ∈ minimals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, rlt y x → y ∉ s
state_after: no goals
tactic: simp [minimals, right_iff_left_not_left_of r rlt, not_imp_not, imp.swap (a := _ ∈ _)]
Theorem: InnerProductGeometry.sin_angle_add_mul_norm_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
⊢ Real.sin (angle x (x + y)) * ‖x + y‖ = ‖y‖
state_after: case pos
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x = 0 ∧ y = 0
⊢ Real.sin (angle x (x + y)) * ‖x + y‖ = ‖y‖

case neg
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬(x = 0 ∧ y = 0)
⊢ Real.sin (angle x (x + y)) * ‖x + y‖ = ‖y‖
tactic: by_cases h0 : x = 0 ∧ y = 0
state_before: case neg
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬(x = 0 ∧ y = 0)
⊢ Real.sin (angle x (x + y)) * ‖x + y‖ = ‖y‖
state_after: case neg
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬x = 0 ∨ ¬y = 0
⊢ Real.sin (angle x (x + y)) * ‖x + y‖ = ‖y‖
tactic: rw [not_and_or] at h0
state_before: case neg
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬x = 0 ∨ ¬y = 0
⊢ Real.sin (angle x (x + y)) * ‖x + y‖ = ‖y‖
state_after: case neg.h
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬x = 0 ∨ ¬y = 0
⊢ ‖x + y‖ ≠ 0
tactic: rw [sin_angle_add_of_inner_eq_zero h h0, div_mul_cancel₀]
state_before: case neg.h
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬x = 0 ∨ ¬y = 0
⊢ ‖x + y‖ ≠ 0
state_after: case neg.h
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬x = 0 ∨ ¬y = 0
⊢ ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ≠ 0
tactic: rw [← mul_self_ne_zero, norm_add_sq_eq_norm_sq_add_norm_sq_real h]
state_before: case neg.h
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬x = 0 ∨ ¬y = 0
⊢ ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ≠ 0
state_after: case neg.h
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬x = 0 ∨ ¬y = 0
⊢ 0 < ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖
tactic: refine (ne_of_lt ?_).symm
state_before: case neg.h
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬x = 0 ∨ ¬y = 0
⊢ 0 < ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖
state_after: case neg.h.inl
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬x = 0
⊢ 0 < ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖

case neg.h.inr
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : ¬y = 0
⊢ 0 < ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖
tactic: rcases h0 with (h0 | h0)
Theorem: List.chain_cons
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
R : α → α → Prop
a b : α
l : List α
p : Chain R a (b :: l)
⊢ R a b ∧ Chain R b l
state_after: no goals
tactic: cases p with | cons n p => exact ⟨n, p⟩
Theorem: PiTensorProduct.mapL_coe
File: Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean

Proof steps:
state_before: ι : Type uι
inst✝⁹ : Fintype ι
𝕜 : Type u𝕜
inst✝⁸ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝⁵ : SeminormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E' : ι → Type u_1
E'' : ι → Type u_2
inst✝³ : (i : ι) → SeminormedAddCommGroup (E' i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E' i)
inst✝¹ : (i : ι) → SeminormedAddCommGroup (E'' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (E'' i)
g : (i : ι) → E' i →L[𝕜] E'' i
f : (i : ι) → E i →L[𝕜] E' i
⊢ ↑(mapL f) = map fun i => ↑(f i)
state_after: case H.H
ι : Type uι
inst✝⁹ : Fintype ι
𝕜 : Type u𝕜
inst✝⁸ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝⁵ : SeminormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E' : ι → Type u_1
E'' : ι → Type u_2
inst✝³ : (i : ι) → SeminormedAddCommGroup (E' i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E' i)
inst✝¹ : (i : ι) → SeminormedAddCommGroup (E'' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (E'' i)
g : (i : ι) → E' i →L[𝕜] E'' i
f : (i : ι) → E i →L[𝕜] E' i
x✝ : (i : ι) → E i
⊢ ((↑(mapL f)).compMultilinearMap (tprod 𝕜)) x✝ = ((map fun i => ↑(f i)).compMultilinearMap (tprod 𝕜)) x✝
tactic: ext
state_before: case H.H
ι : Type uι
inst✝⁹ : Fintype ι
𝕜 : Type u𝕜
inst✝⁸ : NontriviallyNormedField 𝕜
E : ι → Type uE
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E i)
F : Type uF
inst✝⁵ : SeminormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E' : ι → Type u_1
E'' : ι → Type u_2
inst✝³ : (i : ι) → SeminormedAddCommGroup (E' i)
inst✝² : (i : ι) → NormedSpace 𝕜 (E' i)
inst✝¹ : (i : ι) → SeminormedAddCommGroup (E'' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (E'' i)
g : (i : ι) → E' i →L[𝕜] E'' i
f : (i : ι) → E i →L[𝕜] E' i
x✝ : (i : ι) → E i
⊢ ((↑(mapL f)).compMultilinearMap (tprod 𝕜)) x✝ = ((map fun i => ↑(f i)).compMultilinearMap (tprod 𝕜)) x✝
state_after: no goals
tactic: simp only [mapL, LinearMap.compMultilinearMap_apply, ContinuousLinearMap.coe_coe,
    liftIsometry_apply_apply, lift.tprod, ContinuousMultilinearMap.coe_coe,
    ContinuousMultilinearMap.compContinuousLinearMap_apply, tprodL_toFun, map_tprod]
Theorem: Function.minimalPeriod_snd_dvd
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod g x.2 ∣ minimalPeriod (Prod.map f g) x
state_after: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod g x.2 ∣ (minimalPeriod f x.1).lcm (minimalPeriod g x.2)
tactic: rw [minimalPeriod_prod_map]
state_before: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod g x.2 ∣ (minimalPeriod f x.1).lcm (minimalPeriod g x.2)
state_after: no goals
tactic: exact Nat.dvd_lcm_right _ _
Theorem: MeasurableSpace.generateFrom_natGeneratingSequence
File: Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
m : MeasurableSpace α
inst✝ : CountablyGenerated α
⊢ generateFrom (range (natGeneratingSequence α)) = m
state_after: no goals
tactic: rw [natGeneratingSequence, range_enumerateCountable_of_mem _ empty_mem_countableGeneratingSet,
    generateFrom_countableGeneratingSet]
Theorem: inner_smul_real_left
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
r : ℝ
⊢ ⟪↑r • x, y⟫_𝕜 = r • ⟪x, y⟫_𝕜
state_after: no goals
tactic: rw [inner_smul_left, conj_ofReal, Algebra.smul_def]
Theorem: CategoryTheory.MorphismProperty.inverseImage_equivalence_inverse_eq_map_functor
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 D
inst✝ : P.RespectsIso
E : C ≌ D
⊢ P.inverseImage E.functor = P.map E.inverse
state_after: case a
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
P : MorphismProperty D
inst✝ : P.RespectsIso
E : C ≌ D
⊢ P.inverseImage E.functor ≤ P.map E.inverse

case a
C : Type u
inst✝² : Category.{v, u} C
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
P : MorphismProperty D
inst✝ : P.RespectsIso
E : C ≌ D
⊢ P.map E.inverse ≤ P.inverseImage E.functor
tactic: apply le_antisymm
Theorem: Matrix.empty_vecAlt1
File: Mathlib/Data/Fin/VecNotation.lean

Proof steps:
state_before: α✝ : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
α : Type u_4
h : 0 = 0 + 0
⊢ vecAlt1 h ![] = ![]
state_after: no goals
tactic: simp [eq_iff_true_of_subsingleton]
Theorem: LaurentPolynomial.degree_C
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
a : R
a0 : a ≠ 0
⊢ (C a).degree = 0
state_after: R : Type u_1
inst✝ : Semiring R
a : R
a0 : a ≠ 0
⊢ (C a * T 0).degree = 0
tactic: rw [← mul_one (C a), ← T_zero]
state_before: R : Type u_1
inst✝ : Semiring R
a : R
a0 : a ≠ 0
⊢ (C a * T 0).degree = 0
state_after: no goals
tactic: exact degree_C_mul_T 0 a a0
Theorem: MvPolynomial.supported_le_supported_iff
File: Mathlib/Algebra/MvPolynomial/Supported.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
inst✝ : Nontrivial R
⊢ supported R s ≤ supported R t ↔ s ⊆ t
state_after: case mp
σ : Type u_1
τ : Type u_2
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
inst✝ : Nontrivial R
⊢ supported R s ≤ supported R t → s ⊆ t

case mpr
σ : Type u_1
τ : Type u_2
R : Type u
S : Type v
r : R
e : ℕ
n m : σ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
s t : Set σ
inst✝ : Nontrivial R
⊢ s ⊆ t → supported R s ≤ supported R t
tactic: constructor
Theorem: AddMonoid.le_minOrder_iff_forall_addSubgroup
File: Mathlib/GroupTheory/Order/Min.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
n✝ : ℕ
n : ℕ∞
⊢ n ≤ minOrder α ↔ ∀ ⦃s : Subgroup α⦄, s ≠ ⊥ → (↑s).Finite → n ≤ ↑(Nat.card ↥s)
state_after: α : Type u_1
inst✝ : Group α
s : Subgroup α
n✝ : ℕ
n : ℕ∞
⊢ (∀ ⦃a : α⦄, a ≠ 1 → IsOfFinOrder a → n ≤ ↑(orderOf a)) ↔ ∀ ⦃s : Subgroup α⦄, s ≠ ⊥ → (↑s).Finite → n ≤ ↑(Nat.card ↥s)
tactic: rw [le_minOrder]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
n✝ : ℕ
n : ℕ∞
⊢ (∀ ⦃a : α⦄, a ≠ 1 → IsOfFinOrder a → n ≤ ↑(orderOf a)) ↔ ∀ ⦃s : Subgroup α⦄, s ≠ ⊥ → (↑s).Finite → n ≤ ↑(Nat.card ↥s)
state_after: case refine_1
α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
n✝ : ℕ
n : ℕ∞
h : ∀ ⦃a : α⦄, a ≠ 1 → IsOfFinOrder a → n ≤ ↑(orderOf a)
s : Subgroup α
hs : s ≠ ⊥
hs' : (↑s).Finite
⊢ n ≤ ↑(Nat.card ↥s)

case refine_2
α : Type u_1
inst✝ : Group α
s : Subgroup α
n✝ : ℕ
n : ℕ∞
h : ∀ ⦃s : Subgroup α⦄, s ≠ ⊥ → (↑s).Finite → n ≤ ↑(Nat.card ↥s)
a : α
ha : a ≠ 1
ha' : IsOfFinOrder a
⊢ n ≤ ↑(orderOf a)
tactic: refine ⟨fun h s hs hs' ↦ ?_, fun h a ha ha' ↦ ?_⟩
Theorem: Multiset.ndinter_eq_zero_iff_disjoint
File: Mathlib/Data/Multiset/FinsetOps.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s t : Multiset α
⊢ s.ndinter t = 0 ↔ s.Disjoint t
state_after: α : Type u_1
inst✝ : DecidableEq α
s✝ s t : Multiset α
⊢ s.ndinter t ⊆ 0 ↔ s.Disjoint t
tactic: rw [← subset_zero]
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s t : Multiset α
⊢ s.ndinter t ⊆ 0 ↔ s.Disjoint t
state_after: no goals
tactic: simp [subset_iff, Disjoint]
Theorem: Set.ncard_eq_zero
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
hs : autoParam s.Finite _auto✝
⊢ s.ncard = 0 ↔ s = ∅
state_after: no goals
tactic: rw [← Nat.cast_inj (R := ℕ∞), hs.cast_ncard_eq, Nat.cast_zero, encard_eq_zero]
Theorem: AddMonoidHom.precompEquiv_apply
File: Mathlib/Algebra/Category/Grp/ForgetCorepresentable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝ : β →+ γ
⊢ (fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝) = x✝
state_after: case h
α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝¹ : β →+ γ
x✝ : β
⊢ ((fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝¹ : β →+ γ
x✝ : β
⊢ ((fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝ : α →+ γ
⊢ (fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝) = x✝
state_after: case h
α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝¹ : α →+ γ
x✝ : α
⊢ ((fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
inst✝² : AddMonoid α
inst✝¹ : AddMonoid β
e : α ≃+ β
γ : Type u_3
inst✝ : AddMonoid γ
x✝¹ : α →+ γ
x✝ : α
⊢ ((fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: simp
Theorem: Finset.sum_apply_ite_of_true
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 β
p : α → Prop
hp : DecidablePred p
f g : α → γ
k : γ → β
h : ∀ x ∈ s, p x
⊢ ∏ x ∈ s, k (if p x then f x else g x) = ∏ x ∈ s, k (f x)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
hp : DecidablePred p
f g : α → γ
k : γ → β
h : ∀ x ∈ s, p x
⊢ (∏ x ∈ s, if p x then k (f x) else k (g x)) = ∏ x ∈ s, k (f x)
tactic: simp_rw [apply_ite k]
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 β
p : α → Prop
hp : DecidablePred p
f g : α → γ
k : γ → β
h : ∀ x ∈ s, p x
⊢ (∏ x ∈ s, if p x then k (f x) else k (g x)) = ∏ x ∈ s, k (f x)
state_after: no goals
tactic: exact prod_ite_of_true h _ _
Theorem: Ordinal.add_log_le_log_mul
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
⊢ log b x + log b y ≤ log b (x * y)
state_after: case pos
x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
hb : 1 < b
⊢ log b x + log b y ≤ log b (x * y)

case neg
x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
hb : ¬1 < b
⊢ log b x + log b y ≤ log b (x * y)
tactic: by_cases hb : 1 < b
state_before: case neg
x y b : Ordinal.{u_1}
hx : x ≠ 0
hy : y ≠ 0
hb : ¬1 < b
⊢ log b x + log b y ≤ log b (x * y)
state_after: no goals
tactic: simp only [log_of_not_one_lt_left hb, zero_add, le_refl]
Theorem: ENNReal.sSup_add
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✝ s : Set ℝ≥0∞
hs : s.Nonempty
⊢ sSup s + a = ⨆ b ∈ s, b + a
state_after: no goals
tactic: rw [sSup_eq_iSup, biSup_add hs]
Theorem: AddCommGrp.Colimits.quot_neg
File: Mathlib/Algebra/Category/Grp/Colimits.lean

Proof steps:
state_before: J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
x : ?m.15038
⊢ ColimitType F
state_after: no goals
tactic: exact Quot.mk Setoid.r (neg x)
state_before: J : Type u
inst✝ : Category.{v, u} J
F : J ⥤ AddCommGrp
x : Prequotient F
⊢ ColimitType F
state_after: no goals
tactic: exact Quot.mk Setoid.r x
Theorem: Complex.arg_eq_nhds_of_re_neg_of_im_neg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
⊢ arg =ᶠ[𝓝 x] fun x => Real.arcsin ((-x).im / abs x) - π
state_after: a x z : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
⊢ ∀ᶠ (y : ℂ) in 𝓝 x, y.re < 0 ∧ y.im < 0
tactic: suffices h_forall_nhds : ∀ᶠ y : ℂ in 𝓝 x, y.re < 0 ∧ y.im < 0 from
    h_forall_nhds.mono fun y hy => arg_of_re_neg_of_im_neg hy.1 hy.2
state_before: a x z : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
⊢ ∀ᶠ (y : ℂ) in 𝓝 x, y.re < 0 ∧ y.im < 0
state_after: a x z : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
⊢ IsOpen fun y => y.re < 0 ∧ y.im < 0
tactic: refine IsOpen.eventually_mem ?_ (⟨hx_re, hx_im⟩ : x.re < 0 ∧ x.im < 0)
state_before: a x z : ℂ
hx_re : x.re < 0
hx_im : x.im < 0
⊢ IsOpen fun y => y.re < 0 ∧ y.im < 0
state_after: no goals
tactic: exact
    IsOpen.and (isOpen_lt continuous_re continuous_zero) (isOpen_lt continuous_im continuous_zero)
Theorem: Profinite.NobelingProof.projRestricts_eq_comp
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)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
hJK : ∀ (i : I), J i → K i
hKL : ∀ (i : I), K i → L i
⊢ ProjRestricts C hJK ∘ ProjRestricts C hKL = ProjRestricts C ⋯
state_after: case h.a.h
I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
hJK : ∀ (i : I), J i → K i
hKL : ∀ (i : I), K i → L i
x : ↑(π C L)
i : I
⊢ ↑((ProjRestricts C hJK ∘ ProjRestricts C hKL) x) i = ↑(ProjRestricts C ⋯ x) i
tactic: ext x i
state_before: case h.a.h
I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
hJK : ∀ (i : I), J i → K i
hKL : ∀ (i : I), K i → L i
x : ↑(π C L)
i : I
⊢ ↑((ProjRestricts C hJK ∘ ProjRestricts C hKL) x) i = ↑(ProjRestricts C ⋯ x) i
state_after: case h.a.h
I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
hJK : ∀ (i : I), J i → K i
hKL : ∀ (i : I), K i → L i
x : ↑(π C L)
i : I
⊢ (if J i then if K i then ↑x i else false else false) = if J i then ↑x i else false
tactic: simp only [π, Proj, Function.comp_apply, ProjRestricts_coe]
state_before: case h.a.h
I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
hJK : ∀ (i : I), J i → K i
hKL : ∀ (i : I), K i → L i
x : ↑(π C L)
i : I
⊢ (if J i then if K i then ↑x i else false else false) = if J i then ↑x i else false
state_after: no goals
tactic: aesop
Theorem: SmoothBumpFunction.support_eq_symm_image
File: Mathlib/Geometry/Manifold/BumpFunction.lean

Proof steps:
state_before: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ support ↑f = ↑(extChartAt I c).symm '' (ball (↑(extChartAt I c) c) f.rOut ∩ range ↑I)
state_after: no goals
tactic: rw [f.support_eq_inter_preimage, ← extChartAt_source I,
    ← (extChartAt I c).symm_image_target_inter_eq', inter_comm,
    ball_inter_range_eq_ball_inter_target]
Theorem: SatisfiesM_StateRefT_eq
File: .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean

Proof steps:
state_before: m : Type → Type
ω σ α✝ : Type
p : α✝ → Prop
x : StateRefT' ω σ m α✝
inst✝ : Monad m
⊢ SatisfiesM p x ↔ ∀ (s : ST.Ref ω σ), SatisfiesM p (x s)
state_after: no goals
tactic: simp
Theorem: HahnModule.single_zero_smul_eq_smul
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

Proof steps:
state_before: Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁹ : PartialOrder Γ✝
inst✝⁸ : PartialOrder Γ'
inst✝⁷ : VAdd Γ✝ Γ'
inst✝⁶ : IsOrderedCancelVAdd Γ✝ Γ'
inst✝⁵ : AddCommMonoid V
Γ : Type u_5
inst✝⁴ : OrderedAddCommMonoid Γ
inst✝³ : AddAction Γ Γ'
inst✝² : IsOrderedCancelVAdd Γ Γ'
inst✝¹ : MulZeroClass R
inst✝ : SMulWithZero R V
r : R
x : HahnModule Γ' R V
⊢ (HahnSeries.single 0) r • x = r • x
state_after: case h.h
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁹ : PartialOrder Γ✝
inst✝⁸ : PartialOrder Γ'
inst✝⁷ : VAdd Γ✝ Γ'
inst✝⁶ : IsOrderedCancelVAdd Γ✝ Γ'
inst✝⁵ : AddCommMonoid V
Γ : Type u_5
inst✝⁴ : OrderedAddCommMonoid Γ
inst✝³ : AddAction Γ Γ'
inst✝² : IsOrderedCancelVAdd Γ Γ'
inst✝¹ : MulZeroClass R
inst✝ : SMulWithZero R V
r : R
x : HahnModule Γ' R V
x✝ : Γ'
⊢ ((of R).symm ((HahnSeries.single 0) r • x)).coeff x✝ = ((of R).symm (r • x)).coeff x✝
tactic: ext
state_before: case h.h
Γ✝ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝⁹ : PartialOrder Γ✝
inst✝⁸ : PartialOrder Γ'
inst✝⁷ : VAdd Γ✝ Γ'
inst✝⁶ : IsOrderedCancelVAdd Γ✝ Γ'
inst✝⁵ : AddCommMonoid V
Γ : Type u_5
inst✝⁴ : OrderedAddCommMonoid Γ
inst✝³ : AddAction Γ Γ'
inst✝² : IsOrderedCancelVAdd Γ Γ'
inst✝¹ : MulZeroClass R
inst✝ : SMulWithZero R V
r : R
x : HahnModule Γ' R V
x✝ : Γ'
⊢ ((of R).symm ((HahnSeries.single 0) r • x)).coeff x✝ = ((of R).symm (r • x)).coeff x✝
state_after: no goals
tactic: exact single_zero_smul_coeff