tasksource/leandojo huggingface dataset:
Theorem: AddCommGroupCat.injective_of_mono
File: Mathlib/Algebra/Category/GroupCat/Basic.lean

tactic: have t0 : asHom g₁ ≫ f = asHom g₂ ≫ f := by
  apply int_hom_ext
  simpa using h
state_before: G H : AddCommGroupCat
f : G ⟶ H
inst✝ : Mono f
g₁ g₂ : ↑G
h : ↑f g₁ = ↑f g₂
⊢ g₁ = g₂

tactic: have t1 : asHom g₁ = asHom g₂ := (cancel_mono _).1 t0
state_before: G H : AddCommGroupCat
f : G ⟶ H
inst✝ : Mono f
g₁ g₂ : ↑G
h : ↑f g₁ = ↑f g₂
t0 : asHom g₁ ≫ f = asHom g₂ ≫ f
⊢ g₁ = g₂

tactic: apply asHom_injective t1
state_before: G H : AddCommGroupCat
f : G ⟶ H
inst✝ : Mono f
g₁ g₂ : ↑G
h : ↑f g₁ = ↑f g₂
t0 : asHom g₁ ≫ f = asHom g₂ ≫ f
t1 : asHom g₁ = asHom g₂
⊢ g₁ = g₂

tactic: apply int_hom_ext
state_before: G H : AddCommGroupCat
f : G ⟶ H
inst✝ : Mono f
g₁ g₂ : ↑G
h : ↑f g₁ = ↑f g₂
⊢ asHom g₁ ≫ f = asHom g₂ ≫ f

tactic: simpa using h
state_before: case w
G H : AddCommGroupCat
f : G ⟶ H
inst✝ : Mono f
g₁ g₂ : ↑G
h : ↑f g₁ = ↑f g₂
⊢ ↑(asHom g₁ ≫ f) 1 = ↑(asHom g₂ ≫ f) 1
Theorem: ModuleCat.imageIsoRange_hom_subtype
File: Mathlib/Algebra/Category/ModuleCat/Images.lean

tactic: erw [← imageIsoRange_inv_image_ι f, Iso.hom_inv_id_assoc]
state_before: R : Type u
inst✝ : Ring R
G✝ H✝ : ModuleCat R
f✝ : G✝ ⟶ H✝
G H : ModuleCat R
f : G ⟶ H
⊢ (imageIsoRange f).hom ≫ ofHom (Submodule.subtype (LinearMap.range f)) = Limits.image.ι f
Theorem: Set.prod_eq_prod_iff
File: Mathlib/Data/Set/Prod.lean

tactic: symm
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.88795
δ : Type ?u.88798
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅)

tactic: cases' eq_empty_or_nonempty (s ×ˢ t) with h h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.88795
δ : Type ?u.88798
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅) ↔ s ×ˢ t = s₁ ×ˢ t₁

tactic: rw [prod_eq_prod_iff_of_nonempty h]
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type ?u.88795
δ : Type ?u.88798
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : Set.Nonempty (s ×ˢ t)
⊢ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅) ↔ s ×ˢ t = s₁ ×ˢ t₁

tactic: rw [nonempty_iff_ne_empty, Ne.def, prod_eq_empty_iff] at h
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type ?u.88795
δ : Type ?u.88798
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : Set.Nonempty (s ×ˢ t)
⊢ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅) ↔ s = s₁ ∧ t = t₁

tactic: simp_rw [h, false_and_iff, or_false_iff]
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type ?u.88795
δ : Type ?u.88798
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : ¬(s = ∅ ∨ t = ∅)
⊢ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅) ↔ s = s₁ ∧ t = t₁

tactic: simp_rw [h, @eq_comm _ ∅, prod_eq_empty_iff, prod_eq_empty_iff.mp h, true_and_iff,
  or_iff_right_iff_imp]
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type ?u.88795
δ : Type ?u.88798
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : s ×ˢ t = ∅
⊢ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅) ↔ s ×ˢ t = s₁ ×ˢ t₁

tactic: rintro ⟨rfl, rfl⟩
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type ?u.88795
δ : Type ?u.88798
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
h : s ×ˢ t = ∅
⊢ s = s₁ ∧ t = t₁ → s₁ = ∅ ∨ t₁ = ∅

