1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.mem_argmax_iff
File: Mathlib/Data/List/MinMax.lean

tactic: rintro ⟨hml, ham, hma⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder β
f : α → β
l : List α
o : Option α
a m : α
inst✝ : DecidableEq α
⊢ (m ∈ l ∧ (∀ (a : α), a ∈ l → f a ≤ f m) ∧ ∀ (a : α), a ∈ l → f m ≤ f a → indexOf m l ≤ indexOf a l) → m ∈ argmax f l
state_after: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder β
f : α → β
l : List α
o : Option α
a m : α
inst✝ : DecidableEq α
hml : m ∈ l
ham : ∀ (a : α), a ∈ l → f a ≤ f m
hma : ∀ (a : α), a ∈ l → f m ≤ f a → indexOf m l ≤ indexOf a l
⊢ m ∈ argmax f l

tactic: cases' harg : argmax f l with n
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder β
f : α → β
l : List α
o : Option α
a m : α
inst✝ : DecidableEq α
hml : m ∈ l
ham : ∀ (a : α), a ∈ l → f a ≤ f m
hma : ∀ (a : α), a ∈ l → f m ≤ f a → indexOf m l ≤ indexOf a l
⊢ m ∈ argmax f l
state_after: case intro.intro.none
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder β
f : α → β
l : List α
o : Option α
a m : α
inst✝ : DecidableEq α
hml : m ∈ l
ham : ∀ (a : α), a ∈ l → f a ≤ f m
hma : ∀ (a : α), a ∈ l → f m ≤ f a → indexOf m l ≤ indexOf a l
harg : argmax f l = none
⊢ m ∈ none

case intro.intro.some
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder β
f : α → β
l : List α
o : Option α
a m : α
inst✝ : DecidableEq α
hml : m ∈ l
ham : ∀ (a : α), a ∈ l → f a ≤ f m
hma : ∀ (a : α), a ∈ l → f m ≤ f a → indexOf m l ≤ indexOf a l
n : α
harg : argmax f l = some n
⊢ m ∈ some n

tactic: simp_all
state_before: case intro.intro.none
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder β
f : α → β
l : List α
o : Option α
a m : α
inst✝ : DecidableEq α
hml : m ∈ l
ham : ∀ (a : α), a ∈ l → f a ≤ f m
hma : ∀ (a : α), a ∈ l → f m ≤ f a → indexOf m l ≤ indexOf a l
harg : argmax f l = none
⊢ m ∈ none
state_after: no goals

tactic: have :=
  _root_.le_antisymm (hma n (argmax_mem harg) (le_of_mem_argmax hml harg))
    (index_of_argmax harg hml (ham _ (argmax_mem harg)))
state_before: case intro.intro.some
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder β
f : α → β
l : List α
o : Option α
a m : α
inst✝ : DecidableEq α
hml : m ∈ l
ham : ∀ (a : α), a ∈ l → f a ≤ f m
hma : ∀ (a : α), a ∈ l → f m ≤ f a → indexOf m l ≤ indexOf a l
n : α
harg : argmax f l = some n
⊢ m ∈ some n
state_after: case intro.intro.some
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder β
f : α → β
l : List α
o : Option α
a m : α
inst✝ : DecidableEq α
hml : m ∈ l
ham : ∀ (a : α), a ∈ l → f a ≤ f m
hma : ∀ (a : α), a ∈ l → f m ≤ f a → indexOf m l ≤ indexOf a l
n : α
harg : argmax f l = some n
this : indexOf m l = indexOf n l
⊢ m ∈ some n

tactic: rw [(indexOf_inj hml (argmax_mem harg)).1 this, Option.mem_def]
state_before: case intro.intro.some
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder β
f : α → β
l : List α
o : Option α
a m : α
inst✝ : DecidableEq α
hml : m ∈ l
ham : ∀ (a : α), a ∈ l → f a ≤ f m
hma : ∀ (a : α), a ∈ l → f m ≤ f a → indexOf m l ≤ indexOf a l
n : α
harg : argmax f l = some n
this : indexOf m l = indexOf n l
⊢ m ∈ some n
state_after: no goals
Theorem: Primrec.list_join
File: Mathlib/Computability/Primrec.lean

