tasksource/leandojo huggingface dataset:
Theorem: toDual_compares_toDual
File: Mathlib/Order/Compare.lean

tactic: cases o
state_before: α : Type u_1
β : Type ?u.10829
inst✝ : LT α
a b : α
o : Ordering
⊢ Compares o (↑toDual a) (↑toDual b) ↔ Compares o b a

tactic: exacts [Iff.rfl, eq_comm, Iff.rfl]
state_before: case lt
α : Type u_1
β : Type ?u.10829
inst✝ : LT α
a b : α
⊢ Compares lt (↑toDual a) (↑toDual b) ↔ Compares lt b a

case eq
α : Type u_1
β : Type ?u.10829
inst✝ : LT α
a b : α
⊢ Compares eq (↑toDual a) (↑toDual b) ↔ Compares eq b a

case gt
α : Type u_1
β : Type ?u.10829
inst✝ : LT α
a b : α
⊢ Compares gt (↑toDual a) (↑toDual b) ↔ Compares gt b a
Theorem: ENNReal.div_eq_zero_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [div_eq_mul_inv]
state_before: α : Type ?u.320013
β : Type ?u.320016
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a / b = 0 ↔ a = 0 ∨ b = ⊤
Theorem: LinearPMap.closure_def
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

tactic: simp [closure, hf]
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : IsClosable f
⊢ closure f = Exists.choose hf
Theorem: Set.subset_singleton_iff_eq
File: Mathlib/Data/Set/Basic.lean

tactic: obtain rfl | hs := s.eq_empty_or_nonempty
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x : α
⊢ s ⊆ {x} ↔ s = ∅ ∨ s = {x}

tactic: exact ⟨fun _ => Or.inl rfl, fun _ => empty_subset _⟩
state_before: case inl
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
⊢ ∅ ⊆ {x} ↔ ∅ = ∅ ∨ ∅ = {x}

tactic: simp [eq_singleton_iff_nonempty_unique_mem, hs, hs.ne_empty]
state_before: case inr
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x : α
hs : Set.Nonempty s
⊢ s ⊆ {x} ↔ s = ∅ ∨ s = {x}
Theorem: Filter.tendsto_mul_const_atTop_iff_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [mul_comm _ r, tendsto_const_mul_atTop_iff_pos h]
state_before: ι : Type ?u.218886
ι' : Type ?u.218889
α : Type u_2
β : Type u_1
γ : Type ?u.218898
inst✝¹ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
inst✝ : NeBot l
h : Tendsto f l atTop
⊢ Tendsto (fun x => f x * r) l atTop ↔ 0 < r
Theorem: pow_four_add_four_mul_pow_four
File: Mathlib/Algebra/GroupPower/Identities.lean

tactic: ring
state_before: R : Type u_1
inst✝ : CommRing R
a b x₁ x₂ x₃ x₄ x₅ x₆ x₇ x₈ y₁ y₂ y₃ y₄ y₅ y₆ y₇ y₈ n : R
⊢ a ^ 4 + 4 * b ^ 4 = ((a - b) ^ 2 + b ^ 2) * ((a + b) ^ 2 + b ^ 2)
Theorem: SimpleGraph.Walk.dart_snd_mem_support_of_mem_darts
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simpa using p.reverse.dart_fst_mem_support_of_mem_darts (by simp [h] : d.symm ∈ p.reverse.darts)
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
d : Dart G
h : d ∈ darts p
⊢ d.snd ∈ support p

tactic: simp [h]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
d : Dart G
h : d ∈ darts p
⊢ Dart.symm d ∈ darts (reverse p)
Theorem: ContinuousLinearEquiv.comp_hasFDerivAt_iff'
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: simp_rw [← hasFDerivWithinAt_univ, iso.comp_hasFDerivWithinAt_iff']
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_2
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.131121
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
iso : E ≃L[𝕜] F
f : G → E
x : G
f' : G →L[𝕜] F
⊢ HasFDerivAt (↑iso ∘ f) f' x ↔ HasFDerivAt f (comp (↑(ContinuousLinearEquiv.symm iso)) f') x
Theorem: List.map_append
File: Std/Data/List/Init/Lemmas.lean

