ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CoalgebraCat.MonoidalCategoryAux.counit_tensorObj_tensorObj_right
File: Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean

Proof steps:
state_before: R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
⊢ Coalgebra.counit = Coalgebra.counit
state_after: case h
R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
x✝ : ↑(of R M ⊗ of R N ⊗ of R P).toModuleCat
⊢ Coalgebra.counit x✝ = Coalgebra.counit x✝
tactic: ext
state_before: case h
R : Type u
inst✝¹² : CommRing R
M N P Q : Type u
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : AddCommGroup P
inst✝⁸ : AddCommGroup Q
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Coalgebra R M
inst✝² : Coalgebra R N
inst✝¹ : Coalgebra R P
inst✝ : Coalgebra R Q
x✝ : ↑(of R M ⊗ of R N ⊗ of R P).toModuleCat
⊢ Coalgebra.counit x✝ = Coalgebra.counit x✝
state_after: no goals
tactic: rfl
Theorem: Polynomial.Monic.isUnit_leadingCoeff_of_dvd
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q a p : R[X]
hp : p.Monic
hap : a ∣ p
⊢ a.leadingCoeff ∣ 1
state_after: no goals
tactic: simpa only [hp.leadingCoeff] using leadingCoeff_dvd_leadingCoeff hap
Theorem: cfcₙ_nonpos
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁸ : OrderedCommSemiring R
inst✝¹⁷ : Nontrivial R
inst✝¹⁶ : StarRing R
inst✝¹⁵ : StarOrderedRing R
inst✝¹⁴ : MetricSpace R
inst✝¹³ : TopologicalSemiring R
inst✝¹² : ContinuousStar R
inst✝¹¹ : ∀ (α : Type ?u.1216537) [inst : Zero α] [inst_1 : TopologicalSpace α], StarOrderedRing C(α, R)₀
inst✝¹⁰ : TopologicalSpace A
inst✝⁹ : NonUnitalRing A
inst✝⁸ : StarRing A
inst✝⁷ : PartialOrder A
inst✝⁶ : StarOrderedRing A
inst✝⁵ : Module R A
inst✝⁴ : IsScalarTower R A A
inst✝³ : SMulCommClass R A A
inst✝² : StarModule R A
inst✝¹ : NonUnitalContinuousFunctionalCalculus R p
inst✝ : NonnegSpectrumClass R A
f : R → R
a : A
h : ∀ x ∈ σₙ R a, f x ≤ 0
⊢ cfcₙ f a ≤ 0
state_after: case pos
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁸ : OrderedCommSemiring R
inst✝¹⁷ : Nontrivial R
inst✝¹⁶ : StarRing R
inst✝¹⁵ : StarOrderedRing R
inst✝¹⁴ : MetricSpace R
inst✝¹³ : TopologicalSemiring R
inst✝¹² : ContinuousStar R
inst✝¹¹ : ∀ (α : Type ?u.1216537) [inst : Zero α] [inst_1 : TopologicalSpace α], StarOrderedRing C(α, R)₀
inst✝¹⁰ : TopologicalSpace A
inst✝⁹ : NonUnitalRing A
inst✝⁸ : StarRing A
inst✝⁷ : PartialOrder A
inst✝⁶ : StarOrderedRing A
inst✝⁵ : Module R A
inst✝⁴ : IsScalarTower R A A
inst✝³ : SMulCommClass R A A
inst✝² : StarModule R A
inst✝¹ : NonUnitalContinuousFunctionalCalculus R p
inst✝ : NonnegSpectrumClass R A
f : R → R
a : A
h : ∀ x ∈ σₙ R a, f x ≤ 0
hf : ContinuousOn f (σₙ R a) ∧ f 0 = 0
⊢ cfcₙ f a ≤ 0