tactic: dsimp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List (List α)
⊢ List.foldr (fun b s => (fun x x_1 => x ++ x_1) (l, b, s).2.1 (l, b, s).2.2) [] (id l) = l.join
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List (List α)
⊢ List.foldr (fun b s => b ++ s) [] l = l.join

tactic: induction l <;> simp [*]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List (List α)
⊢ List.foldr (fun b s => b ++ s) [] l = l.join
state_after: no goals
Theorem: Polynomial.newtonMap_apply_of_not_isUnit
File: Mathlib/Dynamics/Newton.lean

tactic: simp [newtonMap_apply, Ring.inverse, h]
state_before: R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
x : S
h : ¬IsUnit ((aeval x) (derivative P))
⊢ P.newtonMap x = x
state_after: no goals
Theorem: Orthonormal.equiv_refl
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [Orthonormal.equiv_apply, Equiv.coe_refl, id, LinearIsometryEquiv.coe_refl]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁸ : _root_.RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
ι : Type u_4
ι' : Type u_5
ι'' : Type u_6
E' : Type u_7
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
E'' : Type u_8
inst✝¹ : NormedAddCommGroup E''
inst✝ : InnerProductSpace 𝕜 E''
v : Basis ι 𝕜 E
hv : Orthonormal 𝕜 ⇑v
i : ι
⊢ (hv.equiv hv (Equiv.refl ι)) (v i) = (LinearIsometryEquiv.refl 𝕜 E) (v i)
state_after: no goals
Theorem: CategoryTheory.Sieve.le_pullback_bind
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: rw [← galoisConnection f]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
f : Y ⟶ X
h : S f
⊢ R h ≤ pullback f (bind S R)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
f : Y ⟶ X
h : S f
⊢ pushforward f (R h) ≤ bind S R

tactic: apply pushforward_le_bind_of_mem
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
f : Y ⟶ X
h : S f
⊢ pushforward f (R h) ≤ bind S R
state_after: no goals
Theorem: nsmul_eq_mul'
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: induction n with
| zero => rw [zero_nsmul, Nat.cast_zero, mul_zero]
| succ n ih => rw [succ_nsmul, ih, Nat.cast_succ, mul_add, mul_one]
state_before: α : Type u_1
β : Type u_2
inst✝ : NonAssocSemiring α
a : α
n : ℕ
⊢ n • a = a * ↑n
state_after: no goals

tactic: rw [zero_nsmul, Nat.cast_zero, mul_zero]
state_before: case zero
α : Type u_1
β : Type u_2
inst✝ : NonAssocSemiring α
a : α
⊢ 0 • a = a * ↑0
state_after: no goals

tactic: rw [succ_nsmul, ih, Nat.cast_succ, mul_add, mul_one]
state_before: case succ
α : Type u_1
β : Type u_2
inst✝ : NonAssocSemiring α
a : α
n : ℕ
ih : n • a = a * ↑n
⊢ (n + 1) • a = a * ↑(n + 1)
state_after: no goals
Theorem: Holor.cast_type
File: Mathlib/Data/Holor.lean

tactic: subst eq
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
eq : ds₁ = ds₂
a : Holor α ds₁
⊢ cast ⋯ a = fun t => a (cast ⋯ t)
state_after: α : Type
d : ℕ
ds ds₁ ds₃ : List ℕ
a : Holor α ds₁
⊢ cast ⋯ a = fun t => a (cast ⋯ t)

tactic: rfl
state_before: α : Type
d : ℕ
ds ds₁ ds₃ : List ℕ
a : Holor α ds₁
⊢ cast ⋯ a = fun t => a (cast ⋯ t)
state_after: no goals
Theorem: ENNReal.inv_lt_one
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rw [inv_lt_iff_inv_lt, inv_one]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a⁻¹ < 1 ↔ 1 < a
state_after: no goals
Theorem: CategoryTheory.OplaxNatTrans.whiskerLeft_naturality_comp
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation.lean

