ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: hasSum_fourier_series_of_summable
File: Mathlib/Analysis/Fourier/AddCircle.lean

Proof steps:
state_before: T : ℝ
hT : Fact (0 < T)
f : C(AddCircle T, ℂ)
h : Summable (fourierCoeff ⇑f)
⊢ HasSum (fun i => fourierCoeff (⇑f) i • fourier i) f
state_after: T : ℝ
hT : Fact (0 < T)
f : C(AddCircle T, ℂ)
h : Summable (fourierCoeff ⇑f)
sum_L2 : HasSum (fun i => fourierCoeff (↑↑((toLp 2 haarAddCircle ℂ) f)) i • fourierLp 2 i) ((toLp 2 haarAddCircle ℂ) f)
⊢ HasSum (fun i => fourierCoeff (⇑f) i • fourier i) f
tactic: have sum_L2 := hasSum_fourier_series_L2 (toLp (E := ℂ) 2 haarAddCircle ℂ f)
state_before: T : ℝ
hT : Fact (0 < T)
f : C(AddCircle T, ℂ)
h : Summable (fourierCoeff ⇑f)
sum_L2 : HasSum (fun i => fourierCoeff (↑↑((toLp 2 haarAddCircle ℂ) f)) i • fourierLp 2 i) ((toLp 2 haarAddCircle ℂ) f)
⊢ HasSum (fun i => fourierCoeff (⇑f) i • fourier i) f
state_after: T : ℝ
hT : Fact (0 < T)
f : C(AddCircle T, ℂ)
h : Summable (fourierCoeff ⇑f)
sum_L2 : HasSum (fun i => fourierCoeff (⇑f) i • fourierLp 2 i) ((toLp 2 haarAddCircle ℂ) f)
⊢ HasSum (fun i => fourierCoeff (⇑f) i • fourier i) f
tactic: simp_rw [fourierCoeff_toLp] at sum_L2
state_before: T : ℝ
hT : Fact (0 < T)
f : C(AddCircle T, ℂ)
h : Summable (fourierCoeff ⇑f)
sum_L2 : HasSum (fun i => fourierCoeff (⇑f) i • fourierLp 2 i) ((toLp 2 haarAddCircle ℂ) f)
⊢ HasSum (fun i => fourierCoeff (⇑f) i • fourier i) f
state_after: T : ℝ
hT : Fact (0 < T)
f : C(AddCircle T, ℂ)
h : Summable (fourierCoeff ⇑f)
sum_L2 : HasSum (fun i => fourierCoeff (⇑f) i • fourierLp 2 i) ((toLp 2 haarAddCircle ℂ) f)
⊢ Summable fun a => ‖fourierCoeff (⇑f) a • fourier a‖
tactic: refine ContinuousMap.hasSum_of_hasSum_Lp (.of_norm ?_) sum_L2
state_before: T : ℝ
hT : Fact (0 < T)
f : C(AddCircle T, ℂ)
h : Summable (fourierCoeff ⇑f)
sum_L2 : HasSum (fun i => fourierCoeff (⇑f) i • fourierLp 2 i) ((toLp 2 haarAddCircle ℂ) f)
⊢ Summable fun a => ‖fourierCoeff (⇑f) a • fourier a‖
state_after: T : ℝ
hT : Fact (0 < T)
f : C(AddCircle T, ℂ)
h : Summable (fourierCoeff ⇑f)
sum_L2 : HasSum (fun i => fourierCoeff (⇑f) i • fourierLp 2 i) ((toLp 2 haarAddCircle ℂ) f)
⊢ Summable fun a => ‖fourierCoeff (⇑f) a‖
tactic: simp_rw [norm_smul, fourier_norm, mul_one]
state_before: T : ℝ
hT : Fact (0 < T)
f : C(AddCircle T, ℂ)
h : Summable (fourierCoeff ⇑f)
sum_L2 : HasSum (fun i => fourierCoeff (⇑f) i • fourierLp 2 i) ((toLp 2 haarAddCircle ℂ) f)
⊢ Summable fun a => ‖fourierCoeff (⇑f) a‖
state_after: no goals
tactic: exact h.norm
Theorem: Real.cosh_abs
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ cosh |x| = cosh x
state_after: no goals
tactic: cases le_total x 0 <;> simp [*, _root_.abs_of_nonneg, abs_of_nonpos]
Theorem: Algebra.adjoin_attach_biUnion
File: Mathlib/RingTheory/Adjoin/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁹ : CommSemiring R
inst✝⁸ : CommSemiring S
inst✝⁷ : Semiring A
inst✝⁶ : Semiring B
inst✝⁵ : Algebra R S
inst✝⁴ : Algebra R A
inst✝³ : Algebra S A
inst✝² : Algebra R B
inst✝¹ : IsScalarTower R S A
s✝ t : Set A
inst✝ : DecidableEq A
α : Type u_1
s : Finset α
f : { x // x ∈ s } → Finset A
⊢ adjoin R ↑(s.attach.biUnion f) = ⨆ x, adjoin R ↑(f x)
state_after: no goals
tactic: simp [adjoin_iUnion]
Theorem: BoxIntegral.TaggedPrepartition.mem_iUnion
File: Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean

Proof steps:
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π : TaggedPrepartition I
x : ι → ℝ
⊢ x ∈ π.iUnion ↔ ∃ J ∈ π, x ∈ J
state_after: case h.e'_2.h.e'_2.h.a
ι : Type u_1
I J J₁ J₂ : Box ι
π : TaggedPrepartition I
x : ι → ℝ
x✝ : Box ι
⊢ x✝ ∈ π ∧ x ∈ x✝ ↔ ∃ (_ : x✝ ∈ π.toPrepartition), x ∈ ↑x✝
tactic: convert Set.mem_iUnion₂
state_before: case h.e'_2.h.e'_2.h.a
ι : Type u_1
I J J₁ J₂ : Box ι
π : TaggedPrepartition I
x : ι → ℝ
x✝ : Box ι
⊢ x✝ ∈ π ∧ x ∈ x✝ ↔ ∃ (_ : x✝ ∈ π.toPrepartition), x ∈ ↑x✝
state_after: no goals
tactic: rw [Box.mem_coe, mem_toPrepartition, exists_prop]
Theorem: WittVector.truncateFun_sub
File: Mathlib/RingTheory/WittVector/Truncated.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
x y : 𝕎 R
⊢ truncateFun n (x - y) = truncateFun n x - truncateFun n y
state_after: no goals
tactic: witt_truncateFun_tac
Theorem: Monoid.CoprodI.mrange_eq_iSup
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝¹ : Monoid N✝
N : Type u_4
inst✝ : Monoid N
f : (i : ι) → M i →* N
⊢ MonoidHom.mrange (lift f) = ⨆ i, MonoidHom.mrange (f i)
state_after: ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝¹ : Monoid N✝
N : Type u_4
inst✝ : Monoid N
f : (i : ι) → M i →* N
⊢ ⨆ i, Submonoid.closure (range fun b => (f ⟨i, b⟩.fst) ⟨i, b⟩.snd) = ⨆ i, MonoidHom.mrange (f i)
tactic: rw [lift, Equiv.coe_fn_mk, Con.lift_range, FreeMonoid.mrange_lift,
    range_sigma_eq_iUnion_range, Submonoid.closure_iUnion]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type u_3
inst✝¹ : Monoid N✝
N : Type u_4
inst✝ : Monoid N
f : (i : ι) → M i →* N
⊢ ⨆ i, Submonoid.closure (range fun b => (f ⟨i, b⟩.fst) ⟨i, b⟩.snd) = ⨆ i, MonoidHom.mrange (f i)
state_after: no goals
tactic: simp only [MonoidHom.mclosure_range]
Theorem: FirstOrder.Language.DirectLimit.relMap_unify_equiv
File: Mathlib/ModelTheory/DirectLimit.lean

Proof steps:
state_before: case intro.intro
L : Language
ι : Type v
inst✝³ : Preorder ι
G : ι → Type w
inst✝² : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝¹ : IsDirected ι fun x x_1 => x ≤ x_1
inst✝ : DirectedSystem G fun i j h => ⇑(f i j h)
n : ℕ
R : L.Relations n
x : Fin n → Σˣ f
i j : ι
hi : i ∈ upperBounds (range (Sigma.fst ∘ x))
hj : j ∈ upperBounds (range (Sigma.fst ∘ x))
k : ι
ik : i ≤ k
jk : j ≤ k
⊢ RelMap R (unify f x i hi) = RelMap R (unify f x j hj)
state_after: no goals
tactic: rw [← (f i k ik).map_rel, comp_unify, ← (f j k jk).map_rel, comp_unify]
Theorem: Finsupp.erase_idem
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α →₀ M
a : α
⊢ erase a (erase a f) = erase a f
state_after: no goals
tactic: rw [erase_eq_update_zero, erase_eq_update_zero, update_idem]
Theorem: WeierstrassCurve.Affine.CoordinateRing.smul_basis_mul_Y
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
p q : R[X]
⊢ (p • 1 + q • (mk W) Y) * (mk W) Y =
    (q * (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) • 1 + (p - q * (C W.a₁ * X + C W.a₃)) • (mk W) Y
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
p q : R[X]
Y_sq : (mk W) Y ^ 2 = (mk W) (C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆) - C (C W.a₁ * X + C W.a₃) * Y)
⊢ (p • 1 + q • (mk W) Y) * (mk W) Y =
    (q * (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) • 1 + (p - q * (C W.a₁ * X + C W.a₃)) • (mk W) Y
tactic: have Y_sq : mk W Y ^ 2 =
      mk W (C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆) - C (C W.a₁ * X + C W.a₃) * Y) := by
    exact AdjoinRoot.mk_eq_mk.mpr ⟨1, by rw [polynomial]; ring1⟩
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
p q : R[X]
Y_sq : (mk W) Y ^ 2 = (mk W) (C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆) - C (C W.a₁ * X + C W.a₃) * Y)
⊢ (p • 1 + q • (mk W) Y) * (mk W) Y =
    (q * (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) • 1 + (p - q * (C W.a₁ * X + C W.a₃)) • (mk W) Y
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
p q : R[X]
Y_sq : (mk W) Y ^ 2 = (mk W) (C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆) - C (C W.a₁ * X + C W.a₃) * Y)
⊢ (mk W) (C p) * (1 * (mk W) Y) +
      (mk W) (C q) *
        ((mk W) (C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) - (mk W) (C (C W.a₁ * X + C W.a₃)) * (mk W) Y) =
    (mk W) (C q) * ((mk W) (C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) * 1) +
      ((mk W) (C p) - (mk W) (C q) * (mk W) (C (C W.a₁ * X + C W.a₃))) * (mk W) Y
