ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ring.descPochhammer_smeval_add
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
r s : R
k : ℕ
h : Commute r s
⊢ (descPochhammer ℤ k).smeval (r + s) =
    ∑ ij ∈ antidiagonal k, ↑(k.choose ij.1) * ((descPochhammer ℤ ij.1).smeval r * (descPochhammer ℤ ij.2).smeval s)
state_after: no goals
tactic: induction k with
  | zero => simp
  | succ k ih =>
    rw [descPochhammer_succ_right, mul_comm, smeval_mul, sum_antidiagonal_choose_succ_mul
      fun i j => ((descPochhammer ℤ i).smeval r * (descPochhammer ℤ j).smeval s),
      ← sum_add_distrib, smeval_sub, smeval_X, smeval_natCast, pow_zero, pow_one, ih, mul_sum]
    refine sum_congr rfl ?_
    intro ij hij -- try to move descPochhammers to right, gather multipliers.
    have hdx : (descPochhammer ℤ ij.1).smeval r * (X - (ij.2 : ℤ[X])).smeval s =
        (X - (ij.2 : ℤ[X])).smeval s * (descPochhammer ℤ ij.1).smeval r := by
      refine (commute_iff_eq ((descPochhammer ℤ ij.1).smeval r)
        ((X - (ij.2 : ℤ[X])).smeval s)).mp ?_
      exact smeval_commute ℤ (descPochhammer ℤ ij.1) (X - (ij.2 : ℤ[X])) h
    rw [descPochhammer_succ_right, mul_comm, smeval_mul, descPochhammer_succ_right, mul_comm,
      smeval_mul, ← mul_assoc ((descPochhammer ℤ ij.1).smeval r), hdx]
    simp only [mul_assoc _ ((descPochhammer ℤ ij.1).smeval r) _,
      ← mul_assoc _ _ (((descPochhammer ℤ ij.1).smeval r) * _)]
    have hl : (r + s - k • 1) * (k.choose ij.1) = (k.choose ij.1) * (X - (ij.2 : ℤ[X])).smeval s +
        ↑(k.choose ij.2) * (X - (ij.1 : ℤ[X])).smeval r := by
      simp only [smeval_sub, smeval_X, pow_one, smeval_natCast, pow_zero, ← mul_sub]
      rw [← Nat.choose_symm_of_eq_add (List.Nat.mem_antidiagonal.mp hij).symm,
        (List.Nat.mem_antidiagonal.mp hij).symm, ← mul_add, Nat.cast_comm, add_smul]
      abel_nf
    rw [hl, ← add_mul]
Theorem: differentiableOn_const_add_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.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'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
h : DifferentiableOn 𝕜 (fun y => c + f y) s
⊢ DifferentiableOn 𝕜 f s
state_after: no goals
tactic: simpa using h.const_add (-c)
Theorem: Nat.xor_assoc
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: n m k : ℕ
⊢ n ^^^ m ^^^ k = n ^^^ (m ^^^ k)
state_after: no goals
tactic: bitwise_assoc_tac
Theorem: Equiv.swap_apply_eq_iff
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort u_1
inst✝ : DecidableEq α
x y z w : α
⊢ (swap x y) z = w ↔ z = (swap x y) w
state_after: no goals
tactic: rw [apply_eq_iff_eq_symm_apply, symm_swap]
Theorem: Pi.Lex.noMaxOrder'
File: Mathlib/Order/PiLex.lean

Proof steps:
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : Preorder ι
inst✝¹ : (i : ι) → LT (β i)
i : ι
inst✝ : NoMaxOrder (β i)
a : Lex ((i : ι) → β i)
⊢ ∃ b, a < b
state_after: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : Preorder ι
inst✝¹ : (i : ι) → LT (β i)
i : ι
inst✝ : NoMaxOrder (β i)
a : Lex ((i : ι) → β i)
b : β i
hb : a i < b
⊢ ∃ b, a < b
tactic: let ⟨b, hb⟩ := exists_gt (a i)
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : Preorder ι
inst✝¹ : (i : ι) → LT (β i)
i : ι
inst✝ : NoMaxOrder (β i)
a : Lex ((i : ι) → β i)
b : β i
hb : a i < b
⊢ ∃ b, a < b
state_after: no goals
tactic: classical
    exact ⟨Function.update a i b, i, fun j hj =>
      (Function.update_noteq hj.ne b a).symm, by rwa [Function.update_same i b]⟩