tactic: intro l₁ <;> induction l₁ <;> intros <;> simp_all
state_before: α : Type u_1
β : Type u_2
f : α → β
⊢ ∀ (l₁ l₂ : List α), map f (l₁ ++ l₂) = map f l₁ ++ map f l₂
Theorem: ContDiffOn.sub
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1852360
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s✝ s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
s : Set E
f g : E → F
hf : ContDiffOn 𝕜 n f s
hg : ContDiffOn 𝕜 n g s
⊢ ContDiffOn 𝕜 n (fun x => f x - g x) s
Theorem: Int.ceil_eq_add_one_sub_fract
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [(or_iff_right ha).mp (fract_eq_zero_or_add_one_sub_ceil a)]
state_before: F : Type ?u.234022
α : Type u_1
β : Type ?u.234028
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
ha : fract a ≠ 0
⊢ ↑⌈a⌉ = a + 1 - fract a

tactic: abel
state_before: F : Type ?u.234022
α : Type u_1
β : Type ?u.234028
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
ha : fract a ≠ 0
⊢ ↑⌈a⌉ = a + 1 - (a + 1 - ↑⌈a⌉)
Theorem: le_iff_atom_le_imp
File: Mathlib/Order/Atoms.lean

tactic: rw [← sSup_atoms_le_eq a, ← sSup_atoms_le_eq b]
state_before: α : Type u_1
β : Type ?u.20383
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
a b : α
h : ∀ (c : α), IsAtom c → c ≤ a → c ≤ b
⊢ a ≤ b

tactic: exact sSup_le_sSup fun c hc => ⟨hc.1, h c hc.1 hc.2⟩
state_before: α : Type u_1
β : Type ?u.20383
inst✝¹ : CompleteLattice α
inst✝ : IsAtomistic α
a b : α
h : ∀ (c : α), IsAtom c → c ≤ a → c ≤ b
⊢ sSup {a_1 | IsAtom a_1 ∧ a_1 ≤ a} ≤ sSup {a | IsAtom a ∧ a ≤ b}
Theorem: List.prod_mul_prod_eq_prod_zipWith_mul_prod_drop
File: Mathlib/Data/List/Zip.lean

tactic: simp [Nat.zero_le]
state_before: α : Type u
β : Type ?u.284124
γ : Type ?u.284127
δ : Type ?u.284130
ε : Type ?u.284133
inst✝ : CommMonoid α
ys : List α
⊢ prod [] * prod ys =
    prod (zipWith (fun x x_1 => x * x_1) [] ys) * prod (drop (length ys) []) * prod (drop (length []) ys)

tactic: simp [Nat.zero_le]
state_before: α : Type u
β : Type ?u.284124
γ : Type ?u.284127
δ : Type ?u.284130
ε : Type ?u.284133
inst✝ : CommMonoid α
xs : List α
⊢ prod xs * prod [] =
    prod (zipWith (fun x x_1 => x * x_1) xs []) * prod (drop (length []) xs) * prod (drop (length xs) [])

tactic: simp only [drop, length, zipWith_cons_cons, prod_cons]
state_before: α : Type u
β : Type ?u.284124
γ : Type ?u.284127
δ : Type ?u.284130
ε : Type ?u.284133
inst✝ : CommMonoid α
x : α
xs : List α
y : α
ys : List α
⊢ prod (x :: xs) * prod (y :: ys) =
    prod (zipWith (fun x x_1 => x * x_1) (x :: xs) (y :: ys)) * prod (drop (length (y :: ys)) (x :: xs)) *
      prod (drop (length (x :: xs)) (y :: ys))

tactic: conv =>
  lhs; rw [mul_assoc]; right; rw [mul_comm, mul_assoc]; right
  rw [mul_comm, prod_mul_prod_eq_prod_zipWith_mul_prod_drop xs ys]
state_before: α : Type u
β : Type ?u.284124
γ : Type ?u.284127
δ : Type ?u.284130
ε : Type ?u.284133
inst✝ : CommMonoid α
x : α
xs : List α
y : α
ys : List α
⊢ x * prod xs * (y * prod ys) =
    x * y * prod (zipWith (fun x x_1 => x * x_1) xs ys) * prod (drop (Nat.add (length ys) 0) xs) *
      prod (drop (Nat.add (length xs) 0) ys)

