tasksource/leandojo huggingface dataset:
Theorem: Nat.sInf_add'
File: Mathlib/Data/Nat/Lattice.lean

tactic: suffices h₁ : n ≤ sInf {m | p (m - n)}
state_before: n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
⊢ sInf {m | p m} + n = sInf {m | p (m - n)}

tactic: convert sInf_add h₁
state_before: n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
h₁ : n ≤ sInf {m | p (m - n)}
⊢ sInf {m | p m} + n = sInf {m | p (m - n)}

case h₁
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
⊢ n ≤ sInf {m | p (m - n)}

tactic: obtain ⟨m, hm⟩ := nonempty_of_pos_sInf h
state_before: case h₁
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
⊢ n ≤ sInf {m | p (m - n)}

tactic: refine'
  le_csInf ⟨m + n, _⟩ fun b hb ↦
    le_of_not_lt fun hbn ↦
      ne_of_mem_of_not_mem _ (not_mem_of_lt_sInf h) (tsub_eq_zero_of_le hbn.le)
state_before: case h₁.intro
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ n ≤ sInf {m | p (m - n)}

tactic: simp_rw [add_tsub_cancel_right]
state_before: case h.e'_2.h.e'_5.h.e'_3.h.e'_2.h.h.e'_1
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
h₁ : n ≤ sInf {m | p (m - n)}
x✝ : ℕ
⊢ x✝ = x✝ + n - n

tactic: dsimp
state_before: case h₁.intro.refine'_1
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ m + n ∈ {m | p (m - n)}

tactic: rwa [add_tsub_cancel_right]
state_before: case h₁.intro.refine'_1
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
⊢ p (m + n - n)

tactic: exact hb
state_before: case h₁.intro.refine'_2
n : ℕ
p : ℕ → Prop
h : 0 < sInf {m | p m}
m : ℕ
hm : m ∈ {m | p m}
b : ℕ
hb : b ∈ {m | p (m - n)}
hbn : b < n
⊢ b - n ∈ {m | p m}
Theorem: contDiffAt_top
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp [← contDiffWithinAt_univ, contDiffWithinAt_top]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ContDiffAt 𝕜 ⊤ f x ↔ ∀ (n : ℕ), ContDiffAt 𝕜 (↑n) f x
Theorem: Submonoid.coe_mul_self_eq
File: Mathlib/GroupTheory/Submonoid/Pointwise.lean

tactic: ext x
state_before: α : Type ?u.3401
G : Type ?u.3404
M : Type u_1
R : Type ?u.3410
A : Type ?u.3413
inst✝¹ : Monoid M
inst✝ : AddMonoid A
s✝ t u : Set M
s : Submonoid M
⊢ ↑s * ↑s = ↑s

tactic: refine' ⟨_, fun h => ⟨x, 1, h, s.one_mem, mul_one x⟩⟩
state_before: case h
α : Type ?u.3401
G : Type ?u.3404
M : Type u_1
R : Type ?u.3410
A : Type ?u.3413
inst✝¹ : Monoid M
inst✝ : AddMonoid A
s✝ t u : Set M
s : Submonoid M
x : M
⊢ x ∈ ↑s * ↑s ↔ x ∈ ↑s

tactic: rintro ⟨a, b, ha, hb, rfl⟩
state_before: case h
α : Type ?u.3401
G : Type ?u.3404
M : Type u_1
R : Type ?u.3410
A : Type ?u.3413
inst✝¹ : Monoid M
inst✝ : AddMonoid A
s✝ t u : Set M
s : Submonoid M
x : M
⊢ x ∈ ↑s * ↑s → x ∈ ↑s

tactic: exact s.mul_mem ha hb
state_before: case h.intro.intro.intro.intro
α : Type ?u.3401
G : Type ?u.3404
M : Type u_1
R : Type ?u.3410
A : Type ?u.3413
inst✝¹ : Monoid M
inst✝ : AddMonoid A
s✝ t u : Set M
s : Submonoid M
a b : M
ha : a ∈ ↑s
hb : b ∈ ↑s
⊢ (fun x x_1 => x * x_1) a b ∈ ↑s
Theorem: pochhammer_zero_eval_zero
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: simp
state_before: S : Type u
inst✝ : Semiring S
⊢ eval 0 (pochhammer S 0) = 1
Theorem: inseparable_iff_closure_eq
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [inseparable_iff_specializes_and, specializes_iff_closure_subset, ← subset_antisymm_iff,
  eq_comm]