Theorem: Isometry.completion_extension
File: Mathlib/Topology/MetricSpace/Completion.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
h : Isometry f
x y : Completion α
⊢ Continuous fun x => dist (Completion.extension f x.1) (Completion.extension f x.2)
state_after: no goals
tactic: fun_prop
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
h : Isometry f
x y : Completion α
⊢ Continuous fun x => dist x.1 x.2
state_after: no goals
tactic: fun_prop
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
h : Isometry f
x y : Completion α
x✝¹ x✝ : α
⊢ dist (Completion.extension f (↑α x✝¹)) (Completion.extension f (↑α x✝)) = dist (↑α x✝¹) (↑α x✝)
state_after: no goals
tactic: simp only [extension_coe h.uniformContinuous, Completion.dist_eq, h.dist_eq]
Theorem: List.Sublist.eq_of_length
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
l₁ l₂ l₁✝ l₂✝ : List α✝
a : α✝
s : l₁✝ <+ l₂✝
h : (a :: l₁✝).length = (a :: l₂✝).length
⊢ a :: l₁✝ = a :: l₂✝
state_after: no goals
tactic: rw [s.eq_of_length (succ.inj h)]
Theorem: jacobiSym.mod_left'
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

Proof steps:
state_before: a₁ a₂ : ℤ
b : ℕ
h : a₁ % ↑b = a₂ % ↑b
⊢ J(a₁ | b) = J(a₂ | b)
state_after: no goals
tactic: rw [mod_left, h, ← mod_left]
Theorem: Submonoid.LocalizationMap.mulEquivOfLocalizations_right_inv_apply
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
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
Q : Type u_4
inst✝ : CommMonoid Q
k : S.LocalizationMap P
x : M
⊢ (f.ofMulEquivOfLocalizations (f.mulEquivOfLocalizations k)).toMap x = k.toMap x
state_after: no goals
tactic: simp
Theorem: Fin.last_sub
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
i : Fin (n + 1)
⊢ ↑(last n - i) = ↑i.rev
state_after: no goals
tactic: rw [coe_sub_iff_le.2 i.le_last, val_last, val_rev, Nat.succ_sub_succ_eq_sub]
Theorem: WittVector.mul_polyOfInterest_aux2
File: Mathlib/RingTheory/WittVector/MulCoeff.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ↑p ^ n * wittMul p n + wittPolyProdRemainder p n = wittPolyProd p n
state_after: case h.e'_2
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ↑p ^ n * wittMul p n + wittPolyProdRemainder p n = ∑ i ∈ range (n + 1), ↑p ^ i * wittMul p i ^ p ^ (n - i)
tactic: convert mul_polyOfInterest_aux1 p n
state_before: case h.e'_2
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ↑p ^ n * wittMul p n + wittPolyProdRemainder p n = ∑ i ∈ range (n + 1), ↑p ^ i * wittMul p i ^ p ^ (n - i)
state_after: case h.e'_2
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ wittPolyProdRemainder p n + ↑p ^ n * wittMul p n =
    ∑ x ∈ range n, ↑p ^ x * wittMul p x ^ p ^ (n - x) + ↑p ^ n * wittMul p n
tactic: rw [sum_range_succ, add_comm, Nat.sub_self, pow_zero, pow_one]
state_before: case h.e'_2
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ wittPolyProdRemainder p n + ↑p ^ n * wittMul p n =
    ∑ x ∈ range n, ↑p ^ x * wittMul p x ^ p ^ (n - x) + ↑p ^ n * wittMul p n
state_after: no goals
tactic: rfl
Theorem: Batteries.AssocList.all_eq
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
p : α → β → Bool
l : AssocList α β
⊢ all p l =
    l.toList.all fun x =>
      match x with
      | (a, b) => p a b