tactic: simp only [add_eq, add_zero]
state_before: α : Type u
β : Type ?u.284124
γ : Type ?u.284127
δ : Type ?u.284130
ε : Type ?u.284133
inst✝ : CommMonoid α
x : α
xs : List α
y : α
ys : List α
⊢ x * (y * (prod (zipWith (fun x x_1 => x * x_1) xs ys) * prod (drop (length ys) xs) * prod (drop (length xs) ys))) =
    x * y * prod (zipWith (fun x x_1 => x * x_1) xs ys) * prod (drop (Nat.add (length ys) 0) xs) *
      prod (drop (Nat.add (length xs) 0) ys)

tactic: ac_rfl
state_before: α : Type u
β : Type ?u.284124
γ : Type ?u.284127
δ : Type ?u.284130
ε : Type ?u.284133
inst✝ : CommMonoid α
x : α
xs : List α
y : α
ys : List α
⊢ x * (y * (prod (zipWith (fun x x_1 => x * x_1) xs ys) * prod (drop (length ys) xs) * prod (drop (length xs) ys))) =
    x * y * prod (zipWith (fun x x_1 => x * x_1) xs ys) * prod (drop (length ys) xs) * prod (drop (length xs) ys)
Theorem: union_mem_nhdsSet
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [nhdsSet_union]
state_before: α : Type u_1
β : Type ?u.13910
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t s₁ s₂ t₁ t₂ : Set α
x : α
h₁ : s₁ ∈ 𝓝ˢ t₁
h₂ : s₂ ∈ 𝓝ˢ t₂
⊢ s₁ ∪ s₂ ∈ 𝓝ˢ (t₁ ∪ t₂)

tactic: exact union_mem_sup h₁ h₂
state_before: α : Type u_1
β : Type ?u.13910
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t s₁ s₂ t₁ t₂ : Set α
x : α
h₁ : s₁ ∈ 𝓝ˢ t₁
h₂ : s₂ ∈ 𝓝ˢ t₂
⊢ s₁ ∪ s₂ ∈ 𝓝ˢ t₁ ⊔ 𝓝ˢ t₂
Theorem: Int.neg_add_lt_of_lt_add
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_left h (-b)
state_before: a b c : Int
h : a < b + c
⊢ -b + a < c

tactic: rwa [Int.neg_add_cancel_left] at h
state_before: a b c : Int
h✝ : a < b + c
h : -b + a < -b + (b + c)
⊢ -b + a < c
Theorem: map_compl
File: Mathlib/Order/Heyting/Hom.lean

tactic: rw [← himp_bot, ← himp_bot, map_himp, map_bot]
state_before: F : Type u_3
α : Type u_2
β : Type u_1
γ : Type ?u.30200
δ : Type ?u.30203
inst✝² : HeytingAlgebra α
inst✝¹ : HeytingAlgebra β
inst✝ : HeytingHomClass F α β
f : F
a : α
⊢ ↑f (aᶜ) = ↑f aᶜ
Theorem: MeasureTheory.Content.le_outerMeasure_compacts
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: rw [Content.outerMeasure, inducedOuterMeasure_eq_iInf]
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
K : Compacts G
⊢ (fun s => ↑(toFun μ s)) K ≤ ↑(Content.outerMeasure μ) ↑K