tactic: simp_rw [← whiskerLeft_comp, naturality_comp]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f : a' ⟶ (↑G.toPrelaxFunctor).obj a
g : a ⟶ b
h : b ⟶ c
⊢ f ◁ θ.naturality (g ≫ h) ≫ f ◁ θ.app a ◁ H.mapComp g h =
    f ◁ G.mapComp g h ▷ θ.app c ≫
      f ◁ (α_ ((↑G.toPrelaxFunctor).map g) ((↑G.toPrelaxFunctor).map h) (θ.app c)).hom ≫
        f ◁ (↑G.toPrelaxFunctor).map g ◁ θ.naturality h ≫
          f ◁ (α_ ((↑G.toPrelaxFunctor).map g) (θ.app b) ((↑H.toPrelaxFunctor).map h)).inv ≫
            f ◁ θ.naturality g ▷ (↑H.toPrelaxFunctor).map h ≫
              f ◁ (α_ (θ.app a) ((↑H.toPrelaxFunctor).map g) ((↑H.toPrelaxFunctor).map h)).hom
state_after: no goals
Theorem: surjective_algebraMap_of_linearMap
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: obtain ⟨x, rfl⟩ := hb x
state_before: F : Type u_1
E : Type u_2
inst✝² : CommSemiring F
inst✝¹ : Semiring E
inst✝ : Algebra F E
b : F →ₗ[F] E
hb : Function.Surjective ⇑b
x : E
⊢ ∃ a, (algebraMap F E) a = x
state_after: case intro
F : Type u_1
E : Type u_2
inst✝² : CommSemiring F
inst✝¹ : Semiring E
inst✝ : Algebra F E
b : F →ₗ[F] E
hb : Function.Surjective ⇑b
x : F
⊢ ∃ a, (algebraMap F E) a = b x

tactic: obtain ⟨y, hy⟩ := hb (b 1 * b 1)
state_before: case intro
F : Type u_1
E : Type u_2
inst✝² : CommSemiring F
inst✝¹ : Semiring E
inst✝ : Algebra F E
b : F →ₗ[F] E
hb : Function.Surjective ⇑b
x : F
⊢ ∃ a, (algebraMap F E) a = b x
state_after: case intro.intro
F : Type u_1
E : Type u_2
inst✝² : CommSemiring F
inst✝¹ : Semiring E
inst✝ : Algebra F E
b : F →ₗ[F] E
hb : Function.Surjective ⇑b
x y : F
hy : b y = b 1 * b 1
⊢ ∃ a, (algebraMap F E) a = b x

tactic: refine ⟨x * y, ?_⟩
state_before: case intro.intro
F : Type u_1
E : Type u_2
inst✝² : CommSemiring F
inst✝¹ : Semiring E
inst✝ : Algebra F E
b : F →ₗ[F] E
hb : Function.Surjective ⇑b
x y : F
hy : b y = b 1 * b 1
⊢ ∃ a, (algebraMap F E) a = b x
state_after: case intro.intro
F : Type u_1
E : Type u_2
inst✝² : CommSemiring F
inst✝¹ : Semiring E
inst✝ : Algebra F E
b : F →ₗ[F] E
hb : Function.Surjective ⇑b
x y : F
hy : b y = b 1 * b 1
⊢ (algebraMap F E) (x * y) = b x

tactic: obtain ⟨z, hz⟩ := hb 1
state_before: case intro.intro
F : Type u_1
E : Type u_2
inst✝² : CommSemiring F
inst✝¹ : Semiring E
inst✝ : Algebra F E
b : F →ₗ[F] E
hb : Function.Surjective ⇑b
x y : F
hy : b y = b 1 * b 1
⊢ (algebraMap F E) (x * y) = b x
state_after: case intro.intro.intro
F : Type u_1
E : Type u_2
inst✝² : CommSemiring F
inst✝¹ : Semiring E
inst✝ : Algebra F E
b : F →ₗ[F] E
hb : Function.Surjective ⇑b
x y : F
hy : b y = b 1 * b 1
z : F
hz : b z = 1
⊢ (algebraMap F E) (x * y) = b x

tactic: rwa [← map_smul, smul_eq_mul, mul_comm, ← smul_mul_assoc, ← map_smul _ z, smul_eq_mul, mul_one,
  ← smul_eq_mul, map_smul, hz, one_mul, ← map_smul, smul_eq_mul, mul_one, smul_smul,
  ← Algebra.algebraMap_eq_smul_one] at hy
