ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.ae_restrict_eq
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : MeasurableSet s
⊢ ae (μ.restrict s) = ae μ ⊓ 𝓟 s
state_after: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
t : Set α
⊢ t ∈ ae (μ.restrict s) ↔ t ∈ ae μ ⊓ 𝓟 s
tactic: ext t
state_before: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
t : Set α
⊢ t ∈ ae (μ.restrict s) ↔ t ∈ ae μ ⊓ 𝓟 s
state_after: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
t : Set α
⊢ μ (tᶜ ∩ s) = 0 ↔ μ {a | a ∉ t ∧ a ∈ s} = 0
tactic: simp only [mem_inf_principal, mem_ae_iff, restrict_apply_eq_zero' hs, compl_setOf,
    Classical.not_imp, fun a => and_comm (a := a ∈ s) (b := ¬a ∈ t)]
state_before: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
t : Set α
⊢ μ (tᶜ ∩ s) = 0 ↔ μ {a | a ∉ t ∧ a ∈ s} = 0
state_after: no goals
tactic: rfl
Theorem: riemannZeta_eulerProduct_hasProd
File: Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean

Proof steps:
state_before: s : ℂ
hs : 1 < s.re
⊢ HasProd (fun p => (1 - ↑↑p ^ (-s))⁻¹) (riemannZeta s)
state_after: s : ℂ
hs : 1 < s.re
⊢ HasProd (fun p => (1 - ↑↑p ^ (-s))⁻¹) (∑' (n : ℕ), (riemannZetaSummandHom ⋯) n)
tactic: rw [← tsum_riemannZetaSummand hs]
state_before: s : ℂ
hs : 1 < s.re
⊢ HasProd (fun p => (1 - ↑↑p ^ (-s))⁻¹) (∑' (n : ℕ), (riemannZetaSummandHom ⋯) n)
state_after: no goals
tactic: apply eulerProduct_completely_multiplicative_hasProd <| summable_riemannZetaSummand hs
Theorem: CategoryTheory.Functor.Iteration.coconeOfLE_pt
File: Mathlib/CategoryTheory/SmallObject/Iteration.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{?u.11479, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
F : { i // i ≤ j } ⥤ C
i : J
hi : i ≤ j
x✝ : { k // k < i }
k : J
hk : k < i
⊢ ⋯.functor.obj ⟨k, hk⟩ ≤ ⟨i, hi⟩
state_after: no goals
tactic: simpa using hk.le
state_before: C : Type u_1
inst✝³ : Category.{?u.11479, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
F : { i // i ≤ j } ⥤ C
i : J
hi : i ≤ j
x✝² x✝¹ : { k // k < i }
k₁ : J
hk₁ : k₁ < i
k₂ : J
hk₂ : k₂ < i
x✝ : ⟨k₁, hk₁⟩ ⟶ ⟨k₂, hk₂⟩
⊢ (restrictionLT F hi).map x✝ ≫
      (fun x =>
          match x with
          | ⟨k, hk⟩ => F.map (homOfLE ⋯))
        ⟨k₂, hk₂⟩ =
    (fun x =>
          match x with
          | ⟨k, hk⟩ => F.map (homOfLE ⋯))
        ⟨k₁, hk₁⟩ ≫
      ((const { k // k < i }).obj (F.obj ⟨i, hi⟩)).map x✝
state_after: no goals
tactic: simp [comp_id, ← Functor.map_comp, homOfLE_comp]
Theorem: SemiNormedGrp.explicitCokernelπ_apply_dom_eq_zero
File: Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean

Proof steps:
state_before: X Y : SemiNormedGrp
f : X ⟶ Y
x : ↑X
⊢ (f ≫ explicitCokernelπ f) x = 0
state_after: X Y : SemiNormedGrp
f : X ⟶ Y
x : ↑X
⊢ 0 x = 0
tactic: rw [comp_explicitCokernelπ]
state_before: X Y : SemiNormedGrp
f : X ⟶ Y
x : ↑X
⊢ 0 x = 0
state_after: no goals
tactic: rfl
Theorem: _private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.lin_1
File: Mathlib/NumberTheory/NumberField/House.lean

Proof steps:
state_before: K : Type u_1
inst✝⁴ : Field K
inst✝³ : NumberField K
inst✝² : DecidableEq (K →+* ℂ)
α : Type u_2
β : Type u_3
inst✝¹ : Fintype α
inst✝ : Fintype β
a : Matrix α β (𝓞 K)
ha : a ≠ 0
p q : ℕ
cardα : Fintype.card α = p
cardβ : Fintype.card β = q
h0p : 0 < p
hpq : p < q
x : β × (K →+* ℂ) → ℤ
hxl : x ≠ 0
hmulvec0 : NumberField.house.asiegel K a *ᵥ x = 0
hxbound : ‖x‖ ≤ (↑q * ↑(finrank ℚ K) * ‖NumberField.house.asiegel K a‖) ^ (↑p / (↑q - ↑p))
l : β
k : α
r : K →+* ℂ
⊢ a k l * (NumberField.house.newBasis K) r =
    ∑ u : K →+* ℂ, ↑(NumberField.house.a' K a k l r u) * (NumberField.house.newBasis K) u
state_after: no goals
tactic: simp only [Basis.sum_repr (newBasis K) (a k l * (newBasis K) r), a', ← zsmul_eq_mul]
Theorem: Set.add_mem_centralizer
File: Mathlib/Algebra/Ring/Centralizer.lean

Proof steps:
state_before: M : Type u_1
S T : Set M
a b : M
inst✝ : Distrib M
ha : a ∈ S.centralizer
hb : b ∈ S.centralizer
c : M
hc : c ∈ S
⊢ c * (a + b) = (a + b) * c
state_after: no goals
tactic: rw [add_mul, mul_add, ha c hc, hb c hc]
Theorem: Nat.Prime.primeFactors
File: Mathlib/Data/Nat/PrimeFin.lean

Proof steps:
state_before: a b k m n p : ℕ
hp : Prime p
⊢ p.primeFactors = {p}
state_after: no goals
tactic: simp [Nat.primeFactors, primeFactorsList_prime hp]
Theorem: EMetric.preimage_add_right_closedBall
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

Proof steps:
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoEMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoEMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ≥0∞
⊢ (fun x => x * a) ⁻¹' closedBall b r = closedBall (b / a) r
state_after: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoEMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoEMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ≥0∞
⊢ (fun x => x * a) ⁻¹' closedBall b r = closedBall (b * a⁻¹) r
tactic: rw [div_eq_mul_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoEMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoEMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ≥0∞
⊢ (fun x => x * a) ⁻¹' closedBall b r = closedBall (b * a⁻¹) r
state_after: no goals
tactic: exact preimage_smul_closedBall (MulOpposite.op a) b r
Theorem: WType.cardinal_mk_eq_sum
File: Mathlib/Data/W/Cardinal.lean

Proof steps:
state_before: α : Type u
β✝ : α → Type v
β : α → Type u
⊢ (sum fun a => #(WType β) ^ lift.{u, u} #(β a)) = sum fun a => #(WType β) ^ #(β a)
state_after: no goals
tactic: simp_rw [lift_id]
Theorem: MeasureTheory.continuous_setToFun
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
⊢ Continuous fun f => setToFun μ T hT ↑↑f
state_after: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
⊢ Continuous fun f => (L1.setToL1 hT) f
tactic: simp_rw [L1.setToFun_eq_setToL1 hT]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
⊢ Continuous fun f => (L1.setToL1 hT) f
state_after: no goals
tactic: exact ContinuousLinearMap.continuous _
Theorem: Filter.le_map_of_right_inverse
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
mab : α → β
mba : β → α
f : Filter α
g : Filter β
h₁ : mab ∘ mba =ᶠ[g] id
h₂ : Tendsto mba g f
⊢ g ≤ map mab f
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
mab : α → β
mba : β → α
f : Filter α
g : Filter β
h₁ : mab ∘ mba =ᶠ[g] id
h₂ : Tendsto mba g f
⊢ map mab (map mba g) ≤ map mab f
tactic: rw [← @map_id _ g, ← map_congr h₁, ← map_map]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
mab : α → β
mba : β → α
f : Filter α
g : Filter β
h₁ : mab ∘ mba =ᶠ[g] id
h₂ : Tendsto mba g f
⊢ map mab (map mba g) ≤ map mab f
state_after: no goals
tactic: exact map_mono h₂
Theorem: CategoryTheory.Discrete.mk_as
File: Mathlib/CategoryTheory/DiscreteCategory.lean

Proof steps:
state_before: α : Type u₁
X : Discrete α
⊢ { as := X.as } = X
state_after: no goals
tactic: rfl
Theorem: FirstOrder.Language.Ultraproduct.funMap_cast
File: Mathlib/ModelTheory/Ultraproducts.lean

Proof steps:
state_before: α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝ : (a : α) → L.Structure (M a)
n : ℕ
f : L.Functions n
x : Fin n → (a : α) → M a
⊢ (funMap f fun i => Quotient.mk' (x i)) = Quotient.mk' fun a => funMap f fun i => x i a
state_after: no goals
tactic: apply funMap_quotient_mk'
Theorem: Monotone.frequently_ge_map_of_frequently_ge
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
l : R
freq_ge : ∃ᶠ (x : R) in F, l ≤ x
⊢ ∃ᶠ (x' : S) in map f F, f l ≤ x'
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
l : R
freq_ge : ∃ᶠ (x : R) in F, l ≤ x
ev : ∀ᶠ (x : S) in map f F, ¬(fun x' => f l ≤ x') x
⊢ ∀ᶠ (x : R) in F, ¬(fun x => l ≤ x) x
tactic: refine fun ev ↦ freq_ge ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
l : R
freq_ge : ∃ᶠ (x : R) in F, l ≤ x
ev : ∀ᶠ (x : S) in map f F, ¬(fun x' => f l ≤ x') x
⊢ ∀ᶠ (x : R) in F, ¬(fun x => l ≤ x) x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
l : R
freq_ge : ∃ᶠ (x : R) in F, l ≤ x
ev : ∀ᶠ (x : S) in map f F, x < f l
⊢ ∀ᶠ (x : R) in F, x < l
tactic: simp only [not_le, not_lt] at ev freq_ge ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
l : R
freq_ge : ∃ᶠ (x : R) in F, l ≤ x
ev : ∀ᶠ (x : S) in map f F, x < f l
⊢ ∀ᶠ (x : R) in F, x < l
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
l : R
freq_ge : ∃ᶠ (x : R) in F, l ≤ x
ev : ∀ᶠ (x : S) in map f F, x < f l
z : R
hz : z ∈ f ⁻¹' {x | x < f l}
⊢ z < l
tactic: filter_upwards [ev] with z hz
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
l : R
freq_ge : ∃ᶠ (x : R) in F, l ≤ x
ev : ∀ᶠ (x : S) in map f F, x < f l
z : R
hz : z ∈ f ⁻¹' {x | x < f l}
⊢ z < l
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
l : R
freq_ge : ∃ᶠ (x : R) in F, l ≤ x
ev : ∀ᶠ (x : S) in map f F, x < f l
z : R
hz : z ∈ f ⁻¹' {x | x < f l}
con : ¬z < l
⊢ False
tactic: by_contra con
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
R : Type u_6
S : Type u_7
F : Filter R
inst✝¹ : LinearOrder R
inst✝ : LinearOrder S
f : R → S
f_incr : Monotone f
l : R
freq_ge : ∃ᶠ (x : R) in F, l ≤ x
ev : ∀ᶠ (x : S) in map f F, x < f l
z : R
hz : z ∈ f ⁻¹' {x | x < f l}
con : ¬z < l
⊢ False
state_after: no goals
tactic: exact lt_irrefl (f l) <| lt_of_le_of_lt (f_incr <| not_lt.mp con) hz
Theorem: List.zipLeft_eq_zipLeft'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
as✝ : List α
b : β
bs✝ : List β
as : List α
bs : List β
⊢ as.zipLeft bs = (as.zipLeft' bs).1
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
as✝ : List α
b : β
bs✝ : List β
as : List α
bs : List β
⊢ zipWithLeft Prod.mk as bs = (zipWithLeft' Prod.mk as bs).1
tactic: rw [zipLeft, zipLeft']
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
as✝ : List α
b : β
bs✝ : List β
as : List α
bs : List β
⊢ zipWithLeft Prod.mk as bs = (zipWithLeft' Prod.mk as bs).1
state_after: no goals
tactic: cases as with
  | nil => rfl
  | cons _ atl =>
    cases bs with
    | nil => rfl
    | cons _ btl =>
      rw [zipWithLeft, zipWithLeft', cons_inj_right]
      exact @zipLeft_eq_zipLeft' atl btl
Theorem: Int.toNat_of_nonpos
File: Mathlib/Data/Int/Lemmas.lean

Proof steps:
state_before: a b : ℤ
n✝ n : ℕ
h : ↑(n + 1) ≤ 0
⊢ 0 < ↑(n + 1)
state_after: no goals
tactic: simp
Theorem: differentiableWithinAt_sub_const_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
⊢ DifferentiableWithinAt 𝕜 (fun y => f y - c) s x ↔ DifferentiableWithinAt 𝕜 f s x
state_after: no goals
tactic: simp only [sub_eq_add_neg, differentiableWithinAt_add_const_iff]
Theorem: bernsteinPolynomial.derivative_succ
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
⊢ Polynomial.derivative (bernsteinPolynomial R n (ν + 1)) =
    ↑n * (bernsteinPolynomial R (n - 1) ν - bernsteinPolynomial R (n - 1) (ν + 1))
state_after: case zero
R : Type u_1
inst✝ : CommRing R
ν : ℕ
⊢ Polynomial.derivative (bernsteinPolynomial R 0 (ν + 1)) =
    ↑0 * (bernsteinPolynomial R (0 - 1) ν - bernsteinPolynomial R (0 - 1) (ν + 1))

case succ
R : Type u_1
inst✝ : CommRing R
ν n✝ : ℕ
⊢ Polynomial.derivative (bernsteinPolynomial R (n✝ + 1) (ν + 1)) =
    ↑(n✝ + 1) * (bernsteinPolynomial R (n✝ + 1 - 1) ν - bernsteinPolynomial R (n✝ + 1 - 1) (ν + 1))
tactic: cases n
Theorem: CategoryTheory.ShortComplex.RightHomologyData.ofIsLimitKernelFork_p
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.19876, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ S.f ≫ 𝟙 S.X₂ = 0
state_after: no goals
tactic: rw [comp_id, hf]
state_before: C : Type u_1
inst✝¹ : Category.{?u.19876, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
c : KernelFork S.g
hc : IsLimit c
⊢ (Iso.refl c.pt).hom ≫ Fork.ι (KernelFork.ofι (Fork.ι c) ⋯) = Fork.ι c
state_after: no goals
tactic: aesop_cat
Theorem: FormalMultilinearSeries.rightInv_coeff_one
File: Mathlib/Analysis/Analytic/Inverse.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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
⊢ p.rightInv i 1 = (continuousMultilinearCurryFin1 𝕜 F E).symm ↑i.symm
state_after: no goals
tactic: rw [rightInv]
Theorem: Ideal.mem_span_singleton
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
x y x✝ : α
⊢ x✝ * y = x ↔ x = y * x✝
state_after: no goals
tactic: rw [eq_comm, mul_comm]
Theorem: round_one
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
⊢ round 1 = 1
state_after: no goals
tactic: simp [round]
Theorem: CategoryTheory.Pretriangulated.productTriangle.π_hom₂
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ (productTriangle T).mor₃ ≫ (shiftFunctor C 1).map (Pi.π (fun j => (T j).obj₁) j) =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ ((Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)) ≫
      (shiftFunctor C 1).map (Pi.π (fun j => (T j).obj₁) j) =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
tactic: dsimp
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ ((Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)) ≫
      (shiftFunctor C 1).map (Pi.π (fun j => (T j).obj₁) j) =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ (Pi.map fun j => (T j).mor₃) ≫ Pi.π (fun b => (shiftFunctor C 1).obj (T b).obj₁) j =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
tactic: rw [← piComparison_comp_π, assoc, IsIso.inv_hom_id_assoc]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ (Pi.map fun j => (T j).mor₃) ≫ Pi.π (fun b => (shiftFunctor C 1).obj (T b).obj₁) j =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
state_after: no goals
tactic: simp only [limMap_π, Discrete.natTrans_app]
Theorem: List.length_ofFn
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
n : ℕ
f : Fin n → α
⊢ (ofFn f).length = n
state_after: no goals
tactic: simp [ofFn, length_ofFn_go]
Theorem: mem_sphere_iff_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ b ∈ sphere a r ↔ ‖b / a‖ = r
state_after: no goals
tactic: simp [dist_eq_norm_div]
Theorem: AddSubmonoid.fromLeftNeg_eq_neg
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

Proof steps:
state_before: M : Type u_1
inst✝ : Group M
S : Submonoid M
x : ↥S.leftInv
⊢ ↑(S.fromLeftInv x) = (↑x)⁻¹
state_after: no goals
tactic: rw [← mul_right_inj (x : M), mul_right_inv, mul_fromLeftInv]
Theorem: Ordnode.dual_node'
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
⊢ (l.node' x r).dual = r.dual.node' x l.dual
state_after: no goals
tactic: simp [node', add_comm]
Theorem: GenContFract.convs'_of_int
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
a : ℤ
⊢ (of ↑a).convs' n = ↑a
state_after: case zero
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n : ℕ
a : ℤ
⊢ (of ↑a).convs' 0 = ↑a

case succ
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
n✝ : ℕ
a : ℤ
n : ℕ
a✝ : (of ↑a).convs' n = ↑a
⊢ (of ↑a).convs' (n + 1) = ↑a
tactic: induction' n with n
Theorem: not_integrableOn_Ioi_cpow
File: Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean

Proof steps:
state_before: s : ℂ
⊢ ¬IntegrableOn (fun x => ↑x ^ s) (Ioi 0) volume
state_after: s : ℂ
h : IntegrableOn (fun x => ↑x ^ s) (Ioi 0) volume
⊢ False
tactic: intro h
state_before: s : ℂ
h : IntegrableOn (fun x => ↑x ^ s) (Ioi 0) volume
⊢ False
state_after: case inl
s : ℂ
h : IntegrableOn (fun x => ↑x ^ s) (Ioi 0) volume
hs : s.re ≤ -1
⊢ False

case inr
s : ℂ
h : IntegrableOn (fun x => ↑x ^ s) (Ioi 0) volume
hs : -1 < s.re
⊢ False
tactic: rcases le_or_lt s.re (-1) with hs|hs
Theorem: contDiffWithinAt_euclidean
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
H : Type u_3
inst✝³ : _root_.RCLike 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
n : ℕ∞
⊢ ContDiffWithinAt 𝕜 n f t y ↔ ∀ (i : ι), ContDiffWithinAt 𝕜 n (fun x => f x i) t y
state_after: 𝕜 : Type u_1
ι : Type u_2
H : Type u_3
inst✝³ : _root_.RCLike 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
n : ℕ∞
⊢ (∀ (i : ι), ContDiffWithinAt 𝕜 n (fun x => (⇑(EuclideanSpace.equiv ι 𝕜) ∘ f) x i) t y) ↔
    ∀ (i : ι), ContDiffWithinAt 𝕜 n (fun x => f x i) t y
tactic: rw [← (EuclideanSpace.equiv ι 𝕜).comp_contDiffWithinAt_iff, contDiffWithinAt_pi]
state_before: 𝕜 : Type u_1
ι : Type u_2
H : Type u_3
inst✝³ : _root_.RCLike 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
n : ℕ∞
⊢ (∀ (i : ι), ContDiffWithinAt 𝕜 n (fun x => (⇑(EuclideanSpace.equiv ι 𝕜) ∘ f) x i) t y) ↔
    ∀ (i : ι), ContDiffWithinAt 𝕜 n (fun x => f x i) t y
state_after: no goals
tactic: rfl