ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Continuous.min
File: Mathlib/Topology/Order/OrderClosed.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
⊢ Continuous fun b => min (f b) (g b)
state_after: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
⊢ Continuous fun b => if f b ≤ g b then f b else g b
tactic: simp only [min_def]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
⊢ Continuous fun b => if f b ≤ g b then f b else g b
state_after: no goals
tactic: exact hf.if_le hg hf hg fun x => id
Theorem: Quiver.SingleObj.toPrefunctor_symm_comp
File: Mathlib/Combinatorics/Quiver/SingleObj.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : SingleObj α ⥤q SingleObj β
g : SingleObj β ⥤q SingleObj γ
⊢ toPrefunctor.symm (f ⋙q g) = toPrefunctor.symm g ∘ toPrefunctor.symm f
state_after: no goals
tactic: simp only [Equiv.symm_apply_eq, toPrefunctor_comp, Equiv.apply_symm_apply]
Theorem: SpectrumRestricts.nnreal_iff_spectralRadius_le
File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
t : ℝ≥0
ht : spectralRadius ℝ a ≤ ↑t
⊢ SpectrumRestricts a ⇑ContinuousMap.realToNNReal ↔ spectralRadius ℝ ((algebraMap ℝ A) ↑t - a) ≤ ↑t
state_after: 𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
t : ℝ≥0
ht : spectralRadius ℝ a ≤ ↑t
this : spectrum ℝ a ⊆ Set.Icc (-↑t) ↑t
⊢ SpectrumRestricts a ⇑ContinuousMap.realToNNReal ↔ spectralRadius ℝ ((algebraMap ℝ A) ↑t - a) ≤ ↑t
tactic: have : spectrum ℝ a ⊆ Set.Icc (-t) t := by
    intro x hx
    rw [Set.mem_Icc, ← abs_le, ← Real.norm_eq_abs, ← coe_nnnorm, NNReal.coe_le_coe,
      ← ENNReal.coe_le_coe]
    exact le_iSup₂ (α := ℝ≥0∞) x hx |>.trans ht
state_before: 𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
t : ℝ≥0
ht : spectralRadius ℝ a ≤ ↑t
this : spectrum ℝ a ⊆ Set.Icc (-↑t) ↑t
⊢ SpectrumRestricts a ⇑ContinuousMap.realToNNReal ↔ spectralRadius ℝ ((algebraMap ℝ A) ↑t - a) ≤ ↑t
state_after: 𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
t : ℝ≥0
ht : spectralRadius ℝ a ≤ ↑t
this : spectrum ℝ a ⊆ Set.Icc (-↑t) ↑t
⊢ (∀ x ∈ spectrum ℝ a, 0 ≤ x) ↔ spectralRadius ℝ ((algebraMap ℝ A) ↑t - a) ≤ ↑t
tactic: rw [nnreal_iff]
state_before: 𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
t : ℝ≥0
ht : spectralRadius ℝ a ≤ ↑t
this : spectrum ℝ a ⊆ Set.Icc (-↑t) ↑t
⊢ (∀ x ∈ spectrum ℝ a, 0 ≤ x) ↔ spectralRadius ℝ ((algebraMap ℝ A) ↑t - a) ≤ ↑t
state_after: case refine_1
𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
t : ℝ≥0
ht : spectralRadius ℝ a ≤ ↑t
this : spectrum ℝ a ⊆ Set.Icc (-↑t) ↑t
h : ∀ x ∈ spectrum ℝ a, 0 ≤ x
x : ℝ
hx : x ∈ spectrum ℝ ((algebraMap ℝ A) ↑t - a)
⊢ ↑‖x‖₊ ≤ ↑t

