ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Even.nsmul
File: Mathlib/Algebra/Group/Even.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : Monoid α
n✝ : ℕ
a : α
n : ℕ
⊢ IsSquare a → IsSquare (a ^ n)
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : Monoid α
n✝ n : ℕ
a : α
⊢ IsSquare ((a * a) ^ n)
tactic: rintro ⟨a, rfl⟩
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : Monoid α
n✝ n : ℕ
a : α
⊢ IsSquare ((a * a) ^ n)
state_after: no goals
tactic: exact ⟨a ^ n, (Commute.refl _).mul_pow _⟩
Theorem: ForInStep.bind_yield_bindList
File: .lake/packages/batteries/Batteries/Control/ForInStep/Lemmas.lean

Proof steps:
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
f : α → β → m (ForInStep β)
s : ForInStep β
l : List α
⊢ (s.bind fun a => bindList f l (yield a)) = bindList f l s
state_after: no goals
tactic: cases s <;> simp
Theorem: ContinuousAt.comp₂_continuousWithinAt_of_eq
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 δ
f : β × γ → δ
g : α → β
h : α → γ
x : α
s : Set α
y : β × γ
hf : ContinuousAt f y
hg : ContinuousWithinAt g s x
hh : ContinuousWithinAt h s x
e : (g x, h x) = y
⊢ ContinuousWithinAt (fun x => f (g x, h x)) s x
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 δ
f : β × γ → δ
g : α → β
h : α → γ
x : α
s : Set α
y : β × γ
hf : ContinuousAt f (g x, h x)
hg : ContinuousWithinAt g s x
hh : ContinuousWithinAt h s x
e : (g x, h x) = y
⊢ ContinuousWithinAt (fun x => f (g x, h x)) s x
tactic: rw [← e] at hf
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 δ
f : β × γ → δ
g : α → β
h : α → γ
x : α
s : Set α
y : β × γ
hf : ContinuousAt f (g x, h x)
hg : ContinuousWithinAt g s x
hh : ContinuousWithinAt h s x
e : (g x, h x) = y
⊢ ContinuousWithinAt (fun x => f (g x, h x)) s x
state_after: no goals
tactic: exact hf.comp₂_continuousWithinAt hg hh
Theorem: MvPolynomial.vars_C
File: Mathlib/Algebra/MvPolynomial/Variables.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
⊢ (C r).vars = ∅
state_after: no goals
tactic: classical rw [vars_def, degrees_C, Multiset.toFinset_zero]
Theorem: List.dropLast_append_getLast?
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
c : α
hc : c ∈ (a :: b :: l).getLast?
⊢ (a :: b :: l).dropLast ++ [c] = a :: b :: l
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
c : α
hc : c ∈ (b :: l).getLast?
⊢ (a :: b :: l).dropLast ++ [c] = a :: b :: l
tactic: rw [getLast?_cons_cons] at hc
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
c : α
hc : c ∈ (b :: l).getLast?
⊢ (a :: b :: l).dropLast ++ [c] = a :: b :: l
state_after: no goals
tactic: rw [dropLast_cons₂, cons_append, dropLast_append_getLast? _ hc]
Theorem: Finset.forall_mem_map
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s✝ : Finset α
f : α ↪ β
s : Finset α
p : (a : β) → a ∈ map f s → Prop
h : ∀ (x : α) (H : x ∈ s), p (f x) ⋯
x : β
hx : x ∈ map f s
⊢ p x hx
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s✝ : Finset α
f : α ↪ β
s : Finset α
p : (a : β) → a ∈ map f s → Prop
h : ∀ (x : α) (H : x ∈ s), p (f x) ⋯
y : α
hy : y ∈ s
hx : f y ∈ map f s
⊢ p (f y) hx
tactic: obtain ⟨y, hy, rfl⟩ := mem_map.1 hx
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : α ↪ β
s✝ : Finset α
f : α ↪ β
s : Finset α
p : (a : β) → a ∈ map f s → Prop
h : ∀ (x : α) (H : x ∈ s), p (f x) ⋯
y : α
hy : y ∈ s
hx : f y ∈ map f s
⊢ p (f y) hx
state_after: no goals
tactic: exact h _ hy
Theorem: Filter.comap_sup
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ comap m (g₁ ⊔ g₂) = comap m g₁ ⊔ comap m g₂
state_after: no goals
tactic: rw [sup_eq_iSup, comap_iSup, iSup_bool_eq, Bool.cond_true, Bool.cond_false]
Theorem: Int.emod_two_ne_zero
File: Mathlib/Algebra/Group/Int.lean

