tasksource/leandojo huggingface dataset:
Theorem: circleIntegrable_zero_radius
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp [CircleIntegrable]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
f : ℂ → E
c : ℂ
⊢ CircleIntegrable f c 0
Theorem: pos_and_pos_or_neg_and_neg_of_mul_pos
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: rcases lt_trichotomy a 0 with (ha | rfl | ha)
state_before: α : Type u_1
a b c d : α
inst✝³ : MulZeroClass α
inst✝² : LinearOrder α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
hab : 0 < a * b
⊢ 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0

tactic: refine' Or.inr ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
state_before: case inl
α : Type u_1
a b c d : α
inst✝³ : MulZeroClass α
inst✝² : LinearOrder α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
hab : 0 < a * b
ha : a < 0
⊢ 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0

tactic: exact mul_nonpos_of_nonpos_of_nonneg ha.le hb
state_before: case inl
α : Type u_1
a b c d : α
inst✝³ : MulZeroClass α
inst✝² : LinearOrder α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
hab : 0 < a * b
ha : a < 0
hb : 0 ≤ b
⊢ a * b ≤ 0

tactic: rw [zero_mul] at hab
state_before: case inr.inl
α : Type u_1
b c d : α
inst✝³ : MulZeroClass α
inst✝² : LinearOrder α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
hab : 0 < 0 * b
⊢ 0 < 0 ∧ 0 < b ∨ 0 < 0 ∧ b < 0

tactic: exact hab.false.elim
state_before: case inr.inl
α : Type u_1
b c d : α
inst✝³ : MulZeroClass α
inst✝² : LinearOrder α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
hab : 0 < 0
⊢ 0 < 0 ∧ 0 < b ∨ 0 < 0 ∧ b < 0

tactic: refine' Or.inl ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
state_before: case inr.inr
α : Type u_1
a b c d : α
inst✝³ : MulZeroClass α
inst✝² : LinearOrder α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
hab : 0 < a * b
ha : 0 < a
⊢ 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0

tactic: exact mul_nonpos_of_nonneg_of_nonpos ha.le hb
state_before: case inr.inr
α : Type u_1
a b c d : α
inst✝³ : MulZeroClass α
inst✝² : LinearOrder α
inst✝¹ : PosMulMono α
inst✝ : MulPosMono α
hab : 0 < a * b
ha : 0 < a
hb : b ≤ 0
⊢ a * b ≤ 0
Theorem: Finset.map_add_left_Ioo
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_map, coe_Ioo, coe_Ioo]
state_before: ι : Type ?u.226888
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addLeftEmbedding c) (Ioo a b) = Ioo (c + a) (c + b)

tactic: exact Set.image_const_add_Ioo _ _ _
state_before: ι : Type ?u.226888
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ↑(addLeftEmbedding c) '' Set.Ioo a b = Set.Ioo (c + a) (c + b)
Theorem: CompositionAsSet.boundary_length
File: Mathlib/Combinatorics/Composition.lean

tactic: convert Finset.orderEmbOfFin_last rfl c.card_boundaries_pos
state_before: n : ℕ
c : CompositionAsSet n
⊢ ↑(boundary c) { val := length c, isLt := (_ : length c < Finset.card c.boundaries) } = Fin.last n

