ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: continuousWithinAt_prod_of_discrete_right
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
s : Set (α × β)
x : α × β
⊢ ContinuousWithinAt f s x ↔ ContinuousWithinAt (fun x_1 => f (x_1, x.2)) {a | (a, x.2) ∈ s} x.1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
s : Set (α × β)
x : α × β
⊢ ContinuousWithinAt f s (x.1, x.2) ↔
    ContinuousWithinAt (fun x_1 => f (x_1, (x.1, x.2).2)) {a | (a, (x.1, x.2).2) ∈ s} (x.1, x.2).1
tactic: rw [← x.eta]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
s : Set (α × β)
x : α × β
⊢ ContinuousWithinAt f s (x.1, x.2) ↔
    ContinuousWithinAt (fun x_1 => f (x_1, (x.1, x.2).2)) {a | (a, (x.1, x.2).2) ∈ s} (x.1, x.2).1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
s : Set (α × β)
x : α × β
⊢ Tendsto f (map (fun a => (a, x.2)) (𝓝 x.1 ⊓ 𝓟 ((fun a => (a, x.2)) ⁻¹' s))) (𝓝 (f (x.1, x.2))) ↔
    Tendsto (fun x_1 => f (x_1, x.2)) (𝓝 x.1 ⊓ 𝓟 {a | (a, x.2) ∈ s}) (𝓝 (f (x.1, x.2)))
tactic: simp_rw [ContinuousWithinAt, nhdsWithin, nhds_prod_eq, nhds_discrete, prod_pure,
    ← map_inf_principal_preimage]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology β
f : α × β → γ
s : Set (α × β)
x : α × β
⊢ Tendsto f (map (fun a => (a, x.2)) (𝓝 x.1 ⊓ 𝓟 ((fun a => (a, x.2)) ⁻¹' s))) (𝓝 (f (x.1, x.2))) ↔
    Tendsto (fun x_1 => f (x_1, x.2)) (𝓝 x.1 ⊓ 𝓟 {a | (a, x.2) ∈ s}) (𝓝 (f (x.1, x.2)))
state_after: no goals
tactic: rfl
Theorem: Nat.binaryRec_decreasing
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n : ℕ
h : n ≠ 0
⊢ n.div2 < n
state_after: m n : ℕ
h : n ≠ 0
⊢ n / 2 < n
tactic: rw [div2_val]
state_before: m n : ℕ
h : n ≠ 0
⊢ n / 2 < n
state_after: m n : ℕ
h : n ≠ 0
⊢ n < n * succ 1
tactic: apply (div_lt_iff_lt_mul <| succ_pos 1).2
state_before: m n : ℕ
h : n ≠ 0
⊢ n < n * succ 1
state_after: m n : ℕ
h : n ≠ 0
this : n * 1 < n * succ 1
⊢ n < n * succ 1
tactic: have := Nat.mul_lt_mul_of_pos_left (lt_succ_self 1)
    (lt_of_le_of_ne n.zero_le h.symm)
state_before: m n : ℕ
h : n ≠ 0
this : n * 1 < n * succ 1
⊢ n < n * succ 1
state_after: no goals
tactic: rwa [Nat.mul_one] at this
Theorem: isLocallyInjective_iff_isOpen_diagonal
File: Mathlib/Topology/SeparatedMap.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
A : Type ?u.14973
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
⊢ IsLocallyInjective f ↔ IsOpen (Function.pullbackDiagonal f)
state_after: X : Type u_1
Y : Type u_2
A : Type ?u.14973
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
⊢ (∀ (x : X), ∃ U ∈ 𝓝 x, Set.InjOn f U) ↔
    ∀ (a b : X) (b_1 : f a = f b),
      ⟨(a, b), b_1⟩ ∈ Function.pullbackDiagonal f → ∃ t ∈ 𝓝 a ×ˢ 𝓝 b, Subtype.val ⁻¹' t ⊆ Function.pullbackDiagonal f
tactic: simp_rw [isLocallyInjective_iff_nhds, isOpen_iff_mem_nhds,
    Subtype.forall, Prod.forall, nhds_induced, nhds_prod_eq, Filter.mem_comap]
state_before: X : Type u_1
Y : Type u_2
A : Type ?u.14973
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
⊢ (∀ (x : X), ∃ U ∈ 𝓝 x, Set.InjOn f U) ↔
    ∀ (a b : X) (b_1 : f a = f b),
      ⟨(a, b), b_1⟩ ∈ Function.pullbackDiagonal f → ∃ t ∈ 𝓝 a ×ˢ 𝓝 b, Subtype.val ⁻¹' t ⊆ Function.pullbackDiagonal f
state_after: case refine_1
X : Type u_1
Y : Type u_2
A : Type ?u.14973
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
⊢ (∀ (x : X), ∃ U ∈ 𝓝 x, Set.InjOn f U) →
    ∀ (a b : X) (b_1 : f a = f b),
      ⟨(a, b), b_1⟩ ∈ Function.pullbackDiagonal f → ∃ t ∈ 𝓝 a ×ˢ 𝓝 b, Subtype.val ⁻¹' t ⊆ Function.pullbackDiagonal f

case refine_2
X : Type u_1
Y : Type u_2
A : Type ?u.14973
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
h :
  ∀ (a b : X) (b_1 : f a = f b),
    ⟨(a, b), b_1⟩ ∈ Function.pullbackDiagonal f → ∃ t ∈ 𝓝 a ×ˢ 𝓝 b, Subtype.val ⁻¹' t ⊆ Function.pullbackDiagonal f
x : X
⊢ ∃ U ∈ 𝓝 x, Set.InjOn f U
tactic: refine ⟨?_, fun h x ↦ ?_⟩
Theorem: Convex.mem_toCone
File: Mathlib/Analysis/Convex/Cone/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
hs : Convex 𝕜 s
x : E
⊢ x ∈ toCone s hs ↔ ∃ c, 0 < c ∧ ∃ y ∈ s, c • y = x
state_after: no goals
tactic: simp only [toCone, ConvexCone.mem_mk, mem_iUnion, mem_smul_set, eq_comm, exists_prop]
Theorem: topologicalAddGroup_inf
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
ι : Sort u_1
inst✝ : Group G
t₁ t₂ : TopologicalSpace G
h₁ : TopologicalGroup G
h₂ : TopologicalGroup G
⊢ TopologicalGroup G
state_after: G : Type w
H : Type x
α : Type u
β : Type v
ι : Sort u_1
inst✝ : Group G
t₁ t₂ : TopologicalSpace G
h₁ : TopologicalGroup G
h₂ : TopologicalGroup G
b : Bool
⊢ TopologicalGroup G
tactic: refine topologicalGroup_iInf fun b => ?_
state_before: G : Type w
H : Type x
α : Type u
β : Type v
ι : Sort u_1
inst✝ : Group G
t₁ t₂ : TopologicalSpace G
h₁ : TopologicalGroup G
h₂ : TopologicalGroup G
b : Bool
⊢ TopologicalGroup G
state_after: no goals
tactic: cases b <;> assumption
Theorem: FiniteField.pow_card_pow
File: Mathlib/FieldTheory/Finite/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
n : ℕ
a : K
⊢ a ^ q ^ n = a
state_after: case zero
K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
a : K
⊢ a ^ q ^ 0 = a

case succ
K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
a : K
n : ℕ
ih : a ^ q ^ n = a
⊢ a ^ q ^ (n + 1) = a
tactic: induction' n with n ih
Theorem: QuasiErgodic.ae_mem_or_ae_nmem₀
File: Mathlib/Dynamics/Ergodic/Ergodic.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : QuasiErgodic f μ
hsm : NullMeasurableSet s μ
hs : f ⁻¹' s =ᶠ[ae μ] s
⊢ s =ᶠ[ae μ] univ → ∀ᵐ (x : α) ∂μ, x ∈ s
state_after: no goals
tactic: simp [mem_ae_iff]
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : QuasiErgodic f μ
hsm : NullMeasurableSet s μ
hs : f ⁻¹' s =ᶠ[ae μ] s
⊢ s =ᶠ[ae μ] ∅ → ∀ᵐ (x : α) ∂μ, x ∉ s
state_after: no goals
tactic: simp [ae_iff]
Theorem: MvPolynomial.bind₁_monomial
File: Mathlib/Algebra/MvPolynomial/Monad.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ f : σ → MvPolynomial τ R
d : σ →₀ ℕ
r : R
⊢ (bind₁ f) ((monomial d) r) = C r * ∏ i ∈ d.support, f i ^ d i
state_after: no goals
tactic: simp only [monomial_eq, map_mul, bind₁_C_right, Finsupp.prod, map_prod,
    map_pow, bind₁_X_right]
Theorem: HNNExtension.NormalWord.ofGroup_toList
File: Mathlib/GroupTheory/HNNExtension.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
d : TransversalPair G A B
g : G
⊢ ∀ (u : ℤˣ) (g_1 : G), (u, g_1) ∈ { head := g, toList := [], chain := ⋯ }.toList → g_1 ∈ d.set u
state_after: no goals
tactic: simp
Theorem: Flow.isInvariant_omegaLimit
File: Mathlib/Dynamics/OmegaLimit.lean

Proof steps:
state_before: τ : Type u_1
inst✝³ : TopologicalSpace τ
inst✝² : AddMonoid τ
inst✝¹ : ContinuousAdd τ
α : Type u_2
inst✝ : TopologicalSpace α
f : Filter τ
ϕ : Flow τ α
s : Set α
hf : ∀ (t : τ), Tendsto (fun x => t + x) f f
⊢ IsInvariant ϕ.toFun (ω f ϕ.toFun s)
state_after: τ : Type u_1
inst✝³ : TopologicalSpace τ
inst✝² : AddMonoid τ
inst✝¹ : ContinuousAdd τ
α : Type u_2
inst✝ : TopologicalSpace α
f : Filter τ
ϕ : Flow τ α
s : Set α
hf : ∀ (t : τ), Tendsto (fun x => t + x) f f
t : τ
⊢ MapsTo (ϕ.toFun t) (ω f ϕ.toFun s) (ω f (fun t_1 x => ϕ.toFun (t + t_1) x) s)
tactic: refine fun t ↦ MapsTo.mono_right ?_ (omegaLimit_subset_of_tendsto ϕ s (hf t))
state_before: τ : Type u_1
inst✝³ : TopologicalSpace τ
inst✝² : AddMonoid τ
inst✝¹ : ContinuousAdd τ
α : Type u_2
inst✝ : TopologicalSpace α
f : Filter τ
ϕ : Flow τ α
s : Set α
hf : ∀ (t : τ), Tendsto (fun x => t + x) f f
t : τ
⊢ MapsTo (ϕ.toFun t) (ω f ϕ.toFun s) (ω f (fun t_1 x => ϕ.toFun (t + t_1) x) s)
state_after: no goals
tactic: exact
    mapsTo_omegaLimit _ (mapsTo_id _) (fun t' x ↦ (ϕ.map_add _ _ _).symm)
      (continuous_const.flow ϕ continuous_id)
Theorem: edist_mulIndicator
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₂ : ℝ
inst✝ : FunLike 𝓕 E F
s t : Set α
f : α → E
x : α
⊢ edist (s.mulIndicator f x) (t.mulIndicator f x) = ↑‖(s ∆ t).mulIndicator f x‖₊
state_after: no goals
tactic: rw [edist_nndist, nndist_mulIndicator]
Theorem: padicValRat.self
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p : ℕ
hp : 1 < p
⊢ padicValRat p ↑p = 1
state_after: no goals
tactic: simp [hp]
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.map_on_summand'
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
⊢ ((splitting K).cofan Δ).inj A ≫ (obj K).map θ =
    Termwise.mapMono K (image.ι (θ.unop ≫ A.e)) ≫ ((splitting K).cofan Δ').inj (A.pull θ)
state_after: case fac
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
⊢ factorThruImage (θ.unop ≫ A.e) ≫ image.ι (θ.unop ≫ A.e) = θ.unop ≫ A.e
tactic: apply Obj.map_on_summand
state_before: case fac
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
Δ Δ' : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
θ : Δ ⟶ Δ'
⊢ factorThruImage (θ.unop ≫ A.e) ≫ image.ι (θ.unop ≫ A.e) = θ.unop ≫ A.e
state_after: no goals
tactic: apply image.fac
Theorem: WeierstrassCurve.φ_one
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.φ 1 = C X
state_after: no goals
tactic: erw [φ, ψ_one, one_pow, mul_one, ψ_zero, mul_zero, sub_zero]
Theorem: ENNReal.inv_strictAnti
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ StrictAnti Inv.inv
state_after: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
h : a < b
⊢ b⁻¹ < a⁻¹
tactic: intro a b h
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
h : a < b
⊢ b⁻¹ < a⁻¹
state_after: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
b : ℝ≥0∞
a : ℝ≥0
h : ↑a < b
⊢ b⁻¹ < (↑a)⁻¹
tactic: lift a to ℝ≥0 using h.ne_top
state_before: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
b : ℝ≥0∞
a : ℝ≥0
h : ↑a < b
⊢ b⁻¹ < (↑a)⁻¹
state_after: case intro.top
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
h : ↑a < ⊤
⊢ ⊤⁻¹ < (↑a)⁻¹

case intro.coe
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : ↑a < ↑x✝
⊢ (↑x✝)⁻¹ < (↑a)⁻¹
tactic: induction b
state_before: case intro.coe
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : ↑a < ↑x✝
⊢ (↑x✝)⁻¹ < (↑a)⁻¹
state_after: case intro.coe
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
⊢ (↑x✝)⁻¹ < (↑a)⁻¹
tactic: rw [coe_lt_coe] at h
state_before: case intro.coe
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
⊢ (↑x✝)⁻¹ < (↑a)⁻¹
state_after: case intro.coe.inl
a b c d : ℝ≥0∞
r p q x✝ : ℝ≥0
h : 0 < x✝
⊢ (↑x✝)⁻¹ < (↑0)⁻¹

case intro.coe.inr
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
ha : a ≠ 0
⊢ (↑x✝)⁻¹ < (↑a)⁻¹
tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: case intro.coe.inr
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
ha : a ≠ 0
⊢ (↑x✝)⁻¹ < (↑a)⁻¹
state_after: case intro.coe.inr
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
ha : a ≠ 0
⊢ x✝⁻¹ < a⁻¹
tactic: rw [← coe_inv h.ne_bot, ← coe_inv ha, coe_lt_coe]
state_before: case intro.coe.inr
a✝ b c d : ℝ≥0∞
r p q a x✝ : ℝ≥0
h : a < x✝
ha : a ≠ 0
⊢ x✝⁻¹ < a⁻¹
state_after: no goals
tactic: exact NNReal.inv_lt_inv ha h
Theorem: List.trop_sum
File: Mathlib/Algebra/Tropical/BigOperators.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝ : AddMonoid R
l : List R
⊢ trop l.sum = (map trop l).prod
state_after: case nil
R : Type u_1
S : Type u_2
inst✝ : AddMonoid R
⊢ trop [].sum = (map trop []).prod

case cons
R : Type u_1
S : Type u_2
inst✝ : AddMonoid R
hd : R
tl : List R
IH : trop tl.sum = (map trop tl).prod
⊢ trop (hd :: tl).sum = (map trop (hd :: tl)).prod
tactic: induction' l with hd tl IH
Theorem: PNat.dvd_prime
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: p m : ℕ+
pp : p.Prime
⊢ m ∣ p ↔ m = 1 ∨ m = p
state_after: p m : ℕ+
pp : p.Prime
⊢ ↑m ∣ ↑p ↔ m = 1 ∨ m = p
tactic: rw [PNat.dvd_iff]
state_before: p m : ℕ+
pp : p.Prime
⊢ ↑m ∣ ↑p ↔ m = 1 ∨ m = p
state_after: p m : ℕ+
pp : p.Prime
⊢ ↑m = 1 ∨ ↑m = ↑p ↔ m = 1 ∨ m = p
tactic: rw [Nat.dvd_prime pp]
state_before: p m : ℕ+
pp : p.Prime
⊢ ↑m = 1 ∨ ↑m = ↑p ↔ m = 1 ∨ m = p
state_after: no goals
tactic: simp
Theorem: add_pow_expChar_of_commute
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R : Type u
inst✝ : Semiring R
q : ℕ
hR : ExpChar R q
x y : R
h : Commute x y
⊢ (x + y) ^ q = x ^ q + y ^ q
state_after: case zero
R : Type u
inst✝¹ : Semiring R
x y : R
h : Commute x y
inst✝ : CharZero R
⊢ (x + y) ^ 1 = x ^ 1 + y ^ 1

case prime
R : Type u
inst✝ : Semiring R
q : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x + y) ^ q = x ^ q + y ^ q
tactic: cases' hR with _ _ hprime _
state_before: case prime
R : Type u
inst✝ : Semiring R
q : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x + y) ^ q = x ^ q + y ^ q
state_after: case prime
R : Type u
inst✝ : Semiring R
q : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x + y) ^ q = x ^ q + y ^ q
tactic: haveI := Fact.mk hprime
state_before: case prime
R : Type u
inst✝ : Semiring R
q : ℕ
x y : R
h : Commute x y
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x + y) ^ q = x ^ q + y ^ q
state_after: no goals
tactic: exact add_pow_char_of_commute R x y h
Theorem: Finset.prod_union_eq_right
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
hs : ∀ a ∈ s₁, a ∉ s₂ → f a = 1
⊢ ∏ a ∈ s₁ ∪ s₂, f a = ∏ a ∈ s₂, f a
state_after: no goals
tactic: rw [union_comm, prod_union_eq_left hs]
Theorem: CategoryTheory.Localization.hasSmallLocalizedHom_of_isLocalization
File: Mathlib/CategoryTheory/Localization/SmallHom.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
D' : Type u₃
inst✝¹ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝ : L.IsLocalization W
X Y Z : C
⊢ HasSmallLocalizedHom W X Y
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
D' : Type u₃
inst✝¹ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝ : L.IsLocalization W
X Y Z : C
⊢ Small.{v₂, v₂} (L.obj X ⟶ L.obj Y)
tactic: rw [hasSmallLocalizedHom_iff W L]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
D' : Type u₃
inst✝¹ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝ : L.IsLocalization W
X Y Z : C
⊢ Small.{v₂, v₂} (L.obj X ⟶ L.obj Y)
state_after: no goals
tactic: infer_instance
Theorem: AddSubsemigroup.top_prod
File: Mathlib/Algebra/Group/Subsemigroup/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
σ : Type u_4
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S : Subsemigroup M
s : Subsemigroup N
x : M × N
⊢ x ∈ ⊤.prod s ↔ x ∈ comap (MulHom.snd M N) s
state_after: no goals
tactic: simp [mem_prod, MulHom.coe_snd]
Theorem: Ordinal.lt_opow_of_limit
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: a b c : Ordinal.{u_1}
b0 : b ≠ 0
h : c.IsLimit
⊢ a < b ^ c ↔ ∃ c' < c, a < b ^ c'
state_after: a b c : Ordinal.{u_1}
b0 : b ≠ 0
h : c.IsLimit
⊢ ¬a < b ^ c ↔ ∀ (x : Ordinal.{u_1}), ¬(x < c ∧ a < b ^ x)
tactic: rw [← not_iff_not, not_exists]
state_before: a b c : Ordinal.{u_1}
b0 : b ≠ 0
h : c.IsLimit
⊢ ¬a < b ^ c ↔ ∀ (x : Ordinal.{u_1}), ¬(x < c ∧ a < b ^ x)
state_after: no goals
tactic: simp only [not_lt, opow_le_of_limit b0 h, exists_prop, not_and]
Theorem: SetTheory.PGame.invVal_isEmpty
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: l r : Type u
b : Bool
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
i : InvTy l r b
x : PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
⊢ invVal L R IHl IHr x i = 0
state_after: case zero
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
x : PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
⊢ invVal L R IHl IHr x InvTy.zero = 0

case left₁
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
x : PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : r
a✝ : InvTy l r false
⊢ invVal L R IHl IHr x (InvTy.left₁ a a✝) = 0

case left₂
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
x : PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : l
a✝ : InvTy l r true
⊢ invVal L R IHl IHr x (InvTy.left₂ a a✝) = 0

case right₁
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
x : PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : l
a✝ : InvTy l r false
⊢ invVal L R IHl IHr x (InvTy.right₁ a a✝) = 0

case right₂
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
x : PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : r
a✝ : InvTy l r true
⊢ invVal L R IHl IHr x (InvTy.right₂ a a✝) = 0
tactic: cases' i with a _ a _ a _ a
state_before: case left₁
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
x : PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : r
a✝ : InvTy l r false
⊢ invVal L R IHl IHr x (InvTy.left₁ a a✝) = 0

case left₂
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
x : PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : l
a✝ : InvTy l r true
⊢ invVal L R IHl IHr x (InvTy.left₂ a a✝) = 0

case right₁
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
x : PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : l
a✝ : InvTy l r false
⊢ invVal L R IHl IHr x (InvTy.right₁ a a✝) = 0

case right₂
l r : Type u
L : l → PGame
R : r → PGame
IHl : l → PGame
IHr : r → PGame
x : PGame
inst✝¹ : IsEmpty l
inst✝ : IsEmpty r
a : r
a✝ : InvTy l r true
⊢ invVal L R IHl IHr x (InvTy.right₂ a a✝) = 0
state_after: no goals
tactic: all_goals exact isEmptyElim a
Theorem: Set.sInter_prod
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
S : Set (Set α)
hS : S.Nonempty
t : Set β
⊢ ⋂₀ S ×ˢ t = ⋂ s ∈ S, s ×ˢ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
S : Set (Set α)
hS : S.Nonempty
t : Set β
⊢ ⋂ r ∈ S ×ˢ {t}, r.1 ×ˢ r.2 = ⋂ s ∈ S, s ×ˢ t
tactic: rw [← sInter_singleton t, sInter_prod_sInter hS (singleton_nonempty t), sInter_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
S : Set (Set α)
hS : S.Nonempty
t : Set β
⊢ ⋂ r ∈ S ×ˢ {t}, r.1 ×ˢ r.2 = ⋂ s ∈ S, s ×ˢ t
state_after: no goals
tactic: simp_rw [prod_singleton, mem_image, iInter_exists, biInter_and', iInter_iInter_eq_right]
Theorem: Real.exp_approx_end
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: n m : ℕ
x : ℝ
e₁ : n + 1 = m
h : |x| ≤ 1
⊢ |rexp x - expNear m x 0| ≤ |x| ^ m / ↑m.factorial * ((↑m + 1) / ↑m)
state_after: n m : ℕ
x : ℝ
e₁ : n + 1 = m
h : |x| ≤ 1
⊢ |rexp x - ∑ m ∈ range m, x ^ m / ↑m.factorial| ≤ |x| ^ m / ↑m.factorial * ((↑m + 1) / ↑m)
tactic: simp only [expNear, mul_zero, add_zero]
state_before: n m : ℕ
x : ℝ
e₁ : n + 1 = m
h : |x| ≤ 1
⊢ |rexp x - ∑ m ∈ range m, x ^ m / ↑m.factorial| ≤ |x| ^ m / ↑m.factorial * ((↑m + 1) / ↑m)
state_after: case h.e'_4
n m : ℕ
x : ℝ
e₁ : n + 1 = m
h : |x| ≤ 1
⊢ |x| ^ m / ↑m.factorial * ((↑m + 1) / ↑m) = |x| ^ m * (↑m.succ / (↑m.factorial * ↑m))

n m : ℕ
x : ℝ
e₁ : n + 1 = m
h : |x| ≤ 1
⊢ 0 < m
tactic: convert exp_bound (n := m) h ?_ using 1
Theorem: AbstractCompletion.extend_unique
File: Mathlib/Topology/UniformSpace/AbstractCompletion.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝² : UniformSpace β
f : α → β
inst✝¹ : CompleteSpace β
inst✝ : T0Space β
hf : UniformContinuous f
g : pkg.space → β
hg : UniformContinuous g
h : ∀ (a : α), f a = g (pkg.coe a)
⊢ pkg.extend f = g
state_after: α : Type u_1
inst✝³ : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝² : UniformSpace β
f : α → β
inst✝¹ : CompleteSpace β
inst✝ : T0Space β
hf : UniformContinuous f
g : pkg.space → β
hg : UniformContinuous g
h : ∀ (a : α), f a = g (pkg.coe a)
⊢ ∀ (a : α), pkg.extend f (pkg.coe a) = g (pkg.coe a)
tactic: apply pkg.funext pkg.continuous_extend hg.continuous
state_before: α : Type u_1
inst✝³ : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝² : UniformSpace β
f : α → β
inst✝¹ : CompleteSpace β
inst✝ : T0Space β
hf : UniformContinuous f
g : pkg.space → β
hg : UniformContinuous g
h : ∀ (a : α), f a = g (pkg.coe a)
⊢ ∀ (a : α), pkg.extend f (pkg.coe a) = g (pkg.coe a)
state_after: no goals
tactic: simpa only [pkg.extend_coe hf] using h