Proof steps:
state_before: u v m n : ℤ
⊢ ¬n % 2 = 0 ↔ n % 2 = 1
state_after: no goals
tactic: cases' emod_two_eq_zero_or_one n with h h <;> simp [h]
Theorem: coplanar_insert_iff_of_mem_affineSpan
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
p : P
h : p ∈ affineSpan k s
⊢ Coplanar k (insert p s) ↔ Coplanar k s
state_after: no goals
tactic: rw [Coplanar, Coplanar, vectorSpan_insert_eq_vectorSpan h]
Theorem: monovary_iff_smul_rearrangement
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
f : ι → α
g : ι → β
s : Set ι
a a₁ a₂ : α
b b₁ b₂ : β
⊢ (∀ ⦃i : ι⦄, i ∈ Set.univ → ∀ ⦃j : ι⦄, j ∈ Set.univ → f i • g j + f j • g i ≤ f i • g i + f j • g j) ↔
    ∀ (i j : ι), f i • g j + f j • g i ≤ f i • g i + f j • g j
state_after: no goals
tactic: simp only [Set.mem_univ, forall_true_left]
Theorem: CauSeq.add_limZero
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
hf : f.LimZero
hg : g.LimZero
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ j ≥ i, abv (↑f j) < ε / 2 ∧ abv (↑g j) < ε / 2
j : ℕ
ij : j ≥ i
⊢ abv (↑(f + g) j) < ε
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
hf : f.LimZero
hg : g.LimZero
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ j ≥ i, abv (↑f j) < ε / 2 ∧ abv (↑g j) < ε / 2
j : ℕ
ij : j ≥ i
H₁ : abv (↑f j) < ε / 2
H₂ : abv (↑g j) < ε / 2
⊢ abv (↑(f + g) j) < ε
tactic: let ⟨H₁, H₂⟩ := H _ ij
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
hf : f.LimZero
hg : g.LimZero
ε : α
ε0 : ε > 0
i : ℕ
H : ∀ j ≥ i, abv (↑f j) < ε / 2 ∧ abv (↑g j) < ε / 2
j : ℕ
ij : j ≥ i
H₁ : abv (↑f j) < ε / 2
H₂ : abv (↑g j) < ε / 2
⊢ abv (↑(f + g) j) < ε
state_after: no goals
tactic: simpa [add_halves ε] using lt_of_le_of_lt (abv_add abv _ _) (add_lt_add H₁ H₂)
Theorem: CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction_counit_app
File: Mathlib/CategoryTheory/Monad/Monadicity.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
G : D ⥤ C
F : C ⥤ D
adj : F ⊣ G
inst✝ : ∀ (A : adj.toMonad.Algebra), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ (comparisonAdjunction adj).counit.app B =
    colimit.desc (parallelPair (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B))))
      (counitCofork adj B)
state_after: case h
C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
G : D ⥤ C
F : C ⥤ D
adj : F ⊣ G
inst✝ : ∀ (A : adj.toMonad.Algebra), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      (comparisonAdjunction adj).counit.app B =
    coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      colimit.desc (parallelPair (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B))))
        (counitCofork adj B)