case refine_2
𝕜 : Type u_1
A✝ : Type u_2
A : Type u_3
inst✝¹ : Ring A
inst✝ : Algebra ℝ A
a : A
t : ℝ≥0
ht : spectralRadius ℝ a ≤ ↑t
this : spectrum ℝ a ⊆ Set.Icc (-↑t) ↑t
h : spectralRadius ℝ ((algebraMap ℝ A) ↑t - a) ≤ ↑t
⊢ ∀ x ∈ spectrum ℝ a, 0 ≤ x
tactic: refine ⟨fun h ↦ iSup₂_le fun x hx ↦ ?_, fun h ↦ ?_⟩
Theorem: CategoryTheory.Over.pullback_map_left
File: Mathlib/CategoryTheory/Adjunction/Over.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPullbacks C
X Y : C
f : X ⟶ Y
g h : Over Y
k : g ⟶ h
⊢ (pullback.fst g.hom f ≫ k.left) ≫ h.hom = pullback.snd g.hom f ≫ f
state_after: no goals
tactic: simp [pullback.condition]
Theorem: Finset.min'_eq_sorted_zero
File: Mathlib/Data/Finset/Sort.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : s.Nonempty
⊢ 0 < (sort (fun x x_1 => x ≤ x_1) s).length
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : s.Nonempty
⊢ 0 < s.card
tactic: rw [length_sort]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : s.Nonempty
⊢ 0 < s.card
state_after: no goals
tactic: exact card_pos.2 h
Theorem: Nat.toDigitsCore_lens_eq_aux
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n b f : ℕ
⊢ ∀ (n : ℕ) (l1 l2 : List Char), l1.length = l2.length → (b.toDigitsCore f n l1).length = (b.toDigitsCore f n l2).length
state_after: no goals
tactic: induction f with (simp only [Nat.toDigitsCore, List.length]; intro n l1 l2 hlen)
  | zero => assumption
  | succ f ih =>
    if hx : n / b = 0 then
      simp only [hx, if_true, List.length, congrArg (fun l ↦ l + 1) hlen]
    else
      simp only [hx, if_false]
      specialize ih (n / b) (Nat.digitChar (n % b) :: l1) (Nat.digitChar (n % b) :: l2)
      simp only [List.length, congrArg (fun l ↦ l + 1) hlen] at ih
      exact ih trivial
Theorem: MulAction.smul_orbit_eq_orbit_smul
File: Mathlib/GroupTheory/GroupAction/Blocks.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
⊢ g • orbit (↥N) a = orbit (↥N) (g • a)
state_after: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
⊢ (Set.range fun i => g • i • a) = Set.range fun m => m • g • a
tactic: simp only [orbit, Set.image_smul, Set.smul_set_range]
state_before: G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
⊢ (Set.range fun i => g • i • a) = Set.range fun m => m • g • a
state_after: case h
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
x✝ : X
⊢ (x✝ ∈ Set.range fun i => g • i • a) ↔ x✝ ∈ Set.range fun m => m • g • a
tactic: ext
state_before: case h
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
x✝ : X
⊢ (x✝ ∈ Set.range fun i => g • i • a) ↔ x✝ ∈ Set.range fun m => m • g • a
state_after: case h
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
x✝ : X
⊢ (∃ y, g • y • a = x✝) ↔ ∃ y, y • g • a = x✝
tactic: simp only [Set.mem_range]
state_before: case h
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
x✝ : X
⊢ (∃ y, g • y • a = x✝) ↔ ∃ y, y • g • a = x✝
state_after: case h.mp
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
x✝ : X
⊢ (∃ y, g • y • a = x✝) → ∃ y, y • g • a = x✝

