1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Subobject.ofLE_comp_ofLE
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp only [ofLE, ← Functor.map_comp underlying]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
B : C
X Y Z : Subobject B
h₁ : X ≤ Y
h₂ : Y ≤ Z
⊢ X.ofLE Y h₁ ≫ Y.ofLE Z h₂ = X.ofLE Z ⋯
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
B : C
X Y Z : Subobject B
h₁ : X ≤ Y
h₂ : Y ≤ Z
⊢ underlying.map (h₁.hom ≫ h₂.hom) = underlying.map ⋯.hom

tactic: congr 1
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
B : C
X Y Z : Subobject B
h₁ : X ≤ Y
h₂ : Y ≤ Z
⊢ underlying.map (h₁.hom ≫ h₂.hom) = underlying.map ⋯.hom
state_after: no goals
Theorem: Cardinal.succ_eq_of_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: obtain ⟨n, hn⟩ := Cardinal.lt_aleph0.mp h
state_before: α β : Type u
c : Cardinal.{u_1}
h : c < ℵ₀
⊢ succ c = c + 1
state_after: case intro
α β : Type u
c : Cardinal.{u_1}
h : c < ℵ₀
n : ℕ
hn : c = ↑n
⊢ succ c = c + 1

tactic: rw [hn, succ_natCast]
state_before: case intro
α β : Type u
c : Cardinal.{u_1}
h : c < ℵ₀
n : ℕ
hn : c = ↑n
⊢ succ c = c + 1
state_after: no goals
Theorem: Mathlib.Meta.NormNum.jacobiSymNat.zero_left
File: Mathlib/Tactic/NormNum/LegendreSymbol.lean

tactic: rw [jacobiSymNat, Nat.cast_zero, jacobiSym.zero_left ?_]
state_before: b : ℕ
hb : (b / 2).beq 0 = false
⊢ jacobiSymNat 0 b = 0
state_after: b : ℕ
hb : (b / 2).beq 0 = false
⊢ 1 < b

tactic: calc
  1 < 2 * 1       := by decide
  _ ≤ 2 * (b / 2) :=
    Nat.mul_le_mul_left _ (Nat.succ_le.mpr (Nat.pos_of_ne_zero (Nat.ne_of_beq_eq_false hb)))
  _ ≤ b           := Nat.mul_div_le b 2
state_before: b : ℕ
hb : (b / 2).beq 0 = false
⊢ 1 < b
state_after: no goals

tactic: decide
state_before: b : ℕ
hb : (b / 2).beq 0 = false
⊢ 1 < 2 * 1
state_after: no goals
Theorem: Filter.eventually_cardinal_forall
File: Mathlib/Order/Filter/CardinalInter.lean

tactic: simp only [Filter.Eventually, setOf_forall]
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
p : α → ι → Prop
hic : #ι < c
⊢ (∀ᶠ (x : α) in l, ∀ (i : ι), p x i) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p x i
state_after: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
p : α → ι → Prop
hic : #ι < c
⊢ ⋂ i, {x | p x i} ∈ l ↔ ∀ (i : ι), {x | p x i} ∈ l

tactic: exact cardinal_iInter_mem hic
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
p : α → ι → Prop
hic : #ι < c
⊢ ⋂ i, {x | p x i} ∈ l ↔ ∀ (i : ι), {x | p x i} ∈ l
state_after: no goals
Theorem: Matrix.toLinAlgEquiv_one
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: rw [← LinearMap.toMatrixAlgEquiv_id v₁, Matrix.toLinAlgEquiv_toMatrixAlgEquiv]
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
⊢ (toLinAlgEquiv v₁) 1 = LinearMap.id
state_after: no goals
Theorem: MeasureTheory.snormEssSup_const
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: rw [snormEssSup, essSup_const _ hμ]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
hμ : μ ≠ 0
⊢ snormEssSup (fun x => c) μ = ↑‖c‖₊
state_after: no goals
Theorem: equivShrink_inv
File: Mathlib/Logic/Small/Group.lean

tactic: rw [Equiv.inv_def]
state_before: α : Type u_1
inst✝¹ : Inv α
inst✝ : Small.{u_2, u_1} α
x : α
⊢ (equivShrink α) x⁻¹ = ((equivShrink α) x)⁻¹
state_after: α : Type u_1
inst✝¹ : Inv α
inst✝ : Small.{u_2, u_1} α
x : α
⊢ (equivShrink α) x⁻¹ = (equivShrink α).symm.symm ((equivShrink α).symm ((equivShrink α) x))⁻¹