tactic: exact le_iInf fun U => le_iInf fun hU => le_iInf <| μ.le_innerContent K ⟨U, hU⟩
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
K : Compacts G
⊢ (fun s => ↑(toFun μ s)) K ≤
    ⨅ (t : Set G) (ht : IsOpen t) (_ : ↑K ⊆ t), innerContent μ { carrier := t, is_open' := ht }

tactic: exact fun U hU => isOpen_iUnion hU
state_before: case PU
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
K : Compacts G
⊢ ∀ ⦃f : ℕ → Set G⦄, (∀ (i : ℕ), IsOpen (f i)) → IsOpen (⋃ (i : ℕ), f i)

tactic: exact μ.innerContent_iUnion_nat
state_before: case msU
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
K : Compacts G
⊢ ∀ ⦃f : ℕ → Set G⦄ (hm : ∀ (i : ℕ), IsOpen (f i)),
    innerContent μ { carrier := ⋃ (i : ℕ), f i, is_open' := (_ : IsOpen (⋃ (i : ℕ), (fun i => f i) i)) } ≤
      ∑' (i : ℕ), innerContent μ { carrier := f i, is_open' := (_ : IsOpen (f i)) }

tactic: exact μ.innerContent_mono
state_before: case m_mono
G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
K : Compacts G
⊢ ∀ ⦃s₁ s₂ : Set G⦄ (hs₁ : IsOpen s₁) (hs₂ : IsOpen s₂),
    s₁ ⊆ s₂ → innerContent μ { carrier := s₁, is_open' := hs₁ } ≤ innerContent μ { carrier := s₂, is_open' := hs₂ }
Theorem: Fintype.card_le_card_of_rightTotal_unique
File: Mathlib/Combinatorics/DoubleCounting.lean

tactic: simpa using h₁
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
r : α → β → Prop
h₁ : RightTotal r
h₂ : RightUnique r
⊢ ∀ (b : β), b ∈ univ → ∃ a, a ∈ univ ∧ r a b
Theorem: MvPowerSeries.smul_eq_C_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
f : MvPowerSeries σ R
a : R
⊢ a • f = ↑(C σ R) a * f

tactic: simp
state_before: case h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
f : MvPowerSeries σ R
a : R
n✝ : σ →₀ ℕ
⊢ ↑(coeff R n✝) (a • f) = ↑(coeff R n✝) (↑(C σ R) a * f)
Theorem: Nat.floor_eq_iff'
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← le_floor_iff' hn, ← Nat.cast_one, ← Nat.cast_add, ← floor_lt' (Nat.add_one_ne_zero n),
  Nat.lt_add_one_iff, le_antisymm_iff, and_comm]
state_before: F : Type ?u.38289
α : Type u_1
β : Type ?u.38295
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
hn : n ≠ 0
⊢ ⌊a⌋₊ = n ↔ ↑n ≤ a ∧ a < ↑n + 1
Theorem: RatFunc.algebraMap_apply
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [← mk_eq_div]
state_before: K : Type u
inst✝³ : CommRing K
inst✝² : IsDomain K
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R K[X]
x : R
⊢ ↑(algebraMap R (RatFunc K)) x =
    ↑(algebraMap ((fun x => K[X]) x) (RatFunc K)) (↑(algebraMap R K[X]) x) / ↑(algebraMap K[X] (RatFunc K)) 1

tactic: rfl
state_before: K : Type u
inst✝³ : CommRing K
inst✝² : IsDomain K
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R K[X]
x : R
⊢ ↑(algebraMap R (RatFunc K)) x = RatFunc.mk (↑(algebraMap R K[X]) x) 1
Theorem: ZFSet.hereditarily_iff
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rw [← Hereditarily]
state_before: p : ZFSet → Prop
x y : ZFSet
⊢ Hereditarily p x ↔ p x ∧ ∀ (y : ZFSet), y ∈ x → Hereditarily p y
Theorem: WithTop.sub_top
File: Mathlib/Algebra/Order/Sub/WithTop.lean