case h.mpr
G : Type u_1
inst✝¹ : Group G
X : Type u_2
inst✝ : MulAction G X
N : Subgroup G
nN : N.Normal
a : X
g : G
x✝ : X
⊢ (∃ y, y • g • a = x✝) → ∃ y, g • y • a = x✝
tactic: constructor
Theorem: Mathlib.Tactic.Ring.nsmul_congr
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a✝ a'✝ a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R
a a' : ℕ
x✝² : a = a'
x✝¹ : b = b'
x✝ : a' • b' = c
⊢ a • b = c
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a'✝ a₁ a₂ a₃ b' b₁ b₂ b₃ c₁ c₂ : R
a' : ℕ
⊢ a' • b' = a' • b'
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a'✝ a₁ a₂ a₃ b' b₁ b₂ b₃ c₁ c₂ : R
a' : ℕ
⊢ a' • b' = a' • b'
state_after: no goals
tactic: rfl
Theorem: HomologicalComplex.opEquivalence_counitIso
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.44478, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex V c)ᵒᵖ
⊢ (opFunctor V c).map ((opUnitIso V c).hom.app X) ≫ (opCounitIso V c).hom.app ((opFunctor V c).obj X) =
    𝟙 ((opFunctor V c).obj X)
state_after: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.44478, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex V c)ᵒᵖ
i✝ : ι
⊢ ((opFunctor V c).map ((opUnitIso V c).hom.app X) ≫ (opCounitIso V c).hom.app ((opFunctor V c).obj X)).f i✝ =
    (𝟙 ((opFunctor V c).obj X)).f i✝
tactic: ext
state_before: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.44478, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex V c)ᵒᵖ
i✝ : ι
⊢ ((opFunctor V c).map ((opUnitIso V c).hom.app X) ≫ (opCounitIso V c).hom.app ((opFunctor V c).obj X)).f i✝ =
    (𝟙 ((opFunctor V c).obj X)).f i✝
state_after: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.44478, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex V c)ᵒᵖ
i✝ : ι
⊢ (Iso.refl ((unop X).op.unopSymm.X i✝)).hom.op ≫
      (Iso.refl (((opInverse V c ⋙ opFunctor V c).obj ((opFunctor V c).obj X)).X i✝)).hom =
    (𝟙 ((opFunctor V c).obj X)).f i✝
tactic: simp only [opUnitIso, opCounitIso, NatIso.ofComponents_hom_app, Iso.op_hom, comp_f,
      opFunctor_map_f, Quiver.Hom.unop_op, Hom.isoOfComponents_hom_f]
state_before: case h
ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.44478, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : (HomologicalComplex V c)ᵒᵖ
i✝ : ι
⊢ (Iso.refl ((unop X).op.unopSymm.X i✝)).hom.op ≫
      (Iso.refl (((opInverse V c ⋙ opFunctor V c).obj ((opFunctor V c).obj X)).X i✝)).hom =
    (𝟙 ((opFunctor V c).obj X)).f i✝
state_after: no goals
tactic: exact Category.comp_id _
Theorem: Profinite.NobelingProof.one_sub_e_mem_of_false
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)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
a : I
ha : ↑y a = true
hx : ↑x a = false
⊢ 1 - e (π C fun x => x ∈ s) a ∈ factors C s x
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
a : I
ha : ↑y a = true
hx : ↑x a = false
⊢ ∃ a_1 ∈ s,
    (if ↑x a_1 = true then e (π C fun x => x ∈ s) a_1 else 1 - e (π C fun x => x ∈ s) a_1) =
      1 - e (π C fun x => x ∈ s) a
tactic: simp only [factors, List.mem_map, Finset.mem_sort]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
a : I
ha : ↑y a = true
hx : ↑x a = false
⊢ ∃ a_1 ∈ s,
    (if ↑x a_1 = true then e (π C fun x => x ∈ s) a_1 else 1 - e (π C fun x => x ∈ s) a_1) =
      1 - e (π C fun x => x ∈ s) a
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
a : I
ha : ↑y a = true
hx : ↑x a = false
⊢ a ∈ s ∧
    (if ↑x a = true then e (π C fun x => x ∈ s) a else 1 - e (π C fun x => x ∈ s) a) = 1 - e (π C fun x => x ∈ s) a
