1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Cardinal.natCast_lt
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [lt_iff_le_not_le, ← not_le]
state_before: α β : Type u
m n : ℕ
⊢ ↑m < ↑n ↔ m < n
state_after: α β : Type u
m n : ℕ
⊢ ↑m ≤ ↑n ∧ ¬↑n ≤ ↑m ↔ ¬n ≤ m

tactic: simp only [natCast_le, not_le, and_iff_right_iff_imp]
state_before: α β : Type u
m n : ℕ
⊢ ↑m ≤ ↑n ∧ ¬↑n ≤ ↑m ↔ ¬n ≤ m
state_after: α β : Type u
m n : ℕ
⊢ m < n → m ≤ n

tactic: exact fun h ↦ le_of_lt h
state_before: α β : Type u
m n : ℕ
⊢ m < n → m ≤ n
state_after: no goals
Theorem: CategoryTheory.initiallySmall_of_small_weakly_initial_set
File: Mathlib/CategoryTheory/Limits/FinallySmall.lean

tactic: refine Functor.initial_of_exists_of_isCofiltered_of_fullyFaithful _ (fun i => ?_)
state_before: J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsCofilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
⊢ (fullSubcategoryInclusion fun x => x ∈ s).Initial
state_after: J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsCofilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
i : J
⊢ ∃ c, Nonempty ((fullSubcategoryInclusion fun x => x ∈ s).obj c ⟶ i)

tactic: obtain ⟨j, hj₁, hj₂⟩ := hs i
state_before: J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsCofilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
i : J
⊢ ∃ c, Nonempty ((fullSubcategoryInclusion fun x => x ∈ s).obj c ⟶ i)
state_after: case intro.intro
J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsCofilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
i j : J
hj₁ : j ∈ s
hj₂ : Nonempty (j ⟶ i)
⊢ ∃ c, Nonempty ((fullSubcategoryInclusion fun x => x ∈ s).obj c ⟶ i)

tactic: exact ⟨⟨j, hj₁⟩, hj₂⟩
state_before: case intro.intro
J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsCofilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
i j : J
hj₁ : j ∈ s
hj₂ : Nonempty (j ⟶ i)
⊢ ∃ c, Nonempty ((fullSubcategoryInclusion fun x => x ∈ s).obj c ⟶ i)
state_after: no goals
Theorem: Matrix.vecMulLinear_transpose
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: ext
state_before: R : Type u_1
inst✝¹ : CommSemiring R
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝ : Fintype n
M : Matrix m n R
⊢ Mᵀ.vecMulLinear = M.mulVecLin
state_after: case h.h
R : Type u_1
inst✝¹ : CommSemiring R
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝ : Fintype n
M : Matrix m n R
x✝¹ : n → R
x✝ : m
⊢ Mᵀ.vecMulLinear x✝¹ x✝ = M.mulVecLin x✝¹ x✝

tactic: simp [vecMul_transpose]
state_before: case h.h
R : Type u_1
inst✝¹ : CommSemiring R
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝ : Fintype n
M : Matrix m n R
x✝¹ : n → R
x✝ : m
⊢ Mᵀ.vecMulLinear x✝¹ x✝ = M.mulVecLin x✝¹ x✝
state_after: no goals
Theorem: eq_of_forall_symmetric
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: simpa
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : UniformSpace α✝
inst✝³ : UniformSpace β
inst✝² : UniformSpace γ
α : Type u_1
inst✝¹ : UniformSpace α
inst✝ : T0Space α
x y : α
h : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → SymmetricRel V → (x, y) ∈ V
⊢ ∀ {i : Set (α × α)}, i ∈ 𝓤 α ∧ SymmetricRel i → (x, y) ∈ id i
state_after: no goals
Theorem: FixedPoints.smul_polynomial
File: Mathlib/FieldTheory/Fixed.lean

tactic: rw [Polynomial.smul_C, smul]
state_before: M : Type u
inst✝⁴ : Monoid M
G : Type u
inst✝³ : Group G
F : Type v
inst✝² : Field F
inst✝¹ : MulSemiringAction M F
inst✝ : MulSemiringAction G F
m✝ m : M
p : Polynomial ↥(subfield M F)
x : ↥(subfield M F)
⊢ m • Polynomial.C x = Polynomial.C x
state_after: no goals