tactic: cases a <;> rfl
state_before: α : Type u_1
β : Type ?u.1766
inst✝¹ : Sub α
inst✝ : Zero α
a : WithTop α
⊢ a - ⊤ = 0
Theorem: Localization.mk_eq_monoidOf_mk'_apply
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [← mk_one_eq_monoidOf_mk, ← mk_one_eq_monoidOf_mk, mk_mul x y y 1, mul_comm y 1]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type ?u.3263012
inst✝¹ : CommMonoid N
P : Type ?u.3263018
inst✝ : CommMonoid P
x : M
y : { x // x ∈ S }
⊢ mk x y * ↑(Submonoid.LocalizationMap.toMap (monoidOf S)) ↑y = ↑(Submonoid.LocalizationMap.toMap (monoidOf S)) x

tactic: conv => rhs ; rw [← mul_one 1] ; rw [← mul_one x]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type ?u.3263012
inst✝¹ : CommMonoid N
P : Type ?u.3263018
inst✝ : CommMonoid P
x : M
y : { x // x ∈ S }
⊢ mk (x * ↑y) (1 * y) = mk x 1

tactic: exact mk_eq_mk_iff.2 (Con.symm _ <| (Localization.r S).mul (Con.refl _ (x, 1)) <| one_rel _)
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type ?u.3263012
inst✝¹ : CommMonoid N
P : Type ?u.3263018
inst✝ : CommMonoid P
x : M
y : { x // x ∈ S }
⊢ mk (x * ↑y) (1 * y) = mk (x * 1) (1 * 1)
Theorem: ContinuousMap.tendsto_of_tendstoLocallyUniformly
File: Mathlib/Topology/UniformSpace/CompactConvergence.lean

tactic: rw [tendsto_iff_forall_compact_tendstoUniformlyOn]
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => ↑(F i) a) (↑f) p
⊢ Tendsto F p (𝓝 f)

tactic: intro K hK
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => ↑(F i) a) (↑f) p
⊢ ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => ↑(F i) a) (↑f) p K

tactic: rw [← tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hK]
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => ↑(F i) a) (↑f) p
K : Set α
hK : IsCompact K
⊢ TendstoUniformlyOn (fun i a => ↑(F i) a) (↑f) p K

tactic: exact h.tendstoLocallyUniformlyOn
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
h : TendstoLocallyUniformly (fun i a => ↑(F i) a) (↑f) p
K : Set α
hK : IsCompact K
⊢ TendstoLocallyUniformlyOn (fun i a => ↑(F i) a) (↑f) p K
Theorem: Submonoid.mul_subset
File: Mathlib/GroupTheory/Submonoid/Pointwise.lean

tactic: rintro _ ⟨p, q, hp, hq, rfl⟩
state_before: α : Type ?u.68
G : Type ?u.71
M : Type u_1
R : Type ?u.77
A : Type ?u.80
inst✝¹ : Monoid M
inst✝ : AddMonoid A
s t u : Set M
S : Submonoid M
hs : s ⊆ ↑S
ht : t ⊆ ↑S
⊢ s * t ⊆ ↑S

tactic: exact Submonoid.mul_mem _ (hs hp) (ht hq)
state_before: case intro.intro.intro.intro
α : Type ?u.68
G : Type ?u.71
M : Type u_1
R : Type ?u.77
A : Type ?u.80
inst✝¹ : Monoid M
inst✝ : AddMonoid A
s t u : Set M
S : Submonoid M
hs : s ⊆ ↑S
ht : t ⊆ ↑S
p q : M
hp : p ∈ s
hq : q ∈ t
⊢ (fun x x_1 => x * x_1) p q ∈ ↑S
Theorem: one_div_lt_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simpa using inv_lt_of_neg ha hb
state_before: ι : Type ?u.157245
α : Type u_1
β : Type ?u.157251
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : a < 0
hb : b < 0
⊢ 1 / a < b ↔ 1 / b < a
Theorem: Option.pbind_eq_some
File: Mathlib/Data/Option/Basic.lean

tactic: rcases x with (_|x)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.11629
δ : Type ?u.11632
p : α → Prop
f✝ : (a : α) → p a → β
x : Option α
f : (a : α) → a ∈ x → Option β
y : β
⊢ pbind x f = some y ↔ ∃ z H, f z H = some y

tactic: simp only [pbind, false_iff, not_exists]
state_before: case none
α : Type u_1
β : Type u_2
γ : Type ?u.11629
δ : Type ?u.11632
p : α → Prop
f✝ : (a : α) → p a → β
y : β
f : (a : α) → a ∈ none → Option β
⊢ pbind none f = some y ↔ ∃ z H, f z H = some y

tactic: intro z h
state_before: case none
α : Type u_1
β : Type u_2
γ : Type ?u.11629
δ : Type ?u.11632
p : α → Prop
f✝ : (a : α) → p a → β
y : β
f : (a : α) → a ∈ none → Option β
⊢ ∀ (x : α) (x_1 : x ∈ none), ¬f x x_1 = some y

