ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DFinsupp.support_update
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
⊢ (update i f b).support = if b = 0 then (erase i f).support else insert i f.support
state_after: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
j : ι
⊢ j ∈ (update i f b).support ↔ j ∈ if b = 0 then (erase i f).support else insert i f.support
tactic: ext j
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
j : ι
⊢ j ∈ (update i f b).support ↔ j ∈ if b = 0 then (erase i f).support else insert i f.support
state_after: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
j : ι
hb : b = 0
⊢ j ∈ (update i f b).support ↔ j ∈ (erase i f).support

case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
inst✝ : Decidable (b = 0)
j : ι
hb : ¬b = 0
⊢ j ∈ (update i f b).support ↔ j ∈ insert i f.support
tactic: split_ifs with hb
Theorem: Algebra.FiniteType.polynomial
File: Mathlib/RingTheory/FiniteType.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
M : Type uM
N : Type uN
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring S
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R B
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
⊢ adjoin R ↑{X} = ⊤
state_after: R : Type uR
S : Type uS
A : Type uA
B : Type uB
M : Type uM
N : Type uN
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring S
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R B
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
⊢ adjoin R {X} = ⊤
tactic: rw [Finset.coe_singleton]
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
M : Type uM
N : Type uN
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring S
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R B
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
⊢ adjoin R {X} = ⊤
state_after: no goals
tactic: exact Polynomial.adjoin_X
Theorem: Polynomial.monomial_mem_lifts
File: Mathlib/Algebra/Polynomial/Lifts.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
s : S
n : ℕ
h : s ∈ Set.range ⇑f
⊢ (monomial n) s ∈ lifts f
state_after: case intro
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
n : ℕ
r : R
h : f r ∈ Set.range ⇑f
⊢ (monomial n) (f r) ∈ lifts f
tactic: obtain ⟨r, rfl⟩ := Set.mem_range.1 h
state_before: case intro
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
n : ℕ
r : R
h : f r ∈ Set.range ⇑f
⊢ (monomial n) (f r) ∈ lifts f
state_after: case h
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
n : ℕ
r : R
h : f r ∈ Set.range ⇑f
⊢ (mapRingHom f) ((monomial n) r) = (monomial n) (f r)
tactic: use monomial n r
state_before: case h
R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
n : ℕ
r : R
h : f r ∈ Set.range ⇑f
⊢ (mapRingHom f) ((monomial n) r) = (monomial n) (f r)
state_after: no goals
tactic: simp only [coe_mapRingHom, Set.mem_univ, map_monomial, Subsemiring.coe_top, eq_self_iff_true,
    and_self_iff]
Theorem: Sum.elim_const_const
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: γ : Sort u_1
α : Type u_2
β : Type u_3
c : γ
⊢ Sum.elim (const α c) (const β c) = const (α ⊕ β) c
state_after: case h
γ : Sort u_1
α : Type u_2
β : Type u_3
c : γ
x : α ⊕ β
⊢ Sum.elim (const α c) (const β c) x = const (α ⊕ β) c x
tactic: ext x
state_before: case h
γ : Sort u_1
α : Type u_2
β : Type u_3
c : γ
x : α ⊕ β
⊢ Sum.elim (const α c) (const β c) x = const (α ⊕ β) c x
state_after: no goals
tactic: cases x <;> rfl
Theorem: Set.eq_of_mem_uIcc_of_mem_uIcc'
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DistribLattice α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ∈ [[a, c]] → c ∈ [[a, b]] → b = c
state_after: no goals
tactic: simpa only [uIcc_comm a] using eq_of_mem_uIcc_of_mem_uIcc
Theorem: LSeries.absicssaOfAbsConv_logPowMul
File: Mathlib/NumberTheory/LSeries/Deriv.lean

Proof steps:
state_before: f : ℕ → ℂ
m : ℕ
⊢ abscissaOfAbsConv (logMul^[m] f) = abscissaOfAbsConv f
state_after: case zero
f : ℕ → ℂ
⊢ abscissaOfAbsConv (logMul^[0] f) = abscissaOfAbsConv f