tactic: rw [smul_add, ihp, ihq]
state_before: M : Type u
inst✝⁴ : Monoid M
G : Type u
inst✝³ : Group G
F : Type v
inst✝² : Field F
inst✝¹ : MulSemiringAction M F
inst✝ : MulSemiringAction G F
m✝ m : M
p✝ p q : Polynomial ↥(subfield M F)
ihp : m • p = p
ihq : m • q = q
⊢ m • (p + q) = p + q
state_after: no goals

tactic: rw [smul_mul', Polynomial.smul_C, smul, smul_pow', Polynomial.smul_X]
state_before: M : Type u
inst✝⁴ : Monoid M
G : Type u
inst✝³ : Group G
F : Type v
inst✝² : Field F
inst✝¹ : MulSemiringAction M F
inst✝ : MulSemiringAction G F
m✝ m : M
p : Polynomial ↥(subfield M F)
n : ℕ
x : ↥(subfield M F)
x✝ : m • (Polynomial.C x * Polynomial.X ^ n) = Polynomial.C x * Polynomial.X ^ n
⊢ m • (Polynomial.C x * Polynomial.X ^ (n + 1)) = Polynomial.C x * Polynomial.X ^ (n + 1)
state_after: no goals
Theorem: Codisjoint.ne
File: Mathlib/Order/Disjoint.lean

tactic: rwa [← h] at hab
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : OrderTop α
a b c d : α
ha : a ≠ ⊤
hab : Codisjoint a b
h : a = b
⊢ Codisjoint a a
state_after: no goals
Theorem: FractionalIdeal.coeIdeal_mul
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

tactic: simp only [mul_def]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : Ideal R
⊢ ↑(I * J) = ↑I * ↑J
state_after: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : Ideal R
⊢ ↑(I * J) = ⟨↑↑I * ↑↑J, ⋯⟩

tactic: exact coeToSubmodule_injective (coeSubmodule_mul _ _ _)
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : Ideal R
⊢ ↑(I * J) = ⟨↑↑I * ↑↑J, ⋯⟩
state_after: no goals
Theorem: Set.univ_pi_nonempty_iff
File: Mathlib/Data/Set/Prod.lean

tactic: simp [Classical.skolem, Set.Nonempty]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ (univ.pi t).Nonempty ↔ ∀ (i : ι), (t i).Nonempty
state_after: no goals
Theorem: Nat.sInf_empty
File: Mathlib/Data/Nat/Lattice.lean

tactic: rw [sInf_eq_zero]
state_before: ⊢ sInf ∅ = 0
state_after: ⊢ 0 ∈ ∅ ∨ ∅ = ∅

tactic: right
state_before: ⊢ 0 ∈ ∅ ∨ ∅ = ∅
state_after: case h

⊢ ∅ = ∅

tactic: rfl
state_before: case h

⊢ ∅ = ∅
state_after: no goals
Theorem: Equiv.swap_mul_eq_iff
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: rw [mul_left_eq_self, swap_eq_one_iff]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
i j : α
σ : Perm α
⊢ swap i j * σ = σ ↔ i = j
state_after: no goals
Theorem: List.sym2_eq_sym_two
File: Mathlib/Data/List/Sym.lean

tactic: induction xs with
| nil => simp only [List.sym, map_eq_nil, sym2_eq_nil_iff]
| cons x xs ih =>
  rw [List.sym, ← ih, sym_one_eq, map_map, List.sym2, map_append, map_map]
  rfl
state_before: α : Type u_1
xs ys : List α
n : ℕ
⊢ map (⇑(Sym2.equivSym α)) xs.sym2 = List.sym 2 xs
state_after: no goals

tactic: simp only [List.sym, map_eq_nil, sym2_eq_nil_iff]
state_before: case nil
α : Type u_1
xs ys : List α
n : ℕ
⊢ map ⇑(Sym2.equivSym α) [].sym2 = List.sym 2 []
state_after: no goals