state_before: case intro.intro.intro
F : Type u_1
E : Type u_2
inst✝² : CommSemiring F
inst✝¹ : Semiring E
inst✝ : Algebra F E
b : F →ₗ[F] E
hb : Function.Surjective ⇑b
x y z : F
hz : b z = 1
hy : x • z • b y = x • z • (b 1 * b 1)
⊢ (algebraMap F E) (x * y) = b x
state_after: no goals
Theorem: Int.add_emod_eq_add_mod_right
File: Mathlib/Data/Int/Defs.lean

tactic: rw [← emod_add_emod, ← emod_add_emod k, H]
state_before: a b c d m✝ n✝ m n k i : ℤ
H : m % n = k % n
⊢ (m + i) % n = (k + i) % n
state_after: no goals
Theorem: CPolynomialOn.continuous
File: Mathlib/Analysis/Analytic/CPolynomial.lean

tactic: rw [continuous_iff_continuousOn_univ]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m : ℕ
f : E → F
fa : CPolynomialOn 𝕜 f univ
⊢ Continuous f
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m : ℕ
f : E → F
fa : CPolynomialOn 𝕜 f univ
⊢ ContinuousOn f univ

tactic: exact fa.continuousOn
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m : ℕ
f : E → F
fa : CPolynomialOn 𝕜 f univ
⊢ ContinuousOn f univ
state_after: no goals
Theorem: ContinuousLinearMap.comp_add
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁹ : Semiring R₁
inst✝¹⁸ : Semiring R₂
inst✝¹⁷ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁶ : TopologicalSpace M₁
inst✝¹⁵ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁴ : TopologicalSpace M'₁
inst✝¹³ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹² : TopologicalSpace M₂
inst✝¹¹ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹⁰ : TopologicalSpace M₃
inst✝⁹ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁸ : TopologicalSpace M₄
inst✝⁷ : AddCommMonoid M₄
inst✝⁶ : Module R₁ M₁
inst✝⁵ : Module R₁ M'₁
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : ContinuousAdd M₂
inst✝ : ContinuousAdd M₃
g : M₂ →SL[σ₂₃] M₃
f₁ f₂ : M₁ →SL[σ₁₂] M₂
⊢ g.comp (f₁ + f₂) = g.comp f₁ + g.comp f₂
state_after: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁹ : Semiring R₁
inst✝¹⁸ : Semiring R₂
inst✝¹⁷ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁶ : TopologicalSpace M₁
inst✝¹⁵ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁴ : TopologicalSpace M'₁
inst✝¹³ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹² : TopologicalSpace M₂
inst✝¹¹ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹⁰ : TopologicalSpace M₃
inst✝⁹ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁸ : TopologicalSpace M₄
inst✝⁷ : AddCommMonoid M₄
inst✝⁶ : Module R₁ M₁
inst✝⁵ : Module R₁ M'₁
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : ContinuousAdd M₂
inst✝ : ContinuousAdd M₃
g : M₂ →SL[σ₂₃] M₃
f₁ f₂ : M₁ →SL[σ₁₂] M₂
x✝ : M₁
⊢ (g.comp (f₁ + f₂)) x✝ = (g.comp f₁ + g.comp f₂) x✝

tactic: simp
state_before: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁹ : Semiring R₁
inst✝¹⁸ : Semiring R₂
inst✝¹⁷ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁶ : TopologicalSpace M₁
inst✝¹⁵ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁴ : TopologicalSpace M'₁
inst✝¹³ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹² : TopologicalSpace M₂
inst✝¹¹ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹⁰ : TopologicalSpace M₃
inst✝⁹ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁸ : TopologicalSpace M₄
inst✝⁷ : AddCommMonoid M₄
inst✝⁶ : Module R₁ M₁
inst✝⁵ : Module R₁ M'₁
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : ContinuousAdd M₂
inst✝ : ContinuousAdd M₃
g : M₂ →SL[σ₂₃] M₃
f₁ f₂ : M₁ →SL[σ₁₂] M₂
x✝ : M₁
⊢ (g.comp (f₁ + f₂)) x✝ = (g.comp f₁ + g.comp f₂) x✝
state_after: no goals
Theorem: UniformContinuous.prod_mk
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [UniformContinuous, uniformity_prod]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f₁ : α → β
f₂ : α → γ
h₁ : UniformContinuous f₁
h₂ : UniformContinuous f₂
⊢ UniformContinuous fun a => (f₁ a, f₂ a)
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f₁ : α → β
f₂ : α → γ
h₁ : UniformContinuous f₁
h₂ : UniformContinuous f₂
⊢ Tendsto (fun x => ((f₁ x.1, f₂ x.1), f₁ x.2, f₂ x.2)) (𝓤 α)
    (comap (fun p => (p.1.1, p.2.1)) (𝓤 β) ⊓ comap (fun p => (p.1.2, p.2.2)) (𝓤 γ))