state_after: no goals
tactic: induction l <;> simp [all, *]
Theorem: CategoryTheory.Dial.braiding_naturality_left
File: Mathlib/CategoryTheory/Dialectica/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X Y : Dial C
f : X ⟶ Y
Z : Dial C
⊢ tensorHom f (𝟙 Z) ≫ (Y.braiding Z).hom = (X.braiding Z).hom ≫ tensorHom (𝟙 Z) f
state_after: no goals
tactic: aesop_cat
Theorem: Polynomial.map_surjective
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝¹ q✝ r : R[X]
inst✝ : Semiring S
f : R →+* S
hf : Function.Surjective ⇑f
p✝ p q : S[X]
hp : ∃ a, map f a = p
hq : ∃ a, map f a = q
p' : R[X]
hp' : map f p' = p
q' : R[X]
hq' : map f q' = q
⊢ map f (p' + q') = p + q
state_after: no goals
tactic: rw [Polynomial.map_add f, hp', hq']
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q r✝ : R[X]
inst✝ : Semiring S
f : R →+* S
hf : Function.Surjective ⇑f
p : S[X]
n : ℕ
s : S
r : R
hr : f r = s
⊢ map f ((monomial n) r) = (monomial n) s
state_after: no goals
tactic: rw [map_monomial f, hr]
Theorem: MonoidAlgebra.singleOneAlgHom_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
A : Type u_3
inst✝³ : CommSemiring k
inst✝² : Semiring A
inst✝¹ : Algebra k A
inst✝ : Monoid G
r : k
⊢ (↑↑__src✝).toFun ((algebraMap k A) r) = (algebraMap k (MonoidAlgebra A G)) r
state_after: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
A : Type u_3
inst✝³ : CommSemiring k
inst✝² : Semiring A
inst✝¹ : Algebra k A
inst✝ : Monoid G
r : k
x✝ : G
⊢ ((↑↑__src✝).toFun ((algebraMap k A) r)) x✝ = ((algebraMap k (MonoidAlgebra A G)) r) x✝
tactic: refine Finsupp.ext fun _ => ?_
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
A : Type u_3
inst✝³ : CommSemiring k
inst✝² : Semiring A
inst✝¹ : Algebra k A
inst✝ : Monoid G
r : k
x✝ : G
⊢ ((↑↑__src✝).toFun ((algebraMap k A) r)) x✝ = ((algebraMap k (MonoidAlgebra A G)) r) x✝
state_after: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
A : Type u_3
inst✝³ : CommSemiring k
inst✝² : Semiring A
inst✝¹ : Algebra k A
inst✝ : Monoid G
r : k
x✝ : G
⊢ (Finsupp.single 1 ((algebraMap k A) r)) x✝ = ((algebraMap k (MonoidAlgebra A G)) r) x✝
tactic: simp
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
A : Type u_3
inst✝³ : CommSemiring k
inst✝² : Semiring A
inst✝¹ : Algebra k A
inst✝ : Monoid G
r : k
x✝ : G
⊢ (Finsupp.single 1 ((algebraMap k A) r)) x✝ = ((algebraMap k (MonoidAlgebra A G)) r) x✝
state_after: no goals
tactic: rfl
Theorem: Polynomial.SplittingFieldAux.splits
File: Mathlib/FieldTheory/SplittingField/Construction.lean

Proof steps:
state_before: F : Type u
K✝¹ : Type v
L : Type w
inst✝³ : Field K✝¹
inst✝² : Field L
inst✝¹ : Field F
n✝ : ℕ
K✝ : Type u
inst✝ : Field K✝
n : ℕ
ih :
  (fun n =>
      ∀ {K : Type u} [inst : Field K] (f : K[X]), f.natDegree = n → Splits (algebraMap K (SplittingFieldAux n f)) f)
    n
K : Type u
x✝ : Field K
f : K[X]
hf : f.natDegree = n.succ
⊢ Splits (algebraMap K (SplittingFieldAux n.succ f)) f
state_after: F : Type u
K✝¹ : Type v
L : Type w
inst✝³ : Field K✝¹
inst✝² : Field L
inst✝¹ : Field F
n✝ : ℕ
K✝ : Type u
inst✝ : Field K✝
n : ℕ
ih :
  (fun n =>
      ∀ {K : Type u} [inst : Field K] (f : K[X]), f.natDegree = n → Splits (algebraMap K (SplittingFieldAux n f)) f)
    n
