tasksource/leandojo huggingface dataset:
Theorem: ContDiffBump.integral_pos
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: refine' (integral_pos_iff_support_of_nonneg f.nonneg' f.integrable).mpr _
state_before: E : Type u_1
X : Type ?u.1741316
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace ℝ X
inst✝⁵ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
inst✝⁴ : MeasurableSpace E
μ : MeasureTheory.Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : Measure.IsOpenPosMeasure μ
⊢ 0 < ∫ (x : E), ↑f x ∂μ

tactic: rw [f.support_eq]
state_before: E : Type u_1
X : Type ?u.1741316
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace ℝ X
inst✝⁵ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
inst✝⁴ : MeasurableSpace E
μ : MeasureTheory.Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : Measure.IsOpenPosMeasure μ
⊢ 0 < ↑↑μ (Function.support fun i => ↑f i)

tactic: exact measure_ball_pos μ c f.rOut_pos
state_before: E : Type u_1
X : Type ?u.1741316
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace ℝ X
inst✝⁵ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
inst✝⁴ : MeasurableSpace E
μ : MeasureTheory.Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : Measure.IsOpenPosMeasure μ
⊢ 0 < ↑↑μ (ball c f.rOut)
Theorem: Polynomial.X_sub_C_mul_divByMonic_eq_sub_modByMonic
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [eq_sub_iff_add_eq, ← eq_sub_iff_add_eq', modByMonic_eq_sub_mul_div]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
⊢ (X - ↑C a) * (f /ₘ (X - ↑C a)) = f - f %ₘ (X - ↑C a)

tactic: exact monic_X_sub_C a
state_before: case _hq
R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
⊢ Monic (X - ↑C a)
Theorem: AffineSubspace.vectorSpan_eq_top_of_affineSpan_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [← direction_affineSpan, h, direction_top]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s : Set P
h : affineSpan k s = ⊤
⊢ vectorSpan k s = ⊤
Theorem: ContractingWith.one_sub_K_pos'
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: simp [hf.1]
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
⊢ 0 < 1 - ↑K
Theorem: mul_gauge_le_norm
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: obtain hr | hr := le_or_lt r 0
state_before: 𝕜 : Type ?u.292192
E : Type u_1
F : Type ?u.292198
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : Metric.ball 0 r ⊆ s
⊢ r * gauge s x ≤ ‖x‖

tactic: rw [mul_comm, ← le_div_iff hr, ← gauge_ball hr]
state_before: case inr
𝕜 : Type ?u.292192
E : Type u_1
F : Type ?u.292198
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : Metric.ball 0 r ⊆ s
hr : 0 < r
⊢ r * gauge s x ≤ ‖x‖

tactic: exact gauge_mono (absorbent_ball_zero hr) hs x
state_before: case inr
𝕜 : Type ?u.292192
E : Type u_1
F : Type ?u.292198
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : Metric.ball 0 r ⊆ s
hr : 0 < r
⊢ gauge s x ≤ gauge (Metric.ball 0 r) x

tactic: exact (mul_nonpos_of_nonpos_of_nonneg hr <| gauge_nonneg _).trans (norm_nonneg _)
state_before: case inl
𝕜 : Type ?u.292192
E : Type u_1
F : Type ?u.292198
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x : E
hs : Metric.ball 0 r ⊆ s
hr : r ≤ 0
⊢ r * gauge s x ≤ ‖x‖
Theorem: Filter.eventually_lt_of_lt_liminf
File: Mathlib/Order/LiminfLimsup.lean

tactic: obtain ⟨c, hc, hbc⟩ : ∃ (c : β) (_ : c ∈ { c : β | ∀ᶠ n : α in f, c ≤ u n }), b < c := by
  simp_rw [exists_prop]
  exact exists_lt_of_lt_csSup hu h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.187657
ι : Type ?u.187660
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder β
u : α → β
b : β
h : b < liminf u f
hu : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) f u) _auto✝
⊢ ∀ᶠ (a : α) in f, b < u a