tactic: simp
state_before: α : Type u_1
inst✝¹ : Inv α
inst✝ : Small.{u_2, u_1} α
x : α
⊢ (equivShrink α) x⁻¹ = (equivShrink α).symm.symm ((equivShrink α).symm ((equivShrink α) x))⁻¹
state_after: no goals
Theorem: Set.image_restrict
File: Mathlib/Data/Set/Function.lean

tactic: rw [restrict_eq, image_comp, image_preimage_eq_inter_range, Subtype.range_coe]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
f : α → β
s t : Set α
⊢ s.restrict f '' (Subtype.val ⁻¹' t) = f '' (t ∩ s)
state_after: no goals
Theorem: strictConcaveOn_sqrt_mul_log_Ioi
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

tactic: apply strictConcaveOn_of_deriv2_neg' (convex_Ioi 1) _ fun x hx => ?_
state_before: ⊢ StrictConcaveOn ℝ (Ioi 1) fun x => √x * log x
state_after: ⊢ ContinuousOn (fun x => √x * log x) (Ioi 1)

x : ℝ
hx : x ∈ Ioi 1
⊢ deriv^[2] (fun x => √x * log x) x < 0

tactic: exact continuous_sqrt.continuousOn.mul
  (continuousOn_log.mono fun x hx => ne_of_gt (zero_lt_one.trans hx))
state_before: ⊢ ContinuousOn (fun x => √x * log x) (Ioi 1)
state_after: no goals

tactic: rw [deriv2_sqrt_mul_log x]
state_before: x : ℝ
hx : x ∈ Ioi 1
⊢ deriv^[2] (fun x => √x * log x) x < 0
state_after: x : ℝ
hx : x ∈ Ioi 1
⊢ -log x / (4 * √x ^ 3) < 0

tactic: exact div_neg_of_neg_of_pos (neg_neg_of_pos (log_pos hx))
  (mul_pos four_pos (pow_pos (sqrt_pos.mpr (zero_lt_one.trans hx)) 3))
state_before: x : ℝ
hx : x ∈ Ioi 1
⊢ -log x / (4 * √x ^ 3) < 0
state_after: no goals
Theorem: Matrix.conjTranspose_eq_one
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [conjTranspose_one]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : StarRing α
M : Matrix n n α
⊢ M = 1ᴴ ↔ M = 1
state_after: no goals
Theorem: CauSeq.mul_equiv_mul
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: change LimZero (f1 * g1 - f2 * g2)
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ f1 * g1 ≈ f2 * g2
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ (f1 * g1 - f2 * g2).LimZero

tactic: convert add_limZero (mul_limZero_left g1 hf) (mul_limZero_right f2 hg) using 1
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ (f1 * g1 - f2 * g2).LimZero
state_after: case h.e'_6
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ f1 * g1 - f2 * g2 = (f1 - f2) * g1 + f2 * (g1 - g2)

tactic: rw [mul_sub, sub_mul]
state_before: case h.e'_6
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ f1 * g1 - f2 * g2 = (f1 - f2) * g1 + f2 * (g1 - g2)
state_after: case h.e'_6
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ f1 * g1 - f2 * g2 = f1 * g1 - f2 * g1 + (f2 * g1 - f2 * g2)

tactic: exact (sub_add_sub_cancel (f1*g1) (f2*g1) (f2*g2)).symm
state_before: case h.e'_6
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 g1 g2 : CauSeq β abv
hf : f1 ≈ f2
hg : g1 ≈ g2
⊢ f1 * g1 - f2 * g2 = f1 * g1 - f2 * g1 + (f2 * g1 - f2 * g2)
state_after: no goals
Theorem: Set.Icc_diff_Ico_same
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [← Icc_diff_right, diff_diff_cancel_left (singleton_subset_iff.2 <| right_mem_Icc.2 h)]
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ Icc a b \ Ico a b = {b}
state_after: no goals
Theorem: Sum.getRight?_swap
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

tactic: cases x <;> rfl
state_before: α : Type u_1
β : Type u_2
x : α ⊕ β
⊢ x.swap.getRight? = x.getLeft?
state_after: no goals
Theorem: fderivWithin_of_mem_nhds
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [← fderivWithin_univ, ← univ_inter s, fderivWithin_inter h]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : s ∈ 𝓝 x
⊢ fderivWithin 𝕜 f s x = fderiv 𝕜 f x
state_after: no goals
Theorem: CategoryTheory.Presieve.isSheafFor_arrows_iff_pullbacks
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

tactic: simp_rw [← Arrows.pullbackCompatible_iff, isSheafFor_arrows_iff]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (ofArrows X π).hasPullbacks
⊢ IsSheafFor P (ofArrows X π) ↔
    ∀ (x : (i : I) → P.obj { unop := X i }), Arrows.PullbackCompatible P π x → ∃! t, ∀ (i : I), P.map (π i).op t = x i
state_after: no goals
Theorem: SimpleGraph.Walk.IsPath.nil
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: constructor <;> simp
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 u : V
⊢ Walk.nil.IsPath
state_after: no goals
Theorem: CategoryTheory.Subobject.map_comp
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: induction' x using Quotient.inductionOn' with t
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : Mono f
inst✝ : Mono g
x : Subobject X
⊢ (map (f ≫ g)).obj x = (map g).obj ((map f).obj x)
state_after: case h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : Mono f
inst✝ : Mono g
t : MonoOver X
⊢ (map (f ≫ g)).obj (Quotient.mk'' t) = (map g).obj ((map f).obj (Quotient.mk'' t))

tactic: exact Quotient.sound ⟨(MonoOver.mapComp _ _).app t⟩
state_before: case h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : Mono f
inst✝ : Mono g
t : MonoOver X
⊢ (map (f ≫ g)).obj (Quotient.mk'' t) = (map g).obj ((map f).obj (Quotient.mk'' t))
state_after: no goals
Theorem: Array.size_filter_le
File: .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean

tactic: simp only [← data_length, filter_data]
state_before: α : Type u_1
p : α → Bool
l : Array α
⊢ (filter p l 0).size ≤ l.size
state_after: α : Type u_1
p : α → Bool
l : Array α
⊢ (List.filter p l.data).length ≤ l.data.length

tactic: apply List.length_filter_le
state_before: α : Type u_1
p : α → Bool
l : Array α
⊢ (List.filter p l.data).length ≤ l.data.length
state_after: no goals
Theorem: prod_nhdsSet_le_of_disjoint_cocompact
File: Mathlib/Topology/Compactness/Compact.lean

tactic: obtain ⟨K, hKf, hK⟩ := (disjoint_cocompact_right f).mp hf
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : Filter X
ht : IsCompact t
hf : Disjoint f (cocompact X)
⊢ f ×ˢ 𝓝ˢ t ≤ 𝓝ˢ (univ ×ˢ t)
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : Filter X
ht : IsCompact t
hf : Disjoint f (cocompact X)
K : Set X
hKf : K ∈ f
hK : IsCompact K
⊢ f ×ˢ 𝓝ˢ t ≤ 𝓝ˢ (univ ×ˢ t)

tactic: calc
  f ×ˢ 𝓝ˢ t
  _ ≤ (𝓟 K) ×ˢ 𝓝ˢ t      := Filter.prod_mono_left _ (Filter.le_principal_iff.mpr hKf)
  _ ≤ 𝓝ˢ K ×ˢ 𝓝ˢ t       := Filter.prod_mono_left _ principal_le_nhdsSet
  _ = 𝓝ˢ (K ×ˢ t)         := (hK.nhdsSet_prod_eq ht).symm
  _ ≤ 𝓝ˢ (Set.univ ×ˢ t)  := nhdsSet_mono (prod_mono_left le_top)
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : Filter X
ht : IsCompact t
hf : Disjoint f (cocompact X)
K : Set X
hKf : K ∈ f
hK : IsCompact K
⊢ f ×ˢ 𝓝ˢ t ≤ 𝓝ˢ (univ ×ˢ t)
state_after: no goals
Theorem: Complex.orderClosedTopology
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simp_rw [le_def, Set.setOf_and]
state_before: z : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
⊢ IsClosed {p | p.1 ≤ p.2}
state_after: z : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
⊢ IsClosed ({a | a.1.re ≤ a.2.re} ∩ {a | a.1.im = a.2.im})

tactic: refine IsClosed.inter (isClosed_le ?_ ?_) (isClosed_eq ?_ ?_) <;> continuity
state_before: z : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
⊢ IsClosed ({a | a.1.re ≤ a.2.re} ∩ {a | a.1.im = a.2.im})
state_after: no goals
Theorem: antivary_iff_forall_smul_nonpos
File: Mathlib/Algebra/Order/Monovary.lean

tactic: rw [monovary_iff_forall_smul_nonneg]
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₂ : β
⊢ Monovary f (⇑OrderDual.toDual ∘ g) ↔ ∀ (i j : ι), (f j - f i) • (g j - g i) ≤ 0
state_after: ι : 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 j : ι), 0 ≤ (f j - f i) • ((⇑OrderDual.toDual ∘ g) j - (⇑OrderDual.toDual ∘ g) i)) ↔
    ∀ (i j : ι), (f j - f i) • (g j - g i) ≤ 0