state_before: X : Type u_1
Y : Type ?u.31736
Z : Type ?u.31739
α : Type ?u.31742
ι : Type ?u.31745
π : ι → Type ?u.31750
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
⊢ (x ~ᵢ y) ↔ closure {x} = closure {y}
Theorem: Bool.beq_comm
File: Mathlib/Data/Bool/Basic.lean

tactic: simp [@eq_comm α]
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
⊢ (a == b) = true ↔ (b == a) = true
Theorem: sSup_eq_iSup'
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iSup, Subtype.range_coe]
state_before: α : Type u_1
β : Type ?u.60201
β₂ : Type ?u.60204
γ : Type ?u.60207
ι : Sort ?u.60210
ι' : Sort ?u.60213
κ : ι → Sort ?u.60218
κ' : ι' → Sort ?u.60223
inst✝ : SupSet α
f g : ι → α
s : Set α
⊢ sSup s = ⨆ (a : ↑s), ↑a
Theorem: Matrix.conjTranspose_one
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [conjTranspose]
state_before: l : Type ?u.960961
m : Type ?u.960964
n : Type u_1
o : Type ?u.960970
m' : o → Type ?u.960975
n' : o → Type ?u.960980
R : Type ?u.960983
S : Type ?u.960986
α : Type v
β : Type w
γ : Type ?u.960993
inst✝² : DecidableEq n
inst✝¹ : Semiring α
inst✝ : StarRing α
⊢ 1ᴴ = 1
Theorem: Submonoid.mrange_inr
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: simpa only [mrange_eq_map] using map_inr ⊤
state_before: M : Type u_1
N : Type u_2
P : Type ?u.150835
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.150856
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ mrange (inr M N) = prod ⊥ ⊤
Theorem: MvPolynomial.monomial_sum_index
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [← monomial_sum_one, C_mul', ← (monomial _).map_smul, smul_eq_mul, mul_one]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_2
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
α : Type u_1
s : Finset α
f : α → σ →₀ ℕ
a : R
⊢ ↑(monomial (∑ i in s, f i)) a = ↑C a * ∏ i in s, ↑(monomial (f i)) 1
Theorem: Subadditive.eventually_div_lt_of_div_lt
File: Mathlib/Analysis/Subadditive.lean

tactic: refine .atTop_of_arithmetic hn fun r _ => ?_
state_before: u : ℕ → ℝ
h : Subadditive u
L : ℝ
n : ℕ
hn : n ≠ 0
hL : u n / ↑n < L
⊢ ∀ᶠ (p : ℕ) in atTop, u p / ↑p < L

tactic: have A : Tendsto (fun x : ℝ => (u n + u r / x) / (n + r / x)) atTop (𝓝 ((u n + 0) / (n + 0))) :=
  (tendsto_const_nhds.add <| tendsto_const_nhds.div_atTop tendsto_id).div
    (tendsto_const_nhds.add <| tendsto_const_nhds.div_atTop tendsto_id) <| by simpa
state_before: u : ℕ → ℝ
h : Subadditive u
L : ℝ
n : ℕ
hn : n ≠ 0
hL : u n / ↑n < L
r : ℕ
x✝ : r < n
⊢ ∀ᶠ (a : ℕ) in atTop, u (n * a + r) / ↑(n * a + r) < L

tactic: refine ((B.comp tendsto_nat_cast_atTop_atTop).eventually (gt_mem_nhds hL)).mono fun k hk => ?_
state_before: u : ℕ → ℝ
h : Subadditive u
L : ℝ
n : ℕ
hn : n ≠ 0
hL : u n / ↑n < L
r : ℕ
x✝ : r < n
A : Tendsto (fun x => (u n + u r / x) / (↑n + ↑r / x)) atTop (𝓝 ((u n + 0) / (↑n + 0)))
B : Tendsto (fun x => (x * u n + u r) / (x * ↑n + ↑r)) atTop (𝓝 (u n / ↑n))
⊢ ∀ᶠ (a : ℕ) in atTop, u (n * a + r) / ↑(n * a + r) < L

tactic: rw [mul_comm]
state_before: u : ℕ → ℝ
h : Subadditive u
L : ℝ
n : ℕ
hn : n ≠ 0
hL : u n / ↑n < L
r : ℕ
x✝ : r < n
A : Tendsto (fun x => (u n + u r / x) / (↑n + ↑r / x)) atTop (𝓝 ((u n + 0) / (↑n + 0)))
B : Tendsto (fun x => (x * u n + u r) / (x * ↑n + ↑r)) atTop (𝓝 (u n / ↑n))
k : ℕ
hk : ((fun x => (x * u n + u r) / (x * ↑n + ↑r)) ∘ Nat.cast) k < L
⊢ u (n * k + r) / ↑(n * k + r) < L

tactic: refine lt_of_le_of_lt ?_ hk
state_before: u : ℕ → ℝ
h : Subadditive u
L : ℝ
n : ℕ
hn : n ≠ 0
hL : u n / ↑n < L
r : ℕ
x✝ : r < n
A : Tendsto (fun x => (u n + u r / x) / (↑n + ↑r / x)) atTop (𝓝 ((u n + 0) / (↑n + 0)))
B : Tendsto (fun x => (x * u n + u r) / (x * ↑n + ↑r)) atTop (𝓝 (u n / ↑n))
k : ℕ
hk : ((fun x => (x * u n + u r) / (x * ↑n + ↑r)) ∘ Nat.cast) k < L
⊢ u (k * n + r) / ↑(k * n + r) < L

tactic: exact div_le_div_of_le (Nat.cast_nonneg _) (h.apply_mul_add_le _ _ _)
state_before: u : ℕ → ℝ
h : Subadditive u
L : ℝ
n : ℕ
hn : n ≠ 0
hL : u n / ↑n < L
r : ℕ
x✝ : r < n
A : Tendsto (fun x => (u n + u r / x) / (↑n + ↑r / x)) atTop (𝓝 ((u n + 0) / (↑n + 0)))
B : Tendsto (fun x => (x * u n + u r) / (x * ↑n + ↑r)) atTop (𝓝 (u n / ↑n))
k : ℕ
hk : ((fun x => (x * u n + u r) / (x * ↑n + ↑r)) ∘ Nat.cast) k < L
⊢ u (k * n + r) / ↑(k * n + r) ≤ (↑k * u n + u r) / ↑(k * n + r)

tactic: simpa
state_before: u : ℕ → ℝ
h : Subadditive u
L : ℝ
n : ℕ
hn : n ≠ 0
hL : u n / ↑n < L
r : ℕ
x✝ : r < n
⊢ ↑n + 0 ≠ 0

tactic: rw [add_zero, add_zero] at A
state_before: u : ℕ → ℝ
h : Subadditive u
L : ℝ
n : ℕ
hn : n ≠ 0
hL : u n / ↑n < L
r : ℕ
x✝ : r < n
A : Tendsto (fun x => (u n + u r / x) / (↑n + ↑r / x)) atTop (𝓝 ((u n + 0) / (↑n + 0)))
⊢ Tendsto (fun x => (x * u n + u r) / (x * ↑n + ↑r)) atTop (𝓝 (u n / ↑n))

tactic: refine A.congr' <| (eventually_ne_atTop 0).mono fun x hx => ?_
state_before: u : ℕ → ℝ
h : Subadditive u
L : ℝ
n : ℕ
hn : n ≠ 0
hL : u n / ↑n < L
r : ℕ
x✝ : r < n
A : Tendsto (fun x => (u n + u r / x) / (↑n + ↑r / x)) atTop (𝓝 (u n / ↑n))
⊢ Tendsto (fun x => (x * u n + u r) / (x * ↑n + ↑r)) atTop (𝓝 (u n / ↑n))
Theorem: Multiset.Ico_disjoint_Ico
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [mem_Ico] at hab hbc
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c d : α
h : b ≤ c
x : α
hab : x ∈ Ico a b
hbc : x ∈ Ico c d
⊢ False

tactic: exact hab.2.not_le (h.trans hbc.1)
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c d : α
h : b ≤ c
x : α
hab : a ≤ x ∧ x < b
hbc : c ≤ x ∧ x < d
⊢ False
Theorem: TopCat.snd_iso_of_left_embedding_range_subset
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: let esto : (pullback f g : TopCat) ≃ₜ Y :=
  (Homeomorph.ofEmbedding _ (snd_embedding_of_left_embedding hf g)).trans
    { toFun := Subtype.val
      invFun := fun x =>
        ⟨x, by
          rw [pullback_snd_range]
          exact ⟨_, (H (Set.mem_range_self x)).choose_spec⟩⟩
      left_inv := fun ⟨_, _⟩ => rfl
      right_inv := fun x => rfl }
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ((forget TopCat).map f)
g : Y ⟶ S
H : Set.range ((forget TopCat).map g) ⊆ Set.range ((forget TopCat).map f)
⊢ IsIso pullback.snd

tactic: convert IsIso.of_iso (isoOfHomeo esto)
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ((forget TopCat).map f)
g : Y ⟶ S
H : Set.range ((forget TopCat).map g) ⊆ Set.range ((forget TopCat).map f)
esto : ↑(pullback f g) ≃ₜ ↑Y :=
  Homeomorph.trans
    (Homeomorph.ofEmbedding ((forget TopCat).map pullback.snd) (_ : Embedding ((forget TopCat).map pullback.snd)))
    (Homeomorph.mk
      { toFun := Subtype.val,
        invFun := fun x => { val := x, property := (_ : x ∈ Set.range ((forget TopCat).map pullback.snd)) },
        left_inv :=
          (_ :
            ∀ (x : ↑(Set.range ((forget TopCat).map pullback.snd))),
              (fun x => { val := x, property := (_ : x ∈ Set.range ((forget TopCat).map pullback.snd)) }) ↑x = x),
        right_inv :=
          (_ :
            ∀ (x : ↑Y),
              ↑((fun x => { val := x, property := (_ : x ∈ Set.range ((forget TopCat).map pullback.snd)) }) x) =
                ↑((fun x => { val := x, property := (_ : x ∈ Set.range ((forget TopCat).map pullback.snd)) }) x)) })
⊢ IsIso pullback.snd

tactic: rw [pullback_snd_range]
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ((forget TopCat).map f)
g : Y ⟶ S
H : Set.range ((forget TopCat).map g) ⊆ Set.range ((forget TopCat).map f)
x : ↑Y
⊢ x ∈ Set.range ((forget TopCat).map pullback.snd)

tactic: exact ⟨_, (H (Set.mem_range_self x)).choose_spec⟩
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
hf : Embedding ((forget TopCat).map f)
g : Y ⟶ S
H : Set.range ((forget TopCat).map g) ⊆ Set.range ((forget TopCat).map f)
x : ↑Y
⊢ x ∈ {y | ∃ x, (forget TopCat).map f x = (forget TopCat).map g y}
Theorem: StarConvex.preimage_add_right
File: Mathlib/Analysis/Convex/Star.lean

tactic: intro y hy a b ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.67540
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
s : Set E
hs : StarConvex 𝕜 (z + x) s
⊢ StarConvex 𝕜 x ((fun x => z + x) ⁻¹' s)

tactic: have h := hs hy ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.67540
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z : E
s : Set E
hs : StarConvex 𝕜 (z + x) s
y : E
hy : y ∈ (fun x => z + x) ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ (fun x => z + x) ⁻¹' s

tactic: rwa [smul_add, smul_add, add_add_add_comm, ← add_smul, hab, one_smul] at h
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.67540
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z : E
s : Set E
hs : StarConvex 𝕜 (z + x) s
y : E
hy : y ∈ (fun x => z + x) ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
h : a • (z + x) + b • (fun x => z + x) y ∈ s
⊢ a • x + b • y ∈ (fun x => z + x) ⁻¹' s
Theorem: Monoid.fg_of_surjective
File: Mathlib/GroupTheory/Finiteness.lean

tactic: classical
  obtain ⟨s, hs⟩ := Monoid.fg_def.mp ‹_›
  use s.image f
  rwa [Finset.coe_image, ← MonoidHom.map_mclosure, hs, ← MonoidHom.mrange_eq_map,
    MonoidHom.mrange_top_iff_surjective]
state_before: M : Type u_2
N : Type ?u.44817
inst✝³ : Monoid M
inst✝² : AddMonoid N
M' : Type u_1
inst✝¹ : Monoid M'
inst✝ : FG M
f : M →* M'
hf : Function.Surjective ↑f
⊢ FG M'

tactic: obtain ⟨s, hs⟩ := Monoid.fg_def.mp ‹_›
state_before: M : Type u_2
N : Type ?u.44817
inst✝³ : Monoid M
inst✝² : AddMonoid N
M' : Type u_1
inst✝¹ : Monoid M'
inst✝ : FG M
f : M →* M'
hf : Function.Surjective ↑f
⊢ FG M'

tactic: use s.image f
state_before: case intro
M : Type u_2
N : Type ?u.44817
inst✝³ : Monoid M
inst✝² : AddMonoid N
M' : Type u_1
inst✝¹ : Monoid M'
inst✝ : FG M
f : M →* M'
hf : Function.Surjective ↑f
s : Finset ?m.53983
hs : Submonoid.closure ↑s = ⊤
⊢ FG M'

tactic: rwa [Finset.coe_image, ← MonoidHom.map_mclosure, hs, ← MonoidHom.mrange_eq_map,
  MonoidHom.mrange_top_iff_surjective]
state_before: case intro
M : Type u_2
N : Type ?u.44817
inst✝³ : Monoid M
inst✝² : AddMonoid N
M' : Type u_1
inst✝¹ : Monoid M'
inst✝ : FG M
f : M →* M'
hf : Function.Surjective ↑f
s : Finset M
hs : Submonoid.closure ↑s = ⊤
⊢ Submonoid.closure ↑(Finset.image (↑f) s) = ⊤
Theorem: Order.Ioo_pred_right_eq_insert
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp_rw [← Ioi_inter_Iio, Ioi_pred_eq_insert, insert_inter_of_mem (mem_Iio.2 h)]
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : PredOrder α
a b : α
inst✝ : NoMinOrder α
h : a < b
⊢ Ioo (pred a) b = insert a (Ioo a b)
Theorem: Set.countable_iff_exists_subset_range
File: Mathlib/Data/Set/Countable.lean

tactic: inhabit α
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝ : Nonempty α
s : Set α
h : Set.Countable s
⊢ ∃ f, s ⊆ range f

tactic: exact ⟨enumerateCountable h default, subset_range_enumerate _ _⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝ : Nonempty α
s : Set α
h : Set.Countable s
inhabited_h : Inhabited α
⊢ ∃ f, s ⊆ range f
Theorem: nonzero_of_invertible
File: Mathlib/Algebra/Invertible.lean

tactic: simp [ha]
state_before: α : Type u
inst✝² : MulZeroOneClass α
a : α
inst✝¹ : Nontrivial α
inst✝ : Invertible a
ha : a = 0
⊢ 0 = ⅟a * a
Theorem: not_nontrivial_iff_subsingleton
File: Mathlib/Logic/Nontrivial.lean

tactic: simp only [nontrivial_iff, subsingleton_iff, not_exists, Ne.def, not_not]
state_before: α : Type u_1
β : Type ?u.2730
⊢ ¬Nontrivial α ↔ Subsingleton α
Theorem: Real.Angle.toReal_eq_neg_pi_div_two_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← toReal_inj, toReal_neg_pi_div_two]
state_before: θ : Angle
⊢ toReal θ = -π / 2 ↔ θ = ↑(-π / 2)
Theorem: MeasureTheory.union_ae_eq_univ_of_ae_eq_univ_right
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: convert ae_eq_set_union (ae_eq_refl s) h
state_before: α : Type u_1
β : Type ?u.115131
γ : Type ?u.115134
δ : Type ?u.115137
ι : Type ?u.115140
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : t =ᵐ[μ] univ
⊢ s ∪ t =ᵐ[μ] univ

tactic: rw [union_univ]
state_before: case h.e'_5
α : Type u_1
β : Type ?u.115131
γ : Type ?u.115134
δ : Type ?u.115137
ι : Type ?u.115140
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : t =ᵐ[μ] univ
⊢ univ = s ∪ univ
Theorem: List.lookupAll_eq_dlookup
File: Mathlib/Data/List/Sigma.lean

tactic: rw [← head?_lookupAll]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : NodupKeys l
⊢ lookupAll a l = Option.toList (dlookup a l)

tactic: have h1 := lookupAll_length_le_one a h
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : NodupKeys l
⊢ lookupAll a l = Option.toList (head? (lookupAll a l))

tactic: revert h1
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : NodupKeys l
h1 : length (lookupAll a l) ≤ 1
⊢ lookupAll a l = Option.toList (head? (lookupAll a l))

tactic: rcases lookupAll a l with (_ | ⟨b, _ | ⟨c, l⟩⟩) <;> intro h1 <;> try rfl
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : NodupKeys l
⊢ length (lookupAll a l) ≤ 1 → lookupAll a l = Option.toList (head? (lookupAll a l))

tactic: exact absurd h1 (by simp)
state_before: case cons.cons
α : Type u
β : α → Type v
l✝¹ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l✝ : List (Sigma β)
h : NodupKeys l✝
b c : β a
l : List (β a)
h1 : length (b :: c :: l) ≤ 1
⊢ b :: c :: l = Option.toList (head? (b :: c :: l))

tactic: rfl
state_before: case cons.cons
α : Type u
β : α → Type v
l✝¹ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l✝ : List (Sigma β)
h : NodupKeys l✝
b c : β a
l : List (β a)
h1 : length (b :: c :: l) ≤ 1
⊢ b :: c :: l = Option.toList (head? (b :: c :: l))

tactic: simp
state_before: α : Type u
β : α → Type v
l✝¹ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l✝ : List (Sigma β)
h : NodupKeys l✝
b c : β a
l : List (β a)
h1 : length (b :: c :: l) ≤ 1
⊢ ¬length (b :: c :: l) ≤ 1
Theorem: Equiv.Perm.disjoint_conj
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: simp only [mul_apply, eq_inv_iff_eq]
state_before: α : Type u_1
f g h✝ h : Perm α
x✝ : α
⊢ ↑(h * f * h⁻¹) x✝ = x✝ ∨ ↑(h * g * h⁻¹) x✝ = x✝ ↔ ↑f (↑h⁻¹ x✝) = ↑h⁻¹ x✝ ∨ ↑g (↑h⁻¹ x✝) = ↑h⁻¹ x✝
Theorem: Asymptotics.isBigOWith_zero_right_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigOWith_def, exists_prop, true_and_iff, norm_zero, MulZeroClass.mul_zero,
  norm_le_zero_iff, EventuallyEq, Pi.zero_apply]