tactic: exact hc.mono fun x hx => lt_of_lt_of_le hbc hx
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.187657
ι : Type ?u.187660
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder β
u : α → β
b : β
h : b < liminf u f
hu : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) f u) _auto✝
c : β
hc : c ∈ {c | ∀ᶠ (n : α) in f, c ≤ u n}
hbc : b < c
⊢ ∀ᶠ (a : α) in f, b < u a

tactic: simp_rw [exists_prop]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.187657
ι : Type ?u.187660
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder β
u : α → β
b : β
h : b < liminf u f
hu : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) f u) _auto✝
⊢ ∃ c x, b < c

tactic: exact exists_lt_of_lt_csSup hu h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.187657
ι : Type ?u.187660
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder β
u : α → β
b : β
h : b < liminf u f
hu : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) f u) _auto✝
⊢ ∃ c, c ∈ {c | ∀ᶠ (n : α) in f, c ≤ u n} ∧ b < c
Theorem: Set.Ioc_union_Ioi
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: cases' le_total a b with hab hab <;> simp [hab] at h
state_before: α : Type u_1
β : Type ?u.87359
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : c ≤ max a b
⊢ Ioc a b ∪ Ioi c = Ioi (min a c)

tactic: exact Ioc_union_Ioi' h
state_before: case inl
α : Type u_1
β : Type ?u.87359
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
h : c ≤ b
⊢ Ioc a b ∪ Ioi c = Ioi (min a c)