case neg
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁸ : OrderedCommSemiring R
inst✝¹⁷ : Nontrivial R
inst✝¹⁶ : StarRing R
inst✝¹⁵ : StarOrderedRing R
inst✝¹⁴ : MetricSpace R
inst✝¹³ : TopologicalSemiring R
inst✝¹² : ContinuousStar R
inst✝¹¹ : ∀ (α : Type ?u.1216537) [inst : Zero α] [inst_1 : TopologicalSpace α], StarOrderedRing C(α, R)₀
inst✝¹⁰ : TopologicalSpace A
inst✝⁹ : NonUnitalRing A
inst✝⁸ : StarRing A
inst✝⁷ : PartialOrder A
inst✝⁶ : StarOrderedRing A
inst✝⁵ : Module R A
inst✝⁴ : IsScalarTower R A A
inst✝³ : SMulCommClass R A A
inst✝² : StarModule R A
inst✝¹ : NonUnitalContinuousFunctionalCalculus R p
inst✝ : NonnegSpectrumClass R A
f : R → R
a : A
h : ∀ x ∈ σₙ R a, f x ≤ 0
hf : ¬(ContinuousOn f (σₙ R a) ∧ f 0 = 0)
⊢ cfcₙ f a ≤ 0
tactic: by_cases hf : ContinuousOn f (σₙ R a) ∧ f 0 = 0
Theorem: NormedAddGroupHom.completion_toCompl
File: Mathlib/Analysis/Normed/Group/HomCompletion.lean