tactic: exact tendsto_inf.2 ⟨tendsto_comap_iff.2 h₁, tendsto_comap_iff.2 h₂⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f₁ : α → β
f₂ : α → γ
h₁ : UniformContinuous f₁
h₂ : UniformContinuous f₂
⊢ Tendsto (fun x => ((f₁ x.1, f₂ x.1), f₁ x.2, f₂ x.2)) (𝓤 α)
    (comap (fun p => (p.1.1, p.2.1)) (𝓤 β) ⊓ comap (fun p => (p.1.2, p.2.2)) (𝓤 γ))
state_after: no goals
Theorem: SimpleGraph.Walk.transfer_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [he]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
H : SimpleGraph V
w : V
q : G.Walk v w
hpq : ∀ e ∈ (p.append q).edges, e ∈ H.edgeSet
e : Sym2 V
he : e ∈ p.edges
⊢ e ∈ (p.append q).edges
state_after: no goals

tactic: simp [he]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
H : SimpleGraph V
w : V
q : G.Walk v w
hpq : ∀ e ∈ (p.append q).edges, e ∈ H.edgeSet
e : Sym2 V
he : e ∈ q.edges
⊢ e ∈ (p.append q).edges
state_after: no goals

tactic: induction p with
| nil => simp
| cons _ _ ih => simp only [Walk.transfer, cons_append, cons.injEq, heq_eq_eq, true_and, ih]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
H : SimpleGraph V
w : V
q : G.Walk v w
hpq : ∀ e ∈ (p.append q).edges, e ∈ H.edgeSet
⊢ (p.append q).transfer H hpq = (p.transfer H ⋯).append (q.transfer H ⋯)
state_after: no goals

tactic: simp
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
H : SimpleGraph V
w u✝ : V
q : G.Walk u✝ w
hpq : ∀ e ∈ (nil.append q).edges, e ∈ H.edgeSet
⊢ (nil.append q).transfer H hpq = (nil.transfer H ⋯).append (q.transfer H ⋯)
state_after: no goals

tactic: simp only [Walk.transfer, cons_append, cons.injEq, heq_eq_eq, true_and, ih]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
H : SimpleGraph V
w u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p✝ : G.Walk v✝ w✝
ih :
  ∀ (q : G.Walk w✝ w) (hpq : ∀ e ∈ (p✝.append q).edges, e ∈ H.edgeSet),
    (p✝.append q).transfer H hpq = (p✝.transfer H ⋯).append (q.transfer H ⋯)
q : G.Walk w✝ w
hpq : ∀ e ∈ ((cons h✝ p✝).append q).edges, e ∈ H.edgeSet
⊢ ((cons h✝ p✝).append q).transfer H hpq = ((cons h✝ p✝).transfer H ⋯).append (q.transfer H ⋯)
state_after: no goals
Theorem: CategoryTheory.Abelian.Pseudoelement.pseudoZero_iff
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: rw [← pseudoZero_aux P a]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P : C
a : Over P
⊢ Quot.mk (PseudoEqual P) a = 0 ↔ a.hom = 0
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P : C
a : Over P
⊢ Quot.mk (PseudoEqual P) a = 0 ↔ a ≈ Over.mk 0

tactic: exact Quotient.eq'
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P : C
a : Over P
⊢ Quot.mk (PseudoEqual P) a = 0 ↔ a ≈ Over.mk 0
state_after: no goals
Theorem: MonoidAlgebra.support_mul_single_subset
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: rw [Finset.image₂_singleton_right]
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
a : G
⊢ image₂ (fun x x_1 => x * x_1) f.support {a} ⊆ image (fun x => x * a) f.support
state_after: no goals
Theorem: continuousAt_prod_of_discrete_right
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp_rw [← continuousWithinAt_univ]
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 : α × β → γ
x : α × β
⊢ ContinuousAt f x ↔ ContinuousAt (fun x_1 => f (x_1, x.2)) 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 : α × β → γ
x : α × β
⊢ ContinuousWithinAt f univ x ↔ ContinuousWithinAt (fun x_1 => f (x_1, x.2)) univ x.1