tactic: rw [List.sym, ← ih, sym_one_eq, map_map, List.sym2, map_append, map_map]
state_before: case cons
α : Type u_1
xs✝ ys : List α
n : ℕ
x : α
xs : List α
ih : map (⇑(Sym2.equivSym α)) xs.sym2 = List.sym 2 xs
⊢ map (⇑(Sym2.equivSym α)) (x :: xs).sym2 = List.sym 2 (x :: xs)
state_after: case cons
α : Type u_1
xs✝ ys : List α
n : ℕ
x : α
xs : List α
ih : map (⇑(Sym2.equivSym α)) xs.sym2 = List.sym 2 xs
⊢ map (⇑(Sym2.equivSym α) ∘ fun y => s(x, y)) (x :: xs) ++ map (⇑(Sym2.equivSym α)) xs.sym2 =
    map ((fun p => x ::ₛ p) ∘ fun x => x ::ₛ Sym.nil) (x :: xs) ++ map (⇑(Sym2.equivSym α)) xs.sym2

tactic: rfl
state_before: case cons
α : Type u_1
xs✝ ys : List α
n : ℕ
x : α
xs : List α
ih : map (⇑(Sym2.equivSym α)) xs.sym2 = List.sym 2 xs
⊢ map (⇑(Sym2.equivSym α) ∘ fun y => s(x, y)) (x :: xs) ++ map (⇑(Sym2.equivSym α)) xs.sym2 =
    map ((fun p => x ::ₛ p) ∘ fun x => x ::ₛ Sym.nil) (x :: xs) ++ map (⇑(Sym2.equivSym α)) xs.sym2
state_after: no goals
Theorem: WithBot.image_coe_Ioi
File: Mathlib/Order/Interval/Set/WithBotTop.lean