tactic: rfl
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 j : ι), 0 ≤ (f j - f i) • ((⇑OrderDual.toDual ∘ g) j - (⇑OrderDual.toDual ∘ g) i)) ↔
    ∀ (i j : ι), (f j - f i) • (g j - g i) ≤ 0
state_after: no goals
Theorem: CategoryTheory.epi_iff_isPushout
File: Mathlib/CategoryTheory/Limits/EpiMono.lean

tactic: constructor
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ Epi f ↔ IsPushout f f (𝟙 Y) (𝟙 Y)
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ Epi f → IsPushout f f (𝟙 Y) (𝟙 Y)

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ IsPushout f f (𝟙 Y) (𝟙 Y) → Epi f

tactic: intro
state_before: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ Epi f → IsPushout f f (𝟙 Y) (𝟙 Y)
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
a✝ : Epi f
⊢ IsPushout f f (𝟙 Y) (𝟙 Y)

tactic: exact IsPushout.of_isColimit (PushoutCocone.isColimitMkIdId f)
state_before: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
a✝ : Epi f
⊢ IsPushout f f (𝟙 Y) (𝟙 Y)
state_after: no goals

tactic: intro hf
state_before: case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ IsPushout f f (𝟙 Y) (𝟙 Y) → Epi f
state_after: case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : IsPushout f f (𝟙 Y) (𝟙 Y)
⊢ Epi f

