ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Mathlib.Vector.scanl_get
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α n
i : Fin n
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
state_after: case zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α 0
i : Fin 0
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)

case succ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
n : ℕ
v : Vector α (n + 1)
i : Fin (n + 1)
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
tactic: cases' n with n
state_before: case succ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
n : ℕ
v : Vector α (n + 1)
i : Fin (n + 1)
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
state_after: case succ.zero
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v : Vector α (0 + 1)
i : Fin (0 + 1)
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)

case succ.succ
α : Type u_1
β : Type u_2
f : β → α → β
n : ℕ
hn :
  ∀ (b : β) (v : Vector α (n + 1)) (i : Fin (n + 1)),
    (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
b : β
v : Vector α (n + 1 + 1)
i : Fin (n + 1 + 1)
⊢ (scanl f b v).get i.succ = f ((scanl f b v).get i.castSucc) (v.get i)
tactic: induction' n with n hn generalizing b
Theorem: Finset.not_mem_uIcc_of_lt
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ c < a → c < b → c ∉ [[a, b]]
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ c < a → c < b → ¬(a ⊓ b ≤ c ∧ c ≤ a ⊔ b)
tactic: rw [mem_uIcc]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ c < a → c < b → ¬(a ⊓ b ≤ c ∧ c ≤ a ⊔ b)
state_after: no goals
tactic: exact Set.not_mem_uIcc_of_lt
Theorem: le_iff_le_of_cmp_eq_cmp
File: Mathlib/Order/Compare.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
inst✝¹ : LinearOrder α
x y : α
β : Type u_3
inst✝ : LinearOrder β
x' y' : β
h : cmp x y = cmp x' y'
⊢ x ≤ y ↔ x' ≤ y'
state_after: α : Type u_1
β✝ : Type u_2
inst✝¹ : LinearOrder α
x y : α
β : Type u_3
inst✝ : LinearOrder β
x' y' : β
h : cmp x y = cmp x' y'
⊢ ¬y < x ↔ ¬y' < x'
tactic: rw [← not_lt, ← not_lt]
state_before: α : Type u_1
β✝ : Type u_2
inst✝¹ : LinearOrder α
x y : α
β : Type u_3
inst✝ : LinearOrder β
x' y' : β
h : cmp x y = cmp x' y'
⊢ ¬y < x ↔ ¬y' < x'
state_after: case h
α : Type u_1
β✝ : Type u_2
inst✝¹ : LinearOrder α
x y : α
β : Type u_3
inst✝ : LinearOrder β
x' y' : β
h : cmp x y = cmp x' y'
⊢ y < x ↔ y' < x'
tactic: apply not_congr
state_before: case h
α : Type u_1
β✝ : Type u_2
inst✝¹ : LinearOrder α
x y : α
β : Type u_3
inst✝ : LinearOrder β
x' y' : β
h : cmp x y = cmp x' y'
⊢ y < x ↔ y' < x'
state_after: case h.h
α : Type u_1
β✝ : Type u_2
inst✝¹ : LinearOrder α
x y : α
β : Type u_3
inst✝ : LinearOrder β
x' y' : β
h : cmp x y = cmp x' y'
⊢ cmp y x = cmp y' x'
tactic: apply lt_iff_lt_of_cmp_eq_cmp
state_before: case h.h
α : Type u_1
β✝ : Type u_2
inst✝¹ : LinearOrder α
x y : α
β : Type u_3
inst✝ : LinearOrder β
x' y' : β
h : cmp x y = cmp x' y'
⊢ cmp y x = cmp y' x'
state_after: no goals
tactic: rwa [cmp_eq_cmp_symm]
Theorem: Finset.nullMeasurableSet
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s✝ t : Set α
inst✝ : MeasurableSingletonClass (NullMeasurableSpace α μ)
s : Finset α
⊢ NullMeasurableSet (↑s) μ
state_after: no goals
tactic: apply Finset.measurableSet
Theorem: WeierstrassCurve.Affine.evalEval_polynomialY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ evalEval x y W.polynomialY = 2 * y + W.a₁ * x + W.a₃
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ evalEval x y (C (C 2) * Y + C (C W.a₁ * X + C W.a₃)) = 2 * y + W.a₁ * x + W.a₃
tactic: simp only [polynomialY]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ evalEval x y (C (C 2) * Y + C (C W.a₁ * X + C W.a₃)) = 2 * y + W.a₁ * x + W.a₃
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ 2 * y + (W.a₁ * x + W.a₃) = 2 * y + W.a₁ * x + W.a₃
tactic: eval_simp
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ 2 * y + (W.a₁ * x + W.a₃) = 2 * y + W.a₁ * x + W.a₃
state_after: no goals
tactic: rw [← add_assoc]
Theorem: CategoryTheory.counit_obj_eq_map_counit
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
j : C ⥤ D
inst✝ : Coreflective j
X : D
⊢ (coreflectorAdjunction j).counit.app (j.obj ((coreflector j).obj X)) =
    j.map ((coreflector j).map ((coreflectorAdjunction j).counit.app X))
state_after: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
j : C ⥤ D
inst✝ : Coreflective j
X : D
⊢ j.map ((coreflectorAdjunction j).unit.app ((coreflector j).obj X)) ≫
      (coreflectorAdjunction j).counit.app (j.obj ((coreflector j).obj X)) =
    j.map
      ((coreflectorAdjunction j).unit.app ((coreflector j).obj X) ≫
        (coreflector j).map ((coreflectorAdjunction j).counit.app X))
tactic: rw [← cancel_epi (j.map ((coreflectorAdjunction j).unit.app ((coreflector j).obj X))),
    ← j.map_comp]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
j : C ⥤ D
inst✝ : Coreflective j
X : D
⊢ j.map ((coreflectorAdjunction j).unit.app ((coreflector j).obj X)) ≫
      (coreflectorAdjunction j).counit.app (j.obj ((coreflector j).obj X)) =
    j.map
      ((coreflectorAdjunction j).unit.app ((coreflector j).obj X) ≫
        (coreflector j).map ((coreflectorAdjunction j).counit.app X))
state_after: no goals
tactic: simp
Theorem: WithTop.map₂_top_right
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
f : α → β → γ
a : WithTop α
⊢ map₂ f a ⊤ = ⊤
state_after: no goals
tactic: cases a <;> rfl
Theorem: CochainComplex.HomComplex.δ_v
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
hnm : n + 1 = m
z : Cochain F G n
p q : ℤ
hpq : p + m = q
q₁ q₂ : ℤ
hq₁ : q₁ = q - 1
hq₂ : p + 1 = q₂
⊢ p + n = q₁
state_after: no goals
tactic: rw [hq₁, ← hpq, ← hnm, ← add_assoc, add_sub_cancel_right]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
hnm : n + 1 = m
z : Cochain F G n
p q : ℤ
hpq : p + m = q
q₁ q₂ : ℤ
hq₁ : q₁ = q - 1
hq₂ : p + 1 = q₂
⊢ q₂ + n = q
state_after: no goals
tactic: rw [← hq₂, add_assoc, add_comm 1, hnm, hpq]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
hnm : n + 1 = m
z : Cochain F G n
p q : ℤ
hpq : p + m = q
q₁ q₂ : ℤ
hq₁ : q₁ = q - 1
hq₂ : p + 1 = q₂
⊢ (δ n m z).v p q hpq = z.v p q₁ ⋯ ≫ G.d q₁ q + m.negOnePow • F.d p q₂ ≫ z.v q₂ q ⋯
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
hnm : n + 1 = m
z : Cochain F G n
p q : ℤ
hpq : p + m = q
q₂ : ℤ
hq₂ : p + 1 = q₂
hq₁ : p + n = q - 1
⊢ (δ n m z).v p q hpq = z.v p (p + n) ⋯ ≫ G.d (p + n) q + m.negOnePow • F.d p q₂ ≫ z.v q₂ q ⋯
tactic: obtain rfl : q₁ = p + n := by omega
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
hnm : n + 1 = m
z : Cochain F G n
p q : ℤ
hpq : p + m = q
q₂ : ℤ
hq₂ : p + 1 = q₂
hq₁ : p + n = q - 1
⊢ (δ n m z).v p q hpq = z.v p (p + n) ⋯ ≫ G.d (p + n) q + m.negOnePow • F.d p q₂ ≫ z.v q₂ q ⋯
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
hnm : n + 1 = m
z : Cochain F G n
p q : ℤ
hpq : p + m = q
hq₁ : p + n = q - 1
hq₂ : p + 1 = p + m - n
⊢ (δ n m z).v p q hpq = z.v p (p + n) ⋯ ≫ G.d (p + n) q + m.negOnePow • F.d p (p + m - n) ≫ z.v (p + m - n) q ⋯
tactic: obtain rfl : q₂ = p + m - n := by omega
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
hnm : n + 1 = m
z : Cochain F G n
p q : ℤ
hpq : p + m = q
hq₁ : p + n = q - 1
hq₂ : p + 1 = p + m - n
⊢ (δ n m z).v p q hpq = z.v p (p + n) ⋯ ≫ G.d (p + n) q + m.negOnePow • F.d p (p + m - n) ≫ z.v (p + m - n) q ⋯
state_after: no goals
tactic: rfl
Theorem: RingTheory.Sequence.IsWeaklyRegular.isWeaklyRegular_lTensor
File: Mathlib/RingTheory/Regular/RegularSequence.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : Module.Flat R M₂
rs : List R
h : IsWeaklyRegular M rs
⊢ IsWeaklyRegular (M₂ ⊗[R] M) rs
state_after: no goals
tactic: induction h with
  | nil N => exact nil R (M₂ ⊗[R] N)
  | @cons N _ _ r rs' h1 _ ih =>
    let e := tensorQuotSMulTopEquivQuotSMulTop r M₂ N
    exact ((e.isWeaklyRegular_congr rs').mp ih).cons (h1.lTensor M₂)
Theorem: HasFPowerSeriesOnBall.image_sub_sub_deriv_le
File: Mathlib/Analysis/Analytic/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
hr : r' < r
⊢ ∃ C,
    ∀ y ∈ EMetric.ball x r',
      ∀ z ∈ EMetric.ball x r', ‖f y - f z - (p 1) fun x => y - z‖ ≤ C * max ‖y - x‖ ‖z - x‖ * ‖y - z‖
state_after: no goals
tactic: simpa only [isBigO_principal, mul_assoc, norm_mul, norm_norm, Prod.forall, EMetric.mem_ball,
    Prod.edist_eq, max_lt_iff, and_imp, @forall_swap (_ < _) E] using
    hf.isBigO_image_sub_image_sub_deriv_principal hr
Theorem: IsOfFinOrder.pow
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m n : ℕ
⊢ IsOfFinOrder a → IsOfFinOrder (a ^ n)
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m n : ℕ
⊢ (∃ n, 0 < n ∧ a ^ n = 1) → ∃ n_1, 0 < n_1 ∧ (a ^ n) ^ n_1 = 1
tactic: simp_rw [isOfFinOrder_iff_pow_eq_one]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m n : ℕ
⊢ (∃ n, 0 < n ∧ a ^ n = 1) → ∃ n_1, 0 < n_1 ∧ (a ^ n) ^ n_1 = 1
state_after: case intro.intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m✝ n m : ℕ
hm : 0 < m
ha : a ^ m = 1
⊢ ∃ n_1, 0 < n_1 ∧ (a ^ n) ^ n_1 = 1
tactic: rintro ⟨m, hm, ha⟩
state_before: case intro.intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m✝ n m : ℕ
hm : 0 < m
ha : a ^ m = 1
⊢ ∃ n_1, 0 < n_1 ∧ (a ^ n) ^ n_1 = 1
state_after: no goals
tactic: exact ⟨m, hm, by simp [pow_right_comm _ n, ha]⟩
Theorem: VectorFourier.contDiff_fourierIntegral
File: Mathlib/Analysis/Fourier/FourierTransformDeriv.lean

Proof steps:
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝⁶ : NormedAddCommGroup V
inst✝⁵ : NormedSpace ℝ V
inst✝⁴ : NormedAddCommGroup W
inst✝³ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
inst✝² : SecondCountableTopology V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
μ : Measure V
N : ℕ∞
hf : ∀ (n : ℕ), ↑n ≤ N → Integrable (fun v => ‖v‖ ^ n * ‖f v‖) μ
⊢ ContDiff ℝ N (fourierIntegral 𝐞 μ L.toLinearMap₂ f)
state_after: case pos
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝⁶ : NormedAddCommGroup V
inst✝⁵ : NormedSpace ℝ V
inst✝⁴ : NormedAddCommGroup W
inst✝³ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
inst✝² : SecondCountableTopology V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
μ : Measure V
N : ℕ∞
hf : ∀ (n : ℕ), ↑n ≤ N → Integrable (fun v => ‖v‖ ^ n * ‖f v‖) μ
h'f : Integrable f μ
⊢ ContDiff ℝ N (fourierIntegral 𝐞 μ L.toLinearMap₂ f)

case neg
E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝⁶ : NormedAddCommGroup V
inst✝⁵ : NormedSpace ℝ V
inst✝⁴ : NormedAddCommGroup W
inst✝³ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
inst✝² : SecondCountableTopology V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
μ : Measure V
N : ℕ∞
hf : ∀ (n : ℕ), ↑n ≤ N → Integrable (fun v => ‖v‖ ^ n * ‖f v‖) μ
h'f : ¬Integrable f μ
⊢ ContDiff ℝ N (fourierIntegral 𝐞 μ L.toLinearMap₂ f)
tactic: by_cases h'f : Integrable f μ
Theorem: List.forall₂_take
File: Mathlib/Data/List/Forall2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
x✝² : List α
x✝¹ : List β
x✝ : Forall₂ R x✝² x✝¹
⊢ Forall₂ R (take 0 x✝²) (take 0 x✝¹)
state_after: no goals
tactic: simp only [Forall₂.nil, take]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
n✝ : ℕ
⊢ Forall₂ R (take (n✝ + 1) []) (take (n✝ + 1) [])
state_after: no goals
tactic: simp only [Forall₂.nil, take]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
n : ℕ
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
⊢ Forall₂ R (take (n + 1) (a✝ :: l₁✝)) (take (n + 1) (b✝ :: l₂✝))
state_after: no goals
tactic: simp [And.intro h₁ h₂, forall₂_take n]
Theorem: Real.nnnorm_abs
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r✝ r₁ r₂ r : ℝ
⊢ ‖|r|‖₊ = ‖r‖₊
state_after: no goals
tactic: simp [nnnorm]
Theorem: ascPochhammer_eval_comp
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: S : Type u
inst✝³ : Semiring S
T : Type v
inst✝² : Semiring T
R : Type u_1
inst✝¹ : CommSemiring R
n : ℕ
p : R[X]
inst✝ : Algebra R S
x : S
⊢ eval x ((ascPochhammer S n).comp (map (algebraMap R S) p)) = eval (eval₂ (algebraMap R S) x p) (ascPochhammer S n)
state_after: no goals
tactic: rw [ascPochhammer_eval₂ (algebraMap R S), ← eval₂_comp', ← ascPochhammer_map (algebraMap R S),
    ← map_comp, eval_map]
Theorem: IsRingHom.id
File: Mathlib/Deprecated/Ring.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : Ring α
inst✝ : Ring β
f : α → β
hf : IsRingHom f
x y : α
⊢ IsRingHom _root_.id
state_after: no goals
tactic: constructor <;> intros <;> rfl
Theorem: PartENat.lt_find
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
⊢ ↑n < find P
state_after: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
⊢ ∀ (h : (find P).Dom), n < (find P).get h
tactic: rw [coe_lt_iff]
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
⊢ ∀ (h : (find P).Dom), n < (find P).get h
state_after: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
h₁ : (find P).Dom
⊢ n < (find P).get h₁
tactic: intro h₁
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
h₁ : (find P).Dom
⊢ n < (find P).get h₁
state_after: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
h₁ : (find P).Dom
⊢ n < Nat.find h₁
tactic: rw [find_get]
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
h₁ : (find P).Dom
⊢ n < Nat.find h₁
state_after: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
h₁ : (find P).Dom
h₂ : P (Nat.find h₁)
⊢ n < Nat.find h₁
tactic: have h₂ := @Nat.find_spec P _ h₁
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
h₁ : (find P).Dom
h₂ : P (Nat.find h₁)
⊢ n < Nat.find h₁
state_after: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
h₁ : (find P).Dom
⊢ P (Nat.find h₁) → n < Nat.find h₁
tactic: revert h₂
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
h₁ : (find P).Dom
⊢ P (Nat.find h₁) → n < Nat.find h₁
state_after: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
h₁ : (find P).Dom
⊢ Nat.find h₁ ≤ n → ¬P (Nat.find h₁)
tactic: contrapose!
state_before: P : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ∀ m ≤ n, ¬P m
h₁ : (find P).Dom
⊢ Nat.find h₁ ≤ n → ¬P (Nat.find h₁)
state_after: no goals
tactic: exact h _
Theorem: Ideal.IsPrincipal.of_comap
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
S : Type u_1
N : Type u_2
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Ring S
inst✝¹ : Module R M
inst✝ : Module R N
f : R →+* S
hf : Surjective ⇑f
I : Ideal S
hI : IsPrincipal (comap f I)
⊢ I = Submodule.span S {f (IsPrincipal.generator (comap f I))}
state_after: no goals
tactic: rw [Ideal.submodule_span_eq, ← Set.image_singleton, ← Ideal.map_span,
        Ideal.span_singleton_generator, Ideal.map_comap_of_surjective f hf]
Theorem: Ring.mul_inverse_cancel_right
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x y : M₀
h : IsUnit x
⊢ y * x * inverse x = y
state_after: no goals
tactic: rw [mul_assoc, mul_inverse_cancel x h, mul_one]
Theorem: Nat.prod_pow_prime_padicValNat
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m✝ n✝ p n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ ∏ p ∈ Finset.filter Prime (Finset.range m), p ^ padicValNat p n = n
state_after: a b m✝ n✝ p n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ ∏ p ∈ Finset.filter Prime (Finset.range m), p ^ padicValNat p n = n.factorization.prod fun x x_1 => x ^ x_1
tactic: conv =>
    rhs
    rw [← factorization_prod_pow_eq_self hn]
state_before: a b m✝ n✝ p n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ ∏ p ∈ Finset.filter Prime (Finset.range m), p ^ padicValNat p n = n.factorization.prod fun x x_1 => x ^ x_1
state_after: a b m✝ n✝ p n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ (n.factorization.prod fun x x_1 => x ^ x_1) = ∏ p ∈ Finset.filter Prime (Finset.range m), p ^ padicValNat p n
tactic: rw [eq_comm]
state_before: a b m✝ n✝ p n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ (n.factorization.prod fun x x_1 => x ^ x_1) = ∏ p ∈ Finset.filter Prime (Finset.range m), p ^ padicValNat p n
state_after: case h
a b m✝ n✝ p n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ n.factorization.support ⊆ Finset.filter Prime (Finset.range m)

case hg
a b m✝ n✝ p n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ ∀ x ∈ Finset.filter Prime (Finset.range m) \ n.factorization.support, x ^ padicValNat x n = 1

case hfg
a b m✝ n✝ p n : ℕ
hn : n ≠ 0
m : ℕ
pr : n < m
⊢ ∀ x ∈ n.factorization.support, (fun x x_1 => x ^ x_1) x (n.factorization x) = x ^ padicValNat x n
tactic: apply Finset.prod_subset_one_on_sdiff
Theorem: Traversable.pure_traverse
File: Mathlib/Control/Traversable/Lemmas.lean

Proof steps:
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse pure x = pure x
state_after: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
this : traverse pure x = pure (traverse pure x)
⊢ traverse pure x = pure x
tactic: have : traverse pure x = pure (traverse (m := Id) pure x) :=
      (naturality (PureTransformation F) pure x).symm
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
this : traverse pure x = pure (traverse pure x)
⊢ traverse pure x = pure x
state_after: no goals
tactic: rwa [id_traverse] at this
Theorem: selfZPow_mul_neg
File: Mathlib/RingTheory/Localization/Away/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommRing R
x : R
B : Type u_2
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
⊢ selfZPow x B d * selfZPow x B (-d) = 1
state_after: case pos
R : Type u_1
inst✝³ : CommRing R
x : R
B : Type u_2
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
hd : d ≤ 0
⊢ selfZPow x B d * selfZPow x B (-d) = 1

case neg
R : Type u_1
inst✝³ : CommRing R
x : R
B : Type u_2
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℤ
hd : ¬d ≤ 0
⊢ selfZPow x B d * selfZPow x B (-d) = 1
tactic: by_cases hd : d ≤ 0
Theorem: Real.arccos_neg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ arccos (-x) = π - arccos x
state_after: no goals
tactic: rw [← add_halves π, arccos, arcsin_neg, arccos, add_sub_assoc, sub_sub_self, sub_neg_eq_add]
Theorem: InnerProductGeometry.angle_add_lt_pi_div_two_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
h0 : x ≠ 0
⊢ angle x (x + y) < π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0
⊢ 0 < ‖x‖ / √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖)
tactic: rw [angle_add_eq_arccos_of_inner_eq_zero h, Real.arccos_lt_pi_div_two,
    norm_add_eq_sqrt_iff_real_inner_eq_zero.2 h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0
⊢ 0 < ‖x‖ / √(‖x‖ * ‖x‖ + ‖y‖ * ‖y‖)
state_after: no goals
tactic: exact div_pos (norm_pos_iff.2 h0) (Real.sqrt_pos.2 (Left.add_pos_of_pos_of_nonneg
    (mul_self_pos.2 (norm_ne_zero_iff.2 h0)) (mul_self_nonneg _)))
Theorem: AddSubmonoid.isAddSubmonoid
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type u_2
inst✝ : AddMonoid A
t : Set A
S : Submonoid M
⊢ IsSubmonoid ↑S
state_after: no goals
tactic: exact ⟨S.2, S.1.2⟩
Theorem: MeasurableSpace.empty_mem_generateMeasurableRec
File: Mathlib/MeasureTheory/MeasurableSpace/Card.lean

Proof steps:
state_before: α : Type u
s : Set (Set α)
i : (Quotient.out (aleph 1).ord).α
⊢ ∅ ∈ generateMeasurableRec s i
state_after: α : Type u
s : Set (Set α)
i : (Quotient.out (aleph 1).ord).α
⊢ ∅ ∈
    let i := i;
    let S := ⋃ j, generateMeasurableRec s ↑j;
    s ∪ {∅} ∪ compl '' S ∪ range fun f => ⋃ n, ↑(f n)
tactic: unfold generateMeasurableRec
state_before: α : Type u
s : Set (Set α)
i : (Quotient.out (aleph 1).ord).α
⊢ ∅ ∈
    let i := i;
    let S := ⋃ j, generateMeasurableRec s ↑j;
    s ∪ {∅} ∪ compl '' S ∪ range fun f => ⋃ n, ↑(f n)
state_after: no goals
tactic: exact mem_union_left _ (mem_union_left _ (mem_union_right _ (mem_singleton ∅)))