ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: lTensor_mkQ
File: Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N✝ : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N✝
inst✝² : Module R P
f : M →ₗ[R] N✝
g : N✝ →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
N : Submodule R M
⊢ ker (lTensor Q N.mkQ) = range (lTensor Q N.subtype)
state_after: R : Type u_1
M : Type u_2
N✝ : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N✝
inst✝² : Module R P
f : M →ₗ[R] N✝
g : N✝ →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
N : Submodule R M
⊢ Exact ⇑(lTensor Q N.subtype) ⇑(lTensor Q N.mkQ)
tactic: rw [← exact_iff]
state_before: R : Type u_1
M : Type u_2
N✝ : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N✝
inst✝² : Module R P
f : M →ₗ[R] N✝
g : N✝ →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
N : Submodule R M
⊢ Exact ⇑(lTensor Q N.subtype) ⇑(lTensor Q N.mkQ)
state_after: no goals
tactic: exact lTensor_exact Q (LinearMap.exact_subtype_mkQ N) (Submodule.mkQ_surjective N)
Theorem: Polynomial.separable_iff_derivative_ne_zero
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : Irreducible f
h : derivative f ≠ 0
g : F[X]
hg1 : g ∈ nonunits F[X]
_hg2 : g ≠ 0
x✝ : g ∣ f
hg4 : g ∣ derivative f
p : F[X]
hg3 : f = g * p
u : F[X]ˣ
hu : ↑u = p
⊢ f ∣ derivative f
state_after: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : Irreducible f
h : derivative f ≠ 0
g : F[X]
hg1 : g ∈ nonunits F[X]
_hg2 : g ≠ 0
x✝ : g ∣ f
hg4 : g ∣ derivative f
p : F[X]
hg3 : f = g * p
u : F[X]ˣ
hu : ↑u = p
⊢ g * ↑u ∣ derivative f
tactic: conv_lhs => rw [hg3, ← hu]
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : Irreducible f
h : derivative f ≠ 0
g : F[X]
hg1 : g ∈ nonunits F[X]
_hg2 : g ≠ 0
x✝ : g ∣ f
hg4 : g ∣ derivative f
p : F[X]
hg3 : f = g * p
u : F[X]ˣ
hu : ↑u = p
⊢ g * ↑u ∣ derivative f
state_after: no goals
tactic: rwa [Units.mul_right_dvd]
Theorem: FirstOrder.Language.Substructure.FG.map
File: Mathlib/ModelTheory/FinitelyGenerated.lean

Proof steps:
state_before: L : Language
M : Type u_1
inst✝¹ : L.Structure M
N : Type u_2
inst✝ : L.Structure N
f : M →[L] N
s : L.Substructure M
hs : s.FG
t : Set M
ht : t.Finite ∧ (closure L).toFun t = s
⊢ (closure L).toFun (⇑f '' t) = Substructure.map f s
state_after: no goals
tactic: rw [closure_image, ht.2]
Theorem: Matrix.toBlocks₁₁_diagonal
File: Mathlib/Data/Matrix/Block.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
v : l ⊕ m → α
⊢ (diagonal v).toBlocks₁₁ = diagonal fun i => v (Sum.inl i)
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
v : l ⊕ m → α
⊢ (of fun i j => diagonal v (Sum.inl i) (Sum.inl j)) = diagonal fun i => v (Sum.inl i)
tactic: unfold toBlocks₁₁
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
v : l ⊕ m → α
⊢ (of fun i j => diagonal v (Sum.inl i) (Sum.inl j)) = diagonal fun i => v (Sum.inl i)
state_after: case h.h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
v : l ⊕ m → α
i j : l
⊢ of (fun i j => diagonal v (Sum.inl i) (Sum.inl j)) i j = diagonal (fun i => v (Sum.inl i)) i j
tactic: funext i j
state_before: case h.h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
v : l ⊕ m → α
i j : l
⊢ of (fun i j => diagonal v (Sum.inl i) (Sum.inl j)) i j = diagonal (fun i => v (Sum.inl i)) i j
state_after: no goals
tactic: simp only [ne_eq, Sum.inl.injEq, of_apply, diagonal_apply]
Theorem: BoxIntegral.Box.splitUpper_le
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ ↑(I.splitUpper i x) ⊆ ↑↑I
state_after: no goals
tactic: simp
Theorem: PythagoreanTriple.classified
File: Mathlib/NumberTheory/PythagoreanTriples.lean