tactic: exact (epi_iff_inl_eq_inr hf.isColimit).2 rfl
state_before: case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : IsPushout f f (𝟙 Y) (𝟙 Y)
⊢ Epi f
state_after: no goals
Theorem: FirstOrder.Language.Term.realize_functions_apply₁
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Functions.apply₁, Term.realize]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 1
t : L.Term α
v : α → M
⊢ realize v (f.apply₁ t) = funMap f ![realize v t]
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 1
t : L.Term α
v : α → M
⊢ (funMap f fun i => realize v (![t] i)) = funMap f ![realize v t]

tactic: refine congr rfl (funext fun i => ?_)
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 1
t : L.Term α
v : α → M
⊢ (funMap f fun i => realize v (![t] i)) = funMap f ![realize v t]
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 1
t : L.Term α
v : α → M
i : Fin 1
⊢ realize v (![t] i) = ![realize v t] i

tactic: simp only [Matrix.cons_val_fin_one]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 1
t : L.Term α
v : α → M
i : Fin 1
⊢ realize v (![t] i) = ![realize v t] i
state_after: no goals
Theorem: Polynomial.ofFinsupp_eq_one
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rw [← ofFinsupp_one, ofFinsupp_inj]
state_before: R : Type u
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
a : R[ℕ]
⊢ { toFinsupp := a } = 1 ↔ a = 1
state_after: no goals
Theorem: MeasureTheory.norm_indicatorConstLp_top
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: rw [Lp.norm_def, snorm_congr_ae indicatorConstLp_coeFn,
  snorm_indicator_const' hs hμs_ne_zero ENNReal.top_ne_zero, ENNReal.top_toReal, _root_.div_zero,
  ENNReal.rpow_zero, mul_one, ENNReal.coe_toReal, coe_nnnorm]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : μ s ≠ ⊤