tactic: apply coequalizer.hom_ext
state_before: case h
C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
G : D ⥤ C
F : C ⥤ D
adj : F ⊣ G
inst✝ : ∀ (A : adj.toMonad.Algebra), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      (comparisonAdjunction adj).counit.app B =
    coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      colimit.desc (parallelPair (F.map (G.map (adj.counit.app B))) (adj.counit.app (F.obj (G.obj B))))
        (counitCofork adj B)
state_after: case h
C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
G : D ⥤ C
F : C ⥤ D
adj : F ⊣ G
inst✝ : ∀ (A : adj.toMonad.Algebra), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      coequalizer.desc ((adj.homEquiv (G.obj B) B).symm (𝟙 (G.obj B))) ⋯ =
    coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      coequalizer.desc (adj.counit.app B) ⋯
tactic: change
    coequalizer.π _ _ ≫ coequalizer.desc ((adj.homEquiv _ B).symm (𝟙 _)) _ =
      coequalizer.π _ _ ≫ coequalizer.desc _ _
state_before: case h
C : Type u₁
D : Type u₂
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₁, u₂} D
G : D ⥤ C
F : C ⥤ D
adj : F ⊣ G
inst✝ : ∀ (A : adj.toMonad.Algebra), HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))
B : D
⊢ coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      coequalizer.desc ((adj.homEquiv (G.obj B) B).symm (𝟙 (G.obj B))) ⋯ =
    coequalizer.π (F.map ((comparison adj).obj B).a) (adj.counit.app (F.obj ((comparison adj).obj B).A)) ≫
      coequalizer.desc (adj.counit.app B) ⋯
state_after: no goals
tactic: simp
Theorem: MeasureTheory.OuterMeasure.smul_boundedBy
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

Proof steps:
state_before: α : Type u_1
m : Set α → ℝ≥0∞
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ c • boundedBy m = boundedBy (c • m)
state_after: α : Type u_1
m : Set α → ℝ≥0∞
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ OuterMeasure.ofFunction (c • fun s => ⨆ (_ : s.Nonempty), m s) ⋯ =
    OuterMeasure.ofFunction (fun s => ⨆ (_ : s.Nonempty), (c • m) s) ⋯
tactic: simp only [boundedBy , smul_ofFunction hc]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ OuterMeasure.ofFunction (c • fun s => ⨆ (_ : s.Nonempty), m s) ⋯ =
    OuterMeasure.ofFunction (fun s => ⨆ (_ : s.Nonempty), (c • m) s) ⋯
state_after: case e_m.h
α : Type u_1
m : Set α → ℝ≥0∞
c : ℝ≥0∞
hc : c ≠ ⊤
s : Set α
⊢ (c • fun s => ⨆ (_ : s.Nonempty), m s) s = ⨆ (_ : s.Nonempty), (c • m) s
tactic: congr 1 with s : 1
state_before: case e_m.h
α : Type u_1
m : Set α → ℝ≥0∞
c : ℝ≥0∞
hc : c ≠ ⊤
s : Set α
⊢ (c • fun s => ⨆ (_ : s.Nonempty), m s) s = ⨆ (_ : s.Nonempty), (c • m) s
state_after: no goals
tactic: rcases s.eq_empty_or_nonempty with (rfl | hs) <;> simp [*]
Theorem: CategoryTheory.Idempotents.isIdempotentComplete_iff_hasEqualizer_of_id_and_idempotent
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ IsIdempotentComplete C ↔ ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ IsIdempotentComplete C → ∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ (∀ (X : C) (p : X ⟶ X), p ≫ p = p → HasEqualizer (𝟙 X) p) → IsIdempotentComplete C
tactic: constructor
Theorem: AddSubmonoid.LocalizationMap.add_mk'_zero_eq_mk'
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x : M
y : ↥S
⊢ f.toMap x * f.mk' 1 y = f.mk' x y
state_after: no goals
tactic: rw [mul_mk'_eq_mk'_of_mul, mul_one]
Theorem: rank_eq_of_equiv_equiv
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

