tasksource/leandojo huggingface dataset:
Theorem: List.pmap_append
File: Mathlib/Data/List/Basic.lean

tactic: induction' l₁ with _ _ ih
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
p : ι → Prop
f : (a : ι) → p a → α
l₁ l₂ : List ι
h : ∀ (a : ι), a ∈ l₁ ++ l₂ → p a
⊢ pmap f (l₁ ++ l₂) h = pmap f l₁ (_ : ∀ (a : ι), a ∈ l₁ → p a) ++ pmap f l₂ (_ : ∀ (a : ι), a ∈ l₂ → p a)

tactic: rfl
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
p : ι → Prop
f : (a : ι) → p a → α
l₁ l₂ : List ι
h✝ : ∀ (a : ι), a ∈ l₁ ++ l₂ → p a
h : ∀ (a : ι), a ∈ [] ++ l₂ → p a
⊢ pmap f ([] ++ l₂) h = pmap f [] (_ : ∀ (a : ι), a ∈ [] → p a) ++ pmap f l₂ (_ : ∀ (a : ι), a ∈ l₂ → p a)

tactic: dsimp only [pmap, cons_append]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
p : ι → Prop
f : (a : ι) → p a → α
l₁ l₂ : List ι
h✝ : ∀ (a : ι), a ∈ l₁ ++ l₂ → p a
head✝ : ι
tail✝ : List ι
ih :
  ∀ (h : ∀ (a : ι), a ∈ tail✝ ++ l₂ → p a),
    pmap f (tail✝ ++ l₂) h = pmap f tail✝ (_ : ∀ (a : ι), a ∈ tail✝ → p a) ++ pmap f l₂ (_ : ∀ (a : ι), a ∈ l₂ → p a)
h : ∀ (a : ι), a ∈ head✝ :: tail✝ ++ l₂ → p a
⊢ pmap f (head✝ :: tail✝ ++ l₂) h =
    pmap f (head✝ :: tail✝) (_ : ∀ (a : ι), a ∈ head✝ :: tail✝ → p a) ++ pmap f l₂ (_ : ∀ (a : ι), a ∈ l₂ → p a)

tactic: rw [ih]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
p : ι → Prop
f : (a : ι) → p a → α
l₁ l₂ : List ι
h✝ : ∀ (a : ι), a ∈ l₁ ++ l₂ → p a
head✝ : ι
tail✝ : List ι
ih :
  ∀ (h : ∀ (a : ι), a ∈ tail✝ ++ l₂ → p a),
    pmap f (tail✝ ++ l₂) h = pmap f tail✝ (_ : ∀ (a : ι), a ∈ tail✝ → p a) ++ pmap f l₂ (_ : ∀ (a : ι), a ∈ l₂ → p a)
h : ∀ (a : ι), a ∈ head✝ :: tail✝ ++ l₂ → p a
⊢ f head✝ (_ : p head✝) :: pmap f (tail✝ ++ l₂) (_ : ∀ (x : ι), x ∈ tail✝ ++ l₂ → p x) =
    f head✝ (_ : p head✝) :: (pmap f tail✝ (_ : ∀ (x : ι), x ∈ tail✝ → p x) ++ pmap f l₂ (_ : ∀ (a : ι), a ∈ l₂ → p a))
Theorem: PowerSeries.map_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext
state_before: R : Type u_2
inst✝² : Semiring R
S : Type u_1
T : Type ?u.2938579
inst✝¹ : Semiring S
inst✝ : Semiring T
f : R →+* S
g : S →+* T
⊢ ↑(map f) X = X

tactic: simp [coeff_X, apply_ite f]
state_before: case h
R : Type u_2
inst✝² : Semiring R
S : Type u_1
T : Type ?u.2938579
inst✝¹ : Semiring S
inst✝ : Semiring T
f : R →+* S
g : S →+* T
n✝ : ℕ
⊢ ↑(coeff S n✝) (↑(map f) X) = ↑(coeff S n✝) X
Theorem: Int.clog_one_right
File: Mathlib/Data/Int/Log.lean

tactic: rw [clog_of_one_le_right _ le_rfl, Nat.ceil_one, Nat.clog_one_right, Int.ofNat_zero]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
⊢ clog b 1 = 0
Theorem: OreLocalization.mul_inv_cancel
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: induction' x using OreLocalization.ind with r s
state_before: R : Type u_1
inst✝³ : Ring R
inst✝² : Nontrivial R
inst✝¹ : OreSet R⁰
inst✝ : NoZeroDivisors R
x : OreLocalization R R⁰
h : x ≠ 0
⊢ x * x⁻¹ = 1