tactic: simp only [smul, add_mul, mul_assoc, ← sq, Y_sq, C_sub, map_sub, C_mul, _root_.map_mul]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
p q : R[X]
Y_sq : (mk W) Y ^ 2 = (mk W) (C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆) - C (C W.a₁ * X + C W.a₃) * Y)
⊢ (mk W) (C p) * (1 * (mk W) Y) +
      (mk W) (C q) *
        ((mk W) (C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) - (mk W) (C (C W.a₁ * X + C W.a₃)) * (mk W) Y) =
    (mk W) (C q) * ((mk W) (C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) * 1) +
      ((mk W) (C p) - (mk W) (C q) * (mk W) (C (C W.a₁ * X + C W.a₃))) * (mk W) Y
state_after: no goals
tactic: ring1
Theorem: Ordinal.bsup_le_iff
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
a : Ordinal.{max u v}
h : ∀ (i : (Quotient.out o).α), o.familyOfBFamily f i ≤ a
i : Ordinal.{u}
hi : i < o
⊢ f i hi ≤ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
a : Ordinal.{max u v}
h : ∀ (i : (Quotient.out o).α), o.familyOfBFamily f i ≤ a
i : Ordinal.{u}
hi : i < o
⊢ o.familyOfBFamily f (enum (fun x x_1 => x < x_1) i ⋯) ≤ a
tactic: rw [← familyOfBFamily_enum o f]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
a : Ordinal.{max u v}
h : ∀ (i : (Quotient.out o).α), o.familyOfBFamily f i ≤ a
i : Ordinal.{u}
hi : i < o
⊢ o.familyOfBFamily f (enum (fun x x_1 => x < x_1) i ⋯) ≤ a
state_after: no goals
tactic: exact h _
Theorem: Matrix.posSemidef_iff_eq_transpose_mul_self
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
A : Matrix n n 𝕜
⊢ A.PosSemidef ↔ ∃ B, A = Bᴴ * B
state_after: no goals
tactic: classical
  refine ⟨fun hA ↦ ⟨hA.sqrt, ?_⟩, fun ⟨B, hB⟩ ↦ (hB ▸ posSemidef_conjTranspose_mul_self B)⟩
  simp_rw [← PosSemidef.sq_sqrt hA, pow_two]
  rw [hA.posSemidef_sqrt.1]