case succ
f : ℕ → ℂ
n : ℕ
ih : abscissaOfAbsConv (logMul^[n] f) = abscissaOfAbsConv f
⊢ abscissaOfAbsConv (logMul^[n + 1] f) = abscissaOfAbsConv f
tactic: induction' m with n ih
Theorem: FirstOrder.Language.Equiv.self_comp_symm_toHom
File: Mathlib/ModelTheory/Basic.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
f : M ≃[L] N
⊢ f.toHom.comp f.symm.toHom = Hom.id L N
state_after: no goals
tactic: rw [← comp_toHom, self_comp_symm, refl_toHom]
Theorem: Real.Gamma_neg_nat_eq_zero
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ Gamma (-↑n) = 0
state_after: no goals
tactic: simpa only [← Complex.ofReal_natCast, ← Complex.ofReal_neg, Complex.Gamma_ofReal,
    Complex.ofReal_eq_zero] using Complex.Gamma_neg_nat_eq_zero n
Theorem: Ordinal.mul_lt_omega_opow
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: a b c : Ordinal.{u_1}
c0 : 0 < c
ha : a < ω ^ c
hb : b < ω
⊢ a * b < ω ^ c
state_after: case inl
a b : Ordinal.{u_1}
hb : b < ω
c0 : 0 < 0
ha : a < ω ^ 0
⊢ a * b < ω ^ 0

case inr.inl.intro
a b : Ordinal.{u_1}
hb : b < ω
c : Ordinal.{u_1}
c0 : 0 < succ c
ha : a < ω ^ succ c
⊢ a * b < ω ^ succ c

case inr.inr
a b c : Ordinal.{u_1}
c0 : 0 < c
ha : a < ω ^ c
hb : b < ω
l : c.IsLimit
⊢ a * b < ω ^ c
tactic: rcases zero_or_succ_or_limit c with (rfl | ⟨c, rfl⟩ | l)
Theorem: Filter.map₂_left_comm
File: Mathlib/Order/Filter/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → δ → ε
n : β → γ → δ
m' : α → γ → δ'
n' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c)
⊢ map₂ m f (map₂ n g h) = map₂ n' g (map₂ m' f h)
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → δ → ε
n : β → γ → δ
m' : α → γ → δ'
n' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c)
⊢ map₂ (fun a b => m b a) (map₂ n g h) f = map₂ n' g (map₂ (fun a b => m' b a) h f)
tactic: rw [map₂_swap m', map₂_swap m]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → δ → ε
n : β → γ → δ
m' : α → γ → δ'
n' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c)
⊢ map₂ (fun a b => m b a) (map₂ n g h) f = map₂ n' g (map₂ (fun a b => m' b a) h f)
state_after: no goals
tactic: exact map₂_assoc fun _ _ _ => h_left_comm _ _ _
Theorem: Specializes.zpow
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G✝
inst✝⁵ : Inv G✝
inst✝⁴ : ContinuousInv G✝
G : Type u_1
inst✝³ : DivInvMonoid G
inst✝² : TopologicalSpace G
inst✝¹ : ContinuousMul G
inst✝ : ContinuousInv G
x y : G
h : x ⤳ y
n : ℕ
⊢ (x ^ Int.ofNat n) ⤳ (y ^ Int.ofNat n)
state_after: no goals
tactic: simpa using h.pow n
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G✝
inst✝⁵ : Inv G✝
inst✝⁴ : ContinuousInv G✝
G : Type u_1
inst✝³ : DivInvMonoid G
inst✝² : TopologicalSpace G
inst✝¹ : ContinuousMul G
inst✝ : ContinuousInv G
x y : G
h : x ⤳ y
n : ℕ
⊢ (x ^ Int.negSucc n) ⤳ (y ^ Int.negSucc n)
state_after: no goals
tactic: simpa using (h.pow (n + 1)).inv
Theorem: LocallyLipschitz.const_min
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : PseudoEMetricSpace α
f g : α → ℝ
hf : LocallyLipschitz f
a : ℝ
⊢ LocallyLipschitz fun x => min a (f x)
state_after: no goals
tactic: simpa [min_comm] using (hf.min_const a)
Theorem: RelSeries.reverse_length
File: Mathlib/Order/RelSeries.lean