tactic: simp at h
state_before: case none
α : Type u_1
β : Type u_2
γ : Type ?u.11629
δ : Type ?u.11632
p : α → Prop
f✝ : (a : α) → p a → β
y : β
f : (a : α) → a ∈ none → Option β
z : α
h : z ∈ none
⊢ ¬f z h = some y

tactic: simp only [pbind]
state_before: case some
α : Type u_1
β : Type u_2
γ : Type ?u.11629
δ : Type ?u.11632
p : α → Prop
f✝ : (a : α) → p a → β
y : β
x : α
f : (a : α) → a ∈ some x → Option β
⊢ pbind (some x) f = some y ↔ ∃ z H, f z H = some y

tactic: refine ⟨λ h => ⟨x, rfl, h⟩, ?_⟩
state_before: case some
α : Type u_1
β : Type u_2
γ : Type ?u.11629
δ : Type ?u.11632
p : α → Prop
f✝ : (a : α) → p a → β
y : β
x : α
f : (a : α) → a ∈ some x → Option β
⊢ f x (_ : some x = some x) = some y ↔ ∃ z H, f z H = some y

tactic: rintro ⟨z, H, hz⟩
state_before: case some
α : Type u_1
β : Type u_2
γ : Type ?u.11629
δ : Type ?u.11632
p : α → Prop
f✝ : (a : α) → p a → β
y : β
x : α
f : (a : α) → a ∈ some x → Option β
⊢ (∃ z H, f z H = some y) → f x (_ : some x = some x) = some y

tactic: simp only [mem_def, Option.some_inj] at H
state_before: case some.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.11629
δ : Type ?u.11632
p : α → Prop
f✝ : (a : α) → p a → β
y : β
x : α
f : (a : α) → a ∈ some x → Option β
z : α
H : z ∈ some x
hz : f z H = some y
⊢ f x (_ : some x = some x) = some y

tactic: simpa [H] using hz
state_before: case some.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.11629
δ : Type ?u.11632
p : α → Prop
f✝ : (a : α) → p a → β
y : β
x : α
f : (a : α) → a ∈ some x → Option β
z : α
H✝ : z ∈ some x
hz : f z H✝ = some y
H : x = z
⊢ f x (_ : some x = some x) = some y
Theorem: Finset.eq_of_mem_uIcc_of_mem_uIcc'
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simp_rw [mem_uIcc]
state_before: ι : Type ?u.191847
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ∈ [[a, c]] → c ∈ [[a, b]] → b = c

tactic: exact Set.eq_of_mem_uIcc_of_mem_uIcc'
state_before: ι : Type ?u.191847
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ⊓ c ≤ b ∧ b ≤ a ⊔ c → a ⊓ b ≤ c ∧ c ≤ a ⊔ b → b = c
Theorem: set_smul_mem_nhds_smul
File: Mathlib/Topology/Algebra/ConstMulAction.lean

tactic: rw [mem_nhds_iff] at hs ⊢
state_before: M : Type ?u.159604
α : Type u_1
β : Type ?u.159610
Γ : Type ?u.159613
inst✝⁶ : Group Γ
T : Type ?u.159619
inst✝⁵ : TopologicalSpace T
inst✝⁴ : MulAction Γ T
G₀ : Type u_2
inst✝³ : GroupWithZero G₀
inst✝² : MulAction G₀ α
inst✝¹ : TopologicalSpace α
inst✝ : ContinuousConstSMul G₀ α
c : G₀
s : Set α
x : α
hs : s ∈ 𝓝 x
hc : c ≠ 0
⊢ c • s ∈ 𝓝 (c • x)

tactic: obtain ⟨U, hs', hU, hU'⟩ := hs
state_before: M : Type ?u.159604
α : Type u_1
β : Type ?u.159610
Γ : Type ?u.159613
inst✝⁶ : Group Γ
T : Type ?u.159619
inst✝⁵ : TopologicalSpace T
inst✝⁴ : MulAction Γ T
G₀ : Type u_2
inst✝³ : GroupWithZero G₀
inst✝² : MulAction G₀ α
inst✝¹ : TopologicalSpace α
inst✝ : ContinuousConstSMul G₀ α
c : G₀
s : Set α
x : α
hs : ∃ t, t ⊆ s ∧ IsOpen t ∧ x ∈ t
hc : c ≠ 0
⊢ ∃ t, t ⊆ c • s ∧ IsOpen t ∧ c • x ∈ t