tactic: use a
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
a : I
ha : ↑y a = true
hx : ↑x a = false
⊢ a ∈ s ∧
    (if ↑x a = true then e (π C fun x => x ∈ s) a else 1 - e (π C fun x => x ∈ s) a) = 1 - e (π C fun x => x ∈ s) a
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
a : I
ha : ↑y a = true
hx : ↑x a = false
⊢ a ∈ s
tactic: simp only [hx, ite_false, and_true]
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
a : I
ha : ↑y a = true
hx : ↑x a = false
⊢ a ∈ s
state_after: case h.mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑(π C fun x => x ∈ s)
a : I
hx : ↑x a = false
z : I → Bool
hz : z ∈ C
ha : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ a ∈ s
tactic: rcases y with ⟨_, z, hz, rfl⟩
state_before: case h.mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑(π C fun x => x ∈ s)
a : I
hx : ↑x a = false
z : I → Bool
hz : z ∈ C
ha : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ a ∈ s
state_after: no goals
tactic: aesop (add simp Proj)
Theorem: List.formPerm_pow_apply_get
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
n : ℕ
i : Fin l.length
⊢ (l.formPerm ^ n) (l.get i) = l.get ⟨(↑i + n) % l.length, ⋯⟩
state_after: no goals
tactic: simp [formPerm_pow_apply_getElem, h]
Theorem: Localization.smul_mk
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝⁴ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝³ : CommMonoid N
P : Type u_3
inst✝² : CommMonoid P
R : Type u_4
R₁ : Type u_5
R₂ : Type u_6
inst✝¹ : SMul R M
inst✝ : IsScalarTower R M M
c : R
a : M
b : ↥S
⊢ c • mk a b = mk (c • a) b
state_after: M : Type u_1
inst✝⁴ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝³ : CommMonoid N
P : Type u_3
inst✝² : CommMonoid P
R : Type u_4
R₁ : Type u_5
R₂ : Type u_6
inst✝¹ : SMul R M
inst✝ : IsScalarTower R M M
c : R
a : M
b : ↥S
⊢ OreLocalization.oreNum (c • 1) b • a /ₒ (OreLocalization.oreDenom (c • 1) b * 1) = c • a /ₒ b
tactic: rw [mk, mk, ← OreLocalization.smul_one_oreDiv_one_smul, OreLocalization.oreDiv_smul_oreDiv]
state_before: M : Type u_1
inst✝⁴ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝³ : CommMonoid N
P : Type u_3
inst✝² : CommMonoid P
R : Type u_4
R₁ : Type u_5
R₂ : Type u_6
inst✝¹ : SMul R M
inst✝ : IsScalarTower R M M
c : R
a : M
b : ↥S
⊢ OreLocalization.oreNum (c • 1) b • a /ₒ (OreLocalization.oreDenom (c • 1) b * 1) = c • a /ₒ b
state_after: M : Type u_1
inst✝⁴ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝³ : CommMonoid N
P : Type u_3
inst✝² : CommMonoid P
R : Type u_4
R₁ : Type u_5
R₂ : Type u_6
inst✝¹ : SMul R M
inst✝ : IsScalarTower R M M
c : R
a : M
b : ↥S
⊢ (c • 1) • a /ₒ (b * 1) = c • a /ₒ b
tactic: show (c • 1) • a /ₒ (b * 1) = _
state_before: M : Type u_1
inst✝⁴ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝³ : CommMonoid N
P : Type u_3
inst✝² : CommMonoid P
R : Type u_4
R₁ : Type u_5
R₂ : Type u_6
inst✝¹ : SMul R M
inst✝ : IsScalarTower R M M
c : R
a : M
b : ↥S
⊢ (c • 1) • a /ₒ (b * 1) = c • a /ₒ b
state_after: no goals
tactic: rw [smul_assoc, one_smul, mul_one]
Theorem: CategoryTheory.Adjunction.unit_leftAdjointUniq_hom_app
File: Mathlib/CategoryTheory/Adjunction/Unique.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ adj1.unit.app x ≫ G.map ((adj1.leftAdjointUniq adj2).hom.app x) = adj2.unit.app x
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ adj1.unit.app x ≫ G.map ((adj1.leftAdjointUniq adj2).hom.app x) =
    (adj1.unit ≫ whiskerRight (adj1.leftAdjointUniq adj2).hom G).app x