Proof steps:
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
⊢ r ((p.toFun ∘ Fin.rev) i.succ) ((p.toFun ∘ Fin.rev) i.castSucc)
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
⊢ r (p.toFun i.succ.rev) (p.toFun i.castSucc.rev)
tactic: rw [Function.comp_apply, Function.comp_apply]
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
⊢ r (p.toFun i.succ.rev) (p.toFun i.castSucc.rev)
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
hi : ↑i + 1 ≤ p.length
⊢ r (p.toFun i.succ.rev) (p.toFun i.castSucc.rev)
tactic: have hi : i.1 + 1 ≤ p.length := by omega
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
hi : ↑i + 1 ≤ p.length
⊢ r (p.toFun i.succ.rev) (p.toFun i.castSucc.rev)
state_after: case h.e'_1.h.e'_4
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
hi : ↑i + 1 ≤ p.length
⊢ i.succ.rev = ⟨p.length - (↑i + 1), ⋯⟩.castSucc

case h.e'_2.h.e'_4
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p : RelSeries r
i : Fin p.length
hi : ↑i + 1 ≤ p.length
⊢ i.castSucc.rev = ⟨p.length - (↑i + 1), ⋯⟩.succ
tactic: convert p.step ⟨p.length - (i.1 + 1), Nat.sub_lt_self (by omega) hi⟩
Theorem: SetTheory.PGame.zero_lf
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x : PGame
⊢ 0 ⧏ x ↔ ∃ i, ∀ (j : (x.moveLeft i).RightMoves), 0 ⧏ (x.moveLeft i).moveRight j
state_after: xl xr : Type u
x : PGame
⊢ ((∃ i,
        (∀ (i' : LeftMoves 0), moveLeft 0 i' ⧏ x.moveLeft i) ∧
          ∀ (j : (x.moveLeft i).RightMoves), 0 ⧏ (x.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (moveRight 0 j).LeftMoves), (moveRight 0 j).moveLeft i ⧏ x) ∧
          ∀ (j' : x.RightMoves), moveRight 0 j ⧏ x.moveRight j') ↔
    ∃ i, ∀ (j : (x.moveLeft i).RightMoves), 0 ⧏ (x.moveLeft i).moveRight j
tactic: rw [lf_def]
state_before: xl xr : Type u
x : PGame
⊢ ((∃ i,
        (∀ (i' : LeftMoves 0), moveLeft 0 i' ⧏ x.moveLeft i) ∧
          ∀ (j : (x.moveLeft i).RightMoves), 0 ⧏ (x.moveLeft i).moveRight j) ∨
      ∃ j,
        (∀ (i : (moveRight 0 j).LeftMoves), (moveRight 0 j).moveLeft i ⧏ x) ∧
          ∀ (j' : x.RightMoves), moveRight 0 j ⧏ x.moveRight j') ↔
    ∃ i, ∀ (j : (x.moveLeft i).RightMoves), 0 ⧏ (x.moveLeft i).moveRight j
state_after: no goals
tactic: simp
Theorem: sup_right_comm
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c : α
⊢ a ⊔ b ⊔ c = a ⊔ c ⊔ b
state_after: no goals
tactic: rw [sup_assoc, sup_assoc, sup_comm b]
Theorem: ProbabilityTheory.Kernel.compProd_fst_condKernelCountable
File: Mathlib/Probability/Kernel/Disintegration/StandardBorel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁵ : CountablyGenerated γ
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : Countable α
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
x y : α
h : x ∈ measurableAtom y
⊢ (fun a => (κ a).condKernel) x = (fun a => (κ a).condKernel) y
state_after: no goals
tactic: simp [apply_congr_of_mem_measurableAtom _ h]
Theorem: Complex.cos_int_mul_two_pi_add_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: n : ℤ
⊢ cos (↑n * (2 * ↑π) + ↑π) = -1
state_after: no goals
tactic: simpa only [cos_zero] using (cos_periodic.int_mul n).add_antiperiod_eq cos_antiperiodic
Theorem: HurwitzKernelBounds.F_nat_zero_zero_sub_le
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean

Proof steps:
state_before: t : ℝ
ht : 0 < t
⊢ ‖F_nat 0 0 t - 1‖ ≤ rexp (-π * t) / (1 - rexp (-π * t))
state_after: case h.e'_3.h.e'_3
t : ℝ
ht : 0 < t
⊢ F_nat 0 0 t - 1 = F_nat 0 1 t

case h.e'_4.h.e'_5
t : ℝ
ht : 0 < t
⊢ rexp (-π * t) = rexp (-π * 1 ^ 2 * t)
tactic: convert F_nat_zero_le zero_le_one ht using 2
Theorem: CategoryTheory.Limits.kernelSubobject_factors
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
W : C
h : W ⟶ X
w : h ≫ f = 0
⊢ kernel.lift f h w ≫ (MonoOver.mk' (kernel.ι f)).arrow = h
state_after: no goals
tactic: simp
Theorem: ENNReal.lt_add_right
File: Mathlib/Data/ENNReal/Operations.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
⊢ a < a + b
state_after: no goals
tactic: rwa [← pos_iff_ne_zero, ← ENNReal.add_lt_add_iff_left ha, add_zero] at hb
Theorem: Ordnode.Sized.size_eq_zero
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
t : Ordnode α
ht : t.Sized
⊢ t.size = 0 ↔ t = nil
state_after: no goals
tactic: cases t <;> [simp;simp [ht.1]]
Theorem: convexJoin_empty_left
File: Mathlib/Analysis/Convex/Join.lean

Proof steps:
state_before: ι : Sort u_1
𝕜 : Type u_2
E : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s t✝ s₁ s₂ t₁ t₂ u : Set E
x y : E
t : Set E
⊢ convexJoin 𝕜 ∅ t = ∅
state_after: no goals
tactic: simp [convexJoin]
Theorem: contDiffOn_top_iff_fderivWithin
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
hs : UniqueDiffOn 𝕜 s
⊢ ContDiffOn 𝕜 ⊤ f s ↔ DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s
state_after: case mp
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
hs : UniqueDiffOn 𝕜 s
⊢ ContDiffOn 𝕜 ⊤ f s → DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s

case mpr
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
hs : UniqueDiffOn 𝕜 s
⊢ DifferentiableOn 𝕜 f s ∧ ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s → ContDiffOn 𝕜 ⊤ f s
tactic: constructor
Theorem: UniformOnFun.inf_eq
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u₁ u₂ : UniformSpace γ
⊢ uniformSpace α γ 𝔖 = uniformSpace α γ 𝔖 ⊓ uniformSpace α γ 𝔖
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u₁ u₂ : UniformSpace γ
⊢ ⨅ i, uniformSpace α γ 𝔖 = ⨅ b, bif b then uniformSpace α γ 𝔖 else uniformSpace α γ 𝔖
tactic: rw [inf_eq_iInf, inf_eq_iInf, UniformOnFun.iInf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u₁ u₂ : UniformSpace γ
⊢ ⨅ i, uniformSpace α γ 𝔖 = ⨅ b, bif b then uniformSpace α γ 𝔖 else uniformSpace α γ 𝔖
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u₁ u₂ : UniformSpace γ
i : Bool
⊢ uniformSpace α γ 𝔖 = bif i then uniformSpace α γ 𝔖 else uniformSpace α γ 𝔖
tactic: refine iInf_congr fun i => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
u₁ u₂ : UniformSpace γ
i : Bool
⊢ uniformSpace α γ 𝔖 = bif i then uniformSpace α γ 𝔖 else uniformSpace α γ 𝔖
state_after: no goals
tactic: cases i <;> rfl
Theorem: IsOpen.polishSpace
File: Mathlib/Topology/MetricSpace/Polish.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
⊢ PolishSpace ↑s
state_after: α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
this : UpgradedPolishSpace α := upgradePolishSpace α
⊢ PolishSpace ↑s
tactic: letI := upgradePolishSpace α
state_before: α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
this : UpgradedPolishSpace α := upgradePolishSpace α
⊢ PolishSpace ↑s
state_after: case intro
α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
⊢ PolishSpace ↑↑s
tactic: lift s to Opens α using hs
state_before: case intro
α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
⊢ PolishSpace ↑↑s
state_after: case intro
α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this✝ : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
this : SecondCountableTopology s.CompleteCopy
⊢ PolishSpace ↑↑s
tactic: have : SecondCountableTopology s.CompleteCopy := inferInstanceAs (SecondCountableTopology s)
state_before: case intro
α✝ : Type u_1
β : Type u_2
inst✝² : MetricSpace α✝
s✝ : Opens α✝
α : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
this✝ : UpgradedPolishSpace α := upgradePolishSpace α
s : Opens α
this : SecondCountableTopology s.CompleteCopy
⊢ PolishSpace ↑↑s
state_after: no goals
tactic: exact inferInstanceAs (PolishSpace s.CompleteCopy)
Theorem: WittVector.toZModPow_compat
File: Mathlib/RingTheory/WittVector/Compare.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
m n : ℕ
h : m ≤ n
⊢ (ZMod.castHom ⋯ (ZMod (p ^ m))).comp ((zmodEquivTrunc p n).symm.toRingHom.comp (truncate n)) =
    ((zmodEquivTrunc p m).symm.toRingHom.comp (TruncatedWittVector.truncate h)).comp (truncate n)
state_after: no goals
tactic: rw [commutes_symm, RingHom.comp_assoc]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
m n : ℕ
h : m ≤ n
⊢ ((zmodEquivTrunc p m).symm.toRingHom.comp (TruncatedWittVector.truncate h)).comp (truncate n) =
    (zmodEquivTrunc p m).symm.toRingHom.comp (truncate m)
state_after: no goals
tactic: rw [RingHom.comp_assoc, truncate_comp_wittVector_truncate]
Theorem: LSeries_zero
File: Mathlib/NumberTheory/LSeries/Basic.lean

Proof steps:
state_before: ⊢ LSeries 0 = 0
state_after: case h
x✝ : ℂ
⊢ LSeries 0 x✝ = 0 x✝
tactic: ext
state_before: case h
x✝ : ℂ
⊢ LSeries 0 x✝ = 0 x✝
state_after: no goals
tactic: simp only [LSeries, LSeries.term, Pi.zero_apply, zero_div, ite_self, tsum_zero]
Theorem: isAlgebraic_rat
File: Mathlib/RingTheory/Algebraic.lean

Proof steps:
state_before: R✝ : Type u
S : Type u_1
A✝ : Type v
inst✝⁹ : CommRing R✝
inst✝⁸ : CommRing S
inst✝⁷ : Ring A✝
inst✝⁶ : Algebra R✝ A✝
inst✝⁵ : Algebra R✝ S
inst✝⁴ : Algebra S A✝
inst✝³ : IsScalarTower R✝ S A✝
R : Type u
A : Type v
inst✝² : DivisionRing A
inst✝¹ : Field R
inst✝ : Algebra R A
n : ℚ
⊢ IsAlgebraic R ↑n
state_after: R✝ : Type u
S : Type u_1
A✝ : Type v
inst✝⁹ : CommRing R✝
inst✝⁸ : CommRing S
inst✝⁷ : Ring A✝
inst✝⁶ : Algebra R✝ A✝
inst✝⁵ : Algebra R✝ S
inst✝⁴ : Algebra S A✝
inst✝³ : IsScalarTower R✝ S A✝
R : Type u
A : Type v
inst✝² : DivisionRing A
inst✝¹ : Field R
inst✝ : Algebra R A
n : ℚ
⊢ IsAlgebraic R ((algebraMap R A) ↑n)
tactic: rw [← map_ratCast (algebraMap R A)]
state_before: R✝ : Type u
S : Type u_1
A✝ : Type v
inst✝⁹ : CommRing R✝
inst✝⁸ : CommRing S
inst✝⁷ : Ring A✝
inst✝⁶ : Algebra R✝ A✝
inst✝⁵ : Algebra R✝ S
inst✝⁴ : Algebra S A✝
inst✝³ : IsScalarTower R✝ S A✝
R : Type u
A : Type v
inst✝² : DivisionRing A
inst✝¹ : Field R
inst✝ : Algebra R A
n : ℚ
⊢ IsAlgebraic R ((algebraMap R A) ↑n)
state_after: no goals
tactic: exact isAlgebraic_algebraMap (Rat.cast n)
Theorem: ContinuousLinearMap.hasTemperateGrowth
File: Mathlib/Analysis/Distribution/SchwartzSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E →L[ℝ] F
⊢ Function.HasTemperateGrowth ⇑f
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E →L[ℝ] F
⊢ Function.HasTemperateGrowth (fderiv ℝ ⇑f)

𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E →L[ℝ] F
x : E
⊢ ‖f x‖ ≤ ‖f‖ * (1 + ‖x‖) ^ 1
tactic: apply Function.HasTemperateGrowth.of_fderiv ?_ f.differentiable (k := 1) (C := ‖f‖) (fun x ↦ ?_)