ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.PreGaloisCategory.evaluation_injective_of_isConnected
File: Mathlib/CategoryTheory/Galois/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A X : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective fun f => F.map f a
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A X : C
inst✝ : IsConnected A
a : ↑(F.obj A)
f g : A ⟶ X
h : F.map f a = F.map g a
⊢ f = g
tactic: intro f g (h : F.map f a = F.map g a)
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A X : C
inst✝ : IsConnected A
a : ↑(F.obj A)
f g : A ⟶ X
h : F.map f a = F.map g a
⊢ f = g
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A X : C
inst✝ : IsConnected A
a : ↑(F.obj A)
f g : A ⟶ X
h : F.map f a = F.map g a
this : IsIso (equalizer.ι f g)
⊢ f = g
tactic: haveI : IsIso (equalizer.ι f g) := by
    apply IsConnected.noTrivialComponent _ (equalizer.ι f g)
    exact not_initial_of_inhabited F ((fiberEqualizerEquiv F f g).symm ⟨a, h⟩)
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A X : C
inst✝ : IsConnected A
a : ↑(F.obj A)
f g : A ⟶ X
h : F.map f a = F.map g a
this : IsIso (equalizer.ι f g)
⊢ f = g
state_after: no goals
tactic: exact eq_of_epi_equalizer
Theorem: Real.volume_preimage_mul_left
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
s : Set ℝ
⊢ (Measure.map (fun x => a * x) volume) s = ofReal |a⁻¹| * volume s
state_after: ι : Type u_1
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
s : Set ℝ
⊢ (ofReal |a⁻¹| • volume) s = ofReal |a⁻¹| * volume s
tactic: rw [map_volume_mul_left h]
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ℝ
h : a ≠ 0
s : Set ℝ
⊢ (ofReal |a⁻¹| • volume) s = ofReal |a⁻¹| * volume s
state_after: no goals
tactic: rfl
Theorem: Set.isEmpty_coe_sort
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
⊢ ¬IsEmpty ↑s ↔ ¬s = ∅
state_after: no goals
tactic: simpa using nonempty_iff_ne_empty
Theorem: Int.ofNat_isUnit
File: Mathlib/Algebra/Group/Int.lean

Proof steps:
state_before: u v : ℤ
n : ℕ
⊢ IsUnit ↑n ↔ IsUnit n
state_after: no goals
tactic: simp [isUnit_iff_natAbs_eq]
Theorem: Real.sqrt_le_sqrt_iff'
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x y : ℝ
hx : 0 < x
⊢ √x ≤ √y ↔ x ≤ y
state_after: case inl
x y : ℝ
hx : 0 < x
hy : y ≤ 0
⊢ √x ≤ √y ↔ x ≤ y

case inr
x y : ℝ
hx : 0 < x
hy : 0 ≤ y
⊢ √x ≤ √y ↔ x ≤ y
tactic: obtain hy | hy := le_total y 0
Theorem: Basis.total_dualBasis
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : ι →₀ R
i : ι
⊢ ((Finsupp.total ι (Dual R M) R ⇑b.dualBasis) f) (b i) = f i
state_after: case intro
R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : ι →₀ R
i : ι
val✝ : Fintype ι
⊢ ((Finsupp.total ι (Dual R M) R ⇑b.dualBasis) f) (b i) = f i
tactic: cases nonempty_fintype ι
state_before: case intro
R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : ι →₀ R
i : ι
val✝ : Fintype ι
⊢ ((Finsupp.total ι (Dual R M) R ⇑b.dualBasis) f) (b i) = f i
state_after: case intro
R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : ι →₀ R
i : ι
val✝ : Fintype ι
⊢ ∑ d : ι, (f d • b.dualBasis d) (b i) = f i