tactic: rw [← unit_leftAdjointUniq_hom adj1 adj2]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ adj1.unit.app x ≫ G.map ((adj1.leftAdjointUniq adj2).hom.app x) =
    (adj1.unit ≫ whiskerRight (adj1.leftAdjointUniq adj2).hom G).app x
state_after: no goals
tactic: rfl
Theorem: Real.tan_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ tan (π / 2) = 0
state_after: no goals
tactic: simp [tan_eq_sin_div_cos]
Theorem: Int.eq_one_or_neg_one_of_mul_eq_neg_one'
File: Mathlib/Algebra/Group/Int.lean

Proof steps:
state_before: u v : ℤ
h : u * v = -1
⊢ u = 1 ∧ v = -1 ∨ u = -1 ∧ v = 1
state_after: case inl
v : ℤ
h : 1 * v = -1
⊢ 1 = 1 ∧ v = -1 ∨ 1 = -1 ∧ v = 1

case inr
v : ℤ
h : -1 * v = -1
⊢ -1 = 1 ∧ v = -1 ∨ -1 = -1 ∧ v = 1
tactic: obtain rfl | rfl := isUnit_eq_one_or (IsUnit.mul_iff.mp (Int.isUnit_iff.mpr (Or.inr h))).1
Theorem: padicValNat_le_nat_log
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p n : ℕ
⊢ padicValNat p n ≤ log p n
state_after: case zero
p : ℕ
⊢ padicValNat p 0 ≤ log p 0

case succ
p n : ℕ
⊢ padicValNat p (n + 1) ≤ log p (n + 1)
tactic: rcases n with _ | n
state_before: case succ
p n : ℕ
⊢ padicValNat p (n + 1) ≤ log p (n + 1)
state_after: case succ.zero
n : ℕ
⊢ padicValNat 0 (n + 1) ≤ log 0 (n + 1)

case succ.succ.zero
n : ℕ
⊢ padicValNat (0 + 1) (n + 1) ≤ log (0 + 1) (n + 1)

case succ.succ.succ
n p : ℕ
⊢ padicValNat (p + 1 + 1) (n + 1) ≤ log (p + 1 + 1) (n + 1)
tactic: rcases p with _ | _ | p
state_before: case succ.succ.succ
n p : ℕ
⊢ padicValNat (p + 1 + 1) (n + 1) ≤ log (p + 1 + 1) (n + 1)
state_after: no goals
tactic: exact Nat.le_log_of_pow_le p.one_lt_succ_succ (le_of_dvd n.succ_pos pow_padicValNat_dvd)
Theorem: MvPolynomial.coeff_rename_eq_zero
File: Mathlib/Algebra/MvPolynomial/Rename.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
d : τ →₀ ℕ
h : ∀ (u : σ →₀ ℕ), Finsupp.mapDomain f u = d → coeff u φ = 0
⊢ coeff d ((rename f) φ) = 0
state_after: no goals
tactic: classical
  rw [rename_eq, ← not_mem_support_iff]
  intro H
  replace H := mapDomain_support H
  rw [Finset.mem_image] at H
  obtain ⟨u, hu, rfl⟩ := H
  specialize h u rfl
  simp? at h hu says simp only [Finsupp.mem_support_iff, ne_eq] at h hu
  contradiction