tactic: exact continuousWithinAt_prod_of_discrete_right
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 : α × β → γ
x : α × β
⊢ ContinuousWithinAt f univ x ↔ ContinuousWithinAt (fun x_1 => f (x_1, x.2)) univ x.1
state_after: no goals
Theorem: LinearEquiv.coe_toLinearMap_mul
File: Mathlib/Algebra/Module/Equiv.lean

tactic: rfl
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
K : Type u_6
S : Type u_7
M : Type u_8
M₁ : Type u_9
M₂ : Type u_10
M₃ : Type u_11
N₁ : Type u_12
N₂ : Type u_13
N₃ : Type u_14
N₄ : Type u_15
ι : Type u_16
M₄ : Type u_17
inst✝⁸ : Semiring R
inst✝⁷ : Semiring S
inst✝⁶ : Semiring R₁
inst✝⁵ : Semiring R₂
inst✝⁴ : Semiring R₃
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M
e₁ e₂ : M ≃ₗ[R] M
⊢ ↑(e₁ * e₂) = ↑e₁ * ↑e₂
state_after: no goals
Theorem: Mathlib.Tactic.NoncommRing.nat_lit_mul_eq_nsmul
File: Mathlib/Tactic/NoncommRing.lean

tactic: simp only [nsmul_eq_mul, Nat.cast_eq_ofNat]
state_before: R : Type u_1
inst✝¹ : NonAssocSemiring R
r : R
n : ℕ
inst✝ : n.AtLeastTwo
⊢ OfNat.ofNat n * r = n • r
state_after: no goals
Theorem: npow_mul
File: Mathlib/Algebra/Group/NatPowAssoc.lean

tactic: induction n with
| zero => rw [npow_zero, Nat.mul_zero, npow_zero]
| succ n ih => rw [mul_add, npow_add, ih, mul_one, npow_add, npow_one]
state_before: M : Type u_1
inst✝² : MulOneClass M
inst✝¹ : Pow M ℕ
inst✝ : NatPowAssoc M
x : M
m n : ℕ
⊢ x ^ (m * n) = (x ^ m) ^ n
state_after: no goals

tactic: rw [npow_zero, Nat.mul_zero, npow_zero]
state_before: case zero
M : Type u_1
inst✝² : MulOneClass M
inst✝¹ : Pow M ℕ
inst✝ : NatPowAssoc M
x : M
m : ℕ
⊢ x ^ (m * 0) = (x ^ m) ^ 0
state_after: no goals

tactic: rw [mul_add, npow_add, ih, mul_one, npow_add, npow_one]
state_before: case succ
M : Type u_1
inst✝² : MulOneClass M
inst✝¹ : Pow M ℕ
inst✝ : NatPowAssoc M
x : M
m n : ℕ
ih : x ^ (m * n) = (x ^ m) ^ n
⊢ x ^ (m * (n + 1)) = (x ^ m) ^ (n + 1)
state_after: no goals
Theorem: Matrix.trace_eq_neg_charpoly_coeff
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

tactic: rw [charpoly_coeff_eq_prod_coeff_of_le _ le_rfl, Fintype.card,
  prod_X_sub_C_coeff_card_pred univ (fun i : n => M i i) Fintype.card_pos, neg_neg, trace]
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M✝ : Matrix n n R
inst✝ : Nonempty n
M : Matrix n n R
⊢ M.trace = -M.charpoly.coeff (Fintype.card n - 1)
state_after: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M✝ : Matrix n n R
inst✝ : Nonempty n
M : Matrix n n R
⊢ ∑ i : n, M.diag i = ∑ i : n, M i i

tactic: simp_rw [diag_apply]
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M✝ : Matrix n n R
inst✝ : Nonempty n
M : Matrix n n R
⊢ ∑ i : n, M.diag i = ∑ i : n, M i i
state_after: no goals
Theorem: EuclideanGeometry.oangle_midpoint_rev_left
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

tactic: rw [midpoint_comm, oangle_midpoint_left]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ ∡ (midpoint ℝ p₂ p₁) p₂ p₃ = ∡ p₁ p₂ p₃
state_after: no goals