tactic: rw [← preimage_coe_Ioi, image_preimage_eq_inter_range, range_coe,
  inter_eq_self_of_subset_left (Ioi_subset_Ioi bot_le)]
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some '' Ioi a = Ioi ↑a
state_after: no goals
Theorem: SimpleGraph.Walk.IsTrail.takeUntil
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rwa [← take_spec _ h] at hc
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
hc : p.IsTrail
h : u ∈ p.support
⊢ ((p.takeUntil u h).append ?m.134716).IsTrail
state_after: no goals
Theorem: toIocDiv_neg
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [← neg_neg b, toIcoDiv_neg, neg_neg, neg_neg, neg_add', neg_neg, add_sub_cancel_right]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a (-b) = -(toIcoDiv hp (-a) b + 1)
state_after: no goals
Theorem: Multiset.prod_map_eq_pow_single
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

tactic: induction' m using Quotient.inductionOn with l
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq ι
i : ι
hf : ∀ (i' : ι), i' ≠ i → i' ∈ m → f i' = 1
⊢ (map f m).prod = f i ^ count i m
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq ι
i : ι
l : List ι
hf : ∀ (i' : ι), i' ≠ i → i' ∈ ⟦l⟧ → f i' = 1
⊢ (map f ⟦l⟧).prod = f i ^ count i ⟦l⟧

tactic: simp [List.prod_map_eq_pow_single i f hf]
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq ι
i : ι
l : List ι
hf : ∀ (i' : ι), i' ≠ i → i' ∈ ⟦l⟧ → f i' = 1
⊢ (map f ⟦l⟧).prod = f i ^ count i ⟦l⟧
state_after: no goals
Theorem: lt_of_mul_self_lt_mul_self
File: Mathlib/Algebra/Order/Ring/Basic.lean

tactic: simp_rw [← sq]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
hb : 0 ≤ b
⊢ a * a < b * b → a < b
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
hb : 0 ≤ b
⊢ a ^ 2 < b ^ 2 → a < b

tactic: exact lt_of_pow_lt_pow_left _ hb
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
hb : 0 ≤ b
⊢ a ^ 2 < b ^ 2 → a < b
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.RightFraction.map_hom_ofInv_id
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

tactic: letI := hL _ hs
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
⊢ L.map s ≫ (ofInv s hs).map L hL = 𝟙 (L.obj Y)
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map s) := hL s hs
⊢ L.map s ≫ (ofInv s hs).map L hL = 𝟙 (L.obj Y)

tactic: simp [map]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
s : Y ⟶ X
hs : W s
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map s) := hL s hs
⊢ L.map s ≫ (ofInv s hs).map L hL = 𝟙 (L.obj Y)
state_after: no goals
Theorem: mul_eq_zero_of_ne_zero_imp_eq_zero
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [ha, zero_mul]
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✝ : MulZeroClass M₀
a✝ b✝ a b : M₀
h : a ≠ 0 → b = 0
ha : a = 0
⊢ a * b = 0
state_after: no goals

tactic: rw [h ha, mul_zero]
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✝ : MulZeroClass M₀
a✝ b✝ a b : M₀
h : a ≠ 0 → b = 0
ha : ¬a = 0
⊢ a * b = 0
state_after: no goals
Theorem: Filter.EventuallyEq.deriv_eq
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: unfold deriv
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hL : f₁ =ᶠ[𝓝 x] f
⊢ deriv f₁ x = deriv f x
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hL : f₁ =ᶠ[𝓝 x] f
⊢ (fderiv 𝕜 f₁ x) 1 = (fderiv 𝕜 f x) 1

tactic: rwa [Filter.EventuallyEq.fderiv_eq]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
hL : f₁ =ᶠ[𝓝 x] f
⊢ (fderiv 𝕜 f₁ x) 1 = (fderiv 𝕜 f x) 1
state_after: no goals
Theorem: Filter.subsingleton_iff_exists_le_pure
File: Mathlib/Order/Filter/Subsingleton.lean

tactic: rcases eq_or_neBot l with rfl | hbot
state_before: α : Type u_1
β : Type u_2
l : Filter α
inst✝ : Nonempty α
⊢ l.Subsingleton ↔ ∃ a, l ≤ pure a
state_after: case inl
α : Type u_1
β : Type u_2
inst✝ : Nonempty α
⊢ ⊥.Subsingleton ↔ ∃ a, ⊥ ≤ pure a

case inr
α : Type u_1
β : Type u_2
l : Filter α
inst✝ : Nonempty α
hbot : l.NeBot
⊢ l.Subsingleton ↔ ∃ a, l ≤ pure a

tactic: simp
state_before: case inl
α : Type u_1
β : Type u_2
inst✝ : Nonempty α
⊢ ⊥.Subsingleton ↔ ∃ a, ⊥ ≤ pure a
state_after: no goals

tactic: simp [subsingleton_iff_bot_or_pure, ← hbot.le_pure_iff, hbot.ne]
state_before: case inr
α : Type u_1
β : Type u_2
l : Filter α
inst✝ : Nonempty α
hbot : l.NeBot
⊢ l.Subsingleton ↔ ∃ a, l ≤ pure a
state_after: no goals
Theorem: ENNReal.one_le_rpow_of_pos_of_le_one_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: lift x to ℝ≥0 using ne_of_lt (lt_of_le_of_lt hx2 coe_lt_top)
state_before: x : ℝ≥0∞
z : ℝ
hx1 : 0 < x
hx2 : x ≤ 1
hz : z < 0
⊢ 1 ≤ x ^ z
state_after: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < ↑x
hx2 : ↑x ≤ 1
⊢ 1 ≤ ↑x ^ z

tactic: simp only [coe_le_one_iff, coe_pos] at hx1 hx2 ⊢
state_before: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < ↑x
hx2 : ↑x ≤ 1
⊢ 1 ≤ ↑x ^ z
state_after: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < x
hx2 : x ≤ 1
⊢ 1 ≤ ↑x ^ z

tactic: simp [coe_rpow_of_ne_zero (ne_of_gt hx1),
  NNReal.one_le_rpow_of_pos_of_le_one_of_nonpos hx1 hx2 (le_of_lt hz)]
state_before: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < x
hx2 : x ≤ 1
⊢ 1 ≤ ↑x ^ z
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.tensor_id_comp_id_tensor
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp]
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X Y Z : C
f : W ⟶ X
g : Y ⟶ Z
⊢ (g ⊗ 𝟙 W) ≫ (𝟙 Z ⊗ f) = g ⊗ f
state_after: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X Y Z : C
f : W ⟶ X
g : Y ⟶ Z
⊢ g ≫ 𝟙 Z ⊗ 𝟙 W ≫ f = g ⊗ f

tactic: simp
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X Y Z : C
f : W ⟶ X
g : Y ⟶ Z
⊢ g ≫ 𝟙 Z ⊗ 𝟙 W ≫ f = g ⊗ f
state_after: no goals
Theorem: Filter.prod_inf_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [SProd.sprod, Filter.prod, comap_inf, inf_comm, inf_assoc, inf_left_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
f₁ f₂ : Filter α
g₁ g₂ : Filter β
⊢ f₁ ×ˢ g₁ ⊓ f₂ ×ˢ g₂ = (f₁ ⊓ f₂) ×ˢ (g₁ ⊓ g₂)
state_after: no goals
Theorem: CategoryTheory.ShortComplex.RightHomologyMapData.congr_φH
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

tactic: rw [eq]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
γ₁ γ₂ : RightHomologyMapData φ h₁ h₂
eq : γ₁ = γ₂
⊢ γ₁.φH = γ₂.φH
state_after: no goals
Theorem: isClosed_setOf_inseparable
File: Mathlib/Topology/Separation.lean

tactic: simp only [← specializes_iff_inseparable, isClosed_setOf_specializes]
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
⊢ IsClosed {p | Inseparable p.1 p.2}
state_after: no goals
Theorem: iterateFrobeniusEquiv_one_apply
File: Mathlib/FieldTheory/Perfect.lean

tactic: rw [iterateFrobeniusEquiv_def, pow_one]
state_before: R : Type u_1
p m n : ℕ
inst✝² : CommSemiring R
inst✝¹ : ExpChar R p
inst✝ : PerfectRing R p
x : R
⊢ (iterateFrobeniusEquiv R p 1) x = x ^ p
state_after: no goals
Theorem: Finset.uIcc_injective_left
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: simpa only [uIcc_comm] using uIcc_injective_right a
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a✝ a₁ a₂ b b₁ b₂ c x a : α
⊢ Injective (uIcc a)
state_after: no goals
Theorem: GaloisInsertion.l_sInf_u_image
File: Mathlib/Order/GaloisConnection.lean

tactic: rw [sInf_image, gi.l_biInf_u, sInf_eq_iInf]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
gi : GaloisInsertion l u
s : Set β
⊢ l (sInf (u '' s)) = sInf s
state_after: no goals
Theorem: NeZero.nat_of_injective
File: Mathlib/Data/Nat/Cast/Order.lean

tactic: simpa only [map_natCast, map_zero f]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
S : Type u_4
F : Type u_5
inst✝³ : NonAssocSemiring R
inst✝² : NonAssocSemiring S
inst✝¹ : FunLike F R S
n : ℕ
h✝ : NeZero ↑n
inst✝ : RingHomClass F R S
f : F
hf : Function.Injective ⇑f
h : ↑n = 0
⊢ f ↑n = f 0
state_after: no goals
Theorem: isTopologicalBasis_pi
File: Mathlib/Topology/Bases.lean

tactic: simpa only [Set.pi_def] using IsTopologicalBasis.iInf_induced cond eval
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
T : (i : ι) → Set (Set (X i))
cond : ∀ (i : ι), IsTopologicalBasis (T i)
⊢ IsTopologicalBasis {S | ∃ U F, (∀ i ∈ F, U i ∈ T i) ∧ S = (↑F).pi U}
state_after: no goals
Theorem: Multiset.noncommProd_add
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: rcases s with ⟨⟩
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
s t : Multiset α
comm : {x | x ∈ s + t}.Pairwise Commute
⊢ (s + t).noncommProd comm = s.noncommProd ⋯ * t.noncommProd ⋯
state_after: case mk
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
s t : Multiset α
a✝ : List α
comm : {x | x ∈ Quot.mk Setoid.r a✝ + t}.Pairwise Commute
⊢ (Quot.mk Setoid.r a✝ + t).noncommProd comm = noncommProd (Quot.mk Setoid.r a✝) ⋯ * t.noncommProd ⋯

tactic: rcases t with ⟨⟩
state_before: case mk
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
s t : Multiset α
a✝ : List α
comm : {x | x ∈ Quot.mk Setoid.r a✝ + t}.Pairwise Commute
⊢ (Quot.mk Setoid.r a✝ + t).noncommProd comm = noncommProd (Quot.mk Setoid.r a✝) ⋯ * t.noncommProd ⋯
state_after: case mk.mk
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
s t : Multiset α
a✝¹ a✝ : List α
comm : {x | x ∈ Quot.mk Setoid.r a✝¹ + Quot.mk Setoid.r a✝}.Pairwise Commute
⊢ (Quot.mk Setoid.r a✝¹ + Quot.mk Setoid.r a✝).noncommProd comm =
    noncommProd (Quot.mk Setoid.r a✝¹) ⋯ * noncommProd (Quot.mk Setoid.r a✝) ⋯

tactic: simp
state_before: case mk.mk
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝¹ : Monoid α
inst✝ : Monoid β
s t : Multiset α
a✝¹ a✝ : List α
comm : {x | x ∈ Quot.mk Setoid.r a✝¹ + Quot.mk Setoid.r a✝}.Pairwise Commute
⊢ (Quot.mk Setoid.r a✝¹ + Quot.mk Setoid.r a✝).noncommProd comm =
    noncommProd (Quot.mk Setoid.r a✝¹) ⋯ * noncommProd (Quot.mk Setoid.r a✝) ⋯
state_after: no goals
Theorem: UpperSet.erase_inf_Ici
File: Mathlib/Order/UpperLower/Basic.lean

tactic: rw [← upperClosure_singleton, ← sdiff_singleton, sdiff_inf_upperClosure] <;> simpa
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : Preorder α
s : UpperSet α
t : Set α
a : α
ha : a ∈ s
has : ∀ b ∈ s, b ≤ a → b = a
⊢ s.erase a ⊓ Ici a = s
state_after: no goals
Theorem: StrictAntiOn.strictConcaveOn_of_deriv
File: Mathlib/Analysis/Convex/Deriv.lean

tactic: simpa only [← deriv.neg] using h_anti.neg
state_before: D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
h_anti : StrictAntiOn (deriv f) (interior D)
⊢ StrictMonoOn (deriv (-f)) (interior D)
state_after: no goals
Theorem: CategoryTheory.Functor.uncurry_obj_curry_obj
File: Mathlib/CategoryTheory/Functor/Currying.lean

tactic: simp
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : B × C ⥤ D
⊢ ∀ (X : B × C), (uncurry.obj (curry.obj F)).obj X = F.obj X
state_after: no goals

tactic: dsimp
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : B × C ⥤ D
x✝² x✝¹ : B × C
x₁ : B
x₂ : C
y₁ : B
y₂ : C
x✝ : (x₁, x₂) ⟶ (y₁, y₂)
f₁ : (x₁, x₂).1 ⟶ (y₁, y₂).1
f₂ : (x₁, x₂).2 ⟶ (y₁, y₂).2
⊢ (uncurry.obj (curry.obj F)).map (f₁, f₂) = eqToHom ⋯ ≫ F.map (f₁, f₂) ≫ eqToHom ⋯
state_after: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : B × C ⥤ D
x✝² x✝¹ : B × C
x₁ : B
x₂ : C
y₁ : B
y₂ : C
x✝ : (x₁, x₂) ⟶ (y₁, y₂)
f₁ : (x₁, x₂).1 ⟶ (y₁, y₂).1
f₂ : (x₁, x₂).2 ⟶ (y₁, y₂).2
⊢ F.map (f₁, 𝟙 x₂) ≫ F.map (𝟙 y₁, f₂) = 𝟙 (F.obj (x₁, x₂)) ≫ F.map (f₁, f₂) ≫ 𝟙 (F.obj (y₁, y₂))

tactic: simp only [← F.map_comp, Category.id_comp, Category.comp_id, prod_comp]
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : B × C ⥤ D
x✝² x✝¹ : B × C
x₁ : B
x₂ : C
y₁ : B
y₂ : C
x✝ : (x₁, x₂) ⟶ (y₁, y₂)
f₁ : (x₁, x₂).1 ⟶ (y₁, y₂).1
f₂ : (x₁, x₂).2 ⟶ (y₁, y₂).2
⊢ F.map (f₁, 𝟙 x₂) ≫ F.map (𝟙 y₁, f₂) = 𝟙 (F.obj (x₁, x₂)) ≫ F.map (f₁, f₂) ≫ 𝟙 (F.obj (y₁, y₂))
state_after: no goals