Theorem: Cardinal.mk_univ_quaternionAlgebra_of_infinite
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: R : Type u_1
c₁ c₂ : R
inst✝ : Infinite R
⊢ #↑Set.univ = #R
state_after: no goals
tactic: rw [mk_univ_quaternionAlgebra, pow_four]
Theorem: TopCat.induced_of_isLimit
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
⊢ C.pt.str = ⨅ j, induced (⇑(C.π.app j)) (F.obj j).str
state_after: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (hC.conePointUniqueUpToIso (limitConeInfiIsLimit F))
⊢ C.pt.str = ⨅ j, induced (⇑(C.π.app j)) (F.obj j).str
tactic: let homeo := homeoOfIso (hC.conePointUniqueUpToIso (limitConeInfiIsLimit F))
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (hC.conePointUniqueUpToIso (limitConeInfiIsLimit F))
⊢ C.pt.str = ⨅ j, induced (⇑(C.π.app j)) (F.obj j).str
state_after: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (hC.conePointUniqueUpToIso (limitConeInfiIsLimit F))
⊢ induced (⇑homeo) (limitConeInfi F).pt.topologicalSpace_coe = ⨅ j, induced (⇑(C.π.app j)) (F.obj j).str
tactic: refine homeo.inducing.induced.trans ?_
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (hC.conePointUniqueUpToIso (limitConeInfiIsLimit F))
⊢ induced (⇑homeo) (limitConeInfi F).pt.topologicalSpace_coe = ⨅ j, induced (⇑(C.π.app j)) (F.obj j).str
state_after: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (hC.conePointUniqueUpToIso (limitConeInfiIsLimit F))
⊢ induced (⇑homeo) (⨅ j, induced ((Types.limitCone (F ⋙ forget TopCat)).π.app j) (F.obj j).str) =
    ⨅ j, induced (⇑(C.π.app j)) (F.obj j).str