Proof steps:
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
i : ZeroHom R R'
j : M ≃+ M₁
hi : Bijective ⇑i
hc : ∀ (r : R) (m : M), j (r • m) = i r • j m
⊢ Module.rank R M = Module.rank R' M₁
state_after: no goals
tactic: simpa only [lift_id] using lift_rank_eq_of_equiv_equiv i j hi hc
Theorem: Traversable.foldl_toList
File: Mathlib/Control/Fold.lean

Proof steps:
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
f : α → β → α
xs : t β
x : α
⊢ foldl f x xs = List.foldl f x (toList xs)
state_after: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
f : α → β → α
xs : t β
x : α
⊢ foldl f x xs = unop ((Foldl.ofFreeMonoid f) (FreeMonoid.ofList (toList xs))) x
tactic: rw [← FreeMonoid.toList_ofList (toList xs), ← foldl.unop_ofFreeMonoid]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : LawfulTraversable t
f : α → β → α
xs : t β
x : α
⊢ foldl f x xs = unop ((Foldl.ofFreeMonoid f) (FreeMonoid.ofList (toList xs))) x
state_after: no goals
tactic: simp only [foldl, toList_spec, foldMap_hom_free, foldl.ofFreeMonoid_comp_of, Foldl.get,
    FreeMonoid.ofList_toList]
Theorem: FinVec.sum_eq
File: Mathlib/Data/Fin/Tuple/Reflection.lean

Proof steps:
state_before: m n✝ : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : AddCommMonoid α
n : ℕ
a : Fin (n + 2) → α
⊢ sum a = ∑ i : Fin (n + 2), a i
state_after: no goals
tactic: rw [Fin.sum_univ_castSucc, sum, sum_eq]
Theorem: pow_eq_zero_iff'
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝² : MonoidWithZero M₀
a : M₀
m n : ℕ
inst✝¹ : NoZeroDivisors M₀
inst✝ : Nontrivial M₀
⊢ a ^ n = 0 ↔ a = 0 ∧ n ≠ 0
state_after: no goals
tactic: obtain rfl | hn := eq_or_ne n 0 <;> simp [*]
Theorem: exists_subset_affineIndependent_affineSpan_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : Set P
h : AffineIndependent k fun p => ↑p
⊢ ∃ t, s ⊆ t ∧ (AffineIndependent k fun p => ↑p) ∧ affineSpan k t = ⊤
state_after: case inl
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
h : AffineIndependent k fun p => ↑p
⊢ ∃ t, ∅ ⊆ t ∧ (AffineIndependent k fun p => ↑p) ∧ affineSpan k t = ⊤

case inr.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : Set P
h : AffineIndependent k fun p => ↑p
p₁ : P
hp₁ : p₁ ∈ s
⊢ ∃ t, s ⊆ t ∧ (AffineIndependent k fun p => ↑p) ∧ affineSpan k t = ⊤
tactic: rcases s.eq_empty_or_nonempty with (rfl | ⟨p₁, hp₁⟩)
Theorem: Sum.elim_one_mulSingle
File: Mathlib/Algebra/Group/Pi/Basic.lean

Proof steps:
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f i
i✝ : I
a a' : α → γ
b b' : β → γ
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : One γ
i : β
c : γ
⊢ Sum.elim 1 (Pi.mulSingle i c) = Pi.mulSingle (inr i) c
state_after: no goals
tactic: simp only [Pi.mulSingle, Sum.elim_update_right, elim_one_one]
Theorem: EquicontinuousOn.uniformInducing_uniformOnFun_iff_pi'
File: Mathlib/Topology/UniformSpace/Ascoli.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
F : ι → X → α
G : ι → β → α
inst✝ : UniformSpace ι
𝔖 : Set (Set X)
𝔖_compact : ∀ K ∈ 𝔖, IsCompact K
F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K
⊢ UniformInducing (⇑(UniformOnFun.ofFun 𝔖) ∘ F) ↔ UniformInducing ((⋃₀ 𝔖).restrict ∘ F)
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
F : ι → X → α
G : ι → β → α
inst✝ : UniformSpace ι
𝔖 : Set (Set X)
𝔖_compact : ∀ K ∈ 𝔖, IsCompact K
F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K
⊢ UniformSpace.comap (⇑(UniformOnFun.ofFun 𝔖) ∘ F) (UniformOnFun.uniformSpace X α 𝔖) = inst✝ ↔
    UniformSpace.comap F (UniformOnFun.uniformSpace X α 𝔖) = inst✝