tactic: simp [*]
state_before: case inr
α : Type u_1
β : Type ?u.87359
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
h : c ≤ a
⊢ Ioc a b ∪ Ioi c = Ioi (min a c)
Theorem: QuadraticForm.choose_exists_companion
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [polarBilin_apply, polar, Q.exists_companion.choose_spec, sub_sub, add_sub_cancel']
state_before: S : Type ?u.213182
R : Type u_1
R₁ : Type ?u.213188
M : Type u_2
inst✝⁷ : Ring R
inst✝⁶ : CommRing R₁
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
inst✝³ : CommSemiring S
inst✝² : Algebra S R
inst✝¹ : Module S M
inst✝ : IsScalarTower S R M
x y : M
⊢ BilinForm.bilin (Exists.choose (_ : ∃ B, ∀ (x y : M), ↑Q (x + y) = ↑Q x + ↑Q y + BilinForm.bilin B x y)) x y =
    BilinForm.bilin (polarBilin Q) x y
Theorem: Turing.PartrecToTM2.supports_union
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [Supports, or_imp, forall_and]
state_before: K₁ K₂ S : Finset Λ'
⊢ Supports (K₁ ∪ K₂) S ↔ Supports K₁ S ∧ Supports K₂ S
Theorem: CategoryTheory.Limits.pullback_lift_map_isPullback
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: rw [lift_fst, lift_fst]
state_before: C : Type u_2
inst✝² : Category C
X✝ Y✝ Z : C
inst✝¹ : HasPullbacks C
X Y S X' Y' S' : C
f : X ⟶ S
g : Y ⟶ S
f' : X' ⟶ S'
g' : Y' ⟶ S'
i₁ : X ⟶ X'
i₂ : Y ⟶ Y'
i₃ : S ⟶ S'
e₁ : f ≫ i₃ = i₁ ≫ f'
e₂ : g ≫ i₃ = i₂ ≫ g'
inst✝ : Mono i₃
⊢ lift (map f g f' g' i₁ i₂ i₃ e₁ e₂) fst
        (_ : lift (fst ≫ i₁) (snd ≫ i₂) (_ : (fst ≫ i₁) ≫ f' = (snd ≫ i₂) ≫ g') ≫ fst = fst ≫ i₁) ≫
      fst =
    lift (map f g f' g' i₁ i₂ i₃ e₁ e₂) snd
        (_ : lift (fst ≫ i₁) (snd ≫ i₂) (_ : (fst ≫ i₁) ≫ f' = (snd ≫ i₂) ≫ g') ≫ snd = snd ≫ i₂) ≫
      fst

tactic: simp
state_before: C : Type u_2
inst✝² : Category C
X✝ Y✝ Z : C
inst✝¹ : HasPullbacks C
X Y S X' Y' S' : C
f : X ⟶ S
g : Y ⟶ S
f' : X' ⟶ S'
g' : Y' ⟶ S'
i₁ : X ⟶ X'
i₂ : Y ⟶ Y'
i₃ : S ⟶ S'
e₁ : f ≫ i₃ = i₁ ≫ f'
e₂ : g ≫ i₃ = i₂ ≫ g'
inst✝ : Mono i₃
⊢ (pullbackFstFstIso f g f' g' i₁ i₂ i₃ e₁ e₂).symm.hom ≫ fst =
    lift (map f g f' g' i₁ i₂ i₃ e₁ e₂) fst
      (_ : lift (fst ≫ i₁) (snd ≫ i₂) (_ : (fst ≫ i₁) ≫ f' = (snd ≫ i₂) ≫ g') ≫ fst = fst ≫ i₁)

tactic: simp
state_before: C : Type u_2
inst✝² : Category C
X✝ Y✝ Z : C
inst✝¹ : HasPullbacks C
X Y S X' Y' S' : C
f : X ⟶ S
g : Y ⟶ S
f' : X' ⟶ S'
g' : Y' ⟶ S'
i₁ : X ⟶ X'
i₂ : Y ⟶ Y'
i₃ : S ⟶ S'
e₁ : f ≫ i₃ = i₁ ≫ f'
e₂ : g ≫ i₃ = i₂ ≫ g'
inst✝ : Mono i₃
⊢ (pullbackFstFstIso f g f' g' i₁ i₂ i₃ e₁ e₂).symm.hom ≫ snd =
    lift (map f g f' g' i₁ i₂ i₃ e₁ e₂) snd
      (_ : lift (fst ≫ i₁) (snd ≫ i₂) (_ : (fst ≫ i₁) ≫ f' = (snd ≫ i₂) ≫ g') ≫ snd = snd ≫ i₂)
Theorem: swap_idRel
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simpa [image_swap_eq_preimage_swap] using eq_comm
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.9578
x✝ : α × α
a b : α
⊢ (a, b) ∈ Prod.swap '' idRel ↔ (a, b) ∈ idRel
Theorem: MeasurableSpace.compl_mem_generateMeasurableRec
File: Mathlib/MeasureTheory/CardMeasurableSpace.lean

tactic: unfold generateMeasurableRec
state_before: α : Type u
s : Set (Set α)
i j : (Quotient.out (ord (aleph 1))).α
h : j < i
t : Set α
ht : t ∈ generateMeasurableRec s j
⊢ tᶜ ∈ generateMeasurableRec s i

tactic: exact mem_union_left _ (mem_union_right _ ⟨t, mem_iUnion.2 ⟨⟨j, h⟩, ht⟩, rfl⟩)
state_before: α : Type u
s : Set (Set α)
i j : (Quotient.out (ord (aleph 1))).α
h : j < i
t : Set α
ht : t ∈ generateMeasurableRec s j
⊢ tᶜ ∈
    let i := i;
    let S := ⋃ (j : ↑(Iio i)), generateMeasurableRec s ↑j;
    s ∪ {∅} ∪ compl '' S ∪ range fun f => ⋃ (n : ℕ), ↑(f n)
Theorem: Subtype.restrict_apply
File: Mathlib/Data/Subtype.lean

tactic: rfl
state_before: α✝ : Sort ?u.6402
β✝ : Sort ?u.6405
γ : Sort ?u.6408
p✝ q : α✝ → Prop
α : Sort u_1
β : α → Type u_2
f : (x : α) → β x
p : α → Prop
x : Subtype p
⊢ restrict p f x = f ↑x
Theorem: forall₂_true_iff
File: Mathlib/Logic/Basic.lean

tactic: simp
state_before: ι : Sort ?u.14520
α : Sort ?u.14525
κ : ι → Sort ?u.14522
p q : α → Prop
β : α → Sort u_1
⊢ (∀ (a : α), β a → True) ↔ True
Theorem: CategoryTheory.Limits.IsTerminal.mono_from
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: haveI := t.isSplitMono_from f
state_before: C : Type u₁
inst✝ : Category C
X Y : C
t : IsTerminal X
f : X ⟶ Y
⊢ Mono f

tactic: infer_instance
state_before: C : Type u₁
inst✝ : Category C
X Y : C
t : IsTerminal X
f : X ⟶ Y
this : IsSplitMono f
⊢ Mono f
Theorem: Polynomial.ofFinsupp_add
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [add_def]
state_before: R : Type u
a✝ b✝ : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
a b : AddMonoidAlgebra R ℕ
⊢ { toFinsupp := a + b } = Polynomial.add { toFinsupp := a } { toFinsupp := b }
Theorem: Rack.involutory_invAct_eq_act
File: Mathlib/Algebra/Quandle.lean

tactic: rw [← left_cancel x, right_inv, h x]
state_before: R✝ : Type ?u.30688
inst✝¹ : Rack R✝
R : Type u_1
inst✝ : Rack R
h : IsInvolutory R
x y : R
⊢ x ◃⁻¹ y = x ◃ y
Theorem: interior_eq_nhds
File: Mathlib/Topology/Basic.lean

tactic: simp only [le_principal_iff]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ {a | s ∈ 𝓝 a} = {a | 𝓝 a ≤ 𝓟 s}
Theorem: OpenEmbedding.of_comp_iff
File: Mathlib/Topology/Maps.lean

tactic: simp only [openEmbedding_iff_continuous_injective_open, ← hg.isOpenMap_iff, ←
  hg.1.continuous_iff, hg.inj.of_comp_iff]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.260169
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
g : β → γ
hg : OpenEmbedding g
⊢ OpenEmbedding (g ∘ f) ↔ OpenEmbedding f
Theorem: Nat.pow_le_of_le_log
File: Mathlib/Data/Nat/Log.lean

tactic: refine' (le_or_lt b 1).elim (fun hb => _) fun hb => (pow_le_iff_le_log hb hy).2 h
state_before: b x y : ℕ
hy : y ≠ 0
h : x ≤ log b y
⊢ b ^ x ≤ y

tactic: rw [log_of_left_le_one hb, nonpos_iff_eq_zero] at h
state_before: b x y : ℕ
hy : y ≠ 0
h : x ≤ log b y
hb : b ≤ 1
⊢ b ^ x ≤ y

tactic: rwa [h, pow_zero, one_le_iff_ne_zero]
state_before: b x y : ℕ
hy : y ≠ 0
h : x = 0
hb : b ≤ 1
⊢ b ^ x ≤ y
Theorem: Int.shiftr_neg
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [← shiftl_neg, neg_neg]
state_before: m n : ℤ
⊢ shiftr m (-n) = shiftl m n
Theorem: Tree.mem_treesOfNumNodesEq
File: Mathlib/Combinatorics/Catalan.lean

tactic: induction x using Tree.unitRecOn generalizing n <;> cases n <;>
  simp [treesOfNumNodesEq_succ, Nat.succ_eq_add_one, *]
state_before: x : Tree Unit
n : ℕ
⊢ x ∈ treesOfNumNodesEq n ↔ numNodes x = n

tactic: exact (Nat.succ_ne_zero _).symm
state_before: case base.succ
n✝ : ℕ
⊢ ¬0 = n✝ + 1
Theorem: CategoryTheory.isDetector_unop_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [IsDetector, IsCodetector, ← isDetecting_unop_iff, Set.singleton_unop]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : Cᵒᵖ
⊢ IsDetector G.unop ↔ IsCodetector G
Theorem: finSuccEquivLast_last
File: Mathlib/Logic/Equiv/Fin.lean

tactic: simp [finSuccEquivLast]
state_before: m n : ℕ
⊢ ↑finSuccEquivLast (Fin.last n) = none
Theorem: List.get_attach
File: Mathlib/Data/List/Basic.lean

tactic: simpa using i.2
state_before: ι : Type ?u.488600
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ L : List α
i : Fin (length (attach L))
⊢ ↑i < length (map Subtype.val (attach L))

tactic: rw [get_map]
state_before: ι : Type ?u.488600
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ L : List α
i : Fin (length (attach L))
⊢ ↑(get (attach L) i) =
    get (map Subtype.val (attach L)) { val := ↑i, isLt := (_ : ↑i < length (map Subtype.val (attach L))) }

tactic: congr 2 <;> simp
state_before: ι : Type ?u.488600
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ L : List α
i : Fin (length (attach L))
⊢ get (map Subtype.val (attach L)) { val := ↑i, isLt := (_ : ↑i < length (map Subtype.val (attach L))) } =
    get L { val := ↑i, isLt := (_ : ↑i < length L) }
Theorem: Matrix.smul_stdBasisMatrix
File: Mathlib/Data/Matrix/Basis.lean

tactic: unfold stdBasisMatrix
state_before: l : Type ?u.855
m : Type u_1
n : Type u_2
R : Type ?u.864
α : Type u_3
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
a b : α
⊢ b • stdBasisMatrix i j a = stdBasisMatrix i j (b • a)

tactic: ext
state_before: l : Type ?u.855
m : Type u_1
n : Type u_2
R : Type ?u.864
α : Type u_3
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
a b : α
⊢ (b • fun i' j' => if i = i' ∧ j = j' then a else 0) = fun i' j' => if i = i' ∧ j = j' then b • a else 0

tactic: simp
state_before: case a.h
l : Type ?u.855
m : Type u_1
n : Type u_2
R : Type ?u.864
α : Type u_3
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
a b : α
i✝ : m
x✝ : n
⊢ (b • fun i' j' => if i = i' ∧ j = j' then a else 0) i✝ x✝ = if i = i✝ ∧ j = x✝ then b • a else 0
Theorem: MeasureTheory.L1.SimpleFunc.setToL1S_add
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: simp_rw [setToL1S]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.666025
G : Type ?u.666028
𝕜 : Type ?u.666031
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
f g : { x // x ∈ simpleFunc E 1 μ }
⊢ setToL1S T (f + g) = setToL1S T f + setToL1S T g

tactic: rw [← SimpleFunc.setToSimpleFunc_add T h_add (SimpleFunc.integrable f)
    (SimpleFunc.integrable g)]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.666025
G : Type ?u.666028
𝕜 : Type ?u.666031
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
f g : { x // x ∈ simpleFunc E 1 μ }
⊢ SimpleFunc.setToSimpleFunc T (toSimpleFunc (f + g)) =
    SimpleFunc.setToSimpleFunc T (toSimpleFunc f) + SimpleFunc.setToSimpleFunc T (toSimpleFunc g)

tactic: exact
  SimpleFunc.setToSimpleFunc_congr T h_zero h_add (SimpleFunc.integrable _)
    (add_toSimpleFunc f g)
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.666025
G : Type ?u.666028
𝕜 : Type ?u.666031
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
f g : { x // x ∈ simpleFunc E 1 μ }
⊢ SimpleFunc.setToSimpleFunc T (toSimpleFunc (f + g)) = SimpleFunc.setToSimpleFunc T (toSimpleFunc f + toSimpleFunc g)
Theorem: div_le_div_left₀
File: Mathlib/Algebra/Order/WithZero.lean

tactic: simp only [div_eq_mul_inv, mul_le_mul_left₀ ha, inv_le_inv₀ hb hc]
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
ha : a ≠ 0
hb : b ≠ 0
hc : c ≠ 0
⊢ a / b ≤ a / c ↔ c ≤ b
Theorem: SimpleGraph.Subgraph.IsPerfectMatching.even_card
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

tactic: classical
simpa only [h.2.card_verts] using IsMatching.even_card h.1
state_before: V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
inst✝ : Fintype V
h : IsPerfectMatching M
⊢ Even (Fintype.card V)

tactic: simpa only [h.2.card_verts] using IsMatching.even_card h.1
state_before: V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
inst✝ : Fintype V
h : IsPerfectMatching M
⊢ Even (Fintype.card V)
Theorem: List.Forall₂.prod_le_prod'
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: induction' h with a b la lb hab ih ih'
state_before: ι : Type ?u.73927
α : Type ?u.73930
M : Type u_1
N : Type ?u.73936
P : Type ?u.73939
M₀ : Type ?u.73942
G : Type ?u.73945
R : Type ?u.73948
inst✝⁵ : Monoid M
inst✝⁴ : Monoid N
inst✝³ : Monoid P
l l₁✝ l₂✝ : List M
a : M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l₁ l₂ : List M
h : Forall₂ (fun x x_1 => x ≤ x_1) l₁ l₂
⊢ prod l₁ ≤ prod l₂

tactic: rfl
state_before: case nil
ι : Type ?u.73927
α : Type ?u.73930
M : Type u_1
N : Type ?u.73936
P : Type ?u.73939
M₀ : Type ?u.73942
G : Type ?u.73945
R : Type ?u.73948
inst✝⁵ : Monoid M
inst✝⁴ : Monoid N
inst✝³ : Monoid P
l l₁✝ l₂✝ : List M
a : M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l₁ l₂ : List M
⊢ prod [] ≤ prod []

tactic: simpa only [prod_cons] using mul_le_mul' hab ih'
state_before: case cons
ι : Type ?u.73927
α : Type ?u.73930
M : Type u_1
N : Type ?u.73936
P : Type ?u.73939
M₀ : Type ?u.73942
G : Type ?u.73945
R : Type ?u.73948
inst✝⁵ : Monoid M
inst✝⁴ : Monoid N
inst✝³ : Monoid P
l l₁✝ l₂✝ : List M
a✝ : M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l₁ l₂ : List M
a b : M
la lb : List M
hab : a ≤ b
ih : Forall₂ (fun x x_1 => x ≤ x_1) la lb
ih' : prod la ≤ prod lb
⊢ prod (a :: la) ≤ prod (b :: lb)
Theorem: isPrimitiveRoot_of_mem_primitiveRoots
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: simp [hk] at h
state_before: M : Type ?u.1452815
N : Type ?u.1452818
G : Type ?u.1452821
R : Type u_1
S : Type ?u.1452827
F : Type ?u.1452830
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
h : ζ ∈ primitiveRoots k R
hk : k = 0
⊢ IsPrimitiveRoot ζ k
Theorem: FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
File: Mathlib/Topology/Sequences.lean

tactic: refine ⟨fun s x hcx => ?_⟩
state_before: X : Type u_1
Y : Type ?u.4450
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
h :
  ∀ (f : X → Prop) (a : X), (∀ (u : ℕ → X), Tendsto u atTop (𝓝 a) → Tendsto (f ∘ u) atTop (𝓝 (f a))) → ContinuousAt f a
⊢ FrechetUrysohnSpace X

tactic: by_cases hx : x ∈ s
state_before: X : Type u_1
Y : Type ?u.4450
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
h :
  ∀ (f : X → Prop) (a : X), (∀ (u : ℕ → X), Tendsto u atTop (𝓝 a) → Tendsto (f ∘ u) atTop (𝓝 (f a))) → ContinuousAt f a
s : Set X
x : X
hcx : x ∈ closure s
⊢ x ∈ seqClosure s

tactic: exact subset_seqClosure hx
state_before: case pos
X : Type u_1
Y : Type ?u.4450
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
h :
  ∀ (f : X → Prop) (a : X), (∀ (u : ℕ → X), Tendsto u atTop (𝓝 a) → Tendsto (f ∘ u) atTop (𝓝 (f a))) → ContinuousAt f a
s : Set X
x : X
hcx : x ∈ closure s
hx : x ∈ s
⊢ x ∈ seqClosure s

tactic: obtain ⟨u, hux, hus⟩ : ∃ u, Tendsto u atTop (𝓝 x) ∧ ∃ᶠ x in atTop, u x ∈ s
state_before: case neg
X : Type u_1
Y : Type ?u.4450
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
h :
  ∀ (f : X → Prop) (a : X), (∀ (u : ℕ → X), Tendsto u atTop (𝓝 a) → Tendsto (f ∘ u) atTop (𝓝 (f a))) → ContinuousAt f a
s : Set X
x : X
hcx : x ∈ closure s
hx : ¬x ∈ s
⊢ x ∈ seqClosure s

tactic: rcases extraction_of_frequently_atTop hus with ⟨φ, φ_mono, hφ⟩
state_before: case neg.intro.intro
X : Type u_1
Y : Type ?u.4450
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
h :
  ∀ (f : X → Prop) (a : X), (∀ (u : ℕ → X), Tendsto u atTop (𝓝 a) → Tendsto (f ∘ u) atTop (𝓝 (f a))) → ContinuousAt f a
s : Set X
x : X
hcx : x ∈ closure s
hx : ¬x ∈ s
u : ℕ → X
hux : Tendsto u atTop (𝓝 x)
hus : ∃ᶠ (x : ℕ) in atTop, u x ∈ s
⊢ x ∈ seqClosure s

tactic: exact ⟨u ∘ φ, hφ, hux.comp φ_mono.tendsto_atTop⟩
state_before: case neg.intro.intro.intro.intro
X : Type u_1
Y : Type ?u.4450
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
h :
  ∀ (f : X → Prop) (a : X), (∀ (u : ℕ → X), Tendsto u atTop (𝓝 a) → Tendsto (f ∘ u) atTop (𝓝 (f a))) → ContinuousAt f a
s : Set X
x : X
hcx : x ∈ closure s
hx : ¬x ∈ s
u : ℕ → X
hux : Tendsto u atTop (𝓝 x)
hus : ∃ᶠ (x : ℕ) in atTop, u x ∈ s
φ : ℕ → ℕ
φ_mono : StrictMono φ
hφ : ∀ (n : ℕ), u (φ n) ∈ s
⊢ x ∈ seqClosure s
Theorem: HasFDerivWithinAt.union
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: simp only [HasFDerivWithinAt, nhdsWithin_union]
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.239899
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.239994
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
hs : HasFDerivWithinAt f f' s x
ht : HasFDerivWithinAt f f' t x
⊢ HasFDerivWithinAt f f' (s ∪ t) x

tactic: exact hs.sup ht
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.239899
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.239994
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
hs : HasFDerivWithinAt f f' s x
ht : HasFDerivWithinAt f f' t x
⊢ HasFDerivAtFilter f f' x (𝓝[s] x ⊔ 𝓝[t] x)
Theorem: norm_mul_le'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa [dist_eq_norm_div] using dist_triangle a 1 b⁻¹
state_before: 𝓕 : Type ?u.63293
𝕜 : Type ?u.63296
α : Type ?u.63299
ι : Type ?u.63302
κ : Type ?u.63305
E : Type u_1
F : Type ?u.63311
G : Type ?u.63314
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ ‖a * b‖ ≤ ‖a‖ + ‖b‖
Theorem: Complex.ofReal_tanh_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← tanh_conj, conj_ofReal]
state_before: x✝ y : ℂ
x : ℝ
⊢ ↑(starRingEnd ℂ) (tanh ↑x) = tanh ↑x