case intro.h
R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
f : ι →₀ R
i : ι
val✝ : Fintype ι
⊢ ∀ (i : ι), 0 • b.dualBasis i = 0
tactic: rw [Finsupp.total_apply, Finsupp.sum_fintype, LinearMap.sum_apply]
Theorem: AddSubgroup.addSubgroupOf_sup
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A✝ : Type u_4
inst✝¹ : AddGroup A✝
N : Type u_5
inst✝ : Group N
A A' B : Subgroup G
hA : A ≤ B
hA' : A' ≤ B
⊢ (A ⊔ A').subgroupOf B = A.subgroupOf B ⊔ A'.subgroupOf B
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A✝ : Type u_4
inst✝¹ : AddGroup A✝
N : Type u_5
inst✝ : Group N
A A' B : Subgroup G
hA : A ≤ B
hA' : A' ≤ B
⊢ map B.subtype ((A ⊔ A').subgroupOf B) = map B.subtype (A.subgroupOf B ⊔ A'.subgroupOf B)
tactic: refine
    map_injective_of_ker_le B.subtype (ker_le_comap _ _)
      (le_trans (ker_le_comap B.subtype _) le_sup_left) ?_
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A✝ : Type u_4
inst✝¹ : AddGroup A✝
N : Type u_5
inst✝ : Group N
A A' B : Subgroup G
hA : A ≤ B
hA' : A' ≤ B
⊢ map B.subtype ((A ⊔ A').subgroupOf B) = map B.subtype (A.subgroupOf B ⊔ A'.subgroupOf B)
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A✝ : Type u_4
inst✝¹ : AddGroup A✝
N : Type u_5
inst✝ : Group N
A A' B : Subgroup G
hA : A ≤ B
hA' : A' ≤ B
⊢ B ⊓ (A ⊔ A') = B ⊓ A ⊔ B ⊓ A'
tactic: simp only [subgroupOf, map_comap_eq, map_sup, subtype_range]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A✝ : Type u_4
inst✝¹ : AddGroup A✝
N : Type u_5
inst✝ : Group N
A A' B : Subgroup G
hA : A ≤ B
hA' : A' ≤ B
⊢ B ⊓ (A ⊔ A') = B ⊓ A ⊔ B ⊓ A'
state_after: no goals
tactic: rw [inf_of_le_right (sup_le hA hA'), inf_of_le_right hA', inf_of_le_right hA]
Theorem: LSeriesSummable.add
File: Mathlib/NumberTheory/LSeries/Linearity.lean

Proof steps:
state_before: f g : ℕ → ℂ
s : ℂ
hf : LSeriesSummable f s
hg : LSeriesSummable g s
⊢ LSeriesSummable (f + g) s
state_after: no goals
tactic: simpa only [LSeriesSummable, ← term_add_apply] using Summable.add hf hg
Theorem: summable_bernoulli_fourier
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: k : ℕ
hk : 2 ≤ k
⊢ Summable fun n => -↑k ! / (2 * ↑π * I * ↑n) ^ k
state_after: k : ℕ
hk : 2 ≤ k
this : ∀ (n : ℤ), -↑k ! / (2 * ↑π * I * ↑n) ^ k = -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
⊢ Summable fun n => -↑k ! / (2 * ↑π * I * ↑n) ^ k
tactic: have :
      ∀ n : ℤ, -(k ! : ℂ) / (2 * π * I * n) ^ k = -k ! / (2 * π * I) ^ k * (1 / (n : ℂ) ^ k) := by
    intro n; rw [mul_one_div, div_div, ← mul_pow]
state_before: k : ℕ
hk : 2 ≤ k
this : ∀ (n : ℤ), -↑k ! / (2 * ↑π * I * ↑n) ^ k = -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
⊢ Summable fun n => -↑k ! / (2 * ↑π * I * ↑n) ^ k
state_after: k : ℕ
hk : 2 ≤ k
this : ∀ (n : ℤ), -↑k ! / (2 * ↑π * I * ↑n) ^ k = -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
⊢ Summable fun n => -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
tactic: simp_rw [this]
state_before: k : ℕ
hk : 2 ≤ k
this : ∀ (n : ℤ), -↑k ! / (2 * ↑π * I * ↑n) ^ k = -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
⊢ Summable fun n => -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
state_after: k : ℕ
hk : 2 ≤ k
this : ∀ (n : ℤ), -↑k ! / (2 * ↑π * I * ↑n) ^ k = -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
⊢ Summable fun a => ‖1 / ↑a ^ k‖
tactic: refine Summable.mul_left _ <| .of_norm ?_
state_before: k : ℕ
hk : 2 ≤ k
this : ∀ (n : ℤ), -↑k ! / (2 * ↑π * I * ↑n) ^ k = -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
⊢ Summable fun a => ‖1 / ↑a ^ k‖
state_after: k : ℕ
hk : 2 ≤ k
this✝ : ∀ (n : ℤ), -↑k ! / (2 * ↑π * I * ↑n) ^ k = -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
this : (fun x => ‖1 / ↑x ^ k‖) = fun x => |1 / ↑x ^ k|
⊢ Summable fun a => ‖1 / ↑a ^ k‖
tactic: have : (fun x : ℤ => ‖1 / (x : ℂ) ^ k‖) = fun x : ℤ => |1 / (x : ℝ) ^ k| := by
    ext1 x
    rw [norm_eq_abs, ← Complex.abs_ofReal]
    congr 1
    norm_cast
state_before: k : ℕ
hk : 2 ≤ k
this✝ : ∀ (n : ℤ), -↑k ! / (2 * ↑π * I * ↑n) ^ k = -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
this : (fun x => ‖1 / ↑x ^ k‖) = fun x => |1 / ↑x ^ k|
⊢ Summable fun a => ‖1 / ↑a ^ k‖
state_after: k : ℕ
hk : 2 ≤ k
this✝ : ∀ (n : ℤ), -↑k ! / (2 * ↑π * I * ↑n) ^ k = -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
this : (fun x => ‖1 / ↑x ^ k‖) = fun x => |1 / ↑x ^ k|
⊢ Summable fun x => |1 / ↑x ^ k|
tactic: simp_rw [this]
state_before: k : ℕ
hk : 2 ≤ k
this✝ : ∀ (n : ℤ), -↑k ! / (2 * ↑π * I * ↑n) ^ k = -↑k ! / (2 * ↑π * I) ^ k * (1 / ↑n ^ k)
this : (fun x => ‖1 / ↑x ^ k‖) = fun x => |1 / ↑x ^ k|
⊢ Summable fun x => |1 / ↑x ^ k|
state_after: no goals
tactic: rwa [summable_abs_iff, Real.summable_one_div_int_pow]
Theorem: Finpartition.indiscrete_isEquipartition
File: Mathlib/Order/Partition/Equipartition.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hs : s ≠ ∅
⊢ (indiscrete hs).IsEquipartition
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hs : s ≠ ∅
⊢ {s}.EquitableOn Finset.card
tactic: rw [IsEquipartition, indiscrete_parts, coe_singleton]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hs : s ≠ ∅
⊢ {s}.EquitableOn Finset.card
state_after: no goals
tactic: exact Set.equitableOn_singleton s _
Theorem: continuousAt_sign_of_ne_zero
File: Mathlib/Topology/Instances/Sign.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Zero α
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
h : a ≠ 0
⊢ ContinuousAt (⇑SignType.sign) a
state_after: case inl
α : Type u_1
inst✝³ : Zero α
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
h : a ≠ 0
h_neg : a < 0
⊢ ContinuousAt (⇑SignType.sign) a

case inr
α : Type u_1
inst✝³ : Zero α
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
h : a ≠ 0
h_pos : 0 < a
⊢ ContinuousAt (⇑SignType.sign) a
tactic: rcases h.lt_or_lt with (h_neg | h_pos)
Theorem: MeasureTheory.Measure.prod_apply
File: Mathlib/MeasureTheory/Constructions/Prod/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
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
s : Set (α × β)
hs : MeasurableSet s
⊢ (μ.prod ν) s = ∫⁻ (x : α), ν (Prod.mk x ⁻¹' s) ∂μ
state_after: no goals
tactic: simp_rw [Measure.prod, bind_apply hs (Measurable.map_prod_mk_left (ν := ν)),
    map_apply measurable_prod_mk_left hs]
Theorem: isCoprime_one_left
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
⊢ 1 * 1 + 0 * x = 1
state_after: no goals
tactic: rw [one_mul, zero_mul, add_zero]
Theorem: Matrix.lie_transpose
File: Mathlib/Algebra/Lie/SkewAdjoint.lean

Proof steps:
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
⊢ (A * B - B * A)ᵀ = Bᵀ * Aᵀ - Aᵀ * Bᵀ
state_after: no goals
tactic: simp
Theorem: Nat.Ico_succ_right_eq_insert_Ico
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a b c : ℕ
h : a ≤ b
⊢ Ico a (b + 1) = insert b (Ico a b)
state_after: no goals
tactic: rw [Ico_succ_right, ← Ico_insert_right h]
Theorem: Batteries.RBNode.Ordered.balance1
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
cmp : α → α → Ordering
l : RBNode α
v : α
r : RBNode α
lv : All (fun x => cmpLT cmp x v) l
vr : All (fun x => cmpLT cmp v x) r
hl : Ordered cmp l
hr : Ordered cmp r
⊢ Ordered cmp (l.balance1 v r)
state_after: α : Type u_1
cmp : α → α → Ordering
l : RBNode α
v : α
r : RBNode α
lv : All (fun x => cmpLT cmp x v) l
vr : All (fun x => cmpLT cmp v x) r
hl : Ordered cmp l
hr : Ordered cmp r
⊢ Ordered cmp
    (match l, v, r with
    | node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
    | node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
    | a, x, b => node black a x b)
tactic: unfold balance1
state_before: α : Type u_1
cmp : α → α → Ordering
l : RBNode α
v : α
r : RBNode α
lv : All (fun x => cmpLT cmp x v) l
vr : All (fun x => cmpLT cmp v x) r
hl : Ordered cmp l
hr : Ordered cmp r
⊢ Ordered cmp
    (match l, v, r with
    | node red (node red a x b) y c, z, d => node red (node black a x b) y (node black c z d)
    | node red a x (node red b y c), z, d => node red (node black a x b) y (node black c z d)
    | a, x, b => node black a x b)
state_after: case h_1
α : Type u_1
cmp : α → α → Ordering
v : α
r : RBNode α
vr : All (fun x => cmpLT cmp v x) r
hr : Ordered cmp r
x✝³ : RBNode α
x✝² : α
x✝¹ a✝ : RBNode α
x✝ : α
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
lv : All (fun x => cmpLT cmp x v) (node red (node red a✝ x✝ b✝) y✝ c✝)
hl : Ordered cmp (node red (node red a✝ x✝ b✝) y✝ c✝)
⊢ Ordered cmp (node red (node black a✝ x✝ b✝) y✝ (node black c✝ v r))

case h_2
α : Type u_1
cmp : α → α → Ordering
v : α
r : RBNode α
vr : All (fun x => cmpLT cmp v x) r
hr : Ordered cmp r
x✝⁴ : RBNode α
x✝³ : α
x✝² a✝ : RBNode α
x✝¹ : α
b✝ : RBNode α
y✝ : α
c✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), a✝ = node red a x b → False
lv : All (fun x => cmpLT cmp x v) (node red a✝ x✝¹ (node red b✝ y✝ c✝))
hl : Ordered cmp (node red a✝ x✝¹ (node red b✝ y✝ c✝))
⊢ Ordered cmp (node red (node black a✝ x✝¹ b✝) y✝ (node black c✝ v r))

case h_3
α : Type u_1
cmp : α → α → Ordering
l : RBNode α
v : α
r : RBNode α
lv : All (fun x => cmpLT cmp x v) l
vr : All (fun x => cmpLT cmp v x) r
hl : Ordered cmp l
hr : Ordered cmp r
x✝⁴ : RBNode α
x✝³ : α
x✝² : RBNode α
x✝¹ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red (node red a x b) y c → False
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α) (y : α) (c : RBNode α), l = node red a x (node red b y c) → False
⊢ Ordered cmp (node black l v r)
tactic: split
Theorem: cfcₙ_apply_pi
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
hf✝ : autoParam (ContinuousOn f✝ (σₙ R a✝)) _auto✝
hf0✝ : autoParam (f✝ 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a✝)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha✝ : autoParam (p a✝) _auto✝
ι : Type u_3
f : ι → R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (∀ (i : ι), ContinuousOn (f i) (σₙ R a)) _auto✝
hf0 : autoParam (∀ (i : ι), f i 0 = 0) _auto✝
⊢ (fun i => cfcₙ (f i) a) = fun i =>
    (cfcₙHom ha) { toFun := (σₙ R a).restrict (f i), continuous_toFun := ⋯, map_zero' := ⋯ }
state_after: case h
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
hf✝ : autoParam (ContinuousOn f✝ (σₙ R a✝)) _auto✝
hf0✝ : autoParam (f✝ 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a✝)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha✝ : autoParam (p a✝) _auto✝
ι : Type u_3
f : ι → R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (∀ (i : ι), ContinuousOn (f i) (σₙ R a)) _auto✝
hf0 : autoParam (∀ (i : ι), f i 0 = 0) _auto✝
i : ι
⊢ cfcₙ (f i) a = (cfcₙHom ha) { toFun := (σₙ R a).restrict (f i), continuous_toFun := ⋯, map_zero' := ⋯ }
tactic: ext i
state_before: case h
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
hf✝ : autoParam (ContinuousOn f✝ (σₙ R a✝)) _auto✝
hf0✝ : autoParam (f✝ 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a✝)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha✝ : autoParam (p a✝) _auto✝
ι : Type u_3
f : ι → R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (∀ (i : ι), ContinuousOn (f i) (σₙ R a)) _auto✝
hf0 : autoParam (∀ (i : ι), f i 0 = 0) _auto✝
i : ι
⊢ cfcₙ (f i) a = (cfcₙHom ha) { toFun := (σₙ R a).restrict (f i), continuous_toFun := ⋯, map_zero' := ⋯ }
state_after: no goals
tactic: simp only [cfcₙ_apply (f i) a (hf i) (hf0 i)]
Theorem: CauSeq.lt_trans
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g < h
⊢ (h - f).Pos
state_after: case h.e'_3
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g < h
⊢ h - f = g - f + (h - g)
tactic: convert add_pos fg gh using 1
state_before: case h.e'_3
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g < h
⊢ h - f = g - f + (h - g)
state_after: no goals
tactic: simp
Theorem: Int.not_odd_iff
File: Mathlib/Algebra/Ring/Int.lean

Proof steps:
state_before: m n : ℤ
⊢ ¬Odd n ↔ n % 2 = 0
state_after: no goals
tactic: rw [odd_iff, emod_two_ne_one]
Theorem: cauchy_iInf_uniformSpace
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Nonempty ι
u : ι → UniformSpace β
l : Filter β
⊢ Cauchy l ↔ ∀ (i : ι), Cauchy l
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Nonempty ι
u : ι → UniformSpace β
l : Filter β
⊢ l.NeBot ∧ l ×ˢ l ≤ 𝓤 β ↔ ∀ (i : ι), l.NeBot ∧ l ×ˢ l ≤ 𝓤 β
tactic: unfold Cauchy
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Nonempty ι
u : ι → UniformSpace β
l : Filter β
⊢ l.NeBot ∧ l ×ˢ l ≤ 𝓤 β ↔ ∀ (i : ι), l.NeBot ∧ l ×ˢ l ≤ 𝓤 β
state_after: no goals
tactic: rw [iInf_uniformity, le_iInf_iff, forall_and, forall_const]
Theorem: NNReal.hasSum_iff_tendsto_nat
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
r : ℝ≥0
⊢ HasSum f r ↔ Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
r : ℝ≥0
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, ↑(f i)) atTop (𝓝 ↑r) ↔
    Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r)
tactic: rw [← ENNReal.hasSum_coe, ENNReal.hasSum_iff_tendsto_nat]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
r : ℝ≥0
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, ↑(f i)) atTop (𝓝 ↑r) ↔
    Tendsto (fun n => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
r : ℝ≥0
⊢ Tendsto (fun n => ↑(∑ a ∈ Finset.range n, f a)) atTop (𝓝 ↑r) ↔
    Tendsto (fun n => ∑ a ∈ Finset.range n, f a) atTop (𝓝 r)
tactic: simp only [← ENNReal.coe_finset_sum]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : ℕ → ℝ≥0
r : ℝ≥0
⊢ Tendsto (fun n => ↑(∑ a ∈ Finset.range n, f a)) atTop (𝓝 ↑r) ↔
    Tendsto (fun n => ∑ a ∈ Finset.range n, f a) atTop (𝓝 r)
state_after: no goals
tactic: exact ENNReal.tendsto_coe
Theorem: CategoryTheory.Dial.braiding_inv_F
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
⊢ (X.tensorObj Y).rel =
    (Subobject.pullback (prod.map (prod.braiding X.src Y.src).hom (prod.braiding X.tgt Y.tgt).hom)).obj
      (Y.tensorObj X).rel
state_after: no goals
tactic: simp [Subobject.inf_pullback, ← Subobject.pullback_comp, inf_comm]
Theorem: GaussianInt.intCast_complex_norm
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: x : ℤ[i]
⊢ ↑(norm x) = ↑(normSq (toComplex x))
state_after: case mk
re✝ im✝ : ℤ
⊢ ↑{ re := re✝, im := im✝ }.norm = ↑(normSq (toComplex { re := re✝, im := im✝ }))
tactic: cases x
state_before: case mk
re✝ im✝ : ℤ
⊢ ↑{ re := re✝, im := im✝ }.norm = ↑(normSq (toComplex { re := re✝, im := im✝ }))
state_after: case mk
re✝ im✝ : ℤ
⊢ ↑({ re := re✝, im := im✝ }.re * { re := re✝, im := im✝ }.re -
        -1 * { re := re✝, im := im✝ }.im * { re := re✝, im := im✝ }.im) =
    ↑({ toFun := fun z => z.re * z.re + z.im * z.im, map_zero' := normSq.proof_1, map_one' := normSq.proof_2,
          map_mul' := normSq.proof_3 }
        (toComplex { re := re✝, im := im✝ }))
tactic: rw [Zsqrtd.norm, normSq]
state_before: case mk
re✝ im✝ : ℤ
⊢ ↑({ re := re✝, im := im✝ }.re * { re := re✝, im := im✝ }.re -
        -1 * { re := re✝, im := im✝ }.im * { re := re✝, im := im✝ }.im) =
    ↑({ toFun := fun z => z.re * z.re + z.im * z.im, map_zero' := normSq.proof_1, map_one' := normSq.proof_2,
          map_mul' := normSq.proof_3 }
        (toComplex { re := re✝, im := im✝ }))
state_after: no goals
tactic: simp
Theorem: BddBelow.image2_bddAbove
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
⊢ BddBelow s → BddBelow t → BddAbove (image2 f s t)
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddAbove (image2 f s t)
tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddAbove (image2 f s t)
state_after: no goals
tactic: exact ⟨f a b, mem_upperBounds_image2_of_mem_lowerBounds h₀ h₁ ha hb⟩
Theorem: CategoryTheory.Limits.hasStrictInitialObjects_of_initial_is_strict
File: Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasInitial C
h : ∀ (A : C) (f : A ⟶ ⊥_ C), IsIso f
I A : C
f : A ⟶ I
hI : IsInitial I
this : IsIso (f ≫ hI.to (⊥_ C))
⊢ f ≫ hI.to (⊥_ C) ≫ inv (f ≫ hI.to (⊥_ C)) = 𝟙 A
state_after: no goals
tactic: rw [← assoc, IsIso.hom_inv_id]
Theorem: FirstOrder.Language.Hom.range_le_iff_comap
File: Mathlib/ModelTheory/Substructures.lean

Proof steps:
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
f : M →[L] N
p : L.Substructure N
⊢ f.range ≤ p ↔ comap f p = ⊤
state_after: no goals
tactic: rw [range_eq_map, map_le_iff_le_comap, eq_top_iff]