Theorem: CategoryTheory.GrothendieckTopology.sheafifyMap_sheafifyLift
File: Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ J.sheafifyMap η ≫ J.sheafifyLift γ hR = J.sheafifyLift (η ≫ γ) hR
state_after: case a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ J.toSheafify P ≫ J.sheafifyMap η ≫ J.sheafifyLift γ hR = η ≫ γ
tactic: apply J.sheafifyLift_unique
state_before: case a
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{max v u, w} D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
inst✝ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ J.toSheafify P ≫ J.sheafifyMap η ≫ J.sheafifyLift γ hR = η ≫ γ
state_after: no goals
tactic: rw [← Category.assoc, ← J.toSheafify_naturality, Category.assoc, toSheafify_sheafifyLift]
Theorem: Real.volume_val
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
s : Set ℝ
⊢ volume s = StieltjesFunction.id.measure s
state_after: no goals
tactic: simp [volume_eq_stieltjes_id]
Theorem: Polynomial.derivative_X_sq
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
⊢ derivative (X ^ 2) = C 2 * X
state_after: no goals
tactic: rw [derivative_X_pow, Nat.cast_two, pow_one]
Theorem: _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.filter_pairs_lt
File: Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean

Proof steps:
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
⊢ filter
      (fun x =>
        match x with
        | (s, snd) => s.card < k)
      (MvPolynomial.NewtonIdentities.pairs σ k) =
    (range k).disjiUnion (fun x => powersetCard x univ) ⋯ ×ˢ univ
state_after: case a
σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
a✝ : Finset σ × σ
⊢ a✝ ∈
      filter
        (fun x =>
          match x with
          | (s, snd) => s.card < k)
        (MvPolynomial.NewtonIdentities.pairs σ k) ↔
    a✝ ∈ (range k).disjiUnion (fun x => powersetCard x univ) ⋯ ×ˢ univ
tactic: ext
state_before: case a
σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
a✝ : Finset σ × σ
⊢ a✝ ∈
      filter
        (fun x =>
          match x with
          | (s, snd) => s.card < k)
        (MvPolynomial.NewtonIdentities.pairs σ k) ↔
    a✝ ∈ (range k).disjiUnion (fun x => powersetCard x univ) ⋯ ×ˢ univ
state_after: no goals
tactic: aesop (add unsafe le_of_lt)
Theorem: Complex.conj_ofReal
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: r : ℝ
⊢ ((starRingEnd ℂ) ↑r).re = (↑r).re ∧ ((starRingEnd ℂ) ↑r).im = (↑r).im
state_after: no goals
tactic: simp [star]
Theorem: Polynomial.natDegree_sub_le_iff_left
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

Proof steps:
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Ring R
p q : R[X]
qn : q.natDegree ≤ n
⊢ (p - q).natDegree ≤ n ↔ p.natDegree ≤ n
state_after: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Ring R
p q : R[X]
qn : (-q).natDegree ≤ n
⊢ (p - q).natDegree ≤ n ↔ p.natDegree ≤ n
tactic: rw [← natDegree_neg] at qn
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Ring R
p q : R[X]
qn : (-q).natDegree ≤ n
⊢ (p - q).natDegree ≤ n ↔ p.natDegree ≤ n
state_after: no goals
tactic: rw [sub_eq_add_neg, natDegree_add_le_iff_left _ _ qn]
Theorem: MeasureTheory.weightedSMul_empty
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
⊢ weightedSMul μ ∅ = 0
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
x : F
⊢ (weightedSMul μ ∅) x = 0 x
tactic: ext1 x
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
x : F
⊢ (weightedSMul μ ∅) x = 0 x
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
x : F
⊢ (μ ∅).toReal • x = 0 x
tactic: rw [weightedSMul_apply]
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
x : F
⊢ (μ ∅).toReal • x = 0 x
state_after: no goals
tactic: simp
Theorem: IsCoprime.of_mul_right_left
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H : IsCoprime x (y * z)
⊢ IsCoprime x y
state_after: R : Type u
inst✝ : CommSemiring R
x y z : R
H : IsCoprime (y * z) x
⊢ IsCoprime y x
tactic: rw [isCoprime_comm] at H ⊢
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H : IsCoprime (y * z) x
⊢ IsCoprime y x
state_after: no goals
tactic: exact H.of_mul_left_left