c : E
hμs_ne_zero : μ s ≠ 0
⊢ ‖indicatorConstLp ⊤ hs hμs c‖ = ‖c‖
state_after: no goals
Theorem: List.mem_traverse
File: Mathlib/Control/Traversable/Instances.lean

tactic: simp
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
⊢ [] ∈ traverse f [] ↔ Forall₂ (fun b a => b ∈ f a) [] []
state_after: no goals

tactic: simp
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
a : α'
as : List α'
⊢ [] ∈ traverse f (a :: as) ↔ Forall₂ (fun b a => b ∈ f a) [] (a :: as)
state_after: no goals

tactic: simp
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
b : β'
bs : List β'
⊢ b :: bs ∈ traverse f [] ↔ Forall₂ (fun b a => b ∈ f a) (b :: bs) []
state_after: no goals

tactic: simp [mem_traverse as bs]
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
a : α'
as : List α'
b : β'
bs : List β'
⊢ b :: bs ∈ traverse f (a :: as) ↔ Forall₂ (fun b a => b ∈ f a) (b :: bs) (a :: as)
state_after: no goals
Theorem: List.nodup_iff_injective_get
File: Mathlib/Data/List/Nodup.lean

tactic: rw [nodup_iff_injective_getElem]
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
⊢ l.Nodup ↔ Injective l.get
state_after: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
⊢ (Injective fun i => l[↑i]) ↔ Injective l.get

tactic: change _ ↔ Injective (fun i => l.get i)
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
⊢ (Injective fun i => l[↑i]) ↔ Injective l.get
state_after: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
⊢ (Injective fun i => l[↑i]) ↔ Injective fun i => l.get i

tactic: simp
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
⊢ (Injective fun i => l[↑i]) ↔ Injective fun i => l.get i
state_after: no goals
Theorem: Monoid.Coprod.toProd_surjective
File: Mathlib/GroupTheory/Coprod/Basic.lean

tactic: rw [map_mul, toProd_apply_inl, toProd_apply_inr, Prod.fst_mul_snd]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
x : M × N
⊢ toProd (inl x.1 * inr x.2) = x
state_after: no goals
Theorem: ENNReal.ofReal_eq_ofReal_iff
File: Mathlib/Data/ENNReal/Real.lean

tactic: rw [ENNReal.ofReal, ENNReal.ofReal, coe_inj, Real.toNNReal_eq_toNNReal_iff hp hq]
state_before: a b c d : ℝ≥0∞
r p✝ q✝ : ℝ≥0
p q : ℝ
hp : 0 ≤ p
hq : 0 ≤ q
⊢ ENNReal.ofReal p = ENNReal.ofReal q ↔ p = q
state_after: no goals
Theorem: Ordinal.typein_le_typein
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [← not_lt, typein_lt_typein]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
x x' : α
⊢ typein r x ≤ typein r x' ↔ ¬r x' x
state_after: no goals
Theorem: Polynomial.degree_mul_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: simpa only [degree, ← support_toFinsupp, toFinsupp_mul]
  using AddMonoidAlgebra.sup_support_mul_le (WithBot.coe_add _ _).le _ _
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
⊢ (p * q).degree ≤ p.degree + q.degree
state_after: no goals
Theorem: Sym2.other_eq_other'
File: Mathlib/Data/Sym/Sym2.lean

tactic: rw [← congr_right, other_spec' h, other_spec]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
inst✝ : DecidableEq α
a : α
z : Sym2 α
h : a ∈ z
⊢ Mem.other h = Mem.other' h
state_after: no goals
Theorem: Multiset.stronglyMeasurable_prod'
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: rcases l with ⟨l⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l : Multiset (α → M)
hl : ∀ f ∈ l, StronglyMeasurable f
⊢ StronglyMeasurable l.prod
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, StronglyMeasurable f
⊢ StronglyMeasurable (Multiset.prod (Quot.mk Setoid.r l))

tactic: simpa using l.stronglyMeasurable_prod' (by simpa using hl)
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, StronglyMeasurable f
⊢ StronglyMeasurable (Multiset.prod (Quot.mk Setoid.r l))
state_after: no goals

tactic: simpa using hl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
m : MeasurableSpace α
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, StronglyMeasurable f
⊢ ∀ f ∈ l, StronglyMeasurable f
state_after: no goals