tactic: change induced homeo (⨅ j : J, _) = _
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (hC.conePointUniqueUpToIso (limitConeInfiIsLimit F))
⊢ induced (⇑homeo) (⨅ j, induced ((Types.limitCone (F ⋙ forget TopCat)).π.app j) (F.obj j).str) =
    ⨅ j, induced (⇑(C.π.app j)) (F.obj j).str
state_after: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (hC.conePointUniqueUpToIso (limitConeInfiIsLimit F))
⊢ ⨅ i, induced ((Types.limitCone (F ⋙ forget TopCat)).π.app i ∘ ⇑homeo) (F.obj i).str =
    ⨅ j, induced (⇑(C.π.app j)) (F.obj j).str
tactic: simp [induced_iInf, induced_compose]
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
C : Cone F
hC : IsLimit C
homeo : ↑C.pt ≃ₜ ↑(limitConeInfi F).pt := homeoOfIso (hC.conePointUniqueUpToIso (limitConeInfiIsLimit F))
⊢ ⨅ i, induced ((Types.limitCone (F ⋙ forget TopCat)).π.app i ∘ ⇑homeo) (F.obj i).str =
    ⨅ j, induced (⇑(C.π.app j)) (F.obj j).str
state_after: no goals
tactic: rfl
Theorem: linearIndependent_le_span_aux'
File: Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι✝ : Type w
ι' : Type w'
inst✝² : StrongRankCondition R
ι : Type u_1
inst✝¹ : Fintype ι
v : ι → M
i : LinearIndependent R v
w : Set M
inst✝ : Fintype ↑w
s : range v ≤ ↑(span R w)
⊢ Fintype.card ι ≤ Fintype.card ↑w
state_after: case f
R : Type u
M : Type v
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι✝ : Type w
ι' : Type w'
inst✝² : StrongRankCondition R
ι : Type u_1
inst✝¹ : Fintype ι
v : ι → M
i : LinearIndependent R v
w : Set M
inst✝ : Fintype ↑w
s : range v ≤ ↑(span R w)
⊢ (ι →₀ R) →ₗ[R] ↑w →₀ R