state_before: α : Type u_1
β : Type ?u.266271
E : Type ?u.266274
F : Type ?u.266277
G : Type ?u.266280
E' : Type ?u.266283
F' : Type u_3
G' : Type ?u.266289
E'' : Type u_2
F'' : Type ?u.266295
G'' : Type ?u.266298
R : Type ?u.266301
R' : Type ?u.266304
𝕜 : Type ?u.266307
𝕜' : Type ?u.266310
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
⊢ (IsBigOWith c l f'' fun _x => 0) ↔ f'' =ᶠ[l] 0
Theorem: Finset.prod_lt_one
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: rw [prod_const_one]
state_before: ι : Type u_1
α : Type ?u.136627
β : Type ?u.136630
M : Type u_2
N : Type ?u.136636
G : Type ?u.136639
k : Type ?u.136642
R : Type ?u.136645
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
h : ∀ (i : ι), i ∈ s → f i < 1
hs : Finset.Nonempty s
⊢ ∏ i in s, 1 ≤ 1
Theorem: Matrix.toLin_toMatrix
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: rw [← Matrix.toLin_symm, LinearEquiv.apply_symm_apply]
state_before: R : Type u_1
inst✝⁷ : CommSemiring R
l : Type ?u.1419247
m : Type u_4
n : Type u_5
inst✝⁶ : Fintype n
inst✝⁵ : Fintype m
inst✝⁴ : DecidableEq n
M₁ : Type u_2
M₂ : Type u_3
inst✝³ : AddCommMonoid M₁
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M₁
inst✝ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
f : M₁ →ₗ[R] M₂
⊢ ↑(toLin v₁ v₂) (↑(toMatrix v₁ v₂) f) = f
Theorem: IsCompact.mul_closedBall
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [← smul_closedBall_one, mul_smul_comm, hs.mul_closedBall_one hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x✝ y : E
hs : IsCompact s
hδ : 0 ≤ δ
x : E
⊢ s * closedBall x δ = x • cthickening δ s
Theorem: List.zip_map'
File: Mathlib/Data/List/Zip.lean

tactic: simp only [map, zip_cons_cons, zip_map']
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.62030
ε : Type ?u.62033
f : α → β
g : α → γ
a : α
l : List α
⊢ zip (map f (a :: l)) (map g (a :: l)) = map (fun a => (f a, g a)) (a :: l)
Theorem: List.getLast?_concat
File: Std/Data/List/Lemmas.lean

tactic: simp [getLast?_eq_get?]
state_before: α : Type u_1
a : α
l : List α
⊢ getLast? (l ++ [a]) = some a
Theorem: NonUnitalSubsemiring.coe_closure_eq
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

tactic: simp [← Subsemigroup.nonUnitalSubsemiringClosure_toAddSubmonoid,
  Subsemigroup.nonUnitalSubsemiringClosure_eq_closure]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
s : Set R
⊢ ↑(closure s) = ↑(AddSubmonoid.closure ↑(Subsemigroup.closure s))
Theorem: Pmf.toOuterMeasure_pure_apply
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: refine' (toOuterMeasure_apply (pure a) s).trans _
state_before: α : Type u_1
β : Type ?u.4210
γ : Type ?u.4213
a a' : α
s : Set α
⊢ ↑(toOuterMeasure (pure a)) s = if a ∈ s then 1 else 0

tactic: split_ifs with ha
state_before: α : Type u_1
β : Type ?u.4210
γ : Type ?u.4213
a a' : α
s : Set α
⊢ (∑' (x : α), Set.indicator s (↑(pure a)) x) = if a ∈ s then 1 else 0

tactic: refine' (tsum_congr fun b => _).trans (tsum_ite_eq a 1)
state_before: case inl
α : Type u_1
β : Type ?u.4210
γ : Type ?u.4213
a a' : α
s : Set α
ha : a ∈ s
⊢ (∑' (x : α), Set.indicator s (↑(pure a)) x) = 1

tactic: exact ite_eq_left_iff.2 fun hb => symm (ite_eq_right_iff.2 fun h => (hb <| h.symm ▸ ha).elim)
state_before: case inl
α : Type u_1
β : Type ?u.4210
γ : Type ?u.4213
a a' : α
s : Set α
ha : a ∈ s
b : α
⊢ Set.indicator s (↑(pure a)) b = if b = a then 1 else 0

tactic: refine' (tsum_congr fun b => _).trans tsum_zero
state_before: case inr
α : Type u_1
β : Type ?u.4210
γ : Type ?u.4213
a a' : α
s : Set α
ha : ¬a ∈ s
⊢ (∑' (x : α), Set.indicator s (↑(pure a)) x) = 0

tactic: exact ite_eq_right_iff.2 fun hb => ite_eq_right_iff.2 fun h => (ha <| h ▸ hb).elim
state_before: case inr
α : Type u_1
β : Type ?u.4210
γ : Type ?u.4213
a a' : α
s : Set α
ha : ¬a ∈ s
b : α
⊢ Set.indicator s (↑(pure a)) b = 0
Theorem: inner_zero_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, inner_zero_left, RingHom.map_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1553426
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ inner x 0 = 0
Theorem: LeftOrdContinuous.map_iSup
File: Mathlib/Order/OrdContinuous.lean

tactic: simp only [iSup, hf.map_sSup', ← range_comp]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : α → β
hf : LeftOrdContinuous f
g : ι → α
⊢ f (⨆ (i : ι), g i) = ⨆ (i : ι), f (g i)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : α → β
hf : LeftOrdContinuous f
g : ι → α
⊢ sSup (range (f ∘ fun i => g i)) = sSup (range fun i => f (g i))