tactic: rw [uniformInducing_iff_uniformSpace, uniformInducing_iff_uniformSpace,
      ← EquicontinuousOn.comap_uniformOnFun_eq 𝔖_compact F_eqcont]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
F : ι → X → α
G : ι → β → α
inst✝ : UniformSpace ι
𝔖 : Set (Set X)
𝔖_compact : ∀ K ∈ 𝔖, IsCompact K
F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K
⊢ UniformSpace.comap (⇑(UniformOnFun.ofFun 𝔖) ∘ F) (UniformOnFun.uniformSpace X α 𝔖) = inst✝ ↔
    UniformSpace.comap F (UniformOnFun.uniformSpace X α 𝔖) = inst✝
state_after: no goals
tactic: rfl
Theorem: FinPartOrd.Iso.mk_hom
File: Mathlib/Order/Category/FinPartOrd.lean

Proof steps:
state_before: α β : FinPartOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
⊢ ↑e ≫ ↑e.symm = 𝟙 α
state_after: case w
α β : FinPartOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
x✝ : (forget FinPartOrd).obj α
⊢ (↑e ≫ ↑e.symm) x✝ = (𝟙 α) x✝
tactic: ext
state_before: case w
α β : FinPartOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
x✝ : (forget FinPartOrd).obj α
⊢ (↑e ≫ ↑e.symm) x✝ = (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : FinPartOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
⊢ ↑e.symm ≫ ↑e = 𝟙 β
state_after: case w
α β : FinPartOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
x✝ : (forget FinPartOrd).obj β
⊢ (↑e.symm ≫ ↑e) x✝ = (𝟙 β) x✝
tactic: ext
state_before: case w
α β : FinPartOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
x✝ : (forget FinPartOrd).obj β
⊢ (↑e.symm ≫ ↑e) x✝ = (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: Filter.tendsto_const_mul_pow_atBot_iff
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r c : α
n : ℕ
⊢ Tendsto (fun x => c * x ^ n) atTop atBot ↔ n ≠ 0 ∧ c < 0
state_after: no goals
tactic: simp only [← tendsto_neg_atTop_iff, ← neg_mul, tendsto_const_mul_pow_atTop_iff, neg_pos]
Theorem: AddCircle.intervalIntegral_preimage
File: Mathlib/MeasureTheory/Integral/Periodic.lean

Proof steps:
state_before: T : ℝ
hT : Fact (0 < T)
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
t : ℝ
f : AddCircle T → E
⊢ ∫ (a : ℝ) in t..t + T, f ↑a = ∫ (b : AddCircle T), f b
state_after: T : ℝ
hT : Fact (0 < T)
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
t : ℝ
f : AddCircle T → E
⊢ t ≤ t + T
tactic: rw [integral_of_le, AddCircle.integral_preimage T t f]
state_before: T : ℝ
hT : Fact (0 < T)
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
t : ℝ
f : AddCircle T → E
⊢ t ≤ t + T
state_after: no goals
tactic: linarith [hT.out]
Theorem: LinearMap.BilinForm.apply_dualBasis_right
File: Mathlib/LinearAlgebra/BilinearForm/Properties.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁴ : CommRing R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝¹¹ : Field K
inst✝¹⁰ : AddCommGroup V
inst✝⁹ : Module K V
M'✝ : Type u_7
M'' : Type u_8
inst✝⁸ : AddCommMonoid M'✝
inst✝⁷ : AddCommMonoid M''
inst✝⁶ : Module R M'✝
inst✝⁵ : Module R M''
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type u_9
inst✝⁴ : AddCommMonoid M'
inst✝³ : Module R M'
inst✝² : FiniteDimensional K V
ι : Type u_10
inst✝¹ : DecidableEq ι
inst✝ : Finite ι
B : BilinForm K V
hB : B.Nondegenerate
sym : B.IsSymm
b : Basis ι K V
i j : ι
⊢ (B (b i)) ((B.dualBasis hB b) j) = if i = j then 1 else 0
state_after: no goals
tactic: rw [sym.eq, apply_dualBasis_left]
Theorem: ball_pi'
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α
π : β → Type u_3
inst✝² : Fintype β
inst✝¹ : (b : β) → PseudoMetricSpace (π b)
inst✝ : Nonempty β
x : (b : β) → π b
r : ℝ
hr : r ≤ 0
⊢ ball x r = Set.univ.pi fun b => ball (x b) r
state_after: no goals
tactic: simp [ball_eq_empty.2 hr]
Theorem: Nat.sum_divisors
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
n : ℕ
hn : n ≠ 0
⊢ ∑ d ∈ n.divisors, d = ∏ p ∈ n.primeFactors, ∑ k ∈ range (n.factorization p + 1), p ^ k
state_after: R : Type u_1
n : ℕ
hn : n ≠ 0
⊢ (n.factorization.prod fun p k => (σ 1) (p ^ k)) = ∏ p ∈ n.primeFactors, ∑ k ∈ range (n.factorization p + 1), p ^ k
tactic: rw [← sigma_one_apply, isMultiplicative_sigma.multiplicative_factorization _ hn]
state_before: R : Type u_1
n : ℕ
hn : n ≠ 0
⊢ (n.factorization.prod fun p k => (σ 1) (p ^ k)) = ∏ p ∈ n.primeFactors, ∑ k ∈ range (n.factorization p + 1), p ^ k
state_after: no goals
tactic: exact Finset.prod_congr n.support_factorization fun _ h =>
    sigma_one_apply_prime_pow <| Nat.prime_of_mem_primeFactors h
Theorem: Primrec.list_map
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → List β
g : α → β → σ
hf : Primrec f
hg : Primrec₂ g
a : α
⊢ List.foldr (fun b s => g (a, b, s).1 (a, b, s).2.1 :: (a, b, s).2.2) [] (f a) = List.map (g a) (f a)
state_after: no goals
tactic: induction f a <;> simp [*]
Theorem: Polynomial.Chebyshev.U_sub_one
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
⊢ U R (n - 1) = 2 * X * U R n - U R (n + 1)
state_after: no goals
tactic: linear_combination (norm := ring_nf) U_add_two R (n - 1)
Theorem: IsGroupHom.image_subgroup
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁✝ a₂✝ b c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a₁ a₂ : H
x✝¹ : a₁ ∈ f '' s
x✝ : a₂ ∈ f '' s
b₁ : G
hb₁ : b₁ ∈ s
eq₁ : f b₁ = a₁
b₂ : G
hb₂ : b₂ ∈ s
eq₂ : f b₂ = a₂
⊢ f (b₁ * b₂) = a₁ * a₂
state_after: no goals
tactic: simp [eq₁, eq₂, hf.map_mul]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ f b⁻¹ = a⁻¹
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ (f b)⁻¹ = a⁻¹
tactic: rw [hf.map_inv]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
s : Set G
hs : IsSubgroup s
a : H
x✝ : a ∈ f '' s
b : G
hb : b ∈ s
Eq : f b = a
⊢ (f b)⁻¹ = a⁻¹
state_after: no goals
tactic: simp [*]