tactic: exact prod_eq_empty_iff.mp h
state_before: case inl.intro
α : Type u_1
β : Type u_2
γ : Type ?u.88795
δ : Type ?u.88798
s s₂ : Set α
t t₂ : Set β
a : α
b : β
h : s ×ˢ t = ∅
⊢ s = ∅ ∨ t = ∅
Theorem: Real.cauchy_inv
File: Mathlib/Data/Real/Basic.lean

tactic: rw [inv']
state_before: x y : ℝ
f : Cauchy abs
⊢ (Real.inv' { cauchy := f }).cauchy = { cauchy := f }.cauchy⁻¹
Theorem: ContinuousMultilinearMap.norm_compContinuousLinearMap_le
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: rw [prod_mul_distrib, mul_assoc]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
g : ContinuousMultilinearMap 𝕜 E₁ G
f : (i : ι) → E i →L[𝕜] E₁ i
m : (i : ι) → E i
⊢ ‖g‖ * ∏ i : ι, ‖f i‖ * ‖m i‖ = (‖g‖ * ∏ i : ι, ‖f i‖) * ∏ i : ι, ‖m i‖
Theorem: Finset.coe_powerset
File: Mathlib/Data/Finset/Powerset.lean

tactic: ext
state_before: α : Type u_1
s✝ t s : Finset α
⊢ ↑(powerset s) = toSet ⁻¹' 𝒫↑s

tactic: simp
state_before: case h
α : Type u_1
s✝ t s x✝ : Finset α
⊢ x✝ ∈ ↑(powerset s) ↔ x✝ ∈ toSet ⁻¹' 𝒫↑s
Theorem: Wbtw.left_ne_right_of_ne_left
File: Mathlib/Analysis/Convex/Between.lean

tactic: rintro rfl
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.160970
P : Type u_3
P' : Type ?u.160976
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
h : Wbtw R x y z
hne : y ≠ x
⊢ x ≠ z

tactic: rw [wbtw_self_iff] at h
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.160970
P : Type u_3
P' : Type ?u.160976
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
hne : y ≠ x
h : Wbtw R x y x
⊢ False

tactic: exact hne h
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.160970
P : Type u_3
P' : Type ?u.160976
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
hne : y ≠ x
h : y = x
⊢ False
Theorem: norm_iteratedFDerivWithin_fderivWithin
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rw [iteratedFDerivWithin_succ_eq_comp_right hs hx, comp_apply, LinearIsometryEquiv.norm_map]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
⊢ ‖iteratedFDerivWithin 𝕜 n (fderivWithin 𝕜 f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n + 1) f s x‖
Theorem: Fin.one_succAbove_one
File: Mathlib/Data/Fin/Basic.lean

tactic: have := succ_succAbove_succ (0 : Fin (n + 2)) (0 : Fin (n + 2))
state_before: n✝ m n : ℕ
⊢ ↑(succAbove 1) 1 = 2

tactic: simp only [succ_zero_eq_one, val_zero, Nat.cast_zero, zero_succAbove, succ_one_eq_two] at this
state_before: n✝ m n : ℕ
this : ↑(succAbove (succ 0)) (succ ↑↑0) = succ (↑(succAbove 0) ↑↑0)
⊢ ↑(succAbove 1) 1 = 2

tactic: exact this
state_before: n✝ m n : ℕ
this : ↑(succAbove 1) 1 = 2
⊢ ↑(succAbove 1) 1 = 2
Theorem: Int.card_fintype_Ioo
File: Mathlib/Data/Int/Interval.lean

tactic: rw [← card_Ioo, Fintype.card_ofFinset]
state_before: a b : ℤ
⊢ Fintype.card ↑(Set.Ioo a b) = toNat (b - a - 1)
Theorem: ENorm.map_neg
File: Mathlib/Analysis/NormedSpace/ENorm.lean

tactic: rw [← map_smul, neg_one_smul]
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x : V
⊢ ↑e (-x) = ↑‖-1‖₊ * ↑e x

tactic: simp
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x : V
⊢ ↑‖-1‖₊ * ↑e x = ↑e x
Theorem: StarConvex.union
File: Mathlib/Analysis/Convex/Star.lean

tactic: rintro y (hy | hy) a b ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.8175
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 x t
⊢ StarConvex 𝕜 x (s ∪ t)

tactic: exact Or.inl (hs hy ha hb hab)
state_before: case inl
𝕜 : Type u_1
E : Type u_2
F : Type ?u.8175
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 x t
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ s ∪ t

tactic: exact Or.inr (ht hy ha hb hab)
state_before: case inr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.8175
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
hs : StarConvex 𝕜 x s
ht : StarConvex 𝕜 x t
y : E
hy : y ∈ t
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ s ∪ t
Theorem: Set.PairwiseDisjoint.subset_of_biUnion_subset_biUnion
File: Mathlib/Data/Set/Pairwise/Lattice.lean

tactic: rintro i hi
state_before: α : Type u_1
β : Type ?u.5199
γ : Type ?u.5202
ι : Type u_2
ι' : Type ?u.5208
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : PairwiseDisjoint (s ∪ t) f
h₁ : ∀ (i : ι), i ∈ s → Set.Nonempty (f i)
h : (⋃ (i : ι) (_ : i ∈ s), f i) ⊆ ⋃ (i : ι) (_ : i ∈ t), f i
⊢ s ⊆ t

tactic: obtain ⟨a, hai⟩ := h₁ i hi
state_before: α : Type u_1
β : Type ?u.5199
γ : Type ?u.5202
ι : Type u_2
ι' : Type ?u.5208
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : PairwiseDisjoint (s ∪ t) f
h₁ : ∀ (i : ι), i ∈ s → Set.Nonempty (f i)
h : (⋃ (i : ι) (_ : i ∈ s), f i) ⊆ ⋃ (i : ι) (_ : i ∈ t), f i
i : ι
hi : i ∈ s
⊢ i ∈ t

tactic: obtain ⟨j, hj, haj⟩ := mem_iUnion₂.1 (h <| mem_iUnion₂_of_mem hi hai)
state_before: case intro
α : Type u_1
β : Type ?u.5199
γ : Type ?u.5202
ι : Type u_2
ι' : Type ?u.5208
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : PairwiseDisjoint (s ∪ t) f
h₁ : ∀ (i : ι), i ∈ s → Set.Nonempty (f i)
h : (⋃ (i : ι) (_ : i ∈ s), f i) ⊆ ⋃ (i : ι) (_ : i ∈ t), f i
i : ι
hi : i ∈ s
a : α
hai : a ∈ f i
⊢ i ∈ t

tactic: rwa [h₀.eq (subset_union_left _ _ hi) (subset_union_right _ _ hj)
    (not_disjoint_iff.2 ⟨a, hai, haj⟩)]
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.5199
γ : Type ?u.5202
ι : Type u_2
ι' : Type ?u.5208
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : PairwiseDisjoint (s ∪ t) f
h₁ : ∀ (i : ι), i ∈ s → Set.Nonempty (f i)
h : (⋃ (i : ι) (_ : i ∈ s), f i) ⊆ ⋃ (i : ι) (_ : i ∈ t), f i
i : ι
hi : i ∈ s
a : α
hai : a ∈ f i
j : ι
hj : j ∈ t
haj : a ∈ f j
⊢ i ∈ t
Theorem: orderTopology_of_nhds_abs
File: Mathlib/Topology/Order/Basic.lean

tactic: refine' ⟨eq_of_nhds_eq_nhds fun a => _⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α✝
inst✝³ : LinearOrderedAddCommGroup α✝
inst✝² : OrderTopology α✝
l : Filter β
f g : β → α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : LinearOrderedAddCommGroup α
h_nhds : ∀ (a : α), 𝓝 a = ⨅ (r : α) (_ : r > 0), 𝓟 {b | abs (a - b) < r}
⊢ OrderTopology α

tactic: rw [h_nhds]
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α✝
inst✝³ : LinearOrderedAddCommGroup α✝
inst✝² : OrderTopology α✝
l : Filter β
f g : β → α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : LinearOrderedAddCommGroup α
h_nhds : ∀ (a : α), 𝓝 a = ⨅ (r : α) (_ : r > 0), 𝓟 {b | abs (a - b) < r}
a : α
⊢ 𝓝 a = 𝓝 a

tactic: letI := Preorder.topology α
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α✝
inst✝³ : LinearOrderedAddCommGroup α✝
inst✝² : OrderTopology α✝
l : Filter β
f g : β → α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : LinearOrderedAddCommGroup α
h_nhds : ∀ (a : α), 𝓝 a = ⨅ (r : α) (_ : r > 0), 𝓟 {b | abs (a - b) < r}
a : α
⊢ (⨅ (r : α) (_ : r > 0), 𝓟 {b | abs (a - b) < r}) = 𝓝 a

tactic: letI : OrderTopology α := ⟨rfl⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α✝
inst✝³ : LinearOrderedAddCommGroup α✝
inst✝² : OrderTopology α✝
l : Filter β
f g : β → α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : LinearOrderedAddCommGroup α
h_nhds : ∀ (a : α), 𝓝 a = ⨅ (r : α) (_ : r > 0), 𝓟 {b | abs (a - b) < r}
a : α
this : TopologicalSpace α := Preorder.topology α
⊢ (⨅ (r : α) (_ : r > 0), 𝓟 {b | abs (a - b) < r}) = 𝓝 a

tactic: exact (nhds_eq_iInf_abs_sub a).symm
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α✝
inst✝³ : LinearOrderedAddCommGroup α✝
inst✝² : OrderTopology α✝
l : Filter β
f g : β → α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : LinearOrderedAddCommGroup α
h_nhds : ∀ (a : α), 𝓝 a = ⨅ (r : α) (_ : r > 0), 𝓟 {b | abs (a - b) < r}
a : α
this✝ : TopologicalSpace α := Preorder.topology α
this : OrderTopology α := { topology_eq_generate_intervals := rfl }
⊢ (⨅ (r : α) (_ : r > 0), 𝓟 {b | abs (a - b) < r}) = 𝓝 a
Theorem: FreeAlgebra.lift_symm_apply
File: Mathlib/Algebra/FreeAlgebra.lean

tactic: rw [lift]
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
F : FreeAlgebra R X →ₐ[R] A
⊢ ↑(lift R).symm F = ↑F ∘ ι R

tactic: rfl
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
F : FreeAlgebra R X →ₐ[R] A
⊢ ↑{ toFun := FreeAlgebra.liftAux R, invFun := fun F => ↑F ∘ ι R,
            left_inv := (_ : ∀ (f : X → A), (fun F => ↑F ∘ ι R) (FreeAlgebra.liftAux R f) = f),
            right_inv := (_ : ∀ (F : FreeAlgebra R X →ₐ[R] A), FreeAlgebra.liftAux R ((fun F => ↑F ∘ ι R) F) = F) }.symm
      F =
    ↑F ∘ ι R
Theorem: List.naturality
File: Mathlib/Control/Traversable/Instances.lean

tactic: induction x <;> simp! [*, functor_norm, ApplicativeTransformation.preserves_map,
  ApplicativeTransformation.preserves_seq, ApplicativeTransformation.preserves_pure]
state_before: F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
x : List α
⊢ (fun {α} => ApplicativeTransformation.app η α) (List.traverse f x) =
    List.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) x
Theorem: IsSelfAdjoint.skewAdjointPart_apply
File: Mathlib/Algebra/Star/Module.lean

tactic: rw [skewAdjointPart_apply_coe, hx.star_eq, sub_self, smul_zero, ZeroMemClass.coe_zero]
state_before: R : Type u_2
A : Type u_1
inst✝⁷ : Semiring R
inst✝⁶ : StarSemigroup R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
x : A
hx : IsSelfAdjoint x
⊢ ↑(↑(skewAdjointPart R) x) = ↑0
Theorem: Substring.ValidFor.atEnd
File: Std/Data/String/Lemmas.lean

tactic: simp [Substring.atEnd, Pos.ext_iff, Nat.add_left_cancel_iff]
state_before: l m r : List Char
p : Nat
⊢ Substring.atEnd
        { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
          stopPos := { byteIdx := utf8Len l + utf8Len m } }
        { byteIdx := p } =
      true ↔
    p = utf8Len m
Theorem: Filter.prod_pure
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [prod_eq, seq_pure, map_map]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.44252
δ : Type ?u.44255
ι : Sort ?u.44258
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : Filter α
b : β
⊢ f ×ˢ pure b = map (fun a => (a, b)) f

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.44252
δ : Type ?u.44255
ι : Sort ?u.44258
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : Filter α
b : β
⊢ map ((fun g => g b) ∘ Prod.mk) f = map (fun a => (a, b)) f
Theorem: CategoryTheory.Limits.prod.lift_map
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: apply prod.hom_ext
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ V W X Y Z : C
inst✝¹ : HasBinaryProduct W X
inst✝ : HasBinaryProduct Y Z
f : V ⟶ W
g : V ⟶ X
h : W ⟶ Y
k : X ⟶ Z
⊢ lift f g ≫ map h k = lift (f ≫ h) (g ≫ k)

tactic: simp
state_before: case h₁
C : Type u
inst✝² : Category C
X✝ Y✝ V W X Y Z : C
inst✝¹ : HasBinaryProduct W X
inst✝ : HasBinaryProduct Y Z
f : V ⟶ W
g : V ⟶ X
h : W ⟶ Y
k : X ⟶ Z
⊢ (lift f g ≫ map h k) ≫ fst = lift (f ≫ h) (g ≫ k) ≫ fst

case h₂
C : Type u
inst✝² : Category C
X✝ Y✝ V W X Y Z : C
inst✝¹ : HasBinaryProduct W X
inst✝ : HasBinaryProduct Y Z
f : V ⟶ W
g : V ⟶ X
h : W ⟶ Y
k : X ⟶ Z
⊢ (lift f g ≫ map h k) ≫ snd = lift (f ≫ h) (g ≫ k) ≫ snd

tactic: simp
state_before: case h₂
C : Type u
inst✝² : Category C
X✝ Y✝ V W X Y Z : C
inst✝¹ : HasBinaryProduct W X
inst✝ : HasBinaryProduct Y Z
f : V ⟶ W
g : V ⟶ X
h : W ⟶ Y
k : X ⟶ Z
⊢ (lift f g ≫ map h k) ≫ snd = lift (f ≫ h) (g ≫ k) ≫ snd
Theorem: pochhammer_nat_eq_ascFactorial
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: rw [pochhammer_zero, eval_one, Nat.ascFactorial_zero]
state_before: S : Type u
inst✝ : Semiring S
n : ℕ
⊢ eval (n + 1) (pochhammer ℕ 0) = Nat.ascFactorial n 0

tactic: rw [pochhammer_succ_right, eval_mul, pochhammer_nat_eq_ascFactorial n t]
state_before: S : Type u
inst✝ : Semiring S
n t : ℕ
⊢ eval (n + 1) (pochhammer ℕ (t + 1)) = Nat.ascFactorial n (t + 1)

tactic: simp only [eval_add, eval_X, eval_nat_cast, Nat.cast_id]
state_before: S : Type u
inst✝ : Semiring S
n t : ℕ
⊢ Nat.ascFactorial n t * eval (n + 1) (X + ↑t) = Nat.ascFactorial n (t + 1)

tactic: rw [Nat.ascFactorial_succ, add_right_comm, mul_comm]
state_before: S : Type u
inst✝ : Semiring S
n t : ℕ
⊢ Nat.ascFactorial n t * (n + 1 + t) = Nat.ascFactorial n (t + 1)
Theorem: Set.definable_univ
File: Mathlib/ModelTheory/Definability.lean

tactic: ext
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.10107
B : Set M
s : Set (α → M)
⊢ univ = setOf (Formula.Realize ⊤)

tactic: simp
state_before: case h
M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.10107
B : Set M
s : Set (α → M)
x✝ : α → M
⊢ x✝ ∈ univ ↔ x✝ ∈ setOf (Formula.Realize ⊤)
Theorem: SimpleGraph.Walk.support_nonempty
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ u ∈ {w | w ∈ support p}
Theorem: AlgebraicTopology.DoldKan.Compatibility.equivalence₁UnitIso_eq
File: Mathlib/AlgebraicTopology/DoldKan/Compatibility.lean

tactic: ext X
state_before: A : Type u_1
A' : Type u_5
B : Type ?u.21378
B' : Type u_4
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
⊢ (equivalence₁ hF).unitIso = equivalence₁UnitIso hF

tactic: dsimp [equivalence₁]
state_before: case w.w.h
A : Type u_1
A' : Type u_5
B : Type ?u.21378
B' : Type u_4
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
X : A
⊢ (equivalence₁ hF).unitIso.hom.app X = (equivalence₁UnitIso hF).hom.app X

tactic: unfold Functor.asEquivalence
state_before: case w.w.h
A : Type u_1
A' : Type u_5
B : Type ?u.21378
B' : Type u_4
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
X : A
⊢ (Functor.asEquivalence F).unitIso.hom.app X = (equivalence₁UnitIso hF).hom.app X

tactic: dsimp [NatIso.hcomp, IsEquivalence.ofEquivalence]
state_before: case w.w.h
A : Type u_1
A' : Type u_5
B : Type ?u.21378
B' : Type u_4
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
X : A
⊢ (Equivalence.mk' F (IsEquivalence.inverse F) IsEquivalence.unitIso IsEquivalence.counitIso).unitIso.hom.app X =
    (equivalence₁UnitIso hF).hom.app X

tactic: simp
state_before: case w.w.h
A : Type u_1
A' : Type u_5
B : Type ?u.21378
B' : Type u_4
inst✝³ : Category A
inst✝² : Category A'
inst✝¹ : Category B
inst✝ : Category B'
eA : A ≌ A'
eB : B ≌ B'
e' : A' ≌ B'
F : A ⥤ B'
hF : eA.functor ⋙ e'.functor ≅ F
G : B ⥤ A
hG : eB.functor ⋙ e'.inverse ≅ G ⋙ eA.functor
X : A
⊢ IsEquivalence.unitIso.hom.app X = (equivalence₁UnitIso hF).hom.app X
Theorem: AffineMap.decomp'
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: rw [decomp]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type ?u.607898
V2 : Type u_3
P2 : Type ?u.607904
V3 : Type ?u.607907
P3 : Type ?u.607910
V4 : Type ?u.607913
P4 : Type ?u.607916
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
f : V1 →ᵃ[k] V2
⊢ ↑f.linear = ↑f - fun x => ↑f 0

tactic: simp only [LinearMap.map_zero, Pi.add_apply, add_sub_cancel, zero_add]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type ?u.607898
V2 : Type u_3
P2 : Type ?u.607904
V3 : Type ?u.607907
P3 : Type ?u.607910
V4 : Type ?u.607913
P4 : Type ?u.607916
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
f : V1 →ᵃ[k] V2
⊢ ↑f.linear = (↑f.linear + fun x => ↑f 0) - fun x => (↑f.linear + fun x => ↑f 0) 0
Theorem: MeasureTheory.snorm_mono_measure
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: by_cases hp0 : p = 0
state_before: α : Type u_1
E : Type ?u.1987947
F : Type u_2
G : Type ?u.1987953
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hμν : ν ≤ μ
⊢ snorm f p ν ≤ snorm f p μ

tactic: by_cases hp_top : p = ∞
state_before: case neg
α : Type u_1
E : Type ?u.1987947
F : Type u_2
G : Type ?u.1987953
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hμν : ν ≤ μ
hp0 : ¬p = 0
⊢ snorm f p ν ≤ snorm f p μ

tactic: simp_rw [snorm_eq_snorm' hp0 hp_top]
state_before: case neg
α : Type u_1
E : Type ?u.1987947
F : Type u_2
G : Type ?u.1987953
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hμν : ν ≤ μ
hp0 : ¬p = 0
hp_top : ¬p = ⊤
⊢ snorm f p ν ≤ snorm f p μ

tactic: exact snorm'_mono_measure f hμν ENNReal.toReal_nonneg
state_before: case neg
α : Type u_1
E : Type ?u.1987947
F : Type u_2
G : Type ?u.1987953
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hμν : ν ≤ μ
hp0 : ¬p = 0
hp_top : ¬p = ⊤
⊢ snorm' f (ENNReal.toReal p) ν ≤ snorm' f (ENNReal.toReal p) μ

tactic: simp [hp0]
state_before: case pos
α : Type u_1
E : Type ?u.1987947
F : Type u_2
G : Type ?u.1987953
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hμν : ν ≤ μ
hp0 : p = 0
⊢ snorm f p ν ≤ snorm f p μ

tactic: simp [hp_top, snormEssSup_mono_measure f (Measure.absolutelyContinuous_of_le hμν)]
state_before: case pos
α : Type u_1
E : Type ?u.1987947
F : Type u_2
G : Type ?u.1987953
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hμν : ν ≤ μ
hp0 : ¬p = 0
hp_top : p = ⊤
⊢ snorm f p ν ≤ snorm f p μ