ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Comma.coneOfPreserves_pt_hom
File: Mathlib/CategoryTheory/Limits/Comma.lean

Proof steps:
state_before: J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesLimit (F ⋙ snd L R) R
c₁ : Cone (F ⋙ fst L R)
c₂ : Cone (F ⋙ snd L R)
t₂ : IsLimit c₂
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ ((Functor.const J).obj
            { left := c₁.pt, right := c₂.pt, hom := (isLimitOfPreserves R t₂).lift (limitAuxiliaryCone F c₁) }).map
        t ≫
      (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₂ =
    (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₁ ≫ F.map t
state_after: case h₁
J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesLimit (F ⋙ snd L R) R
c₁ : Cone (F ⋙ fst L R)
c₂ : Cone (F ⋙ snd L R)
t₂ : IsLimit c₂
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ (((Functor.const J).obj
              { left := c₁.pt, right := c₂.pt, hom := (isLimitOfPreserves R t₂).lift (limitAuxiliaryCone F c₁) }).map
          t ≫
        (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₂).left =
    ((fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₁ ≫ F.map t).left

case h₂
J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesLimit (F ⋙ snd L R) R
c₁ : Cone (F ⋙ fst L R)
c₂ : Cone (F ⋙ snd L R)
t₂ : IsLimit c₂
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ (((Functor.const J).obj
              { left := c₁.pt, right := c₂.pt, hom := (isLimitOfPreserves R t₂).lift (limitAuxiliaryCone F c₁) }).map
          t ≫
        (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₂).right =
    ((fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₁ ≫ F.map t).right
tactic: ext
Theorem: RatFunc.map_apply
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝⁴ : Field K
R : Type u_1
F : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F K[X] R[X]
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
f : RatFunc K
⊢ (map φ hφ) f = (algebraMap R[X] (RatFunc R)) (φ f.num) / (algebraMap R[X] (RatFunc R)) (φ f.denom)
state_after: case hq
K : Type u
inst✝⁴ : Field K
R : Type u_1
F : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F K[X] R[X]
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
f : RatFunc K
⊢ f.denom ≠ 0
tactic: rw [← num_div_denom f, map_apply_div_ne_zero, num_div_denom f]
state_before: case hq
K : Type u
inst✝⁴ : Field K
R : Type u_1
F : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F K[X] R[X]
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
f : RatFunc K
⊢ f.denom ≠ 0
state_after: no goals
tactic: exact denom_ne_zero _
Theorem: WeierstrassCurve.Jacobian.polynomialY_eq
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ W'.polynomialY = C 2 * X y + C W'.a₁ * X x * X z + C W'.a₃ * X z ^ 3
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ (pderiv y)
      (X y ^ 2 + C W'.a₁ * X x * X y * X z + C W'.a₃ * X y * X z ^ 3 -
        (X x ^ 3 + C W'.a₂ * X x ^ 2 * X z ^ 2 + C W'.a₄ * X x * X z ^ 4 + C W'.a₆ * X z ^ 6)) =
    C 2 * X y + C W'.a₁ * X x * X z + C W'.a₃ * X z ^ 3
tactic: rw [polynomialY, polynomial]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ (pderiv y)
      (X y ^ 2 + C W'.a₁ * X x * X y * X z + C W'.a₃ * X y * X z ^ 3 -
        (X x ^ 3 + C W'.a₂ * X x ^ 2 * X z ^ 2 + C W'.a₄ * X x * X z ^ 4 + C W'.a₆ * X z ^ 6)) =
    C 2 * X y + C W'.a₁ * X x * X z + C W'.a₃ * X z ^ 3
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ ↑2 * X y ^ (2 - 1) * 1 + (((0 * X x + C W'.a₁ * 0) * X y + C W'.a₁ * X x * 1) * X z + C W'.a₁ * X x * X y * 0) +
        ((0 * X y + C W'.a₃ * 1) * X z ^ 3 + C W'.a₃ * X y * (↑3 * X z ^ (3 - 1) * 0)) -
      (↑3 * X x ^ (3 - 1) * 0 +
            ((0 * X x ^ 2 + C W'.a₂ * (↑2 * X x ^ (2 - 1) * 0)) * X z ^ 2 +
              C W'.a₂ * X x ^ 2 * (↑2 * X z ^ (2 - 1) * 0)) +
          ((0 * X x + C W'.a₄ * 0) * X z ^ 4 + C W'.a₄ * X x * (↑4 * X z ^ (4 - 1) * 0)) +
        (0 * X z ^ 6 + C W'.a₆ * (↑6 * X z ^ (6 - 1) * 0))) =
    2 * X y + C W'.a₁ * X x * X z + C W'.a₃ * X z ^ 3
tactic: pderiv_simp
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
⊢ ↑2 * X y ^ (2 - 1) * 1 + (((0 * X x + C W'.a₁ * 0) * X y + C W'.a₁ * X x * 1) * X z + C W'.a₁ * X x * X y * 0) +
        ((0 * X y + C W'.a₃ * 1) * X z ^ 3 + C W'.a₃ * X y * (↑3 * X z ^ (3 - 1) * 0)) -
      (↑3 * X x ^ (3 - 1) * 0 +
            ((0 * X x ^ 2 + C W'.a₂ * (↑2 * X x ^ (2 - 1) * 0)) * X z ^ 2 +
              C W'.a₂ * X x ^ 2 * (↑2 * X z ^ (2 - 1) * 0)) +
          ((0 * X x + C W'.a₄ * 0) * X z ^ 4 + C W'.a₄ * X x * (↑4 * X z ^ (4 - 1) * 0)) +
        (0 * X z ^ 6 + C W'.a₆ * (↑6 * X z ^ (6 - 1) * 0))) =
    2 * X y + C W'.a₁ * X x * X z + C W'.a₃ * X z ^ 3
state_after: no goals
tactic: ring1
Theorem: List.Nat.antidiagonalTuple_zero_right
File: Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean

Proof steps:
state_before: k : ℕ
⊢ antidiagonalTuple (k + 1) 0 = [0]
state_after: k : ℕ
⊢ [Fin.cons (0, 0).1 0] = [0]
tactic: rw [antidiagonalTuple, antidiagonal_zero, List.bind_singleton, antidiagonalTuple_zero_right k,
      List.map_singleton]
state_before: k : ℕ
⊢ [Fin.cons (0, 0).1 0] = [0]
state_after: no goals
tactic: exact congr_arg (fun x => [x]) Matrix.cons_zero_zero
Theorem: MonoidHomClass.antilipschitz_of_bound
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝¹ : FunLike 𝓕 E F
inst✝ : MonoidHomClass 𝓕 E F
f : 𝓕
K : ℝ≥0
h : ∀ (x : E), ‖x‖ ≤ ↑K * ‖f x‖
x y : E
⊢ dist x y ≤ ↑K * dist (f x) (f y)
state_after: no goals
tactic: simpa only [dist_eq_norm_div, map_div] using h (x / y)
Theorem: MeasureTheory.IsFundamentalDomain.sum_restrict_of_ac
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s μ
hν : ν ≪ μ
⊢ (sum fun g => ν.restrict (g • s)) = ν
state_after: no goals
tactic: rw [← restrict_iUnion_ae (h.aedisjoint.mono fun i j h => hν h) fun g =>
      (h.nullMeasurableSet_smul g).mono_ac hν,
    restrict_congr_set (hν h.iUnion_smul_ae_eq), restrict_univ]
Theorem: RCLike.conj_ofReal
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
r : ℝ
⊢ (starRingEnd K) ↑r = ↑r
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
r : ℝ
⊢ re ((starRingEnd K) ↑r) = re ↑r ∧ im ((starRingEnd K) ↑r) = im ↑r
tactic: rw [ext_iff]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
r : ℝ
⊢ re ((starRingEnd K) ↑r) = re ↑r ∧ im ((starRingEnd K) ↑r) = im ↑r
state_after: no goals
tactic: simp only [ofReal_im, conj_im, eq_self_iff_true, conj_re, and_self_iff, neg_zero]
Theorem: aemeasurable_indicator_iff
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
inst✝¹ : MeasurableSpace δ
f g : α → β
μ ν : Measure α
inst✝ : Zero β
s : Set α
hs : MeasurableSet s
⊢ AEMeasurable (s.indicator f) μ ↔ AEMeasurable f (μ.restrict s)
state_after: case mp
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
inst✝¹ : MeasurableSpace δ
f g : α → β
μ ν : Measure α
inst✝ : Zero β
s : Set α
hs : MeasurableSet s
⊢ AEMeasurable (s.indicator f) μ → AEMeasurable f (μ.restrict s)

case mpr
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
inst✝¹ : MeasurableSpace δ
f g : α → β
μ ν : Measure α
inst✝ : Zero β
s : Set α
hs : MeasurableSet s
⊢ AEMeasurable f (μ.restrict s) → AEMeasurable (s.indicator f) μ
tactic: constructor
Theorem: Nat.uniformEmbedding_coe_rat
File: Mathlib/Topology/Instances/Rat.lean

Proof steps:
state_before: ⊢ Pairwise fun x y => 1 ≤ dist ↑x ↑y
state_after: no goals
tactic: simpa using Nat.pairwise_one_le_dist
Theorem: Matrix.Pivot.exists_list_transvec_mul_mul_list_transvec_eq_diagonal_aux
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n✝ : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁷ : Field 𝕜
inst✝⁶ : DecidableEq n✝
inst✝⁵ : DecidableEq p
inst✝⁴ : CommRing R
r : ℕ
M✝ : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
inst✝³ : Fintype n✝
inst✝² : Fintype p
n : Type
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n 𝕜
⊢ ∃ L L' D, (List.map toMatrix L).prod * M * (List.map toMatrix L').prod = diagonal D
state_after: case zero
n✝ : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁷ : Field 𝕜
inst✝⁶ : DecidableEq n✝
inst✝⁵ : DecidableEq p
inst✝⁴ : CommRing R
r : ℕ
M✝ : Matrix (Fin r ⊕ Unit) (Fin r ⊕ Unit) 𝕜
inst✝³ : Fintype n✝
inst✝² : Fintype p
n : Type
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n 𝕜
hn : Fintype.card n = 0
⊢ ∃ L L' D, (List.map toMatrix L).prod * M * (List.map toMatrix L').prod = diagonal D

case succ
n✝ : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁷ : Field 𝕜
inst✝⁶ : DecidableEq n✝
inst✝⁵ : DecidableEq p
inst✝⁴ : CommRing R
r✝ : ℕ
M✝ : Matrix (Fin r✝ ⊕ Unit) (Fin r✝ ⊕ Unit) 𝕜
inst✝³ : Fintype n✝
inst✝² : Fintype p
r : ℕ
IH :
  ∀ (n : Type) [inst : Fintype n] [inst_1 : DecidableEq n] (M : Matrix n n 𝕜),
    Fintype.card n = r → ∃ L L' D, (List.map toMatrix L).prod * M * (List.map toMatrix L').prod = diagonal D
n : Type
inst✝¹ : Fintype n
inst✝ : DecidableEq n
M : Matrix n n 𝕜
hn : Fintype.card n = r + 1
⊢ ∃ L L' D, (List.map toMatrix L).prod * M * (List.map toMatrix L').prod = diagonal D
tactic: induction' hn : Fintype.card n with r IH generalizing n M
Theorem: Algebra.TensorProduct.natCast_def'
File: Mathlib/RingTheory/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoidWithOne A
inst✝² : Module R A
inst✝¹ : AddCommMonoidWithOne B
inst✝ : Module R B
n : ℕ
⊢ ↑n = 1 ⊗ₜ[R] ↑n
state_after: no goals
tactic: rw [natCast_def, ← nsmul_one, smul_tmul, nsmul_one]
Theorem: HasStrictFDerivAt.to_localInverse
File: Mathlib/Analysis/Calculus/InverseFunctionTheorem/FDeriv.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type u_5
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f : E → F
f' : E ≃L[𝕜] F
a : E
hf : HasStrictFDerivAt f (↑f') a
⊢ HasStrictFDerivAt (↑(toPartialHomeomorph f hf)) (↑f') (↑(toPartialHomeomorph f hf).symm (f a))
state_after: no goals
tactic: simpa [← localInverse_def] using hf
Theorem: Real.differentiableAt_Gamma
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
⊢ DifferentiableAt ℝ Gamma s
state_after: s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
⊢ ∀ (m : ℕ), ↑s ≠ -↑m
tactic: refine (Complex.differentiableAt_Gamma _ ?_).hasDerivAt.real_of_complex.differentiableAt
state_before: s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
⊢ ∀ (m : ℕ), ↑s ≠ -↑m
state_after: s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
⊢ ∀ (m : ℕ), ¬s = -↑m
tactic: simp_rw [← Complex.ofReal_natCast, ← Complex.ofReal_neg, Ne, Complex.ofReal_inj]
state_before: s : ℝ
hs : ∀ (m : ℕ), s ≠ -↑m
⊢ ∀ (m : ℕ), ¬s = -↑m
state_after: no goals
tactic: exact hs
Theorem: Finset.sum_apply_ite_of_false
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 (g 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 (g 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 (g x)
state_after: no goals
tactic: exact prod_ite_of_false h _ _
Theorem: AddAction.pretransitive_iff_unique_quotient_of_nonempty
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : MulAction G β
inst✝ : Nonempty α
⊢ IsPretransitive G α ↔ Nonempty (Unique (orbitRel.Quotient G α))
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : MulAction G β
inst✝ : Nonempty α
⊢ Subsingleton (orbitRel.Quotient G α) → Nonempty (orbitRel.Quotient G α)
tactic: rw [unique_iff_subsingleton_and_nonempty, pretransitive_iff_subsingleton_quotient, iff_self_and]
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : MulAction G β
inst✝ : Nonempty α
⊢ Subsingleton (orbitRel.Quotient G α) → Nonempty (orbitRel.Quotient G α)
state_after: no goals
tactic: exact fun _ ↦ (nonempty_quotient_iff _).mpr inferInstance
Theorem: MeasureTheory.measure_preimage_mul
File: Mathlib/MeasureTheory/Group/Measure.lean

Proof steps:
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulLeftInvariant
g : G
A : Set G
⊢ (Measure.map (fun h => g * h) μ) A = μ A
state_after: no goals
tactic: rw [map_mul_left_eq_self μ g]
Theorem: Nat.fast_fib_aux_eq
File: Mathlib/Data/Nat/Fib/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ n.fastFibAux = (fib n, fib (n + 1))
state_after: n : ℕ
⊢ fastFibAux 0 = (fib 0, fib (0 + 1))

n : ℕ
⊢ ∀ (b : Bool) (n' : ℕ),
    n'.fastFibAux = (fib n', fib (n' + 1)) → (bit b n').fastFibAux = (fib (bit b n'), fib (bit b n' + 1))
tactic: apply Nat.binaryRec _ (fun b n' ih => _) n
Theorem: Subtype.orderEmbedding_apply_coe
File: Mathlib/Order/Hom/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁴ : Preorder α
inst✝³ : Preorder β
inst✝² : Preorder γ
inst✝¹ : Preorder δ
ι : Type u_6
π : ι → Type u_7
inst✝ : (i : ι) → Preorder (π i)
p q : α → Prop
h : ∀ (a : α), p a → q a
⊢ ∀ {a b : { x // p x }}, __src✝ a ≤ __src✝ b ↔ a ≤ b
state_after: no goals
tactic: aesop
Theorem: List.eq_of_prod_take_eq
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : LeftCancelMonoid M
L L' : List M
h : L.length = L'.length
h' : ∀ i ≤ L.length, (take i L).prod = (take i L').prod
⊢ L = L'
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : LeftCancelMonoid M
L L' : List M
h : L.length = L'.length
h' : ∀ i ≤ L.length, (take i L).prod = (take i L').prod
i : ℕ
h₁ : i < L.length
h₂ : i < L'.length
⊢ L.get ⟨i, h₁⟩ = L'.get ⟨i, h₂⟩
tactic: refine ext_get h fun i h₁ h₂ => ?_
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : LeftCancelMonoid M
L L' : List M
h : L.length = L'.length
h' : ∀ i ≤ L.length, (take i L).prod = (take i L').prod
i : ℕ
h₁ : i < L.length
h₂ : i < L'.length
⊢ L.get ⟨i, h₁⟩ = L'.get ⟨i, h₂⟩
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : LeftCancelMonoid M
L L' : List M
h : L.length = L'.length
h' : ∀ i ≤ L.length, (take i L).prod = (take i L').prod
i : ℕ
h₁ : i < L.length
h₂ : i < L'.length
this : (take (i + 1) L).prod = (take (i + 1) L').prod
⊢ L.get ⟨i, h₁⟩ = L'.get ⟨i, h₂⟩
tactic: have : (L.take (i + 1)).prod = (L'.take (i + 1)).prod := h' _ (Nat.succ_le_of_lt h₁)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : LeftCancelMonoid M
L L' : List M
h : L.length = L'.length
h' : ∀ i ≤ L.length, (take i L).prod = (take i L').prod
i : ℕ
h₁ : i < L.length
h₂ : i < L'.length
this : (take (i + 1) L).prod = (take (i + 1) L').prod
⊢ L.get ⟨i, h₁⟩ = L'.get ⟨i, h₂⟩
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : LeftCancelMonoid M
L L' : List M
h : L.length = L'.length
h' : ∀ i ≤ L.length, (take i L).prod = (take i L').prod
i : ℕ
h₁ : i < L.length
h₂ : i < L'.length
this : (take i L').prod * L[i] = (take i L').prod * L'[i]
⊢ L.get ⟨i, h₁⟩ = L'.get ⟨i, h₂⟩
tactic: rw [prod_take_succ L i h₁, prod_take_succ L' i h₂, h' i (le_of_lt h₁)] at this
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : LeftCancelMonoid M
L L' : List M
h : L.length = L'.length
h' : ∀ i ≤ L.length, (take i L).prod = (take i L').prod
i : ℕ
h₁ : i < L.length
h₂ : i < L'.length
this : (take i L').prod * L[i] = (take i L').prod * L'[i]
⊢ L.get ⟨i, h₁⟩ = L'.get ⟨i, h₂⟩
state_after: no goals
tactic: convert mul_left_cancel this
Theorem: Monoid.IsTorsion.torsion_eq_top
File: Mathlib/GroupTheory/Torsion.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
tG : IsTorsion G
⊢ torsion G = ⊤
state_after: case h
G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
tG : IsTorsion G
x✝ : G
⊢ x✝ ∈ torsion G ↔ x✝ ∈ ⊤
tactic: ext
state_before: case h
G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
tG : IsTorsion G
x✝ : G
⊢ x✝ ∈ torsion G ↔ x✝ ∈ ⊤
state_after: no goals
tactic: tauto
Theorem: PiTensorProduct.liftIsometry_symm_apply
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
l : (⨂[𝕜] (i : ι), E i) →L[𝕜] F
⊢ (liftIsometry 𝕜 E F).symm l = l.compContinuousMultilinearMap (tprodL 𝕜)
state_after: case 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
l : (⨂[𝕜] (i : ι), E i) →L[𝕜] F
m : (i : ι) → E i
⊢ ((liftIsometry 𝕜 E F).symm l) m = (l.compContinuousMultilinearMap (tprodL 𝕜)) m
tactic: ext m
state_before: case 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
l : (⨂[𝕜] (i : ι), E i) →L[𝕜] F
m : (i : ι) → E i
⊢ ((liftIsometry 𝕜 E F).symm l) m = (l.compContinuousMultilinearMap (tprodL 𝕜)) m
state_after: case 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
l : (⨂[𝕜] (i : ι), E i) →L[𝕜] F
m : (i : ι) → E i
⊢ ((liftEquiv 𝕜 E F).symm l) m = (l.compContinuousMultilinearMap (tprodL 𝕜)) m
tactic: change (liftEquiv 𝕜 E F).symm l m = _
state_before: case 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
l : (⨂[𝕜] (i : ι), E i) →L[𝕜] F
m : (i : ι) → E i
⊢ ((liftEquiv 𝕜 E F).symm l) m = (l.compContinuousMultilinearMap (tprodL 𝕜)) m
state_after: no goals
tactic: simp only [liftEquiv_symm_apply, lift_symm, MultilinearMap.coe_mkContinuous,
    LinearMap.compMultilinearMap_apply, ContinuousLinearMap.coe_coe,
    ContinuousLinearMap.compContinuousMultilinearMap_coe, Function.comp_apply, tprodL_toFun]
Theorem: Nat.minSqFac_dvd
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
⊢ d * d ∣ n
state_after: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp n.minSqFac
⊢ d * d ∣ n
tactic: have := minSqFac_has_prop n
state_before: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp n.minSqFac
⊢ d * d ∣ n
state_after: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp (some d)
⊢ d * d ∣ n
tactic: rw [h] at this
state_before: s : Finset ℕ
m n✝ p n d : ℕ
h : n.minSqFac = some d
this : n.MinSqFacProp (some d)
⊢ d * d ∣ n
state_after: no goals
tactic: exact this.2.1
Theorem: MeasureTheory.measure_union_add_inter
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
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
ht : MeasurableSet t
⊢ μ (s ∪ t) + μ (s ∩ t) = μ s + μ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
ht : MeasurableSet t
⊢ μ t + μ (s \ t) + μ (s ∩ t) = μ (s ∩ t) + μ (s \ t) + μ t
tactic: rw [← measure_inter_add_diff (s ∪ t) ht, Set.union_inter_cancel_right, union_diff_right, ←
    measure_inter_add_diff s ht]
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
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
ht : MeasurableSet t
⊢ μ t + μ (s \ t) + μ (s ∩ t) = μ (s ∩ t) + μ (s \ t) + μ t
state_after: no goals
tactic: ac_rfl
Theorem: NNReal.summable_iff_not_tendsto_nat_atTop
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
⊢ Summable f ↔ ¬Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop atTop
state_after: no goals
tactic: rw [← not_iff_not, Classical.not_not, not_summable_iff_tendsto_nat_atTop]