Proof steps:
state_before: G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
⊢ f.completion.comp toCompl = toCompl.comp f
state_after: case H
G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
x : G
⊢ (f.completion.comp toCompl) x = (toCompl.comp f) x
tactic: ext x
state_before: case H
G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
x : G
⊢ (f.completion.comp toCompl) x = (toCompl.comp f) x
state_after: no goals
tactic: simp
Theorem: CategoryTheory.leftDistributor_hom_comp_biproduct_π
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X : C
f : J → C
j : J
⊢ (leftDistributor X f).hom ≫ biproduct.π (fun j => X ⊗ f j) j = X ◁ biproduct.π f j
state_after: no goals
tactic: simp [leftDistributor_hom, Preadditive.sum_comp, biproduct.ι_π, comp_dite]
Theorem: NonUnitalNonAssocSemiring.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : NonUnitalNonAssocSemiring R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : NonUnitalNonAssocSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
tactic: rintro rfl
state_before: R : Type u
inst₁ : NonUnitalNonAssocSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
tactic: constructor <;> rfl
Theorem: Set.subset_insert_iff
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 t : Set α
x : α
⊢ s ⊆ insert x t ↔ s ⊆ t ∨ x ∈ s ∧ s \ {x} ⊆ t
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
x : α
⊢ s \ {x} ⊆ t ↔ s ⊆ t ∨ x ∈ s ∧ s \ {x} ⊆ t
tactic: rw [← diff_singleton_subset_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
x : α
⊢ s \ {x} ⊆ t ↔ s ⊆ t ∨ x ∈ s ∧ s \ {x} ⊆ t
state_after: case pos
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
x : α
hx : x ∈ s
⊢ s \ {x} ⊆ t ↔ s ⊆ t ∨ x ∈ s ∧ s \ {x} ⊆ t

case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
x : α
hx : x ∉ s
⊢ s \ {x} ⊆ t ↔ s ⊆ t ∨ x ∈ s ∧ s \ {x} ⊆ t
tactic: by_cases hx : x ∈ s
state_before: case neg
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
x : α
hx : x ∉ s
⊢ s \ {x} ⊆ t ↔ s ⊆ t ∨ x ∈ s ∧ s \ {x} ⊆ t
state_after: no goals
tactic: rw [diff_singleton_eq_self hx, or_iff_left_of_imp And.right]
Theorem: IntermediateField.adjoin.finrank
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝⁶ : Field F
E : Type u_2
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
α : E
K : Type u
inst✝³ : Field K
inst✝² : Algebra F K
L : Type u_3
inst✝¹ : Field L
inst✝ : Algebra K L
x : L
hx : IsIntegral K x
⊢ FiniteDimensional.finrank K ↥K⟮x⟯ = (minpoly K x).natDegree
state_after: F : Type u_1
inst✝⁶ : Field F
E : Type u_2
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
α : E
K : Type u
inst✝³ : Field K
inst✝² : Algebra F K
L : Type u_3
inst✝¹ : Field L
inst✝ : Algebra K L
x : L
hx : IsIntegral K x
⊢ (powerBasis hx).dim = (minpoly K x).natDegree
tactic: rw [PowerBasis.finrank (adjoin.powerBasis hx : _)]
state_before: F : Type u_1
inst✝⁶ : Field F
E : Type u_2
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
α : E
K : Type u
inst✝³ : Field K
inst✝² : Algebra F K
L : Type u_3
inst✝¹ : Field L
inst✝ : Algebra K L
x : L
hx : IsIntegral K x
⊢ (powerBasis hx).dim = (minpoly K x).natDegree
state_after: no goals
tactic: rfl
Theorem: Pell.yz_sub
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ yz a1 (m - n) = xz a1 n * yz a1 m - xz a1 m * yz a1 n
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ yz a1 (m - n) = xz a1 m * -yz a1 n + yz a1 m * xz a1 n
tactic: rw [sub_eq_add_neg, ← mul_neg, mul_comm, add_comm]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ yz a1 (m - n) = xz a1 m * -yz a1 n + yz a1 m * xz a1 n
state_after: no goals
tactic: exact congr_arg Zsqrtd.im (pellZd_sub a1 h)
Theorem: Sym2.map_comp
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
g : β → γ
f : α → β
⊢ map (g ∘ f) = map g ∘ map f
state_after: case h.mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
g : β → γ
f : α → β
x✝ : Sym2 α
x y : α
⊢ map (g ∘ f) (Quot.mk (Rel α) (x, y)) = (map g ∘ map f) (Quot.mk (Rel α) (x, y))
tactic: ext ⟨⟨x, y⟩⟩
state_before: case h.mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
g : β → γ
f : α → β
x✝ : Sym2 α
x y : α
⊢ map (g ∘ f) (Quot.mk (Rel α) (x, y)) = (map g ∘ map f) (Quot.mk (Rel α) (x, y))
state_after: no goals
tactic: rfl
Theorem: Asymptotics.superpolynomialDecay_iff_superpolynomialDecay_norm
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝ : NormedLinearOrderedField β
⊢ (∀ (n : ℕ), Tendsto (fun a => ‖k a ^ n * f a‖) l (𝓝 0)) ↔ SuperpolynomialDecay l (fun a => ‖k a‖) fun a => ‖f a‖
state_after: no goals
tactic: simp [SuperpolynomialDecay]
Theorem: Int.gcd_least_linear
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: a b : ℤ
ha : a ≠ 0
⊢ IsLeast {n | 0 < n ∧ ∃ x y, ↑n = a * x + b * y} (a.gcd b)
state_after: a b : ℤ
ha : a ≠ 0
⊢ IsLeast {n | 0 < n ∧ a.gcd b ∣ n} (a.gcd b)
tactic: simp_rw [← gcd_dvd_iff]
state_before: a b : ℤ
ha : a ≠ 0
⊢ IsLeast {n | 0 < n ∧ a.gcd b ∣ n} (a.gcd b)
state_after: case left
a b : ℤ
ha : a ≠ 0
⊢ a.gcd b ∈ {n | 0 < n ∧ a.gcd b ∣ n}

case right
a b : ℤ
ha : a ≠ 0
⊢ a.gcd b ∈ lowerBounds {n | 0 < n ∧ a.gcd b ∣ n}
tactic: constructor
Theorem: nonneg_of_le_add_right
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : MulOneClass α
inst✝¹ : LE α
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
h : a ≤ a * b
⊢ a * 1 ≤ a * b
state_after: no goals
tactic: simpa only [mul_one]
Theorem: Option.map₂_comm
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
⊢ map₂ f a b = map₂ g b a
state_after: no goals
tactic: cases a <;> cases b <;> simp [h_comm]
Theorem: rank_le_one_iff
File: Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
⊢ Module.rank K V ≤ 1 ↔ ∃ v₀, ∀ (v : V), ∃ r, r • v₀ = v
state_after: case intro.mk
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
κ : Type v
b : Basis κ K V
⊢ Module.rank K V ≤ 1 ↔ ∃ v₀, ∀ (v : V), ∃ r, r • v₀ = v
tactic: obtain ⟨κ, b⟩ := Module.Free.exists_basis (R := K) (M := V)
state_before: case intro.mk
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
κ : Type v
b : Basis κ K V
⊢ Module.rank K V ≤ 1 ↔ ∃ v₀, ∀ (v : V), ∃ r, r • v₀ = v
state_after: case intro.mk.mp
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
κ : Type v
b : Basis κ K V
⊢ Module.rank K V ≤ 1 → ∃ v₀, ∀ (v : V), ∃ r, r • v₀ = v

case intro.mk.mpr
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Module.Free K V
κ : Type v
b : Basis κ K V
⊢ (∃ v₀, ∀ (v : V), ∃ r, r • v₀ = v) → Module.rank K V ≤ 1
tactic: constructor
Theorem: zero_mem_cantorSet
File: Mathlib/Topology/Instances/CantorSet.lean

Proof steps:
state_before: ⊢ 0 ∈ cantorSet
state_after: no goals
tactic: simp [cantorSet, zero_mem_preCantorSet]
Theorem: Real.Ioo_eq_ball
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y : ℝ
⊢ Ioo x y = ball ((x + y) / 2) ((y - x) / 2)
state_after: no goals
tactic: rw [Real.ball_eq_Ioo, ← sub_div, add_comm, ← sub_add, add_sub_cancel_left, add_self_div_two,
    ← add_div, add_assoc, add_sub_cancel, add_self_div_two]
Theorem: BddAbove.image2_bddBelow
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
⊢ BddAbove s → BddAbove t → BddBelow (image2 f s t)
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
ha : a ∈ upperBounds s
b : β
hb : b ∈ upperBounds t
⊢ BddBelow (image2 f s t)
tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
ha : a ∈ upperBounds s
b : β
hb : b ∈ upperBounds t
⊢ BddBelow (image2 f s t)
state_after: no goals
tactic: exact ⟨f a b, mem_lowerBounds_image2_of_mem_upperBounds h₀ h₁ ha hb⟩
Theorem: AlgebraicGeometry.LocallyRingedSpace.stalkMap_congr_point
File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean

Proof steps:
state_before: X✝¹ X✝ Y✝ Z : LocallyRingedSpace
f✝ : X✝ ⟶ Y✝
g : Y✝ ⟶ Z
X Y : LocallyRingedSpace
f : X ⟶ Y
x x' : ↑X.toTopCat
hxx' : x = x'
⊢ Hom.stalkMap f x ≫ X.presheaf.stalkSpecializes ⋯ = Y.presheaf.stalkSpecializes ⋯ ≫ Hom.stalkMap f x'
state_after: X✝¹ X✝ Y✝ Z : LocallyRingedSpace
f✝ : X✝ ⟶ Y✝
g : Y✝ ⟶ Z
X Y : LocallyRingedSpace
f : X ⟶ Y
x : ↑X.toTopCat
⊢ Hom.stalkMap f x ≫ X.presheaf.stalkSpecializes ⋯ = Y.presheaf.stalkSpecializes ⋯ ≫ Hom.stalkMap f x
tactic: subst hxx'
state_before: X✝¹ X✝ Y✝ Z : LocallyRingedSpace
f✝ : X✝ ⟶ Y✝
g : Y✝ ⟶ Z
X Y : LocallyRingedSpace
f : X ⟶ Y
x : ↑X.toTopCat
⊢ Hom.stalkMap f x ≫ X.presheaf.stalkSpecializes ⋯ = Y.presheaf.stalkSpecializes ⋯ ≫ Hom.stalkMap f x
state_after: no goals
tactic: simp
Theorem: Real.two_mul_arctan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: x : ℝ
h₁ : -1 < x
h₂ : x < 1
⊢ 2 * arctan x = arctan (2 * x / (1 - x ^ 2))
state_after: x : ℝ
h₁ : -1 < x
h₂ : x < 1
⊢ arctan ((x + x) / (1 - x * x)) = arctan (2 * x / (1 - x ^ 2))
tactic: rw [two_mul, arctan_add (by nlinarith)]
state_before: x : ℝ
h₁ : -1 < x
h₂ : x < 1
⊢ arctan ((x + x) / (1 - x * x)) = arctan (2 * x / (1 - x ^ 2))
state_after: case e_x
x : ℝ
h₁ : -1 < x
h₂ : x < 1
⊢ (x + x) / (1 - x * x) = 2 * x / (1 - x ^ 2)
tactic: congr 1
state_before: case e_x
x : ℝ
h₁ : -1 < x
h₂ : x < 1
⊢ (x + x) / (1 - x * x) = 2 * x / (1 - x ^ 2)
state_after: no goals
tactic: ring
Theorem: isLittleO_exp_neg_mul_rpow_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

Proof steps:
state_before: a : ℝ
ha : 0 < a
b : ℝ
⊢ (fun x => rexp (-a * x)) =o[atTop] fun x => x ^ b
state_after: case hgf
a : ℝ
ha : 0 < a
b : ℝ
⊢ ∀ᶠ (x : ℝ) in atTop, x ^ b = 0 → rexp (-a * x) = 0

case a
a : ℝ
ha : 0 < a
b : ℝ
⊢ Tendsto (fun x => rexp (-a * x) / x ^ b) atTop (𝓝 0)
tactic: apply isLittleO_of_tendsto'
Theorem: AddMonoidHomClass.isAddFreimanHom
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁴ : CommMonoid α
inst✝³ : CommMonoid β
inst✝² : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f✝ f₁ f₂ : α → β
g : β → γ
m n : ℕ
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
hfAB : MapsTo (⇑f) A B
s t : Multiset α
x✝³ : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
x✝² : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
x✝¹ : card s = n
x✝ : card t = n
h : s.prod = t.prod
⊢ (map (⇑f) s).prod = (map (⇑f) t).prod
state_after: no goals
tactic: rw [← map_multiset_prod, h, map_multiset_prod]
Theorem: Sum.Ioo_inr_inl
File: Mathlib/Data/Sum/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a₁ a₂ : α
b₁ b₂ : β
a b : α ⊕ β
⊢ Ioo (inr b₁) (inl a₂) = ∅
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.Iio_ae_eq_Iic'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : PartialOrder α
a b : α
ha : μ {a} = 0
⊢ Iio a =ᶠ[ae μ] Iic a
state_after: no goals
tactic: rw [← Iic_diff_right, diff_ae_eq_self, measure_mono_null Set.inter_subset_right ha]
Theorem: CoxeterSystem.getD_leftInvSeq
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ (cs.leftInvSeq ω).getD j 1 =
    cs.wordProd (take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (take j ω))⁻¹
state_after: case nil
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
j : ℕ
⊢ (cs.leftInvSeq []).getD j 1 =
    cs.wordProd (take j []) * (Option.map cs.simple ([].get? j)).getD 1 * (cs.wordProd (take j []))⁻¹

case cons
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
i : B
ω : List B
ih :
  ∀ (j : ℕ),
    (cs.leftInvSeq ω).getD j 1 =
      cs.wordProd (take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (take j ω))⁻¹
j : ℕ
⊢ (cs.leftInvSeq (i :: ω)).getD j 1 =
    cs.wordProd (take j (i :: ω)) * (Option.map cs.simple ((i :: ω).get? j)).getD 1 * (cs.wordProd (take j (i :: ω)))⁻¹
tactic: induction' ω with i ω ih generalizing j
Theorem: Stream'.WSeq.join_think
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
S : WSeq (WSeq α)
⊢ S.think.join = S.join.think
state_after: α : Type u
β : Type v
γ : Type w
S : WSeq (WSeq α)
⊢ ((fun o =>
          match o with
          | none => Seq1.ret none
          | some s => (none, s)) <$>
        Seq.cons none S).join =
    Seq.cons none
      ((fun o =>
            match o with
            | none => Seq1.ret none
            | some s => (none, s)) <$>
          S).join
tactic: simp only [join, think]
state_before: α : Type u
β : Type v
γ : Type w
S : WSeq (WSeq α)
⊢ (Seq.map
        (fun o =>
          match o with
          | none => Seq1.ret none
          | some s => (none, s))
        (Seq.cons none S)).join =
    Seq.cons none
      (Seq.map
          (fun o =>
            match o with
            | none => Seq1.ret none
            | some s => (none, s))
          S).join
state_after: no goals
tactic: simp [join, Seq1.ret]
Theorem: SimpleGraph.Subgraph.edgeSet_sup
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
H₁ H₂ : G.Subgraph
⊢ ∀ (x y : V), s(x, y) ∈ (H₁ ⊔ H₂).edgeSet ↔ s(x, y) ∈ H₁.edgeSet ∪ H₂.edgeSet
state_after: no goals
tactic: simp
Theorem: CategoryTheory.GradedObject.Monoidal.ιTensorObj₃_tensorHom
File: Mathlib/CategoryTheory/GradedObject/Monoidal.lean

Proof steps:
state_before: I : Type u
inst✝¹⁰ : AddMonoid I
C : Type u_1
inst✝⁹ : Category.{u_2, u_1} C
inst✝⁸ : MonoidalCategory C
Z : C
X₁ X₂ X₃ : GradedObject I C
inst✝⁷ : X₁.HasTensor X₂
inst✝⁶ : X₂.HasTensor X₃
inst✝⁵ : (tensorObj X₁ X₂).HasTensor X₃
inst✝⁴ : X₁.HasTensor (tensorObj X₂ X₃)
Y₁ Y₂ Y₃ : GradedObject I C
inst✝³ : Y₁.HasTensor Y₂
inst✝² : Y₂.HasTensor Y₃
inst✝¹ : (tensorObj Y₁ Y₂).HasTensor Y₃
inst✝ : Y₁.HasTensor (tensorObj Y₂ Y₃)
f₁ : X₁ ⟶ Y₁
f₂ : X₂ ⟶ Y₂
f₃ : X₃ ⟶ Y₃
i₁ i₂ i₃ j : I
h : i₁ + i₂ + i₃ = j
⊢ ιTensorObj₃ X₁ X₂ X₃ i₁ i₂ i₃ j h ≫ tensorHom f₁ (tensorHom f₂ f₃) j =
    (f₁ i₁ ⊗ f₂ i₂ ⊗ f₃ i₃) ≫ ιTensorObj₃ Y₁ Y₂ Y₃ i₁ i₂ i₃ j h
state_after: no goals
tactic: rw [ιTensorObj₃_eq _ _ _ i₁ i₂ i₃ j h _  rfl,
    ιTensorObj₃_eq _ _ _ i₁ i₂ i₃ j h _  rfl, assoc, ι_tensorHom,
    ← id_tensorHom, ← id_tensorHom, ← MonoidalCategory.tensor_comp_assoc, ι_tensorHom,
    ← MonoidalCategory.tensor_comp_assoc, id_comp, comp_id]
Theorem: Real.Angle.two_zsmul_toReal_eq_two_mul
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ (2 • θ).toReal = 2 * θ.toReal ↔ θ.toReal ∈ Set.Ioc (-π / 2) (π / 2)
state_after: no goals
tactic: rw [two_zsmul, ← two_nsmul, two_nsmul_toReal_eq_two_mul]
Theorem: Associates.prod_mk
File: Mathlib/Algebra/BigOperators/Associated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p : Multiset α
⊢ (Multiset.map Associates.mk 0).prod = Associates.mk (Multiset.prod 0)
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
p : Multiset α
a : α
s : Multiset α
ih : (Multiset.map Associates.mk s).prod = Associates.mk s.prod
⊢ (Multiset.map Associates.mk (a ::ₘ s)).prod = Associates.mk (a ::ₘ s).prod
state_after: no goals
tactic: simp [ih, Associates.mk_mul_mk]
Theorem: Real.summable_one_div_nat_pow
File: Mathlib/Analysis/PSeries.lean

Proof steps:
state_before: p : ℕ
⊢ (Summable fun n => 1 / ↑n ^ p) ↔ 1 < p
state_after: no goals
tactic: simp only [one_div, Real.summable_nat_pow_inv]
Theorem: FunctionField.InftyValuation.map_mul'
File: Mathlib/NumberTheory/FunctionField.lean

Proof steps:
state_before: Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
x y : RatFunc Fq
⊢ inftyValuationDef Fq (x * y) = inftyValuationDef Fq x * inftyValuationDef Fq y
state_after: Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
x y : RatFunc Fq
⊢ (if x * y = 0 then 0 else ↑(Multiplicative.ofAdd (x * y).intDegree)) =
    (if x = 0 then 0 else ↑(Multiplicative.ofAdd x.intDegree)) *
      if y = 0 then 0 else ↑(Multiplicative.ofAdd y.intDegree)
tactic: rw [inftyValuationDef, inftyValuationDef, inftyValuationDef]
state_before: Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
x y : RatFunc Fq
⊢ (if x * y = 0 then 0 else ↑(Multiplicative.ofAdd (x * y).intDegree)) =
    (if x = 0 then 0 else ↑(Multiplicative.ofAdd x.intDegree)) *
      if y = 0 then 0 else ↑(Multiplicative.ofAdd y.intDegree)
state_after: case pos
Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
x y : RatFunc Fq
hx : x = 0
⊢ (if x * y = 0 then 0 else ↑(Multiplicative.ofAdd (x * y).intDegree)) =
    (if x = 0 then 0 else ↑(Multiplicative.ofAdd x.intDegree)) *
      if y = 0 then 0 else ↑(Multiplicative.ofAdd y.intDegree)

case neg
Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
x y : RatFunc Fq
hx : ¬x = 0
⊢ (if x * y = 0 then 0 else ↑(Multiplicative.ofAdd (x * y).intDegree)) =
    (if x = 0 then 0 else ↑(Multiplicative.ofAdd x.intDegree)) *
      if y = 0 then 0 else ↑(Multiplicative.ofAdd y.intDegree)
tactic: by_cases hx : x = 0