K : Type u
x✝ : Field K
f : K[X]
hf : f.natDegree = n.succ
⊢ Splits (algebraMap (AdjoinRoot f.factor) (SplittingFieldAux n f.removeFactor))
    ((X - C (AdjoinRoot.root f.factor)) * f.removeFactor)
tactic: rw [← splits_id_iff_splits, algebraMap_succ, ← map_map, splits_id_iff_splits,
      ← X_sub_C_mul_removeFactor f fun h => by rw [h] at hf; cases hf]
state_before: F : Type u
K✝¹ : Type v
L : Type w
inst✝³ : Field K✝¹
inst✝² : Field L
inst✝¹ : Field F
n✝ : ℕ
K✝ : Type u
inst✝ : Field K✝
n : ℕ
ih :
  (fun n =>
      ∀ {K : Type u} [inst : Field K] (f : K[X]), f.natDegree = n → Splits (algebraMap K (SplittingFieldAux n f)) f)
    n
K : Type u
x✝ : Field K
f : K[X]
hf : f.natDegree = n.succ
⊢ Splits (algebraMap (AdjoinRoot f.factor) (SplittingFieldAux n f.removeFactor))
    ((X - C (AdjoinRoot.root f.factor)) * f.removeFactor)
state_after: no goals
tactic: exact splits_mul _ (splits_X_sub_C _) (ih _ (natDegree_removeFactor' hf))
Theorem: Finset.mulEnergy_pos_iff
File: Mathlib/Combinatorics/Additive/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
h : 0 < Eₘ[s, t]
H : ¬(s.Nonempty ∧ t.Nonempty)
⊢ False
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
h : 0 < Eₘ[s, t]
H : s = ∅ ∨ t = ∅
⊢ False
tactic: simp_rw [not_and_or, not_nonempty_iff_eq_empty] at H
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
h : 0 < Eₘ[s, t]
H : s = ∅ ∨ t = ∅
⊢ False
state_after: no goals
tactic: obtain rfl | rfl := H <;> simp [Nat.not_lt_zero] at h
Theorem: Matroid.Basis.transfer
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
hXY : X ⊆ Y
hJY : M.Basis J Y
⊢ M.Basis I Y
state_after: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
hXY : X ⊆ Y
hJY : M.Basis J Y
⊢ (M ↾ Y).Base I
tactic: rw [← base_restrict_iff]
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
hXY : X ⊆ Y
hJY : M.Basis J Y
⊢ (M ↾ Y).Base I
state_after: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
hXY : X ⊆ Y
hJY : (M ↾ Y).Base J
⊢ (M ↾ Y).Base I
tactic: rw [← base_restrict_iff] at hJY
state_before: α : Type u_1
M : Matroid α
R I J✝ X Y B J : Set α
e : α
hIX : M.Basis I X
hJX : M.Basis J X
hXY : X ⊆ Y
hJY : (M ↾ Y).Base J
⊢ (M ↾ Y).Base I
state_after: no goals
tactic: exact hJY.base_of_basis_superset hJX.subset (hIX.basis_restrict_of_subset hXY)
Theorem: div_sq_cancel
File: Mathlib/Algebra/GroupWithZero/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✝ : CommGroupWithZero G₀
a✝ b✝ c d a b : G₀
⊢ a ^ 2 * b / a = a * b
state_after: case inl
α : 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✝ : CommGroupWithZero G₀
a b✝ c d b : G₀
⊢ 0 ^ 2 * b / 0 = 0 * b

case inr
α : 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✝ : CommGroupWithZero G₀
a✝ b✝ c d a b : G₀
ha : a ≠ 0
⊢ a ^ 2 * b / a = a * b
tactic: obtain rfl | ha := eq_or_ne a 0
Theorem: CategoryTheory.LaxMonoidalFunctor.μ_natural
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X Y X' Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ (F.map f ⊗ F.map g) ≫ F.μ Y Y' = F.μ X X' ≫ F.map (f ⊗ g)
state_after: no goals
tactic: simp [tensorHom_def]
Theorem: homTensorHomEquiv_toLinearMap
File: Mathlib/LinearAlgebra/Contraction.lean

Proof steps:
state_before: ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹³ : CommRing R
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✝⁴ : Free R M
inst✝³ : Module.Finite R M
inst✝² : Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
⊢ ↑(homTensorHomEquiv R M N P Q) = homTensorHomMap R M N P Q
state_after: case H.h.h.H.h.h
ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹³ : CommRing R
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✝⁴ : Free R M
inst✝³ : Module.Finite R M
inst✝² : Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
m : M →ₗ[R] P
n : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ (((TensorProduct.mk R M N).compr₂
          ((((TensorProduct.mk R (M →ₗ[R] P) (N →ₗ[R] Q)).compr₂ ↑(homTensorHomEquiv R M N P Q)) m) n))
        x✝¹)
      x✝ =
    (((TensorProduct.mk R M N).compr₂
          ((((TensorProduct.mk R (M →ₗ[R] P) (N →ₗ[R] Q)).compr₂ (homTensorHomMap R M N P Q)) m) n))
        x✝¹)
      x✝
tactic: ext m n
state_before: case H.h.h.H.h.h
ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹³ : CommRing R
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✝⁴ : Free R M
inst✝³ : Module.Finite R M
inst✝² : Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
m : M →ₗ[R] P
n : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ (((TensorProduct.mk R M N).compr₂
          ((((TensorProduct.mk R (M →ₗ[R] P) (N →ₗ[R] Q)).compr₂ ↑(homTensorHomEquiv R M N P Q)) m) n))
        x✝¹)
      x✝ =
    (((TensorProduct.mk R M N).compr₂
          ((((TensorProduct.mk R (M →ₗ[R] P) (N →ₗ[R] Q)).compr₂ (homTensorHomMap R M N P Q)) m) n))
        x✝¹)
      x✝
state_after: no goals
tactic: simp only [homTensorHomEquiv, compr₂_apply, mk_apply, LinearEquiv.coe_toLinearMap,
    LinearEquiv.trans_apply, lift.equiv_apply, LinearEquiv.arrowCongr_apply, LinearEquiv.refl_symm,
    LinearEquiv.refl_apply, rTensorHomEquivHomRTensor_apply, lTensorHomEquivHomLTensor_apply,
    lTensorHomToHomLTensor_apply, rTensorHomToHomRTensor_apply, homTensorHomMap_apply,
    map_tmul]
Theorem: Batteries.RBNode.all_iff
File: .lake/packages/batteries/Batteries/Data/RBMap/Basic.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
t : RBNode α
⊢ all p t = true ↔ All (fun x => p x = true) t
state_after: no goals
tactic: induction t <;> simp [*, all, All, and_assoc]
Theorem: Complex.abs_exp_mul_exp_add_exp_neg_le_of_abs_im_le
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
⊢ abs (cexp (↑a * (cexp z + cexp (-z)))) ≤ rexp (a * Real.cos b * rexp |z.re|)
state_after: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
⊢ a * ((rexp z.re + rexp (-z.re)) * Real.cos |z.im|) ≤ a * (rexp |z.re| * Real.cos b)
tactic: simp only [abs_exp, Real.exp_le_exp, re_ofReal_mul, add_re, exp_re, neg_im, Real.cos_neg, ←
    add_mul, mul_assoc, mul_comm (Real.cos b), neg_re, ← Real.cos_abs z.im]
state_before: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
⊢ a * ((rexp z.re + rexp (-z.re)) * Real.cos |z.im|) ≤ a * (rexp |z.re| * Real.cos b)
state_after: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ a * ((rexp z.re + rexp (-z.re)) * Real.cos |z.im|) ≤ a * (rexp |z.re| * Real.cos b)
tactic: have : Real.exp |z.re| ≤ Real.exp z.re + Real.exp (-z.re) :=
    apply_abs_le_add_of_nonneg (fun x => (Real.exp_pos x).le) z.re
state_before: a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ a * ((rexp z.re + rexp (-z.re)) * Real.cos |z.im|) ≤ a * (rexp |z.re| * Real.cos b)
state_after: case refine_1
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ Real.cos b ≤ Real.cos |z.im|

case refine_2
a b : ℝ
ha : a ≤ 0
z : ℂ
hz : |z.im| ≤ b
hb : b ≤ π / 2
this : rexp |z.re| ≤ rexp z.re + rexp (-z.re)
⊢ 0 ≤ Real.cos b
tactic: refine mul_le_mul_of_nonpos_left (mul_le_mul this ?_ ?_ ((Real.exp_pos _).le.trans this)) ha
Theorem: LinearMap.ofIsCompl_right_apply
File: Mathlib/LinearAlgebra/Projection.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
φ : ↥p →ₗ[R] F
ψ : ↥q →ₗ[R] F
v : ↥q
⊢ (ofIsCompl h φ ψ) ↑v = ψ v
state_after: no goals
tactic: simp [ofIsCompl]
Theorem: NonUnitalSubalgebra.unitization_injective
File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
A : Type u_3
inst✝³ : Field R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : SetLike S A
hSA : NonUnitalSubringClass S A
hSRA : SMulMemClass S R A
s : S
h1 : 1 ∉ s
x✝ : ↥s
⊢ (unitization s) ↑x✝ = ↑x✝
state_after: no goals
tactic: simp
Theorem: IsCompact.inv
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : InvolutiveInv G
inst✝ : ContinuousInv G
s : Set G
hs : IsCompact s
⊢ IsCompact s⁻¹
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : InvolutiveInv G
inst✝ : ContinuousInv G
s : Set G
hs : IsCompact s
⊢ IsCompact (Inv.inv '' s)
tactic: rw [← image_inv]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : InvolutiveInv G
inst✝ : ContinuousInv G
s : Set G
hs : IsCompact s
⊢ IsCompact (Inv.inv '' s)
state_after: no goals
tactic: exact hs.image continuous_inv
Theorem: Submodule.subsingleton_iff
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
⊢ Subsingleton (Submodule R M) ↔ Subsingleton (AddSubmonoid M)
state_after: no goals
tactic: rw [← subsingleton_iff_bot_eq_top, ← subsingleton_iff_bot_eq_top, ← toAddSubmonoid_eq,
      bot_toAddSubmonoid, top_toAddSubmonoid]
Theorem: MultilinearMap.snoc_smul
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : Fin n.succ) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : (i : Fin n.succ) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
f : MultilinearMap R M M₂
m : (i : Fin n) → M i.castSucc
c : R
x : M (last n)
⊢ f (snoc m (c • x)) = c • f (snoc m x)
state_after: no goals
tactic: simp_rw [← update_snoc_last x m (c • x), f.map_smul, update_snoc_last]
Theorem: MeasureTheory.Measure.rnDeriv_singularPart
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
⊢ (μ.singularPart ν).rnDeriv ν =ᶠ[ae ν] 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
⊢ μ.singularPart ν ⟂ₘ ν
tactic: rw [rnDeriv_eq_zero]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
⊢ μ.singularPart ν ⟂ₘ ν
state_after: no goals
tactic: exact mutuallySingular_singularPart μ ν
Theorem: intervalIntegral.integral_comp_add_div
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d✝ : ℝ
f : ℝ → E
hc : c ≠ 0
d : ℝ
⊢ ∫ (x : ℝ) in a..b, f (d + x / c) = c • ∫ (x : ℝ) in d + a / c..d + b / c, f x
state_after: no goals
tactic: simpa only [div_eq_inv_mul, inv_inv] using integral_comp_add_mul f (inv_ne_zero hc) d
Theorem: Set.ncard_le_one_iff_subset_singleton
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
inst✝ : Nonempty α
hs : autoParam s.Finite _auto✝
⊢ s.ncard ≤ 1 ↔ ∃ x, s ⊆ {x}
state_after: no goals
tactic: simp_rw [ncard_eq_toFinset_card _ hs, Finset.card_le_one_iff_subset_singleton,
    Finite.toFinset_subset, Finset.coe_singleton]