case i
R : Type u
M : Type v
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι✝ : Type w
ι' : Type w'
inst✝² : StrongRankCondition R
ι : Type u_1
inst✝¹ : Fintype ι
v : ι → M
i : LinearIndependent R v
w : Set M
inst✝ : Fintype ↑w
s : range v ≤ ↑(span R w)
⊢ Injective ⇑?f
tactic: fapply card_le_of_injective' R
Theorem: Matrix.nnnorm_row
File: Mathlib/Analysis/Matrix.lean

Proof steps:
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁵ : Fintype l
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Unique ι
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
v : n → α
⊢ ‖row ι v‖₊ = ‖v‖₊
state_after: no goals
tactic: simp [nnnorm_def, Pi.nnnorm_def]
Theorem: CochainComplex.fromSingle₀Equiv_apply_coe
File: Mathlib/Algebra/Homology/Single.lean

Proof steps:
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
φ : (single₀ V).obj X ⟶ C
⊢ φ.f 0 ≫ C.d 0 1 = 0
state_after: no goals
tactic: rw [φ.comm 0 1, HomologicalComplex.single_obj_d, zero_comp]
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : { f // f ≫ C.d 0 1 = 0 }
i : ℕ
hi : (ComplexShape.up ℕ).Rel 0 i
⊢ ↑f ≫ C.d 0 i = 0
state_after: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : { f // f ≫ C.d 0 1 = 0 }
hi : (ComplexShape.up ℕ).Rel 0 1
⊢ ↑f ≫ C.d 0 1 = 0
tactic: obtain rfl : i = 1 := by simpa using hi.symm
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : { f // f ≫ C.d 0 1 = 0 }
hi : (ComplexShape.up ℕ).Rel 0 1
⊢ ↑f ≫ C.d 0 1 = 0
state_after: no goals
tactic: exact f.2
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
φ : (single₀ V).obj X ⟶ C
⊢ (fun f => HomologicalComplex.mkHomFromSingle ↑f ⋯) ((fun φ => ⟨φ.f 0, ⋯⟩) φ) = φ
state_after: no goals
tactic: aesop_cat
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
⊢ Function.RightInverse (fun f => HomologicalComplex.mkHomFromSingle ↑f ⋯) fun φ => ⟨φ.f 0, ⋯⟩
state_after: no goals
tactic: aesop_cat
Theorem: AffineSubspace.subsingleton_of_subsingleton_span_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
⊢ Subsingleton P
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
⊢ Subsingleton P
tactic: obtain ⟨p, hp⟩ := AffineSubspace.nonempty_of_affineSpan_eq_top k V P h₂
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
⊢ Subsingleton P
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P
tactic: have : s = {p} := Subset.antisymm (fun q hq => h₁ hq hp) (by simp [hp])
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
h₂ : affineSpan k s = ⊤
p : P
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
p : P
h₂ : univ.Subsingleton
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P
tactic: rw [this, AffineSubspace.ext_iff, AffineSubspace.coe_affineSpan_singleton,
    AffineSubspace.top_coe, eq_comm, ← subsingleton_iff_singleton (mem_univ _)] at h₂
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h₁ : s.Subsingleton
p : P
h₂ : univ.Subsingleton
hp : p ∈ s
this : s = {p}
⊢ Subsingleton P
state_after: no goals
tactic: exact subsingleton_of_univ_subsingleton h₂
Theorem: List.tail_append_singleton_of_ne_nil
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
l : List α
h : l ≠ []
⊢ (l ++ [a]).tail = l.tail ++ [a]
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
h : [] ≠ []
⊢ ([] ++ [a]).tail = [].tail ++ [a]

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
tail_ih✝ : tail✝ ≠ [] → (tail✝ ++ [a]).tail = tail✝.tail ++ [a]
h : head✝ :: tail✝ ≠ []
⊢ (head✝ :: tail✝ ++ [a]).tail = (head✝ :: tail✝).tail ++ [a]
tactic: induction l
Theorem: PrimeSpectrum.primeSpectrumProd_symm_inr
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
x : PrimeSpectrum S
⊢ (primeSpectrumProd R S).symm (Sum.inr x) = (comap (RingHom.snd R S)) x
state_after: case asIdeal.h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
x : PrimeSpectrum S
x✝ : R × S
⊢ x✝ ∈ ((primeSpectrumProd R S).symm (Sum.inr x)).asIdeal ↔ x✝ ∈ ((comap (RingHom.snd R S)) x).asIdeal
tactic: ext
state_before: case asIdeal.h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
x : PrimeSpectrum S
x✝ : R × S
⊢ x✝ ∈ ((primeSpectrumProd R S).symm (Sum.inr x)).asIdeal ↔ x✝ ∈ ((comap (RingHom.snd R S)) x).asIdeal
state_after: no goals
tactic: simp [Ideal.prod]
Theorem: Set.ncard_le_ncard_diff_add_ncard
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
ht : autoParam t.Finite _auto✝
⊢ s.ncard ≤ (s \ t).ncard + t.ncard
state_after: case inl
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
ht : autoParam t.Finite _auto✝
hs : s.Finite
⊢ s.ncard ≤ (s \ t).ncard + t.ncard

case inr
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
ht : autoParam t.Finite _auto✝
hs : s.Infinite
⊢ s.ncard ≤ (s \ t).ncard + t.ncard
tactic: cases' s.finite_or_infinite with hs hs
state_before: case inr
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
ht : autoParam t.Finite _auto✝
hs : s.Infinite
⊢ s.ncard ≤ (s \ t).ncard + t.ncard
state_after: case h.e'_3
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
ht : autoParam t.Finite _auto✝
hs : s.Infinite
⊢ s.ncard = 0
tactic: convert Nat.zero_le _
state_before: case h.e'_3
α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
ht : autoParam t.Finite _auto✝
hs : s.Infinite
⊢ s.ncard = 0
state_after: no goals
tactic: rw [hs.ncard]
Theorem: MvPolynomial.aeval_algebraMap_eq_zero_iff_of_injective
File: Mathlib/RingTheory/MvPolynomial/Tower.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
σ : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : CommSemiring B
inst✝³ : Algebra R A
inst✝² : Algebra A B
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R A B
x : σ → A
p : MvPolynomial σ R
h : Function.Injective ⇑(algebraMap A B)
⊢ (aeval (⇑(algebraMap A B) ∘ x)) p = 0 ↔ (aeval x) p = 0
state_after: no goals
tactic: rw [aeval_algebraMap_apply, ← (algebraMap A B).map_zero, h.eq_iff]
Theorem: Real.rpow_le_rpow_of_exponent_ge'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx0 : 0 ≤ x
hx1 : x ≤ 1
hz : 0 ≤ z
hyz : z ≤ y
⊢ x ^ y ≤ x ^ z
state_after: case inl
y z : ℝ
n : ℕ
hz : 0 ≤ z
hyz : z ≤ y
hx0 : 0 ≤ 0
hx1 : 0 ≤ 1
⊢ 0 ^ y ≤ 0 ^ z

case inr
x y z : ℝ
n : ℕ
hx0 : 0 ≤ x
hx1 : x ≤ 1
hz : 0 ≤ z
hyz : z ≤ y
hx0' : 0 < x
⊢ x ^ y ≤ x ^ z
tactic: rcases eq_or_lt_of_le hx0 with (rfl | hx0')
Theorem: Equiv.arrowCongr_comp
File: Mathlib/Logic/Equiv/Defs.lean

Proof steps:
state_before: α : Sort u
β : Sort v
γ : Sort w
α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ → β₁
g : β₁ → γ₁
⊢ (ea.arrowCongr ec) (g ∘ f) = (eb.arrowCongr ec) g ∘ (ea.arrowCongr eb) f
state_after: case h
α : Sort u
β : Sort v
γ : Sort w
α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ → β₁
g : β₁ → γ₁
x✝ : α₂
⊢ (ea.arrowCongr ec) (g ∘ f) x✝ = ((eb.arrowCongr ec) g ∘ (ea.arrowCongr eb) f) x✝
tactic: ext
state_before: case h
α : Sort u
β : Sort v
γ : Sort w
α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ → β₁
g : β₁ → γ₁
x✝ : α₂
⊢ (ea.arrowCongr ec) (g ∘ f) x✝ = ((eb.arrowCongr ec) g ∘ (ea.arrowCongr eb) f) x✝
state_after: no goals
tactic: simp only [comp, arrowCongr_apply, eb.symm_apply_apply]