ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CauSeq.le_inf
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : a ≤ b
hc : a ≤ c
⊢ a ≤ b ⊓ c
state_after: case inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hc : a ≤ c
hb : a < b
⊢ a ≤ b ⊓ c

case inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hc : a ≤ c
hb : a ≈ b
⊢ a ≤ b ⊓ c
tactic: cases' hb with hb hb
Theorem: IsAntichain.finite_of_partiallyWellOrderedOn
File: Mathlib/Order/WellFoundedSet.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : s.PartiallyWellOrderedOn r
⊢ s.Finite
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : s.PartiallyWellOrderedOn r
hi : s.Infinite
⊢ False
tactic: refine not_infinite.1 fun hi => ?_
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : s.PartiallyWellOrderedOn r
hi : s.Infinite
⊢ False
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : s.PartiallyWellOrderedOn r
hi : s.Infinite
m n : ℕ
hmn : m < n
h : r ↑((Infinite.natEmbedding s hi) m) ↑((Infinite.natEmbedding s hi) n)
⊢ False
tactic: obtain ⟨m, n, hmn, h⟩ := hp (fun n => hi.natEmbedding _ n) fun n => (hi.natEmbedding _ n).2
state_before: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
ha : IsAntichain r s
hp : s.PartiallyWellOrderedOn r
hi : s.Infinite
m n : ℕ
hmn : m < n
h : r ↑((Infinite.natEmbedding s hi) m) ↑((Infinite.natEmbedding s hi) n)
⊢ False
state_after: no goals
tactic: exact hmn.ne ((hi.natEmbedding _).injective <| Subtype.val_injective <|
    ha.eq (hi.natEmbedding _ m).2 (hi.natEmbedding _ n).2 h)
Theorem: finprod_mem_sUnion
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
t : Set (Set α)
h : t.PairwiseDisjoint id
ht₀ : t.Finite
ht₁ : ∀ x ∈ t, x.Finite
⊢ ∏ᶠ (a : α) (_ : a ∈ ⋃₀ t), f a = ∏ᶠ (s : Set α) (_ : s ∈ t) (a : α) (_ : a ∈ s), f a
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
t : Set (Set α)
h : t.PairwiseDisjoint id
ht₀ : t.Finite
ht₁ : ∀ x ∈ t, x.Finite
⊢ ∏ᶠ (a : α) (_ : a ∈ ⋃ i ∈ t, i), f a = ∏ᶠ (s : Set α) (_ : s ∈ t) (a : α) (_ : a ∈ s), f a
tactic: rw [Set.sUnion_eq_biUnion]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
t : Set (Set α)
h : t.PairwiseDisjoint id
ht₀ : t.Finite
ht₁ : ∀ x ∈ t, x.Finite
⊢ ∏ᶠ (a : α) (_ : a ∈ ⋃ i ∈ t, i), f a = ∏ᶠ (s : Set α) (_ : s ∈ t) (a : α) (_ : a ∈ s), f a
state_after: no goals
tactic: exact finprod_mem_biUnion h ht₀ ht₁
Theorem: sub_pow_expChar_of_commute
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring 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✝¹ : Ring R
x y : R
h : Commute x y
inst✝ : CharZero R
⊢ (x - y) ^ 1 = x ^ 1 - y ^ 1

case prime
R : Type u
inst✝ : Ring 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✝ : Ring 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✝ : Ring 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✝ : Ring 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 sub_pow_char_of_commute R x y h
Theorem: CategoryTheory.ComposableArrows.isoMk₂_hom
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.209062, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 2
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
⊢ g.map' 0 1 ⋯ ⋯ ≫ app₁.inv = app₀.inv ≫ f.map' 0 1 ⋯ ⋯
state_after: no goals
tactic: rw [← cancel_epi app₀.hom, ← reassoc_of% w₀, app₁.hom_inv_id,
      comp_id, app₀.hom_inv_id_assoc]