Proof steps:
state_before: x y z : ℤ
h : PythagoreanTriple x y z
⊢ h.IsClassified
state_after: case pos
x y z : ℤ
h : PythagoreanTriple x y z
h0 : x.gcd y = 0
⊢ h.IsClassified

case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ h.IsClassified
tactic: by_cases h0 : Int.gcd x y = 0
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ h.IsClassified
state_after: case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ ⋯.IsPrimitiveClassified
tactic: apply h.isClassified_of_normalize_isPrimitiveClassified
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ ⋯.IsPrimitiveClassified
state_after: case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ (x / ↑(x.gcd y)).gcd (y / ↑(x.gcd y)) = 1
tactic: apply h.normalize.isPrimitiveClassified_of_coprime
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
h0 : ¬x.gcd y = 0
⊢ (x / ↑(x.gcd y)).gcd (y / ↑(x.gcd y)) = 1
state_after: no goals
tactic: apply Int.gcd_div_gcd_div_gcd (Nat.pos_of_ne_zero h0)
Theorem: KaehlerDifferential.span_range_eq_ideal
File: Mathlib/RingTheory/Kaehler/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
⊢ Ideal.span (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1) = ideal R S
state_after: case a
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
⊢ Ideal.span (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1) ≤ ideal R S

case a
R : Type u
S : Type v
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
⊢ ideal R S ≤ Ideal.span (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1)
tactic: apply le_antisymm
Theorem: RCLike.complexLinearIsometryEquiv_apply
File: Mathlib/Analysis/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝¹ : ℝ
x✝ : 𝕜
⊢ { toFun := __spread✝⁻⁰.toFun, map_add' := ⋯ }.toFun (x✝¹ • x✝) =
    (RingHom.id ℝ) x✝¹ • { toFun := __spread✝⁻⁰.toFun, map_add' := ⋯ }.toFun x✝
state_after: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝¹ : ℝ
x✝ : 𝕜
⊢ ↑x✝¹ * ↑(RCLike.im x✝) * I = ↑x✝¹ * (↑(RCLike.im x✝) * I)
tactic: simp [RCLike.smul_re, RCLike.smul_im, ofReal_mul]
state_before: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝¹ : ℝ
x✝ : 𝕜
⊢ ↑x✝¹ * ↑(RCLike.im x✝) * I = ↑x✝¹ * (↑(RCLike.im x✝) * I)
state_after: no goals
tactic: ring
state_before: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝ : 𝕜
⊢ ‖{ toFun := __spread✝⁻⁰.toFun, map_add' := ⋯, map_smul' := ⋯, invFun := __spread✝⁻⁰.invFun, left_inv := ⋯,
          right_inv := ⋯ }
        x✝‖ =
    ‖x✝‖
state_after: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝ : 𝕜
⊢ normSq
      ({ toFun := __spread✝⁻⁰.toFun, map_add' := ⋯, map_smul' := ⋯, invFun := __spread✝⁻⁰.invFun, left_inv := ⋯,
          right_inv := ⋯ }
        x✝) =
    RCLike.re x✝ * RCLike.re x✝ + RCLike.im x✝ * RCLike.im x✝
tactic: rw [← sq_eq_sq (by positivity) (by positivity), ← normSq_eq_norm_sq, ← RCLike.normSq_eq_def',
      RCLike.normSq_apply]
state_before: z : ℂ
E : Type u_1
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
𝕜 : Type u_2
inst✝ : RCLike 𝕜
h : RCLike.im RCLike.I = 1
x✝ : 𝕜
⊢ normSq
      ({ toFun := __spread✝⁻⁰.toFun, map_add' := ⋯, map_smul' := ⋯, invFun := __spread✝⁻⁰.invFun, left_inv := ⋯,
          right_inv := ⋯ }
        x✝) =
    RCLike.re x✝ * RCLike.re x✝ + RCLike.im x✝ * RCLike.im x✝
state_after: no goals
tactic: simp [normSq_add]
Theorem: PowerSeries.trunc_C
File: Mathlib/RingTheory/PowerSeries/Trunc.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
⊢ (trunc (n + 1) ((C R) a)).coeff m = (Polynomial.C a).coeff m
state_after: R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
⊢ (if m < n + 1 then if m = 0 then a else 0 else 0) = if m = 0 then a else 0
tactic: rw [coeff_trunc, coeff_C, Polynomial.coeff_C]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
a : R
m : ℕ
⊢ (if m < n + 1 then if m = 0 then a else 0 else 0) = if m = 0 then a else 0
state_after: no goals
tactic: split_ifs with H <;> first |rfl|try simp_all
Theorem: eq_mul_inv_iff_mul_eq
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a = b * c⁻¹
⊢ a * c = b
state_after: no goals
tactic: rw [h, inv_mul_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a * c = b
⊢ a = b * c⁻¹
state_after: no goals
tactic: rw [← h, mul_inv_cancel_right]
Theorem: CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
X' Y' : C
f' : X' ⟶ Y'
kf : KernelFork f
kf' : KernelFork f'
hf : IsLimit kf
hf' : IsLimit kf'
φ : Arrow.mk f ≅ Arrow.mk f'
⊢ (kf.mapOfIsLimit hf' φ.hom ≫ kf'.mapOfIsLimit hf φ.inv) ≫ Fork.ι kf = 𝟙 kf.pt ≫ Fork.ι kf
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
X' Y' : C
f' : X' ⟶ Y'
kf : KernelFork f
kf' : KernelFork f'
hf : IsLimit kf
hf' : IsLimit kf'
φ : Arrow.mk f ≅ Arrow.mk f'
⊢ (kf'.mapOfIsLimit hf φ.inv ≫ kf.mapOfIsLimit hf' φ.hom) ≫ Fork.ι kf' = 𝟙 kf'.pt ≫ Fork.ι kf'
state_after: no goals
tactic: simp
Theorem: CategoryTheory.NatIso.mapHomologicalComplex_inv_app_f
File: Mathlib/Algebra/Homology/Additive.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝⁹ : Category.{v, u} V
inst✝⁸ : Preadditive V
W : Type u_2
inst✝⁷ : Category.{?u.62271, u_2} W
inst✝⁶ : Preadditive W
W₁ : Type u_3
W₂ : Type u_4
inst✝⁵ : Category.{?u.62296, u_3} W₁
inst✝⁴ : Category.{?u.62300, u_4} W₂
inst✝³ : HasZeroMorphisms W₁
inst✝² : HasZeroMorphisms W₂
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i : ι
F G : W₁ ⥤ W₂
inst✝¹ : F.PreservesZeroMorphisms
inst✝ : G.PreservesZeroMorphisms
α : F ≅ G
c : ComplexShape ι
⊢ NatTrans.mapHomologicalComplex α.hom c ≫ NatTrans.mapHomologicalComplex α.inv c = 𝟙 (F.mapHomologicalComplex c)
state_after: no goals
tactic: simp only [← NatTrans.mapHomologicalComplex_comp, α.hom_inv_id,
    NatTrans.mapHomologicalComplex_id]
state_before: ι : Type u_1
V : Type u
inst✝⁹ : Category.{v, u} V
inst✝⁸ : Preadditive V
W : Type u_2
inst✝⁷ : Category.{?u.62271, u_2} W
inst✝⁶ : Preadditive W
W₁ : Type u_3
W₂ : Type u_4
inst✝⁵ : Category.{?u.62296, u_3} W₁
inst✝⁴ : Category.{?u.62300, u_4} W₂
inst✝³ : HasZeroMorphisms W₁
inst✝² : HasZeroMorphisms W₂
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i : ι
F G : W₁ ⥤ W₂
inst✝¹ : F.PreservesZeroMorphisms
inst✝ : G.PreservesZeroMorphisms
α : F ≅ G
c : ComplexShape ι
⊢ NatTrans.mapHomologicalComplex α.inv c ≫ NatTrans.mapHomologicalComplex α.hom c = 𝟙 (G.mapHomologicalComplex c)
state_after: no goals
tactic: simp only [← NatTrans.mapHomologicalComplex_comp, α.inv_hom_id,
    NatTrans.mapHomologicalComplex_id]
Theorem: mul_one_add
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝² : Add α
inst✝¹ : MulOneClass α
inst✝ : LeftDistribClass α
a b : α
⊢ a * (1 + b) = a + a * b
state_after: no goals
tactic: rw [mul_add, mul_one]
Theorem: MvPowerSeries.coeff_mul_C
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
n : σ →₀ ℕ
φ : MvPowerSeries σ R
a : R
⊢ (coeff R n) (φ * (C σ R) a) = (coeff R n) φ * a
state_after: no goals
tactic: simpa using coeff_add_mul_monomial n 0 φ a
Theorem: MulChar.ne_one_iff
File: Mathlib/NumberTheory/MulChar/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
⊢ χ ≠ 1 ↔ ∃ a, χ ↑a ≠ 1
state_after: no goals
tactic: simp only [Ne, eq_one_iff, not_forall]
Theorem: MeasureTheory.FiniteMeasure.map_fst_prod
File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
⊢ (μ.prod ν).map Prod.fst = ν univ • μ
state_after: case h
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
s✝ : Set α
a✝ : MeasurableSet s✝
⊢ ↑((μ.prod ν).map Prod.fst) s✝ = ↑(ν univ • μ) s✝
tactic: ext
state_before: case h
α : Type u_1
inst✝¹ : MeasurableSpace α
β : Type u_2
inst✝ : MeasurableSpace β
μ : FiniteMeasure α
ν : FiniteMeasure β
s✝ : Set α
a✝ : MeasurableSet s✝
⊢ ↑((μ.prod ν).map Prod.fst) s✝ = ↑(ν univ • μ) s✝
state_after: no goals
tactic: simp
Theorem: Ordinal.natCast_div
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: m n : ℕ
⊢ ↑(m / n) = ↑m / ↑n
state_after: case inl
m : ℕ
⊢ ↑(m / 0) = ↑m / ↑0

case inr
m n : ℕ
hn : n ≠ 0
⊢ ↑(m / n) = ↑m / ↑n
tactic: rcases eq_or_ne n 0 with (rfl | hn)
Theorem: SimpleGraph.Walk.IsPath.reverse
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w u v : V
p : G.Walk u v
h : p.IsPath
⊢ p.reverse.IsPath
state_after: no goals
tactic: simpa [isPath_def] using h
Theorem: MeasureTheory.SimpleFunc.integral_eq_integral
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 E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α →ₛ E
hfi : Integrable (↑f) μ
⊢ integral μ f = ∫ (x : α), ↑f x ∂μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α →ₛ E
hfi : Integrable (↑f) μ
⊢ integral μ f = integral μ (Lp.simpleFunc.toSimpleFunc (Lp.simpleFunc.toLp f ⋯))
tactic: rw [MeasureTheory.integral_eq f hfi, ← L1.SimpleFunc.toLp_one_eq_toL1,
    L1.SimpleFunc.integral_L1_eq_integral, L1.SimpleFunc.integral_eq_integral]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α →ₛ E
hfi : Integrable (↑f) μ
⊢ integral μ f = integral μ (Lp.simpleFunc.toSimpleFunc (Lp.simpleFunc.toLp f ⋯))
state_after: no goals
tactic: exact SimpleFunc.integral_congr hfi (Lp.simpleFunc.toSimpleFunc_toLp _ _).symm
Theorem: Ideal.map_pi
File: Mathlib/RingTheory/Ideal/Quotient.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
⊢ f x i ∈ I
state_after: no goals
tactic: classical
    cases nonempty_fintype ι
    rw [pi_eq_sum_univ x]
    simp only [Finset.sum_apply, smul_eq_mul, map_sum, Pi.smul_apply, map_smul]
    exact I.sum_mem fun j _ => I.mul_mem_right _ (hi j)
Theorem: InnerProductGeometry.cos_angle_sub_add_angle_sub_rev_eq_neg_cos_angle
File: Mathlib/Geometry/Euclidean/Triangle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
hx : x ≠ 0
hy : y ≠ 0
⊢ Real.cos (angle x (x - y) + angle y (y - x)) = -Real.cos (angle x y)
state_after: case pos
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
hx : x ≠ 0
hy : y ≠ 0
hxy : x = y
⊢ Real.cos (angle x (x - y) + angle y (y - x)) = -Real.cos (angle x y)

case neg
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
hx : x ≠ 0
hy : y ≠ 0
hxy : ¬x = y
⊢ Real.cos (angle x (x - y) + angle y (y - x)) = -Real.cos (angle x y)
tactic: by_cases hxy : x = y
Theorem: Fin.append_rev
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ 0
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.succ
i✝ : Fin n✝
y : α✝ i✝.succ
z : α✝ 0
m n : ℕ
α : Type u_1
xs : Fin m → α
ys : Fin n → α
i : Fin (m + n)
⊢ append xs ys i.rev = append (ys ∘ rev) (xs ∘ rev) (cast ⋯ i)
state_after: case intro
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ 0
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.succ
i✝ : Fin n✝
y : α✝ i✝.succ
z : α✝ 0
m n : ℕ
α : Type u_1
xs : Fin m → α
ys : Fin n → α
i : Fin (m + n)
⊢ append xs ys i.rev.rev = append (ys ∘ rev) (xs ∘ rev) (cast ⋯ i.rev)
tactic: rcases rev_surjective i with ⟨i, rfl⟩
state_before: case intro
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ 0
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.succ
i✝ : Fin n✝
y : α✝ i✝.succ
z : α✝ 0
m n : ℕ
α : Type u_1
xs : Fin m → α
ys : Fin n → α
i : Fin (m + n)
⊢ append xs ys i.rev.rev = append (ys ∘ rev) (xs ∘ rev) (cast ⋯ i.rev)
state_after: case intro
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ 0
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.succ
i✝ : Fin n✝
y : α✝ i✝.succ
z : α✝ 0
m n : ℕ
α : Type u_1
xs : Fin m → α
ys : Fin n → α
i : Fin (m + n)
⊢ append xs ys i = append (ys ∘ rev) (xs ∘ rev) (cast ⋯ i.rev)
tactic: rw [rev_rev]
state_before: case intro
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ 0
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.succ
i✝ : Fin n✝
y : α✝ i✝.succ
z : α✝ 0
m n : ℕ
α : Type u_1
xs : Fin m → α
ys : Fin n → α
i : Fin (m + n)
⊢ append xs ys i = append (ys ∘ rev) (xs ∘ rev) (cast ⋯ i.rev)
state_after: case intro.left
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ 0
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.succ
i : Fin n✝
y : α✝ i.succ
z : α✝ 0
m n : ℕ
α : Type u_1
xs : Fin m → α
ys : Fin n → α
i✝ : Fin m
⊢ append xs ys (castAdd n i✝) = append (ys ∘ rev) (xs ∘ rev) (cast ⋯ (castAdd n i✝).rev)

case intro.right
m✝ n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ 0
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ i.succ
i : Fin n✝
y : α✝ i.succ
z : α✝ 0
m n : ℕ
α : Type u_1
xs : Fin m → α
ys : Fin n → α
i✝ : Fin n
⊢ append xs ys (natAdd m i✝) = append (ys ∘ rev) (xs ∘ rev) (cast ⋯ (natAdd m i✝).rev)
tactic: induction i using Fin.addCases
Theorem: AList.keys_insert
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : AList β
⊢ (insert a b s).keys = a :: s.keys.erase a
state_after: no goals
tactic: simp [insert, keys, keys_kerase]
Theorem: PartialHomeomorph.unitBallBall_symm_apply
File: Mathlib/Analysis/NormedSpace/HomeomorphBall.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
P : Type u_2
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
r : ℝ
hr : 0 < r
⊢ (⇑(IsometryEquiv.vaddConst c) ∘ fun x => r • x) '' ball 0 1 = ball c r
state_after: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
P : Type u_2
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
r : ℝ
hr : 0 < r
⊢ ball ((IsometryEquiv.vaddConst c) 0) ‖r‖ = ball c r
tactic: rw [image_comp, image_smul, smul_unitBall hr.ne', IsometryEquiv.image_ball]
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
P : Type u_2
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
r : ℝ
hr : 0 < r
⊢ ball ((IsometryEquiv.vaddConst c) 0) ‖r‖ = ball c r
state_after: no goals
tactic: simp [abs_of_pos hr]
Theorem: CategoryTheory.Limits.IndObjectPresentation.extend_F
File: Mathlib/CategoryTheory/Limits/Indization/IndObject.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
A✝ : Cᵒᵖ ⥤ Type v
P✝ : IndObjectPresentation A✝
A B : Cᵒᵖ ⥤ Type v
P : IndObjectPresentation A
η : A ⟶ B
inst✝ : IsIso η
⊢ P.cocone.pt ⟶ ?m.7956
state_after: no goals
tactic: exact η
Theorem: Finset.inv_inter
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : DecidableEq α
inst✝ : InvolutiveInv α
s✝ : Finset α
a : α
s t : Finset α
⊢ ↑(s ∩ t)⁻¹ = ↑(s⁻¹ ∩ t⁻¹)
state_after: no goals
tactic: simp
Theorem: lt_isLUB_iff
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝ : LinearOrder α
s : Set α
a b : α
h : IsLUB s a
⊢ b < a ↔ ∃ c ∈ s, b < c
state_after: no goals
tactic: simp_rw [← not_le, isLUB_le_iff h, mem_upperBounds, not_forall, not_le, exists_prop]
Theorem: UpperHalfPlane.c_mul_im_sq_le_normSq_denom
File: Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean

Proof steps:
state_before: z : ℍ
g : SL(2, ℝ)
⊢ (↑↑(toGLPos g) 1 0 * z.im) ^ 2 ≤ Complex.normSq (denom (toGLPos g) z)
state_after: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
⊢ (↑↑(toGLPos g) 1 0 * z.im) ^ 2 ≤ Complex.normSq (denom (toGLPos g) z)
tactic: let c := (↑ₘg 1 0 : ℝ)
state_before: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
⊢ (↑↑(toGLPos g) 1 0 * z.im) ^ 2 ≤ Complex.normSq (denom (toGLPos g) z)
state_after: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
d : ℝ := ↑↑(toGLPos g) 1 1
⊢ (↑↑(toGLPos g) 1 0 * z.im) ^ 2 ≤ Complex.normSq (denom (toGLPos g) z)
tactic: let d := (↑ₘg 1 1 : ℝ)
state_before: z : ℍ
g : SL(2, ℝ)
c : ℝ := ↑↑(toGLPos g) 1 0
d : ℝ := ↑↑(toGLPos g) 1 1
⊢ (↑↑(toGLPos g) 1 0 * z.im) ^ 2 ≤ Complex.normSq (denom (toGLPos g) z)
state_after: no goals
tactic: calc
    (c * z.im) ^ 2 ≤ (c * z.im) ^ 2 + (c * z.re + d) ^ 2 := by nlinarith
    _ = Complex.normSq (denom g z) := by dsimp [c, d, denom, Complex.normSq]; ring