tasksource/leandojo huggingface dataset:
Theorem: Turing.TM2to1.addBottom_map
File: Mathlib/Computability/TuringMachine.lean

tactic: rfl
state_before: K : Type ?u.595576
inst✝² : DecidableEq K
Γ : K → Type ?u.595590
Λ : Type ?u.595593
inst✝¹ : Inhabited Λ
σ : Type ?u.595599
inst✝ : Inhabited σ
L : ListBlank ((k : K) → Option (Γ k))
⊢ default.snd = default

tactic: simp only [addBottom, ListBlank.map_cons]
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type ?u.595593
inst✝¹ : Inhabited Λ
σ : Type ?u.595599
inst✝ : Inhabited σ
L : ListBlank ((k : K) → Option (Γ k))
⊢ ListBlank.map { f := Prod.snd, map_pt' := (_ : default.snd = default.snd) } (addBottom L) = L

tactic: convert ListBlank.cons_head_tail L
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type ?u.595593
inst✝¹ : Inhabited Λ
σ : Type ?u.595599
inst✝ : Inhabited σ
L : ListBlank ((k : K) → Option (Γ k))
⊢ ListBlank.cons (ListBlank.head L)
      (ListBlank.map { f := Prod.snd, map_pt' := (_ : default.snd = default.snd) }
        (ListBlank.map { f := Prod.mk false, map_pt' := (_ : (false, default) = (false, default)) }
          (ListBlank.tail L))) =
    L

tactic: generalize ListBlank.tail L = L'
state_before: case h.e'_2.h.e'_4
K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type ?u.595593
inst✝¹ : Inhabited Λ
σ : Type ?u.595599
inst✝ : Inhabited σ
L : ListBlank ((k : K) → Option (Γ k))
⊢ ListBlank.map { f := Prod.snd, map_pt' := (_ : default.snd = default.snd) }
      (ListBlank.map { f := Prod.mk false, map_pt' := (_ : (false, default) = (false, default)) } (ListBlank.tail L)) =
    ListBlank.tail L

tactic: refine' L'.induction_on fun l ↦ _
state_before: case h.e'_2.h.e'_4
K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type ?u.595593
inst✝¹ : Inhabited Λ
σ : Type ?u.595599
inst✝ : Inhabited σ
L L' : ListBlank ((k : K) → Option (Γ k))
⊢ ListBlank.map { f := Prod.snd, map_pt' := (_ : default.snd = default.snd) }
      (ListBlank.map { f := Prod.mk false, map_pt' := (_ : (false, default) = (false, default)) } L') =
    L'

tactic: simp
state_before: case h.e'_2.h.e'_4
K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type ?u.595593
inst✝¹ : Inhabited Λ
σ : Type ?u.595599
inst✝ : Inhabited σ
L L' : ListBlank ((k : K) → Option (Γ k))
l : List ((k : K) → Option (Γ k))
⊢ ListBlank.map { f := Prod.snd, map_pt' := (_ : default.snd = default.snd) }
      (ListBlank.map { f := Prod.mk false, map_pt' := (_ : (false, default) = (false, default)) } (ListBlank.mk l)) =
    ListBlank.mk l
Theorem: Sym2.other_spec'
File: Mathlib/Data/Sym/Sym2.lean

tactic: induction z using Sym2.ind
state_before: α : Type u_1
β : Type ?u.101059
γ : Type ?u.101062
inst✝ : DecidableEq α
a : α
z : Sym2 α
h : a ∈ z
⊢ Quotient.mk (Rel.setoid α) (a, Mem.other' h) = z

tactic: have h' := mem_iff.mp h
state_before: case h
α : Type u_1
β : Type ?u.101059
γ : Type ?u.101062
inst✝ : DecidableEq α
a x✝ y✝ : α
h : a ∈ Quotient.mk (Rel.setoid α) (x✝, y✝)
⊢ Quotient.mk (Rel.setoid α) (a, Mem.other' h) = Quotient.mk (Rel.setoid α) (x✝, y✝)

tactic: aesop (add norm unfold [Quotient.rec, Quot.rec]) (rule_sets [Sym2])
state_before: case h
α : Type u_1
β : Type ?u.101059
γ : Type ?u.101062
inst✝ : DecidableEq α
a x✝ y✝ : α
h : a ∈ Quotient.mk (Rel.setoid α) (x✝, y✝)
h' : a = x✝ ∨ a = y✝
⊢ Quotient.mk (Rel.setoid α) (a, Mem.other' h) = Quotient.mk (Rel.setoid α) (x✝, y✝)
Theorem: Real.cos_sq'
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← sin_sq_add_cos_sq x, add_sub_cancel']
state_before: x y : ℝ
⊢ cos x ^ 2 = 1 - sin x ^ 2
Theorem: mul_left_eq_self
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [one_mul]
state_before: α : Type ?u.14402
β : Type ?u.14405
G : Type ?u.14408
M : Type u
inst✝ : RightCancelMonoid M
a b : M
⊢ a * b = b ↔ a * b = 1 * b
Theorem: IsMinOn.sub
File: Mathlib/Order/Filter/Extr.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝ : OrderedAddCommGroup β
f g : α → β
a : α
s : Set α
l : Filter α
hf : IsMinOn f s a
hg : IsMaxOn g s a
⊢ IsMinOn (fun x => f x - g x) s a
Theorem: smul_ite
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: split_ifs <;> rfl
state_before: M : Type u_2
N : Type ?u.14217
G : Type ?u.14220
A : Type ?u.14223
B : Type ?u.14226
α : Type u_1
β : Type ?u.14232
γ : Type ?u.14235
δ : Type ?u.14238
inst✝¹ : SMul M α
p : Prop
inst✝ : Decidable p
a : M
b₁ b₂ : α
⊢ (a • if p then b₁ else b₂) = if p then a • b₁ else a • b₂
Theorem: HomogeneousIdeal.toIdeal_iSup₂
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: simp_rw [toIdeal_iSup]
state_before: ι : Type u_3
σ : Type u_4
R : Type ?u.163506
A : Type u_5
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
κ' : κ → Sort u_2
s : (i : κ) → κ' i → HomogeneousIdeal 𝒜
⊢ toIdeal (⨆ (i : κ) (j : κ' i), s i j) = ⨆ (i : κ) (j : κ' i), toIdeal (s i j)
Theorem: Set.infsep_pair_eq_toReal
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: by_cases hxy : x = y
state_before: α : Type u_1
β : Type ?u.57659
inst✝ : PseudoEMetricSpace α
x y : α
s : Set α
⊢ infsep {x, y} = ENNReal.toReal (edist x y)

tactic: rw [hxy]
state_before: case pos
α : Type u_1
β : Type ?u.57659
inst✝ : PseudoEMetricSpace α
x y : α
s : Set α
hxy : x = y
⊢ infsep {x, y} = ENNReal.toReal (edist x y)

tactic: simp only [infsep_singleton, pair_eq_singleton, edist_self, ENNReal.zero_toReal]
state_before: case pos
α : Type u_1
β : Type ?u.57659
inst✝ : PseudoEMetricSpace α
x y : α
s : Set α
hxy : x = y
⊢ infsep {y, y} = ENNReal.toReal (edist y y)

tactic: rw [infsep, einfsep_pair hxy]
state_before: case neg
α : Type u_1
β : Type ?u.57659
inst✝ : PseudoEMetricSpace α
x y : α
s : Set α
hxy : ¬x = y
⊢ infsep {x, y} = ENNReal.toReal (edist x y)
Theorem: List.isPrefix.map
File: Mathlib/Data/List/Infix.lean

tactic: induction' l₁ with hd tl hl generalizing l₂
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
h : l₁ <+: l₂
f : α → β
⊢ List.map f l₁ <+: List.map f l₂

tactic: simp only [nil_prefix, map_nil]
state_before: case nil
α : Type u_1
β : Type u_2
l l₁ l₂✝ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂✝
f : α → β
l₂ : List α
h : [] <+: l₂
⊢ List.map f [] <+: List.map f l₂

tactic: cases' l₂ with hd₂ tl₂
state_before: case cons
α : Type u_1
β : Type u_2
l l₁ l₂✝ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂✝
f : α → β
hd : α
tl : List α
hl : ∀ {l₂ : List α}, tl <+: l₂ → List.map f tl <+: List.map f l₂
l₂ : List α
h : hd :: tl <+: l₂
⊢ List.map f (hd :: tl) <+: List.map f l₂

tactic: simpa only using eq_nil_of_prefix_nil h
state_before: case cons.nil
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂
f : α → β
hd : α
tl : List α
hl : ∀ {l₂ : List α}, tl <+: l₂ → List.map f tl <+: List.map f l₂
h : hd :: tl <+: []
⊢ List.map f (hd :: tl) <+: List.map f []

tactic: rw [cons_prefix_iff] at h
state_before: case cons.cons
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂
f : α → β
hd : α
tl : List α
hl : ∀ {l₂ : List α}, tl <+: l₂ → List.map f tl <+: List.map f l₂
hd₂ : α
tl₂ : List α
h : hd :: tl <+: hd₂ :: tl₂
⊢ List.map f (hd :: tl) <+: List.map f (hd₂ :: tl₂)

tactic: simp only [List.map_cons, h, prefix_cons_inj, hl, map]
state_before: case cons.cons
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
h✝ : l₁ <+: l₂
f : α → β
hd : α
tl : List α
hl : ∀ {l₂ : List α}, tl <+: l₂ → List.map f tl <+: List.map f l₂
hd₂ : α
tl₂ : List α
h : hd = hd₂ ∧ tl <+: tl₂
⊢ List.map f (hd :: tl) <+: List.map f (hd₂ :: tl₂)
Theorem: Bool.and_self
File: src/lean/Init/SimpLemmas.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ (b && b) = b
Theorem: ite_mul
File: Mathlib/Algebra/Ring/Defs.lean

tactic: split_ifs <;> rfl
state_before: α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Mul α
P : Prop
inst✝ : Decidable P
a b c : α
⊢ (if P then a else b) * c = if P then a * c else b * c
Theorem: Relation.TransGen.lift'
File: Mathlib/Logic/Relation.lean

tactic: simpa [transGen_idem] using hab.lift f h
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.23283
δ : Type ?u.23286
r : α → α → Prop
a✝ b✝ c d : α
p : β → β → Prop
a b : α
f : α → β
h : ∀ (a b : α), r a b → TransGen p (f a) (f b)
hab : TransGen r a b
⊢ TransGen p (f a) (f b)
Theorem: ZMod.neg_one_pow_div_two_of_one_mod_four
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: rw [← χ₄_eq_neg_one_pow (Nat.odd_of_mod_four_eq_one hn), ← nat_cast_mod, hn]
state_before: n : ℕ
hn : n % 4 = 1
⊢ (-1) ^ (n / 2) = 1

tactic: rfl
state_before: n : ℕ
hn : n % 4 = 1
⊢ ↑χ₄ ↑1 = 1
Theorem: frequently_nhdsWithin_iff
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [Filter.Frequently, eventually_nhdsWithin_iff, not_and']
state_before: α : Type u_1
β : Type ?u.711
γ : Type ?u.714
δ : Type ?u.717
inst✝ : TopologicalSpace α
z : α
s : Set α
p : α → Prop
⊢ (∃ᶠ (x : α) in 𝓝[s] z, p x) ↔ ∃ᶠ (x : α) in 𝓝 z, p x ∧ x ∈ s
Theorem: Nat.mod_two_eq_zero_or_one
File: Std/Data/Nat/Lemmas.lean

tactic: simp
state_before: n : Nat
⊢ 2 > 0
Theorem: Set.preimage_neg_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iic, ← Ici_inter_Iio, inter_comm]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ -Ioc a b = Ico (-b) (-a)
Theorem: DirectSum.coe_decompose_mul_of_right_mem_of_not_le
File: Mathlib/RingTheory/GradedAlgebra/Basic.lean

tactic: lift b to 𝒜 i using b_mem
state_before: ι : Type u_3
R : Type ?u.348167
A : Type u_1
σ : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : CanonicallyOrderedAddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a b : A
n i : ι
b_mem : b ∈ 𝒜 i
h : ¬i ≤ n
⊢ ↑(↑(↑(decompose 𝒜) (a * b)) n) = 0

tactic: rwa [decompose_mul, decompose_coe, coe_mul_of_apply_of_not_le]
state_before: case intro
ι : Type u_3
R : Type ?u.348167
A : Type u_1
σ : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : CanonicallyOrderedAddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a : A
n i : ι
h : ¬i ≤ n
b : { x // x ∈ 𝒜 i }
⊢ ↑(↑(↑(decompose 𝒜) (a * ↑b)) n) = 0
Theorem: Finset.orderEmbOfCardLe_mem
File: Mathlib/Data/Finset/Sort.lean

tactic: simp only [orderEmbOfCardLe, RelEmbedding.coe_trans, Finset.orderEmbOfFin_mem,
  Function.comp_apply]
state_before: α : Type u_1
β : Type ?u.61043
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : k ≤ card s
a : Fin k
⊢ ↑(orderEmbOfCardLe s h) a ∈ s
Theorem: Multiset.powersetLen_zero_left
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp [powersetLen_coe']
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ powersetLen 0 (Quotient.mk (isSetoid α) l) = {0}
Theorem: Algebra.FinitePresentation.quotient
File: Mathlib/RingTheory/FinitePresentation.lean

tactic: obtain ⟨n, f, hf⟩ := hfp
state_before: R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : CommRing B
inst✝ : Algebra R B
I : Ideal A
h : Ideal.FG I
hfp : FinitePresentation R A
⊢ FinitePresentation R (A ⧸ I)

tactic: refine' ⟨n, (Ideal.Quotient.mkₐ R I).comp f, _, _⟩
state_before: case intro.intro
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : CommRing B
inst✝ : Algebra R B
I : Ideal A
h : Ideal.FG I
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ↑f ∧ Ideal.FG (RingHom.ker ↑f)
⊢ FinitePresentation R (A ⧸ I)

tactic: exact (Ideal.Quotient.mkₐ_surjective R I).comp hf.1
state_before: case intro.intro.refine'_1
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : CommRing B
inst✝ : Algebra R B
I : Ideal A
h : Ideal.FG I
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ↑f ∧ Ideal.FG (RingHom.ker ↑f)
⊢ Surjective ↑(AlgHom.comp (Ideal.Quotient.mkₐ R I) f)

tactic: refine' Ideal.fg_ker_comp _ _ hf.2 _ hf.1
state_before: case intro.intro.refine'_2
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : CommRing B
inst✝ : Algebra R B
I : Ideal A
h : Ideal.FG I
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ↑f ∧ Ideal.FG (RingHom.ker ↑f)
⊢ Ideal.FG (RingHom.ker ↑(AlgHom.comp (Ideal.Quotient.mkₐ R I) f))

tactic: simp [h]
state_before: case intro.intro.refine'_2
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
inst✝¹ : CommRing B
inst✝ : Algebra R B
I : Ideal A
h : Ideal.FG I
n : ℕ
f : MvPolynomial (Fin n) R →ₐ[R] A
hf : Surjective ↑f ∧ Ideal.FG (RingHom.ker ↑f)
⊢ Ideal.FG (RingHom.ker ↑(Ideal.Quotient.mkₐ R I))
Theorem: CategoryTheory.Limits.WidePushout.ι_desc
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

tactic: simp only [colimit.ι_desc, WidePushoutShape.mkCocone_pt, WidePushoutShape.mkCocone_ι_app]
state_before: J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
j : J
⊢ ι arrows j ≫ desc f fs w = fs j
Theorem: div_mul_comm
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.41688
G : Type ?u.41691
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b * c = c / b * a
Theorem: RingQuot.one_quot
File: Mathlib/Algebra/RingQuot.lean

tactic: rw [one_def]
state_before: R : Type u₁
inst✝³ : Semiring R
S : Type u₂
inst✝² : CommSemiring S
A : Type u₃
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
⊢ { toQuot := Quot.mk (Rel r) 1 } = RingQuot.one r
Theorem: Set.mulIndicator_apply
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: unfold mulIndicator
state_before: α : Type u_1
β : Type ?u.1047
ι : Type ?u.1050
M : Type u_2
N : Type ?u.1056
inst✝² : One M
inst✝¹ : One N
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
inst✝ : Decidable (a ∈ s)
⊢ mulIndicator s f a = if a ∈ s then f a else 1

tactic: split_ifs with h <;> simp
state_before: α : Type u_1
β : Type ?u.1047
ι : Type ?u.1050
M : Type u_2
N : Type ?u.1056
inst✝² : One M
inst✝¹ : One N
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
inst✝ : Decidable (a ∈ s)
⊢ (let x := a;
    if x ∈ s then f x else 1) =
    if a ∈ s then f a else 1
Theorem: one_lt_div
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [lt_div_iff hb, one_mul]
state_before: ι : Type ?u.76204
α : Type u_1
β : Type ?u.76210
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hb : 0 < b
⊢ 1 < a / b ↔ b < a
Theorem: List.subperm_singleton_iff
File: Mathlib/Data/List/Perm.lean

tactic: rwa [perm_singleton.mp hla, singleton_sublist] at h
state_before: α✝ : Type uu
β : Type vv
l₁ l₂ : List α✝
inst✝ : DecidableEq α✝
α : Type u_1
l : List α
a : α
x✝ : [a] <+~ l
s : List α
hla : s ~ [a]
h : s <+ l
⊢ a ∈ l
Theorem: FirstOrder.Language.Formula.realize_rel
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.235577
P : Type ?u.235580
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
k : ℕ
R : Relations L k
ts : Fin k → Term L α
⊢ (RelMap R fun i => Term.realize (Sum.elim v default) (Term.relabel Sum.inl (ts i))) ↔
    RelMap R fun i => Term.realize v (ts i)
Theorem: CategoryTheory.ε_inv_app_obj
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: rw [← cancel_mono (F.ε.app ((F.obj n).obj X)), ε_inv_hom_app]
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ (MonoidalFunctor.εIso F).inv.app ((F.obj n).obj X) =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X

tactic: simp
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ 𝟙 ((F.obj (𝟙_ M)).obj ((F.obj n).obj X)) =
    ((LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X) ≫
      F.ε.app ((F.obj n).obj X)

tactic: rfl
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ 𝟙 ((F.obj (𝟙_ M)).obj ((F.obj n).obj X)) = 𝟙 ((F.obj n ⊗ F.obj (𝟙_ M)).obj X)
Theorem: Complex.sin_sub
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sub_eq_add_neg, sin_add, sin_neg, cos_neg]
state_before: x y : ℂ
⊢ sin (x - y) = sin x * cos y - cos x * sin y
Theorem: CategoryTheory.Abelian.Functor.preserves_exact_of_preservesFiniteLimits_of_mono
File: Mathlib/CategoryTheory/Abelian/RightDerived.lean

tactic: simp [← Functor.map_comp, ex.w]
state_before: C : Type u
inst✝⁶ : Category C
D : Type u
inst✝⁵ : Category D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝⁴ : Abelian C
inst✝³ : Abelian D
inst✝² : Functor.Additive F
inst✝¹ : PreservesFiniteLimits F
inst✝ : Mono f
ex : Exact f g
⊢ F.map f ≫ F.map g = 0
Theorem: ENNReal.one_lt_rpow_of_pos_of_lt_one_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: lift x to ℝ≥0 using ne_of_lt (lt_of_lt_of_le hx2 le_top)
state_before: x : ℝ≥0∞
z : ℝ
hx1 : 0 < x
hx2 : x < 1
hz : z < 0
⊢ 1 < x ^ z

tactic: simp only [coe_lt_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

tactic: simp [coe_rpow_of_ne_zero (ne_of_gt hx1), NNReal.one_lt_rpow_of_pos_of_lt_one_of_neg hx1 hx2 hz]
state_before: case intro
z : ℝ
hz : z < 0
x : ℝ≥0
hx1 : 0 < x
hx2 : x < 1
⊢ 1 < ↑x ^ z
Theorem: linearIndependent_le_span
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: apply linearIndependent_le_span' v i w
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.352311
R : Type u
inst✝⁴ : Ring R
inst✝³ : StrongRankCondition R
M : Type v
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_1
v : ι → M
i : LinearIndependent R v
w : Set M
inst✝ : Fintype ↑w
s : span R w = ⊤
⊢ (#ι) ≤ ↑(Fintype.card ↑w)

tactic: rw [s]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.352311
R : Type u
inst✝⁴ : Ring R
inst✝³ : StrongRankCondition R
M : Type v
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_1
v : ι → M
i : LinearIndependent R v
w : Set M
inst✝ : Fintype ↑w
s : span R w = ⊤
⊢ range v ≤ ↑(span R w)

tactic: exact le_top
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.352311
R : Type u
inst✝⁴ : Ring R
inst✝³ : StrongRankCondition R
M : Type v
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_1
v : ι → M
i : LinearIndependent R v
w : Set M
inst✝ : Fintype ↑w
s : span R w = ⊤
⊢ range v ≤ ↑⊤
Theorem: hasFDerivWithinAt_singleton
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: simp only [HasFDerivWithinAt, nhdsWithin_singleton, HasFDerivAtFilter, isLittleO_pure,
  ContinuousLinearMap.zero_apply, sub_self]
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.1399855
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.1399950
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
f : E → F
x : E
⊢ HasFDerivWithinAt f 0 {x} x
Theorem: div_le_iff_of_neg'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, div_le_iff_of_neg hc]
state_before: ι : Type ?u.144376
α : Type u_1
β : Type ?u.144382
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c < 0
⊢ b / c ≤ a ↔ c * a ≤ b
Theorem: CategoryTheory.Limits.Types.colimit_sound'
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: rw [← colimit.w _ f, ← colimit.w _ f']
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
j j' : J
x : F.obj j
x' : F.obj j'
j'' : J
f : j ⟶ j''
f' : j' ⟶ j''
w : F.map f x = F.map f' x'
⊢ colimit.ι F j x = colimit.ι F j' x'

tactic: rw [types_comp_apply, types_comp_apply, w]
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
j j' : J
x : F.obj j
x' : F.obj j'
j'' : J
f : j ⟶ j''
f' : j' ⟶ j''
w : F.map f x = F.map f' x'
⊢ (F.map f ≫ colimit.ι F j'') x = (F.map f' ≫ colimit.ι F j'') x'
Theorem: MeasureTheory.trim_trim
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: refine @Measure.ext _ m₁ _ _ (fun t ht => ?_)
state_before: α : Type u_1
β : Type ?u.3498865
γ : Type ?u.3498868
δ : Type ?u.3498871
ι : Type ?u.3498874
R : Type ?u.3498877
R' : Type ?u.3498880
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
m₁ m₂ : MeasurableSpace α
hm₁₂ : m₁ ≤ m₂
hm₂ : m₂ ≤ m0
⊢ trim (trim μ hm₂) hm₁₂ = trim μ (_ : m₁ ≤ m0)

tactic: rw [trim_measurableSet_eq hm₁₂ ht, trim_measurableSet_eq (hm₁₂.trans hm₂) ht,
  trim_measurableSet_eq hm₂ (hm₁₂ t ht)]
state_before: α : Type u_1
β : Type ?u.3498865
γ : Type ?u.3498868
δ : Type ?u.3498871
ι : Type ?u.3498874
R : Type ?u.3498877
R' : Type ?u.3498880
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
m₁ m₂ : MeasurableSpace α
hm₁₂ : m₁ ≤ m₂
hm₂ : m₂ ≤ m0
t : Set α
ht : MeasurableSet t
⊢ ↑↑(trim (trim μ hm₂) hm₁₂) t = ↑↑(trim μ (_ : m₁ ≤ m0)) t
Theorem: dense_sInter_of_open
File: Mathlib/Topology/MetricSpace/Baire.lean

tactic: cases' S.eq_empty_or_nonempty with h h
state_before: α : Type u_1
β : Type ?u.12812
γ : Type ?u.12815
ι : Type ?u.12818
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
S : Set (Set α)
ho : ∀ (s : Set α), s ∈ S → IsOpen s
hS : Set.Countable S
hd : ∀ (s : Set α), s ∈ S → Dense s
⊢ Dense (⋂₀ S)

tactic: simp [h]
state_before: case inl
α : Type u_1
β : Type ?u.12812
γ : Type ?u.12815
ι : Type ?u.12818
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
S : Set (Set α)
ho : ∀ (s : Set α), s ∈ S → IsOpen s
hS : Set.Countable S
hd : ∀ (s : Set α), s ∈ S → Dense s
h : S = ∅
⊢ Dense (⋂₀ S)

tactic: rcases hS.exists_eq_range h with ⟨f, hf⟩
state_before: case inr
α : Type u_1
β : Type ?u.12812
γ : Type ?u.12815
ι : Type ?u.12818
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
S : Set (Set α)
ho : ∀ (s : Set α), s ∈ S → IsOpen s
hS : Set.Countable S
hd : ∀ (s : Set α), s ∈ S → Dense s
h : Set.Nonempty S
⊢ Dense (⋂₀ S)

tactic: have F : ∀ n, f n ∈ S := fun n => by rw [hf]; exact mem_range_self _
state_before: case inr.intro
α : Type u_1
β : Type ?u.12812
γ : Type ?u.12815
ι : Type ?u.12818
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
S : Set (Set α)
ho : ∀ (s : Set α), s ∈ S → IsOpen s
hS : Set.Countable S
hd : ∀ (s : Set α), s ∈ S → Dense s
h : Set.Nonempty S
f : ℕ → Set α
hf : S = range f
⊢ Dense (⋂₀ S)

tactic: rw [hf, sInter_range]
state_before: case inr.intro
α : Type u_1
β : Type ?u.12812
γ : Type ?u.12815
ι : Type ?u.12818
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
S : Set (Set α)
ho : ∀ (s : Set α), s ∈ S → IsOpen s
hS : Set.Countable S
hd : ∀ (s : Set α), s ∈ S → Dense s
h : Set.Nonempty S
f : ℕ → Set α
hf : S = range f
F : ∀ (n : ℕ), f n ∈ S
⊢ Dense (⋂₀ S)

tactic: exact dense_iInter_of_open_nat (fun n => ho _ (F n)) fun n => hd _ (F n)
state_before: case inr.intro
α : Type u_1
β : Type ?u.12812
γ : Type ?u.12815
ι : Type ?u.12818
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
S : Set (Set α)
ho : ∀ (s : Set α), s ∈ S → IsOpen s
hS : Set.Countable S
hd : ∀ (s : Set α), s ∈ S → Dense s
h : Set.Nonempty S
f : ℕ → Set α
hf : S = range f
F : ∀ (n : ℕ), f n ∈ S
⊢ Dense (⋂ (x : ℕ), f x)

tactic: rw [hf]
state_before: α : Type u_1
β : Type ?u.12812
γ : Type ?u.12815
ι : Type ?u.12818
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
S : Set (Set α)
ho : ∀ (s : Set α), s ∈ S → IsOpen s
hS : Set.Countable S
hd : ∀ (s : Set α), s ∈ S → Dense s
h : Set.Nonempty S
f : ℕ → Set α
hf : S = range f
n : ℕ
⊢ f n ∈ S

tactic: exact mem_range_self _
state_before: α : Type u_1
β : Type ?u.12812
γ : Type ?u.12815
ι : Type ?u.12818
inst✝¹ : TopologicalSpace α
inst✝ : BaireSpace α
S : Set (Set α)
ho : ∀ (s : Set α), s ∈ S → IsOpen s
hS : Set.Countable S
hd : ∀ (s : Set α), s ∈ S → Dense s
h : Set.Nonempty S
f : ℕ → Set α
hf : S = range f
n : ℕ
⊢ f n ∈ range f