state_before: C : Type u_1
inst✝ : Category.{?u.209062, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 2
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
⊢ g.map' 1 2 ⋯ ⋯ ≫ app₂.inv = app₁.inv ≫ f.map' 1 2 ⋯ ⋯
state_after: no goals
tactic: rw [← cancel_epi app₁.hom, ← reassoc_of% w₁, app₂.hom_inv_id,
      comp_id, app₁.hom_inv_id_assoc]
Theorem: Matrix.IsAdjMatrix.toGraph_compl_eq
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

Proof steps:
state_before: V : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
h : A.IsAdjMatrix
⊢ ⋯.toGraph = h.toGraphᶜ
state_after: case Adj.h.h.a
V : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
h : A.IsAdjMatrix
v w : V
⊢ ⋯.toGraph.Adj v w ↔ h.toGraphᶜ.Adj v w
tactic: ext v w
state_before: case Adj.h.h.a
V : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
h : A.IsAdjMatrix
v w : V
⊢ ⋯.toGraph.Adj v w ↔ h.toGraphᶜ.Adj v w
state_after: no goals
tactic: cases' h.zero_or_one v w with h h <;> by_cases hvw : v = w <;> simp [Matrix.compl, h, hvw]
Theorem: Finite.Set.subset
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
inst✝ : Finite ↑s
h : t ⊆ s
⊢ Finite ↑t
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
inst✝ : Finite ↑s
h : t ⊆ s
⊢ Finite ↑{x | x ∈ s ∧ x ∈ t}
tactic: rw [← sep_eq_of_subset h]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
inst✝ : Finite ↑s
h : t ⊆ s
⊢ Finite ↑{x | x ∈ s ∧ x ∈ t}
state_after: no goals
tactic: infer_instance
Theorem: extremallyDisconnected_of_homeo
File: Mathlib/Topology/ExtremallyDisconnected.lean

Proof steps:
state_before: X✝ : Type u
inst✝³ : TopologicalSpace X✝
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : ExtremallyDisconnected X
e : X ≃ₜ Y
U : Set Y
hU : IsOpen U
⊢ IsOpen (closure U)
state_after: X✝ : Type u
inst✝³ : TopologicalSpace X✝
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : ExtremallyDisconnected X
e : X ≃ₜ Y
U : Set Y
hU : IsOpen U
⊢ IsOpen (closure (⇑e.symm '' U))
tactic: rw [e.symm.inducing.closure_eq_preimage_closure_image, Homeomorph.isOpen_preimage]
state_before: X✝ : Type u
inst✝³ : TopologicalSpace X✝
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : ExtremallyDisconnected X
e : X ≃ₜ Y
U : Set Y
hU : IsOpen U
⊢ IsOpen (closure (⇑e.symm '' U))
state_after: no goals
tactic: exact ExtremallyDisconnected.open_closure _ (e.symm.isOpen_image.mpr hU)
Theorem: Associates.mem_factors_of_dvd
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a p : α
ha0 : a ≠ 0
hp : Irreducible p
hd : p ∣ a
⊢ Associates.mk p ∈ (Associates.mk a).factors
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a p : α
ha0 : a ≠ 0
hp : Irreducible p
hd : p ∣ a
⊢ Associates.mk p ∈ ↑(factors' a)
tactic: rw [factors_mk _ ha0]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a p : α
ha0 : a ≠ 0
hp : Irreducible p
hd : p ∣ a
⊢ Associates.mk p ∈ ↑(factors' a)
state_after: no goals
tactic: exact mem_factorSet_some.mpr (mem_factors'_of_dvd ha0 hp hd)
Theorem: Class.sUnion_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: ⊢ ⋃₀ ∅ = ∅
state_after: case a
z✝ : ZFSet
⊢ (⋃₀ ∅) z✝ ↔ ∅ z✝
tactic: ext
state_before: case a
z✝ : ZFSet
⊢ (⋃₀ ∅) z✝ ↔ ∅ z✝
state_after: no goals
tactic: simp
Theorem: Finset.sup'_const
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
a : α
⊢ (s.sup' H fun x => a) = a
state_after: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
a : α
⊢ (s.sup' H fun x => a) ≤ a

case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
a : α
⊢ a ≤ s.sup' H fun x => a
tactic: apply le_antisymm
Theorem: iteratedFDeriv_tsum_apply
File: Mathlib/Analysis/Calculus/SmoothSeries.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x✝ : E
y₀ y : 𝕜
N : ℕ∞
hf : ∀ (i : α), ContDiff 𝕜 N (f i)
hv : ∀ (k : ℕ), ↑k ≤ N → Summable (v k)
h'f : ∀ (k : ℕ) (i : α) (x : E), ↑k ≤ N → ‖iteratedFDeriv 𝕜 k (f i) x‖ ≤ v k i
k : ℕ
hk : ↑k ≤ N
x : E
⊢ iteratedFDeriv 𝕜 k (fun y => ∑' (n : α), f n y) x = ∑' (n : α), iteratedFDeriv 𝕜 k (f n) x
state_after: no goals
tactic: rw [iteratedFDeriv_tsum hf hv h'f hk]
Theorem: ZMod.valMinAbs_mul_two_eq_iff
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
a : ZMod n
⊢ a.valMinAbs * 2 = ↑n ↔ 2 * a.val = n
state_after: case zero
m n : ℕ
a : ZMod 0
⊢ a.valMinAbs * 2 = ↑0 ↔ 2 * a.val = 0

case succ
m n✝ n : ℕ
a : ZMod (n + 1)
⊢ a.valMinAbs * 2 = ↑(n + 1) ↔ 2 * a.val = n + 1
tactic: cases' n with n
state_before: case succ
m n✝ n : ℕ
a : ZMod (n + 1)
⊢ a.valMinAbs * 2 = ↑(n + 1) ↔ 2 * a.val = n + 1
state_after: case pos
m n✝ n : ℕ
a : ZMod (n + 1)
h : a.val ≤ n.succ / 2
⊢ a.valMinAbs * 2 = ↑(n + 1) ↔ 2 * a.val = n + 1

case neg
m n✝ n : ℕ
a : ZMod (n + 1)
h : ¬a.val ≤ n.succ / 2
⊢ a.valMinAbs * 2 = ↑(n + 1) ↔ 2 * a.val = n + 1
tactic: by_cases h : a.val ≤ n.succ / 2
state_before: case neg
m n✝ n : ℕ
a : ZMod (n + 1)
h : ¬a.val ≤ n.succ / 2
⊢ a.valMinAbs * 2 = ↑(n + 1) ↔ 2 * a.val = n + 1
state_after: m n✝ n : ℕ
a : ZMod (n + 1)
h : ¬a.val ≤ n.succ / 2
⊢ ¬a.valMinAbs * 2 = ↑(n + 1)

m n✝ n : ℕ
a : ZMod (n + 1)
h : ¬a.val ≤ n.succ / 2
⊢ 2 * a.val = n + 1 → a.val ≤ n.succ / 2
tactic: apply iff_of_false _ (mt _ h)
Theorem: Real.one_le_exp
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : 0 ≤ x
⊢ 1 ≤ rexp x
state_after: no goals
tactic: linarith [add_one_le_exp_of_nonneg hx]
Theorem: CauchySeq.tendsto_uniformity
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝ : Preorder β
u : β → α
h : CauchySeq u
⊢ Tendsto (Prod.map u u) atTop (𝓤 α)
state_after: no goals
tactic: simpa only [Tendsto, prod_map_map_eq', prod_atTop_atTop_eq] using h.right
Theorem: MeasureTheory.Measure.haar.prehaar_mem_haarProduct
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
⊢ prehaar (↑K₀) U ∈ haarProduct ↑K₀
state_after: case mk
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
hK : IsCompact K
a✝ : { carrier := K, isCompact' := hK } ∈ univ
⊢ prehaar (↑K₀) U { carrier := K, isCompact' := hK } ∈
    (fun K => Icc 0 ↑(index ↑K ↑K₀)) { carrier := K, isCompact' := hK }
tactic: rintro ⟨K, hK⟩ _
state_before: case mk
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
hK : IsCompact K
a✝ : { carrier := K, isCompact' := hK } ∈ univ
⊢ prehaar (↑K₀) U { carrier := K, isCompact' := hK } ∈
    (fun K => Icc 0 ↑(index ↑K ↑K₀)) { carrier := K, isCompact' := hK }
state_after: case mk
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
hK : IsCompact K
a✝ : { carrier := K, isCompact' := hK } ∈ univ
⊢ 0 ≤ prehaar (↑K₀) U { carrier := K, isCompact' := hK } ∧
    prehaar (↑K₀) U { carrier := K, isCompact' := hK } ≤ ↑(index ↑{ carrier := K, isCompact' := hK } ↑K₀)
tactic: rw [mem_Icc]
state_before: case mk
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
hK : IsCompact K
a✝ : { carrier := K, isCompact' := hK } ∈ univ
⊢ 0 ≤ prehaar (↑K₀) U { carrier := K, isCompact' := hK } ∧
    prehaar (↑K₀) U { carrier := K, isCompact' := hK } ≤ ↑(index ↑{ carrier := K, isCompact' := hK } ↑K₀)
state_after: no goals
tactic: exact ⟨prehaar_nonneg K₀ _, prehaar_le_index K₀ _ hU⟩
Theorem: Real.continuousAt_const_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

Proof steps:
state_before: a b : ℝ
h : a ≠ 0
⊢ ContinuousAt (fun x => a ^ x) b
state_after: a b : ℝ
h : a ≠ 0
⊢ ContinuousAt (fun x => (↑a ^ ↑x).re) b
tactic: simp only [rpow_def]
state_before: a b : ℝ
h : a ≠ 0
⊢ ContinuousAt (fun x => (↑a ^ ↑x).re) b
state_after: a b : ℝ
h : a ≠ 0
⊢ ContinuousAt (fun x => ↑a ^ ↑x) b
tactic: refine Complex.continuous_re.continuousAt.comp ?_
state_before: a b : ℝ
h : a ≠ 0
⊢ ContinuousAt (fun x => ↑a ^ ↑x) b
state_after: a b : ℝ
h : a ≠ 0
⊢ ↑a ≠ 0
tactic: refine (continuousAt_const_cpow ?_).comp Complex.continuous_ofReal.continuousAt
state_before: a b : ℝ
h : a ≠ 0
⊢ ↑a ≠ 0
state_after: no goals
tactic: norm_cast
Theorem: contDiffWithinAt_zero
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
hx : x ∈ s
⊢ ContDiffWithinAt 𝕜 0 f s x ↔ ∃ u ∈ 𝓝[s] x, ContinuousOn f (s ∩ u)
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
hx : x ∈ s
⊢ ContDiffWithinAt 𝕜 0 f s x → ∃ u ∈ 𝓝[s] x, ContinuousOn f (s ∩ u)

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
hx : x ∈ s
⊢ (∃ u ∈ 𝓝[s] x, ContinuousOn f (s ∩ u)) → ContDiffWithinAt 𝕜 0 f s x
tactic: constructor
Theorem: HomologicalComplex₂.d₂_eq_zero
File: Mathlib/Algebra/Homology/TotalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ : I₁
i₂ : I₂
i₁₂ : I₁₂
h : ¬c₂.Rel i₂ (c₂.next i₂)
⊢ K.d₂ c₁₂ i₁ i₂ i₁₂ = 0
state_after: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ : I₁
i₂ : I₂
i₁₂ : I₁₂
h : ¬c₂.Rel i₂ (c₂.next i₂)
⊢ c₁.ε₂ c₂ c₁₂ (i₁, i₂) •
      (K.X i₁).d i₂ (c₂.next i₂) ≫ K.toGradedObject.ιMapObjOrZero (c₁.π c₂ c₁₂) (i₁, c₂.next i₂) i₁₂ =
    0
tactic: dsimp [d₂]
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ : I₁
i₂ : I₂
i₁₂ : I₁₂
h : ¬c₂.Rel i₂ (c₂.next i₂)
⊢ c₁.ε₂ c₂ c₁₂ (i₁, i₂) •
      (K.X i₁).d i₂ (c₂.next i₂) ≫ K.toGradedObject.ιMapObjOrZero (c₁.π c₂ c₁₂) (i₁, c₂.next i₂) i₁₂ =
    0
state_after: no goals
tactic: rw [HomologicalComplex.shape _ _ _ h, zero_comp, smul_zero]
Theorem: Polynomial.lifts_iff_liftsRing
File: Mathlib/Algebra/Polynomial/Lifts.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Ring R
S : Type v
inst✝ : Ring S
f : R →+* S
p : S[X]
⊢ p ∈ lifts f ↔ p ∈ liftsRing f
state_after: no goals
tactic: simp only [lifts, liftsRing, RingHom.mem_range, RingHom.mem_rangeS]
Theorem: measurableSet_pi_of_nonempty
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u : Set α
π : δ → Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
s : Set δ
t : (i : δ) → Set (π i)
hs : s.Countable
h : (s.pi t).Nonempty
⊢ MeasurableSet (s.pi t) ↔ ∀ i ∈ s, MeasurableSet (t i)
state_after: no goals
tactic: classical
    rcases h with ⟨f, hf⟩
    refine ⟨fun hst i hi => ?_, MeasurableSet.pi hs⟩
    convert measurable_update f (a := i) hst
    rw [update_preimage_pi hi]
    exact fun j hj _ => hf j hj
Theorem: List.Palindrome.of_reverse_eq
File: Mathlib/Data/List/Palindrome.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l✝ l : List α
⊢ l.reverse = l → l.Palindrome
state_after: α : Type u_1
β : Type u_2
l✝ l : List α
⊢ ∀ (a : α) (l : List α) (b : α),
    (l.reverse = l → l.Palindrome) → (a :: (l ++ [b])).reverse = a :: (l ++ [b]) → (a :: (l ++ [b])).Palindrome
tactic: refine bidirectionalRecOn l (fun _ => Palindrome.nil) (fun a _ => Palindrome.singleton a) ?_
state_before: α : Type u_1
β : Type u_2
l✝ l : List α
⊢ ∀ (a : α) (l : List α) (b : α),
    (l.reverse = l → l.Palindrome) → (a :: (l ++ [b])).reverse = a :: (l ++ [b]) → (a :: (l ++ [b])).Palindrome
state_after: α : Type u_1
β : Type u_2
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : l.reverse = l → l.Palindrome
hr : (x :: (l ++ [y])).reverse = x :: (l ++ [y])
⊢ (x :: (l ++ [y])).Palindrome
tactic: intro x l y hp hr
state_before: α : Type u_1
β : Type u_2
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : l.reverse = l → l.Palindrome
hr : (x :: (l ++ [y])).reverse = x :: (l ++ [y])
⊢ (x :: (l ++ [y])).Palindrome
state_after: α : Type u_1
β : Type u_2
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : l.reverse = l → l.Palindrome
hr : [y].reverse ++ l.reverse ++ [x] = x :: (l ++ [y])
⊢ (x :: (l ++ [y])).Palindrome
tactic: rw [reverse_cons, reverse_append] at hr
state_before: α : Type u_1
β : Type u_2
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : l.reverse = l → l.Palindrome
hr : [y].reverse ++ l.reverse ++ [x] = x :: (l ++ [y])
⊢ (x :: (l ++ [y])).Palindrome
state_after: α : Type u_1
β : Type u_2
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : l.reverse = l → l.Palindrome
hr : [y].reverse ++ l.reverse ++ [x] = x :: (l ++ [y])
⊢ (x :: (l ++ [x])).Palindrome
tactic: rw [head_eq_of_cons_eq hr]
state_before: α : Type u_1
β : Type u_2
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : l.reverse = l → l.Palindrome
hr : [y].reverse ++ l.reverse ++ [x] = x :: (l ++ [y])
⊢ (x :: (l ++ [x])).Palindrome
state_after: α : Type u_1
β : Type u_2
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : l.reverse = l → l.Palindrome
hr : [y].reverse ++ l.reverse ++ [x] = x :: (l ++ [y])
this : l.Palindrome
⊢ (x :: (l ++ [x])).Palindrome
tactic: have : Palindrome l := hp (append_inj_left' (tail_eq_of_cons_eq hr) rfl)
state_before: α : Type u_1
β : Type u_2
l✝¹ l✝ : List α
x : α
l : List α
y : α
hp : l.reverse = l → l.Palindrome
hr : [y].reverse ++ l.reverse ++ [x] = x :: (l ++ [y])
this : l.Palindrome
⊢ (x :: (l ++ [x])).Palindrome
state_after: no goals
tactic: exact Palindrome.cons_concat x this
Theorem: RatFunc.single_one_eq_pow
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R✝ : Type u_1
F : Type u
inst✝¹ : Field F
p q : F[X]
f g : RatFunc F
R : Type u_2
inst✝ : Ring R
n : ℕ
⊢ (single ↑n) 1 = (single 1) 1 ^ n
state_after: case zero
R✝ : Type u_1
F : Type u
inst✝¹ : Field F
p q : F[X]
f g : RatFunc F
R : Type u_2
inst✝ : Ring R
⊢ (single ↑0) 1 = (single 1) 1 ^ 0

case succ
R✝ : Type u_1
F : Type u
inst✝¹ : Field F
p q : F[X]
f g : RatFunc F
R : Type u_2
inst✝ : Ring R
n : ℕ
h_ind : (single ↑n) 1 = (single 1) 1 ^ n
⊢ (single ↑(n + 1)) 1 = (single 1) 1 ^ (n + 1)
tactic: induction' n with n h_ind
Theorem: AffineBasis.coord_apply
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
k : Type u_3
V : Type u_4
P : Type u_5
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
s : Finset ι
i✝ j✝ : ι
e : ι ≃ ι'
inst✝ : DecidableEq ι
i j : ι
⊢ (b.coord i) (b j) = if i = j then 1 else 0
state_after: no goals
tactic: rcases eq_or_ne i j with h | h <;> simp [h]
Theorem: UpperHalfPlane.image_coe_ball
File: Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean

Proof steps:
state_before: z✝ w : ℍ
r✝ R : ℝ
z : ℍ
r : ℝ
⊢ UpperHalfPlane.coe '' ball z r = ball (↑(z.center r)) (z.im * Real.sinh r)
state_after: case h
z✝ w✝ : ℍ
r✝ R : ℝ
z : ℍ
r : ℝ
w : ℂ
⊢ w ∈ UpperHalfPlane.coe '' ball z r ↔ w ∈ ball (↑(z.center r)) (z.im * Real.sinh r)
tactic: ext w
state_before: case h
z✝ w✝ : ℍ
r✝ R : ℝ
z : ℍ
r : ℝ
w : ℂ
⊢ w ∈ UpperHalfPlane.coe '' ball z r ↔ w ∈ ball (↑(z.center r)) (z.im * Real.sinh r)
state_after: case h.mp
z✝ w✝ : ℍ
r✝ R : ℝ
z : ℍ
r : ℝ
w : ℂ
⊢ w ∈ UpperHalfPlane.coe '' ball z r → w ∈ ball (↑(z.center r)) (z.im * Real.sinh r)

case h.mpr
z✝ w✝ : ℍ
r✝ R : ℝ
z : ℍ
r : ℝ
w : ℂ
⊢ w ∈ ball (↑(z.center r)) (z.im * Real.sinh r) → w ∈ UpperHalfPlane.coe '' ball z r
tactic: constructor