tactic: rw [OreLocalization.inv_def, OreLocalization.one_def]
state_before: case c
R : Type u_1
inst✝³ : Ring R
inst✝² : Nontrivial R
inst✝¹ : OreSet R⁰
inst✝ : NoZeroDivisors R
x : OreLocalization R R⁰
h✝ : x ≠ 0
r : R
s : { x // x ∈ R⁰ }
h : r /ₒ s ≠ 0
⊢ r /ₒ s * (r /ₒ s)⁻¹ = 1

tactic: by_cases hr : r = 0
state_before: case c
R : Type u_1
inst✝³ : Ring R
inst✝² : Nontrivial R
inst✝¹ : OreSet R⁰
inst✝ : NoZeroDivisors R
x : OreLocalization R R⁰
h✝ : x ≠ 0
r : R
s : { x // x ∈ R⁰ }
h : r /ₒ s ≠ 0
⊢ (r /ₒ s * if hr : r = 0 then 0 else ↑s /ₒ { val := r, property := (_ : ∀ (x : R), x * r = 0 → x = 0) }) = 1 /ₒ 1

tactic: exfalso
state_before: case pos
R : Type u_1
inst✝³ : Ring R
inst✝² : Nontrivial R
inst✝¹ : OreSet R⁰
inst✝ : NoZeroDivisors R
x : OreLocalization R R⁰
h✝ : x ≠ 0
r : R
s : { x // x ∈ R⁰ }
h : r /ₒ s ≠ 0
hr : r = 0
⊢ (r /ₒ s * if hr : r = 0 then 0 else ↑s /ₒ { val := r, property := (_ : ∀ (x : R), x * r = 0 → x = 0) }) = 1 /ₒ 1

tactic: apply h
state_before: case pos.h
R : Type u_1
inst✝³ : Ring R
inst✝² : Nontrivial R
inst✝¹ : OreSet R⁰
inst✝ : NoZeroDivisors R
x : OreLocalization R R⁰
h✝ : x ≠ 0
r : R
s : { x // x ∈ R⁰ }
h : r /ₒ s ≠ 0
hr : r = 0
⊢ False

tactic: simp [hr]
state_before: case pos.h
R : Type u_1
inst✝³ : Ring R
inst✝² : Nontrivial R
inst✝¹ : OreSet R⁰
inst✝ : NoZeroDivisors R
x : OreLocalization R R⁰
h✝ : x ≠ 0
r : R
s : { x // x ∈ R⁰ }
h : r /ₒ s ≠ 0
hr : r = 0
⊢ r /ₒ s = 0

tactic: simp [hr]
state_before: case neg
R : Type u_1
inst✝³ : Ring R
inst✝² : Nontrivial R
inst✝¹ : OreSet R⁰
inst✝ : NoZeroDivisors R
x : OreLocalization R R⁰
h✝ : x ≠ 0
r : R
s : { x // x ∈ R⁰ }
h : r /ₒ s ≠ 0
hr : ¬r = 0
⊢ (r /ₒ s * if hr : r = 0 then 0 else ↑s /ₒ { val := r, property := (_ : ∀ (x : R), x * r = 0 → x = 0) }) = 1 /ₒ 1

tactic: apply OreLocalization.div_eq_one'
state_before: case neg
R : Type u_1
inst✝³ : Ring R
inst✝² : Nontrivial R
inst✝¹ : OreSet R⁰
inst✝ : NoZeroDivisors R
x : OreLocalization R R⁰
h✝ : x ≠ 0
r : R
s : { x // x ∈ R⁰ }
h : r /ₒ s ≠ 0
hr : ¬r = 0
⊢ 1 = 1 /ₒ 1
Theorem: FirstOrder.Language.Structure.fg_iff
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [fg_def, Substructure.fg_def]
state_before: L : Language
M : Type u_3
inst✝ : Structure L M
⊢ FG L M ↔ ∃ S, Set.Finite S ∧ LowerAdjoint.toFun (closure L) S = ⊤
Theorem: MeasureTheory.Measure.restrict_eq_self
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← restrict_apply (measurableSet_toMeasurable _ _), measure_toMeasurable]
state_before: α : Type u_1
β : Type ?u.284395
γ : Type ?u.284398
δ : Type ?u.284401
ι : Type ?u.284404
R : Type ?u.284407
R' : Type ?u.284410
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
h : s ⊆ t
⊢ ↑↑μ (toMeasurable (restrict μ t) s ∩ t) = ↑↑(restrict μ t) s
Theorem: bind_pure_unit
File: src/lean/Init/Control/Lawful.lean

tactic: rw [bind_pure]
state_before: m : Type u_1 → Type u_2
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m PUnit
⊢ (do
      x
      pure PUnit.unit) =
    x
Theorem: Complex.interior_setOf_im_le
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [interior_Iic] using interior_preimage_im (Iic a)
state_before: a : ℝ
⊢ interior {z | z.im ≤ a} = {z | z.im < a}
Theorem: Polynomial.eraseLead_coeff
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: simp only [eraseLead, coeff_erase]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
i : ℕ
⊢ coeff (eraseLead f) i = if i = natDegree f then 0 else coeff f i
Theorem: Isometry.completion_extension
File: Mathlib/Topology/MetricSpace/Completion.lean

tactic: continuity
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
h : Isometry f
x y : Completion α
⊢ Continuous fun x => dist (Completion.extension f x.fst) (Completion.extension f x.snd)

tactic: continuity
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
h : Isometry f
x y : Completion α
⊢ Continuous fun x => dist x.fst x.snd

tactic: simp only [extension_coe h.uniformContinuous, Completion.dist_eq, h.dist_eq]
state_before: α : Type u
β : Type v
inst✝² : PseudoMetricSpace α
inst✝¹ : MetricSpace β
inst✝ : CompleteSpace β
f : α → β
h : Isometry f
x y : Completion α
x✝¹ x✝ : α
⊢ dist (Completion.extension f (↑α x✝¹)) (Completion.extension f (↑α x✝)) = dist (↑α x✝¹) (↑α x✝)
Theorem: ENNReal.toNNReal_add
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift r₁ to ℝ≥0 using h₁
state_before: α : Type ?u.80550
β : Type ?u.80553
a b c d : ℝ≥0∞
r p q : ℝ≥0
r₁ r₂ : ℝ≥0∞
h₁ : r₁ ≠ ⊤
h₂ : r₂ ≠ ⊤
⊢ ENNReal.toNNReal (r₁ + r₂) = ENNReal.toNNReal r₁ + ENNReal.toNNReal r₂

tactic: lift r₂ to ℝ≥0 using h₂
state_before: case intro
α : Type ?u.80550
β : Type ?u.80553
a b c d : ℝ≥0∞
r p q : ℝ≥0
r₂ : ℝ≥0∞
h₂ : r₂ ≠ ⊤
r₁ : ℝ≥0
⊢ ENNReal.toNNReal (↑r₁ + r₂) = ENNReal.toNNReal ↑r₁ + ENNReal.toNNReal r₂

tactic: rfl
state_before: case intro.intro
α : Type ?u.80550
β : Type ?u.80553
a b c d : ℝ≥0∞
r p q r₁ r₂ : ℝ≥0
⊢ ENNReal.toNNReal (↑r₁ + ↑r₂) = ENNReal.toNNReal ↑r₁ + ENNReal.toNNReal ↑r₂
Theorem: Finite.Set.finite_biUnion
File: Mathlib/Data/Set/Finite.lean

tactic: rw [biUnion_eq_iUnion]
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
inst✝ : Finite ↑s
t : ι → Set α
H : ∀ (i : ι), i ∈ s → Finite ↑(t i)
⊢ Finite ↑(⋃ (x : ι) (_ : x ∈ s), t x)

tactic: haveI : ∀ i : s, Finite (t i) := fun i => H i i.property
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
inst✝ : Finite ↑s
t : ι → Set α
H : ∀ (i : ι), i ∈ s → Finite ↑(t i)
⊢ Finite ↑(⋃ (x : ↑s), t ↑x)

tactic: infer_instance
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
s : Set ι
inst✝ : Finite ↑s
t : ι → Set α
H : ∀ (i : ι), i ∈ s → Finite ↑(t i)
this : ∀ (i : ↑s), Finite ↑(t ↑i)
⊢ Finite ↑(⋃ (x : ↑s), t ↑x)
Theorem: MeasureTheory.VectorMeasure.subset_le_of_restrict_le_restrict
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: by_cases hj₁ : MeasurableSet j
state_before: α : Type u_1
β : Type ?u.543897
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
hi₂ : restrict v i ≤ restrict w i
j : Set α
hj : j ⊆ i
⊢ ↑v j ≤ ↑w j

tactic: exact (restrict_le_restrict_iff _ _ hi).1 hi₂ hj₁ hj
state_before: case pos
α : Type u_1
β : Type ?u.543897
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
hi₂ : restrict v i ≤ restrict w i
j : Set α
hj : j ⊆ i
hj₁ : MeasurableSet j
⊢ ↑v j ≤ ↑w j

tactic: rw [v.not_measurable hj₁, w.not_measurable hj₁]
state_before: case neg
α : Type u_1
β : Type ?u.543897
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
i : Set α
hi : MeasurableSet i
hi₂ : restrict v i ≤ restrict w i
j : Set α
hj : j ⊆ i
hj₁ : ¬MeasurableSet j
⊢ ↑v j ≤ ↑w j
Theorem: Real.sinh_pos_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: simpa only [sinh_zero] using @sinh_lt_sinh 0 x
state_before: x y z : ℝ
⊢ 0 < sinh x ↔ 0 < x
Theorem: TopCat.snd_embedding_of_left_embedding
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: convert (homeoOfIso (asIso (pullback.snd : pullback (𝟙 S) g ⟶  _))).embedding.comp
    (pullback_map_embedding_of_embeddings (i₂ := 𝟙 Y)
      f g (𝟙 S) g H (homeoOfIso (Iso.refl _)).embedding (𝟙 _) rfl (by simp))
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ((forget TopCat).map f)
g : Y ⟶ S
⊢ Embedding ((forget TopCat).map pullback.snd)

tactic: erw [← coe_comp]
state_before: case h.e'_5.h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ((forget TopCat).map f)
g : Y ⟶ S
e_2✝ : (forget TopCat).obj Y = ↑Y
⊢ (forget TopCat).map pullback.snd =
    ↑(homeoOfIso (asIso pullback.snd)) ∘
      (forget TopCat).map (pullback.map f g (𝟙 S) g f (𝟙 Y) (𝟙 S) (_ : f ≫ 𝟙 S = f ≫ 𝟙 S) (_ : g ≫ 𝟙 S = 𝟙 Y ≫ g))

tactic: simp
state_before: case h.e'_5.h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ((forget TopCat).map f)
g : Y ⟶ S
e_2✝ : (forget TopCat).obj Y = ↑Y
⊢ (forget TopCat).map pullback.snd =
    (forget TopCat).map
      (pullback.map f g (𝟙 S) g f (𝟙 Y) (𝟙 S) (_ : f ≫ 𝟙 S = f ≫ 𝟙 S) (_ : g ≫ 𝟙 S = 𝟙 Y ≫ g) ≫
        (asIso pullback.snd).hom)

tactic: simp
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ((forget TopCat).map f)
g : Y ⟶ S
⊢ g ≫ 𝟙 S = 𝟙 Y ≫ g
Theorem: Fin.cast_eq_cast'
File: Mathlib/Data/Fintype/Card.lean

tactic: cases fin_injective h
state_before: α : Type ?u.10869
β : Type ?u.10872
γ : Type ?u.10875
n m : ℕ
h : Fin n = Fin m
⊢ _root_.cast h = ↑(cast (_ : n = m))

tactic: rfl
state_before: case refl
α : Type ?u.10869
β : Type ?u.10872
γ : Type ?u.10875
n : ℕ
h : Fin n = Fin n
⊢ _root_.cast h = ↑(cast (_ : n = n))
Theorem: Submodule.ideal_span_singleton_smul
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: have : span R (⋃ (t : M) (_ : t ∈ N), {r • t}) = r • N := by
  convert span_eq (r • N)
  exact (Set.image_eq_iUnion _ (N : Set M)).symm
state_before: R : Type u
M : Type v
F : Type ?u.87328
G : Type ?u.87331
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I J : Ideal R
N✝ P : Submodule R M
S : Set R
T : Set M
r : R
N : Submodule R M
⊢ Ideal.span {r} • N = r • N

tactic: conv_lhs => rw [← span_eq N, span_smul_span]
state_before: R : Type u
M : Type v
F : Type ?u.87328
G : Type ?u.87331
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I J : Ideal R
N✝ P : Submodule R M
S : Set R
T : Set M
r : R
N : Submodule R M
this : span R (⋃ (t : M) (_ : t ∈ N), {r • t}) = r • N
⊢ Ideal.span {r} • N = r • N

tactic: simpa
state_before: R : Type u
M : Type v
F : Type ?u.87328
G : Type ?u.87331
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I J : Ideal R
N✝ P : Submodule R M
S : Set R
T : Set M
r : R
N : Submodule R M
this : span R (⋃ (t : M) (_ : t ∈ N), {r • t}) = r • N
⊢ span R (⋃ (s : R) (_ : s ∈ {r}) (t : M) (_ : t ∈ ↑N), {s • t}) = r • N

tactic: convert span_eq (r • N)
state_before: R : Type u
M : Type v
F : Type ?u.87328
G : Type ?u.87331
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I J : Ideal R
N✝ P : Submodule R M
S : Set R
T : Set M
r : R
N : Submodule R M
⊢ span R (⋃ (t : M) (_ : t ∈ N), {r • t}) = r • N

tactic: exact (Set.image_eq_iUnion _ (N : Set M)).symm
state_before: case h.e'_2.h.e'_6
R : Type u
M : Type v
F : Type ?u.87328
G : Type ?u.87331
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
I J : Ideal R
N✝ P : Submodule R M
S : Set R
T : Set M
r : R
N : Submodule R M
⊢ (⋃ (t : M) (_ : t ∈ N), {r • t}) = ↑(r • N)
Theorem: MeasureTheory.VectorMeasure.zero_trim
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: ext1 i hi
state_before: α : Type u_1
β : Type ?u.697802
m : MeasurableSpace α
L : Type ?u.697808
M : Type u_2
N : Type ?u.697814
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
n : MeasurableSpace α
v : VectorMeasure α M
hle : m ≤ n
⊢ trim 0 hle = 0

tactic: exact if_pos hi
state_before: case h
α : Type u_1
β : Type ?u.697802
m : MeasurableSpace α
L : Type ?u.697808
M : Type u_2
N : Type ?u.697814
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
n : MeasurableSpace α
v : VectorMeasure α M
hle : m ≤ n
i : Set α
hi : MeasurableSet i
⊢ ↑(trim 0 hle) i = ↑0 i
Theorem: tendsto_const_nhds_iff
File: Mathlib/Topology/Separation.lean

tactic: simp_rw [Tendsto, Filter.map_const, pure_le_nhds_iff]
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : T1Space α
l : Filter β
inst✝ : NeBot l
c d : α
⊢ Tendsto (fun x => c) l (𝓝 d) ↔ c = d
Theorem: Primrec.map_decode_iff
File: Mathlib/Computability/Primrec.lean

tactic: simp only [Option.map_eq_bind]
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.126196
δ : Type ?u.126199
σ : Type u_2
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → β → σ
⊢ (Primrec₂ fun a n => Option.map (f a) (decode n)) ↔ Primrec₂ f

tactic: exact bind_decode_iff.trans Primrec₂.option_some_iff
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.126196
δ : Type ?u.126199
σ : Type u_2
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → β → σ
⊢ (Primrec₂ fun a n => Option.bind (decode n) (some ∘ f a)) ↔ Primrec₂ f
Theorem: SignType.univ_eq
File: Mathlib/Data/Sign.lean

tactic: decide
state_before: ⊢ Finset.univ = {0, -1, 1}
Theorem: SimpleGraph.Subgraph.degree_spanningCoe
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: rw [← card_neighborSet_eq_degree, Subgraph.degree]
state_before: ι : Sort ?u.203693
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : Subgraph G
v : V
inst✝¹ : Fintype ↑(neighborSet G' v)
inst✝ : Fintype ↑(SimpleGraph.neighborSet (Subgraph.spanningCoe G') v)
⊢ SimpleGraph.degree (Subgraph.spanningCoe G') v = degree G' v

tactic: congr!
state_before: ι : Sort ?u.203693
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
G' : Subgraph G
v : V
inst✝¹ : Fintype ↑(neighborSet G' v)
inst✝ : Fintype ↑(SimpleGraph.neighborSet (Subgraph.spanningCoe G') v)
⊢ Fintype.card ↑(SimpleGraph.neighborSet (Subgraph.spanningCoe G') v) = Fintype.card ↑(neighborSet G' v)
Theorem: div_div_div_comm
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.44922
G : Type ?u.44925
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b / (c / d) = a / c / (b / d)
Theorem: Finsupp.card_toMultiset
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: simp [toMultiset_apply, map_finsupp_sum, Function.id_def]
state_before: α : Type u_1
β : Type ?u.15299
ι : Type ?u.15302
f : α →₀ ℕ
⊢ ↑Multiset.card (↑toMultiset f) = sum f fun x => id
Theorem: Asymptotics.IsEquivalent.tendsto_nhds
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: by_cases h : c = 0
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
⊢ Tendsto v l (𝓝 c)

tactic: subst c
state_before: case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
h : c = 0
⊢ Tendsto v l (𝓝 c)

tactic: rw [← isLittleO_one_iff ℝ] at hu⊢
state_before: case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hu : Tendsto u l (𝓝 0)
⊢ Tendsto v l (𝓝 0)

tactic: simpa using (huv.symm.isLittleO.trans hu).add hu
state_before: case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hu : u =o[l] fun _x => 1
⊢ v =o[l] fun _x => 1

tactic: rw [← isEquivalent_const_iff_tendsto h] at hu⊢
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
h : ¬c = 0
⊢ Tendsto v l (𝓝 c)

tactic: exact huv.symm.trans hu
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : u ~[l] const α c
h : ¬c = 0
⊢ v ~[l] const α c
Theorem: MeasureTheory.Memℒp.integrable_sq
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: simpa [← memℒp_one_iff_integrable] using h.norm_rpow two_ne_zero ENNReal.two_ne_top
state_before: α : Type u_1
F : Type ?u.1981
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → ℝ
h : Memℒp f 2
⊢ Integrable fun x => f x ^ 2
Theorem: Finset.coe_eq_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← coe_singleton, coe_inj]
state_before: α : Type u_1
β : Type ?u.30150
γ : Type ?u.30153
s✝ : Finset α
a✝ b : α
s : Finset α
a : α
⊢ ↑s = {a} ↔ s = {a}
Theorem: AddLECancellable.lt_of_tsub_lt_tsub_left_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: conv_lhs at h => rw [← tsub_add_cancel_of_le hca]
state_before: α : Type u_1
inst✝⁶ : AddCommSemigroup α
inst✝⁵ : PartialOrder α
inst✝⁴ : ExistsAddOfLE α
inst✝³ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
hb : AddLECancellable b
hca : c ≤ a
h : a - b < a - c
⊢ c < b

tactic: exact lt_of_add_lt_add_left (hb.lt_add_of_tsub_lt_right h)
state_before: α : Type u_1
inst✝⁶ : AddCommSemigroup α
inst✝⁵ : PartialOrder α
inst✝⁴ : ExistsAddOfLE α
inst✝³ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x < x_1
hb : AddLECancellable b
hca : c ≤ a
h : a - c + c - b < a - c
⊢ c < b
Theorem: Set.preimage_boolIndicator
File: Mathlib/Data/Set/BoolIndicator.lean

tactic: simp only [preimage_boolIndicator_eq_union]
state_before: α : Type u_1
s : Set α
t : Set Bool
⊢ boolIndicator s ⁻¹' t = univ ∨ boolIndicator s ⁻¹' t = s ∨ boolIndicator s ⁻¹' t = sᶜ ∨ boolIndicator s ⁻¹' t = ∅

tactic: split_ifs <;> simp [s.union_compl_self]
state_before: α : Type u_1
s : Set α
t : Set Bool
⊢ ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = univ ∨
    ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = s ∨
      ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = sᶜ ∨
        ((if true ∈ t then s else ∅) ∪ if false ∈ t then sᶜ else ∅) = ∅
Theorem: Quot.liftIndepPr1
File: src/lean/Init/Core.lean

tactic: induction q using Quot.ind
state_before: a b c d : Prop
α : Sort u
r : α → α → Prop
motive : Quot r → Sort v
f : (a : α) → motive (mk r a)
h : ∀ (a b : α) (p : r a b), Eq.ndrec (f a) (_ : mk r a = mk r b) = f b
q : Quot r
⊢ (lift (Quot.indep f) (_ : ∀ (a b : α), r a b → Quot.indep f a = Quot.indep f b) q).fst = q

tactic: exact rfl
state_before: case mk
a b c d : Prop
α : Sort u
r : α → α → Prop
motive : Quot r → Sort v
f : (a : α) → motive (mk r a)
h : ∀ (a b : α) (p : r a b), Eq.ndrec (f a) (_ : mk r a = mk r b) = f b
a✝ : α
⊢ (lift (Quot.indep f) (_ : ∀ (a b : α), r a b → Quot.indep f a = Quot.indep f b) (mk r a✝)).fst = mk r a✝
Theorem: Finsupp.subtypeDomain_eq_zero_iff
File: Mathlib/Data/Finsupp/Basic.lean

tactic: classical exact if hx : p x then H x hx else not_mem_support_iff.1 <| mt (hf x) hx
state_before: α : Type u_1
β : Type ?u.487267
γ : Type ?u.487270
ι : Type ?u.487273
M : Type u_2
M' : Type ?u.487279
N : Type ?u.487282
P : Type ?u.487285
G : Type ?u.487288
H✝ : Type ?u.487291
R : Type ?u.487294
S : Type ?u.487297
inst✝ : Zero M
p : α → Prop
f : α →₀ M
hf : ∀ (x : α), x ∈ f.support → p x
H : ∀ (x : α), p x → ↑f x = 0
x : α
⊢ ↑f x = ↑0 x

tactic: exact if hx : p x then H x hx else not_mem_support_iff.1 <| mt (hf x) hx
state_before: α : Type u_1
β : Type ?u.487267
γ : Type ?u.487270
ι : Type ?u.487273
M : Type u_2
M' : Type ?u.487279
N : Type ?u.487282
P : Type ?u.487285
G : Type ?u.487288
H✝ : Type ?u.487291
R : Type ?u.487294
S : Type ?u.487297
inst✝ : Zero M
p : α → Prop
f : α →₀ M
hf : ∀ (x : α), x ∈ f.support → p x
H : ∀ (x : α), p x → ↑f x = 0
x : α
⊢ ↑f x = ↑0 x

tactic: simp [H]
state_before: α : Type u_1
β : Type ?u.487267
γ : Type ?u.487270
ι : Type ?u.487273
M : Type u_2
M' : Type ?u.487279
N : Type ?u.487282
P : Type ?u.487285
G : Type ?u.487288
H✝ : Type ?u.487291
R : Type ?u.487294
S : Type ?u.487297
inst✝ : Zero M
p : α → Prop
f : α →₀ M
hf : ∀ (x : α), x ∈ f.support → p x
H : f = 0
x : α
x✝ : p x
⊢ ↑f x = 0
Theorem: Prime.left_dvd_or_dvd_right_of_dvd_mul
File: Mathlib/Algebra/Associated.lean

tactic: rintro ⟨c, hc⟩
state_before: α : Type u_1
β : Type ?u.29194
γ : Type ?u.29197
δ : Type ?u.29200
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b : α
⊢ a ∣ p * b → p ∣ a ∨ a ∣ b

tactic: rcases hp.2.2 a c (hc ▸ dvd_mul_right _ _) with (h | ⟨x, rfl⟩)
state_before: case intro
α : Type u_1
β : Type ?u.29194
γ : Type ?u.29197
δ : Type ?u.29200
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b c : α
hc : p * b = a * c
⊢ p ∣ a ∨ a ∣ b

tactic: exact Or.inl h
state_before: case intro.inl
α : Type u_1
β : Type ?u.29194
γ : Type ?u.29197
δ : Type ?u.29200
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b c : α
hc : p * b = a * c
h : p ∣ a
⊢ p ∣ a ∨ a ∣ b

tactic: rw [mul_left_comm, mul_right_inj' hp.ne_zero] at hc
state_before: case intro.inr.intro
α : Type u_1
β : Type ?u.29194
γ : Type ?u.29197
δ : Type ?u.29200
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b x : α
hc : p * b = a * (p * x)
⊢ p ∣ a ∨ a ∣ b

tactic: exact Or.inr (hc.symm ▸ dvd_mul_right _ _)
state_before: case intro.inr.intro
α : Type u_1
β : Type ?u.29194
γ : Type ?u.29197
δ : Type ?u.29200
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b x : α
hc : b = a * x
⊢ p ∣ a ∨ a ∣ b