tactic: exact le_antisymm (Finset.le_max' _ _ c.getLast_mem) (Fin.le_last _)
state_before: case h.e'_3
n : ℕ
c : CompositionAsSet n
⊢ Fin.last n = Finset.max' c.boundaries (_ : Finset.Nonempty c.boundaries)
Theorem: MeasureTheory.OuterMeasure.exists_measurable_superset_of_trim_eq_zero
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rcases exists_measurable_superset_eq_trim m s with ⟨t, hst, ht, hm⟩
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m✝ m : OuterMeasure α
s : Set α
h : ↑(trim m) s = 0
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ↑m t = 0

tactic: exact ⟨t, hst, ht, h ▸ hm⟩
state_before: case intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
m✝ m : OuterMeasure α
s : Set α
h : ↑(trim m) s = 0
t : Set α
hst : s ⊆ t
ht : MeasurableSet t
hm : ↑m t = ↑(trim m) s
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ↑m t = 0
Theorem: FreeMonoid.toList_prod
File: Mathlib/Algebra/FreeMonoid/Basic.lean

tactic: induction xs <;> simp [*, List.join]
state_before: α : Type u_1
β : Type ?u.8378
γ : Type ?u.8381
M : Type ?u.8384
inst✝¹ : Monoid M
N : Type ?u.8390
inst✝ : Monoid N
xs : List (FreeMonoid α)
⊢ ↑toList (List.prod xs) = List.join (List.map (↑toList) xs)
Theorem: Fin.card_filter_univ_succ'
File: Mathlib/Data/Fintype/Fin.lean

tactic: rw [Fin.univ_succ, filter_cons, card_disjUnion, filter_map, card_map]
state_before: α : Type ?u.9629
β : Type ?u.9632
n : ℕ
p : Fin (n + 1) → Prop
inst✝ : DecidablePred p
⊢ Finset.card (filter p univ) = (if p 0 then 1 else 0) + Finset.card (filter (p ∘ succ) univ)

tactic: split_ifs <;> simp
state_before: α : Type ?u.9629
β : Type ?u.9632
n : ℕ
p : Fin (n + 1) → Prop
inst✝ : DecidablePred p
⊢ Finset.card (if p 0 then {0} else ∅) +
      Finset.card (filter (p ∘ ↑{ toFun := succ, inj' := (_ : Function.Injective succ) }) univ) =
    (if p 0 then 1 else 0) + Finset.card (filter (p ∘ succ) univ)
Theorem: Finset.erase_insert_of_ne
File: Mathlib/Data/Finset/Basic.lean

tactic: have : x ≠ b ∧ x = a ↔ x = a := and_iff_right_of_imp fun hx => hx.symm ▸ h
state_before: α : Type u_1
β : Type ?u.210334
γ : Type ?u.210337
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b✝ a b : α
s : Finset α
h : a ≠ b
x : α
⊢ x ∈ erase (insert a s) b ↔ x ∈ insert a (erase s b)

tactic: simp only [mem_erase, mem_insert, and_or_left, this]
state_before: α : Type u_1
β : Type ?u.210334
γ : Type ?u.210337
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b✝ a b : α
s : Finset α
h : a ≠ b
x : α
this : x ≠ b ∧ x = a ↔ x = a
⊢ x ∈ erase (insert a s) b ↔ x ∈ insert a (erase s b)
Theorem: Setoid.eqv_class_mem'
File: Mathlib/Data/Setoid/Partition.lean

tactic: convert @Setoid.eqv_class_mem _ _  H x using 3
state_before: α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b x, a ∈ b
x : α
⊢ {y | Rel (mkClasses c H) x y} ∈ c

tactic: rw [Setoid.comm']
state_before: case h.e'_4.h.e'_2.h.a
α : Type u_1
c : Set (Set α)
H : ∀ (a : α), ∃! b x, a ∈ b
x x✝ : α
⊢ Rel (mkClasses c H) x x✝ ↔ Rel (mkClasses c H) x✝ x
Theorem: SatisfiesM.imp
File: Std/Classes/LawfulMonad.lean

tactic: rw [← h, ← comp_map]
state_before: m : Type u_1 → Type u_2
α : Type u_1
p q : α → Prop
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x✝ : m α
h✝ : SatisfiesM p x✝
H : ∀ {a : α}, p a → q a
x : m { a // p a }
h : Subtype.val <$> x = x✝
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | { val := a, property := h } => { val := a, property := (_ : q a) }) <$>
        x =
    x✝

tactic: rfl
state_before: m : Type u_1 → Type u_2
α : Type u_1
p q : α → Prop
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x✝ : m α
h✝ : SatisfiesM p x✝
H : ∀ {a : α}, p a → q a
x : m { a // p a }
h : Subtype.val <$> x = x✝
⊢ (Subtype.val ∘ fun x =>
        match x with
        | { val := a, property := h } => { val := a, property := (_ : q a) }) <$>
      x =
    Subtype.val <$> x
Theorem: inf_sup_symmDiff
File: Mathlib/Order/SymmDiff.lean

tactic: rw [sup_comm, symmDiff_sup_inf]
state_before: ι : Type ?u.33973
α : Type u_1
β : Type ?u.33979
π : ι → Type ?u.33984
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ⊓ b ⊔ a ∆ b = a ⊔ b
Theorem: ZNum.mul_comm
File: Mathlib/Data/Num/Lemmas.lean

tactic: transfer
state_before: α : Type ?u.1029930
⊢ ∀ (a b : ZNum), a * b = b * a
Theorem: Finset.mem_powerset
File: Mathlib/Data/Finset/Powerset.lean

tactic: cases s
state_before: α : Type u_1
s✝ t✝ s t : Finset α
⊢ s ∈ powerset t ↔ s ⊆ t

tactic: simp [powerset, mem_mk, mem_pmap, mk.injEq, mem_powerset, exists_prop, exists_eq_right,
  ← val_le_iff]
state_before: case mk
α : Type u_1
s t✝ t : Finset α
val✝ : Multiset α
nodup✝ : Nodup val✝
⊢ { val := val✝, nodup := nodup✝ } ∈ powerset t ↔ { val := val✝, nodup := nodup✝ } ⊆ t
Theorem: Nat.gcd_rec
File: Std/Data/Nat/Gcd.lean

tactic: have := (mod_zero n).symm
state_before: m n : Nat
⊢ gcd 0 n = gcd (n % 0) 0

tactic: rwa [gcd_zero_right]
state_before: m n : Nat
this : n = n % 0
⊢ gcd 0 n = gcd (n % 0) 0

tactic: simp [gcd_succ]
state_before: m n n✝ : Nat
⊢ gcd (n✝ + 1) n = gcd (n % (n✝ + 1)) (n✝ + 1)
Theorem: SimpleGraph.card_incidenceFinset_eq_degree
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rw [← G.card_incidenceSet_eq_degree]
state_before: ι : Sort ?u.275939
𝕜 : Type ?u.275942
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝¹ : Fintype ↑(neighborSet G v)
inst✝ : DecidableEq V
⊢ card (incidenceFinset G v) = degree G v

tactic: apply Set.toFinset_card
state_before: ι : Sort ?u.275939
𝕜 : Type ?u.275942
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝¹ : Fintype ↑(neighborSet G v)
inst✝ : DecidableEq V
⊢ card (incidenceFinset G v) = Fintype.card ↑(incidenceSet G v)
Theorem: continuous_edist
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: apply continuous_of_le_add_edist 2 (by norm_num)
state_before: α : Type u_1
β : Type ?u.422280
γ : Type ?u.422283
inst✝ : PseudoEMetricSpace α
⊢ Continuous fun p => edist p.fst p.snd

tactic: rintro ⟨x, y⟩ ⟨x', y'⟩
state_before: α : Type u_1
β : Type ?u.422280
γ : Type ?u.422283
inst✝ : PseudoEMetricSpace α
⊢ ∀ (x y : α × α), edist x.fst x.snd ≤ edist y.fst y.snd + 2 * edist x y

tactic: calc
  edist x y ≤ edist x x' + edist x' y' + edist y' y := edist_triangle4 _ _ _ _
  _ = edist x' y' + (edist x x' + edist y y') := by simp only [edist_comm]; ac_rfl
  _ ≤ edist x' y' + (edist (x, y) (x', y') + edist (x, y) (x', y')) :=
    (add_le_add_left (add_le_add (le_max_left _ _) (le_max_right _ _)) _)
  _ = edist x' y' + 2 * edist (x, y) (x', y') := by rw [← mul_two, mul_comm]
state_before: case mk.mk
α : Type u_1
β : Type ?u.422280
γ : Type ?u.422283
inst✝ : PseudoEMetricSpace α
x y x' y' : α
⊢ edist (x, y).fst (x, y).snd ≤ edist (x', y').fst (x', y').snd + 2 * edist (x, y) (x', y')

tactic: norm_num
state_before: α : Type u_1
β : Type ?u.422280
γ : Type ?u.422283
inst✝ : PseudoEMetricSpace α
⊢ 2 ≠ ⊤

tactic: simp only [edist_comm]
state_before: α : Type u_1
β : Type ?u.422280
γ : Type ?u.422283
inst✝ : PseudoEMetricSpace α
x y x' y' : α
⊢ edist x x' + edist x' y' + edist y' y = edist x' y' + (edist x x' + edist y y')

tactic: ac_rfl
state_before: α : Type u_1
β : Type ?u.422280
γ : Type ?u.422283
inst✝ : PseudoEMetricSpace α
x y x' y' : α
⊢ edist x x' + edist x' y' + edist y y' = edist x' y' + (edist x x' + edist y y')

tactic: rw [← mul_two, mul_comm]
state_before: α : Type u_1
β : Type ?u.422280
γ : Type ?u.422283
inst✝ : PseudoEMetricSpace α
x y x' y' : α
⊢ edist x' y' + (edist (x, y) (x', y') + edist (x, y) (x', y')) = edist x' y' + 2 * edist (x, y) (x', y')
Theorem: StructureGroupoid.LocalInvariantProp.liftPropAt_congr_iff_of_eventuallyEq
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: simp_rw [nhdsWithin_univ, h₁]
state_before: H : Type u_3
M : Type u_1
H' : Type u_4
M' : Type u_2
X : Type ?u.44946
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
h₁ : g' =ᶠ[𝓝 x] g
⊢ g' =ᶠ[𝓝[univ] x] g
Theorem: Set.image_eq_image
File: Mathlib/Data/Set/Image.lean

tactic: rw [← preimage_image_eq s hf, ← preimage_image_eq t hf, eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.54851
ι : Sort ?u.54854
ι' : Sort ?u.54857
f✝ : α → β
s t : Set α
f : α → β
hf : Injective f
eq : f '' s = f '' t
⊢ s = t
Theorem: add_pow_char_of_commute
File: Mathlib/Algebra/CharP/Basic.lean

tactic: let ⟨r, hr⟩ := h.exists_add_pow_prime_eq hp.out
state_before: R : Type u_1
inst✝¹ : Semiring R
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x + y) ^ p = x ^ p + y ^ p

tactic: simp [hr]
state_before: R : Type u_1
inst✝¹ : Semiring R
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
r : R
hr : (x + y) ^ p = x ^ p + y ^ p + ↑p * r
⊢ (x + y) ^ p = x ^ p + y ^ p
Theorem: finRotate_apply_zero
File: Mathlib/Logic/Equiv/Fin.lean

tactic: rw [finRotate_succ_apply, zero_add]
state_before: m n : ℕ
⊢ ↑(finRotate (Nat.succ n)) 0 = 1
Theorem: MeasureTheory.AEEqFun.inf_le_right
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [← coeFn_le]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.465891
δ : Type ?u.465894
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
⊢ f ⊓ g ≤ g

tactic: filter_upwards [coeFn_inf f g] with _ ha
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.465891
δ : Type ?u.465894
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
⊢ ↑(f ⊓ g) ≤ᵐ[μ] ↑g

tactic: rw [ha]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.465891
δ : Type ?u.465894
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊓ g) a✝ = ↑f a✝ ⊓ ↑g a✝
⊢ ↑(f ⊓ g) a✝ ≤ ↑g a✝

tactic: exact inf_le_right
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.465891
δ : Type ?u.465894
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeInf β
inst✝ : ContinuousInf β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊓ g) a✝ = ↑f a✝ ⊓ ↑g a✝
⊢ ↑f a✝ ⊓ ↑g a✝ ≤ ↑g a✝
Theorem: support_finRotate_of_le
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: obtain ⟨m, rfl⟩ := exists_add_of_le h
state_before: n : ℕ
h : 2 ≤ n
⊢ support (finRotate n) = Finset.univ

tactic: rw [add_comm, support_finRotate]
state_before: case intro
m : ℕ
h : 2 ≤ 2 + m
⊢ support (finRotate (2 + m)) = Finset.univ
Theorem: Int.natAbs_mul_natAbs_eq
File: Std/Data/Int/Lemmas.lean

tactic: rw [← natAbs_mul, h, natAbs]
state_before: a b : Int
c : Nat
h : a * b = ↑c
⊢ natAbs a * natAbs b = c
Theorem: Denumerable.denumerable_list_aux
File: Mathlib/Logic/Equiv/List.lean

tactic: rw [decodeList]
state_before: α : Type u_1
β : Type ?u.30505
inst✝¹ : Denumerable α
inst✝ : Denumerable β
⊢ ∃ a, a ∈ decodeList 0 ∧ encodeList a = 0

tactic: exact ⟨_, rfl, rfl⟩
state_before: α : Type u_1
β : Type ?u.30505
inst✝¹ : Denumerable α
inst✝ : Denumerable β
⊢ ∃ a, a ∈ some [] ∧ encodeList a = 0

tactic: cases' e : unpair v with v₁ v₂
state_before: α : Type u_1
β : Type ?u.30505
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v : ℕ
⊢ ∃ a, a ∈ decodeList (succ v) ∧ encodeList a = succ v

tactic: have h := unpair_right_le v
state_before: case mk
α : Type u_1
β : Type ?u.30505
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
⊢ ∃ a, a ∈ decodeList (succ v) ∧ encodeList a = succ v

tactic: rw [e] at h
state_before: case mk
α : Type u_1
β : Type ?u.30505
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
h : (unpair v).snd ≤ v
⊢ ∃ a, a ∈ decodeList (succ v) ∧ encodeList a = succ v

tactic: rcases have : v₂ < succ v := lt_succ_of_le h
  denumerable_list_aux v₂ with
  ⟨a, h₁, h₂⟩
state_before: case mk
α : Type u_1
β : Type ?u.30505
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
h : (v₁, v₂).snd ≤ v
⊢ ∃ a, a ∈ decodeList (succ v) ∧ encodeList a = succ v

tactic: rw [Option.mem_def] at h₁
state_before: case mk.intro.intro
α : Type u_1
β : Type ?u.30505
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
h : (v₁, v₂).snd ≤ v
a : List α
h₁ : a ∈ decodeList v₂
h₂ : encodeList a = v₂
⊢ ∃ a, a ∈ decodeList (succ v) ∧ encodeList a = succ v

tactic: use ofNat α v₁ :: a
state_before: case mk.intro.intro
α : Type u_1
β : Type ?u.30505
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
h : (v₁, v₂).snd ≤ v
a : List α
h₁ : decodeList v₂ = some a
h₂ : encodeList a = v₂
⊢ ∃ a, a ∈ decodeList (succ v) ∧ encodeList a = succ v

tactic: simp [decodeList, e, h₂, h₁, encodeList, pair_unpair' e]
state_before: case mk.intro.intro
α : Type u_1
β : Type ?u.30505
inst✝¹ : Denumerable α
inst✝ : Denumerable β
v v₁ v₂ : ℕ
e : unpair v = (v₁, v₂)
h : (v₁, v₂).snd ≤ v
a : List α
h₁ : decodeList v₂ = some a
h₂ : encodeList a = v₂
⊢ ofNat α v₁ :: a ∈ decodeList (succ v) ∧ encodeList (ofNat α v₁ :: a) = succ v
Theorem: CategoryTheory.IsPushout.inl_snd'
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: apply flip
state_before: C : Type u₁
inst✝² : Category C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : BinaryBicone.IsBilimit b
⊢ IsPushout b.inl 0 b.snd 0

tactic: refine' of_right _ (by simp) (of_isBilimit h)
state_before: case h
C : Type u₁
inst✝² : Category C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : BinaryBicone.IsBilimit b
⊢ IsPushout 0 b.inl 0 b.snd

tactic: simp
state_before: case h
C : Type u₁
inst✝² : Category C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : BinaryBicone.IsBilimit b
⊢ IsPushout (0 ≫ 0) 0 0 (b.inr ≫ b.snd)

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : BinaryBicone.IsBilimit b
⊢ 0 ≫ 0 = b.inl ≫ b.snd
Theorem: Polynomial.monic_X_pow_sub
File: Mathlib/Data/Polynomial/Monic.lean

tactic: simpa [sub_eq_add_neg] using monic_X_pow_add (show degree (-p) ≤ n by rwa [← degree_neg p] at H)
state_before: R : Type u
S : Type v
a b : R
m n✝ : ℕ
ι : Type y
inst✝ : Ring R
p : R[X]
n : ℕ
H : degree p ≤ ↑n
⊢ Monic (X ^ (n + 1) - p)

tactic: rwa [← degree_neg p] at H
state_before: R : Type u
S : Type v
a b : R
m n✝ : ℕ
ι : Type y
inst✝ : Ring R
p : R[X]
n : ℕ
H : degree p ≤ ↑n
⊢ degree (-p) ≤ ↑n
Theorem: Num.zneg_toZNum
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases n <;> rfl
state_before: α : Type ?u.446504
n : Num
⊢ -toZNum n = toZNumNeg n
Theorem: Real.volume_pi_Ico_toReal
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp only [volume_pi_Ico, ENNReal.toReal_prod, ENNReal.toReal_ofReal (sub_nonneg.2 (h _))]
state_before: ι : Type u_1
inst✝ : Fintype ι
a b : ι → ℝ
h : a ≤ b
⊢ ENNReal.toReal (↑↑volume (Set.pi univ fun i => Ico (a i) (b i))) = ∏ i : ι, (b i - a i)
Theorem: LinearIsometry.im_apply_eq_im_or_neg_of_re_apply_eq_re
File: Mathlib/Analysis/Complex/Isometry.lean

tactic: have h₁ := f.norm_map z
state_before: f : ℂ →ₗᵢ[ℝ] ℂ
h₂ : ∀ (z : ℂ), (↑f z).re = z.re
z : ℂ
⊢ (↑f z).im = z.im ∨ (↑f z).im = -z.im

tactic: simp only [Complex.abs_def, norm_eq_abs] at h₁
state_before: f : ℂ →ₗᵢ[ℝ] ℂ
h₂ : ∀ (z : ℂ), (↑f z).re = z.re
z : ℂ
h₁ : ‖↑f z‖ = ‖z‖
⊢ (↑f z).im = z.im ∨ (↑f z).im = -z.im

tactic: rwa [Real.sqrt_inj (normSq_nonneg _) (normSq_nonneg _), normSq_apply (f z), normSq_apply z,
  h₂, add_left_cancel_iff, mul_self_eq_mul_self_iff] at h₁
state_before: f : ℂ →ₗᵢ[ℝ] ℂ
h₂ : ∀ (z : ℂ), (↑f z).re = z.re
z : ℂ
h₁ : Real.sqrt (↑normSq (↑f z)) = Real.sqrt (↑normSq z)
⊢ (↑f z).im = z.im ∨ (↑f z).im = -z.im
Theorem: Polynomial.iterate_derivative_comp_one_sub_X
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: induction' k with k ih generalizing p
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
k : ℕ
⊢ (↑derivative^[k]) (comp p (1 - X)) = (-1) ^ k * comp ((↑derivative^[k]) p) (1 - X)

tactic: simp
state_before: case zero
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ p : R[X]
⊢ (↑derivative^[Nat.zero]) (comp p (1 - X)) = (-1) ^ Nat.zero * comp ((↑derivative^[Nat.zero]) p) (1 - X)

tactic: simp [ih (derivative p), iterate_derivative_neg, derivative_comp, pow_succ]
state_before: case succ
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ : R[X]
k : ℕ
ih : ∀ (p : R[X]), (↑derivative^[k]) (comp p (1 - X)) = (-1) ^ k * comp ((↑derivative^[k]) p) (1 - X)
p : R[X]
⊢ (↑derivative^[Nat.succ k]) (comp p (1 - X)) = (-1) ^ Nat.succ k * comp ((↑derivative^[Nat.succ k]) p) (1 - X)
Theorem: intervalIntegral.norm_integral_le_integral_norm
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [uIoc_of_le h, integral_of_le h]
state_before: ι : Type ?u.12055077
𝕜 : Type ?u.12055080
E : Type u_1
F : Type ?u.12055086
A : Type ?u.12055089
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
h : a ≤ b
⊢ (∫ (x : ℝ) in Ι a b, ‖f x‖ ∂μ) = ∫ (x : ℝ) in a..b, ‖f x‖ ∂μ
Theorem: Complex.exists_cthickening_tendstoUniformlyOn
File: Mathlib/Analysis/Complex/LocallyUniformLimit.lean

tactic: obtain ⟨δ, hδ, hKδ⟩ := hK.exists_cthickening_subset_open hU hKU
state_before: E : Type u_1
ι : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hf : TendstoLocallyUniformlyOn F f φ U
hF : ∀ᶠ (n : ι) in φ, DifferentiableOn ℂ (F n) U
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
⊢ ∃ δ, δ > 0 ∧ cthickening δ K ⊆ U ∧ TendstoUniformlyOn (deriv ∘ F) (cderiv δ f) φ K

tactic: exact ⟨δ, hδ, hKδ, tendstoUniformlyOn_deriv_of_cthickening_subset hf hF hδ hK hU hKδ⟩
state_before: case intro.intro
E : Type u_1
ι : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ✝ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hf : TendstoLocallyUniformlyOn F f φ U
hF : ∀ᶠ (n : ι) in φ, DifferentiableOn ℂ (F n) U
hK : IsCompact K
hU : IsOpen U
hKU : K ⊆ U
δ : ℝ
hδ : 0 < δ
hKδ : cthickening δ K ⊆ U
⊢ ∃ δ, δ > 0 ∧ cthickening δ K ⊆ U ∧ TendstoUniformlyOn (deriv ∘ F) (cderiv δ f) φ K
Theorem: CategoryTheory.SimplicialObject.δ_comp_σ_succ'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: subst H
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = Fin.succ i
⊢ σ X i ≫ δ X j = 𝟙 (X.obj [n].op)

tactic: rw [δ_comp_σ_succ]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ σ X i ≫ δ X (Fin.succ i) = 𝟙 (X.obj [n].op)
Theorem: Mathlib.Meta.NormNum.IsRat.nonneg_to_eq
File: Mathlib/Tactic/NormNum/Core.lean

tactic: simp [div_eq_mul_inv]
state_before: α : Type u_1
inst✝ : DivisionRing α
n d : ℕ
inv✝ : Invertible ↑d
⊢ ↑(Int.ofNat n) * ⅟↑d = ↑n / ↑d
Theorem: CircleDeg1Lift.translationNumber_eq_int_iff
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: constructor
state_before: f g : CircleDeg1Lift
hf : Continuous ↑f
m : ℤ
⊢ τ f = ↑m ↔ ∃ x, ↑f x = x + ↑m

tactic: intro h
state_before: case mp
f g : CircleDeg1Lift
hf : Continuous ↑f
m : ℤ
⊢ τ f = ↑m → ∃ x, ↑f x = x + ↑m

tactic: simp only [← h]
state_before: case mp
f g : CircleDeg1Lift
hf : Continuous ↑f
m : ℤ
h : τ f = ↑m
⊢ ∃ x, ↑f x = x + ↑m

tactic: exact f.exists_eq_add_translationNumber hf
state_before: case mp
f g : CircleDeg1Lift
hf : Continuous ↑f
m : ℤ
h : τ f = ↑m
⊢ ∃ x, ↑f x = x + τ f

tactic: rintro ⟨x, hx⟩
state_before: case mpr
f g : CircleDeg1Lift
hf : Continuous ↑f
m : ℤ
⊢ (∃ x, ↑f x = x + ↑m) → τ f = ↑m

tactic: exact f.translationNumber_of_eq_add_int hx
state_before: case mpr.intro
f g : CircleDeg1Lift
hf : Continuous ↑f
m : ℤ
x : ℝ
hx : ↑f x = x + ↑m
⊢ τ f = ↑m
Theorem: Bifunctor.comp_snd
File: Mathlib/Control/Bifunctor.lean

tactic: simp [snd, bimap_bimap]
state_before: F : Type u₀ → Type u₁ → Type u₂
inst✝¹ : Bifunctor F
inst✝ : LawfulBifunctor F
α : Type u₀
β₀ β₁ β₂ : Type u₁
g : β₀ → β₁
g' : β₁ → β₂
x : F α β₀
⊢ snd g' (snd g x) = snd (g' ∘ g) x
Theorem: Std.RBNode.foldl_eq_foldl_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: induction t generalizing init <;> simp [*]
state_before: α : Type u_1
α✝ : Type u_2
f : α✝ → α → α✝
init : α✝
t : RBNode α
⊢ foldl f init t = List.foldl f init (toList t)