tactic: exact ⟨c • U, Set.smul_set_mono hs', hU.smul₀ hc, Set.smul_mem_smul_set hU'⟩
state_before: case intro.intro.intro
M : Type ?u.159604
α : Type u_1
β : Type ?u.159610
Γ : Type ?u.159613
inst✝⁶ : Group Γ
T : Type ?u.159619
inst✝⁵ : TopologicalSpace T
inst✝⁴ : MulAction Γ T
G₀ : Type u_2
inst✝³ : GroupWithZero G₀
inst✝² : MulAction G₀ α
inst✝¹ : TopologicalSpace α
inst✝ : ContinuousConstSMul G₀ α
c : G₀
s : Set α
x : α
hc : c ≠ 0
U : Set α
hs' : U ⊆ s
hU : IsOpen U
hU' : x ∈ U
⊢ ∃ t, t ⊆ c • s ∧ IsOpen t ∧ c • x ∈ t
Theorem: dist_add_dist_eq_iff
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: simp only [mem_segment_iff_sameRay, sameRay_iff_norm_add, dist_eq_norm', sub_add_sub_cancel',
  eq_comm]
state_before: 𝕜 : Type ?u.76649
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
⊢ dist x y + dist y z = dist x z ↔ y ∈ [x-[ℝ]z]
Theorem: span_gramSchmidtNormed_range
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

tactic: simpa only [image_univ.symm] using span_gramSchmidtNormed f univ
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
⊢ span 𝕜 (Set.range (gramSchmidtNormed 𝕜 f)) = span 𝕜 (Set.range (gramSchmidt 𝕜 f))
Theorem: List.foldl_assoc_comm_cons
File: Mathlib/Data/List/Basic.lean

tactic: rw [foldl_cons, hc.comm, foldl_assoc]
state_before: ι : Type ?u.275924
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
op : α → α → α
ha : IsAssociative α op
hc : IsCommutative α op
l : List α
a₁ a₂ : α
⊢ ((a₁ :: l) <*> a₂) = op a₁ (l <*> a₂)
Theorem: MeasureTheory.set_lintegral_congr
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [Measure.restrict_congr_set h]
state_before: α : Type u_1
β : Type ?u.294840
γ : Type ?u.294843
δ : Type ?u.294846
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s t : Set α
h : s =ᵐ[μ] t
⊢ (∫⁻ (x : α) in s, f x ∂μ) = ∫⁻ (x : α) in t, f x ∂μ
Theorem: Matrix.zpow_neg_mul_zpow_self
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [zpow_neg h, mul_eq_mul, nonsing_inv_mul _ (h.det_zpow _)]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
n : ℤ
A : M
h : IsUnit (det A)
⊢ A ^ (-n) * A ^ n = 1
Theorem: List.zipWith_map
File: Mathlib/Data/List/Zip.lean

tactic: induction as generalizing bs
state_before: α : Type u
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type ?u.23411
μ : Type u_1
f : γ → δ → μ
g : α → γ
h : β → δ
as : List α
bs : List β
⊢ zipWith f (map g as) (map h bs) = zipWith (fun a b => f (g a) (h b)) as bs

tactic: simp
state_before: case nil
α : Type u
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type ?u.23411
μ : Type u_1
f : γ → δ → μ
g : α → γ
h : β → δ
bs : List β
⊢ zipWith f (map g []) (map h bs) = zipWith (fun a b => f (g a) (h b)) [] bs

tactic: cases bs <;> simp [*]
state_before: case cons
α : Type u
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type ?u.23411
μ : Type u_1
f : γ → δ → μ
g : α → γ
h : β → δ
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (bs : List β), zipWith f (map g tail✝) (map h bs) = zipWith (fun a b => f (g a) (h b)) tail✝ bs
bs : List β
⊢ zipWith f (map g (head✝ :: tail✝)) (map h bs) = zipWith (fun a b => f (g a) (h b)) (head✝ :: tail✝) bs