tasksource/leandojo huggingface dataset:
Theorem: mapsTo_omegaLimit'
File: Mathlib/Dynamics/OmegaLimit.lean

tactic: simp only [omegaLimit_def, mem_iInter, MapsTo]
state_before: τ : Type u_3
α : Type u_4
β : Type u_5
ι : Type ?u.24430
inst✝¹ : TopologicalSpace β
f✝ : Filter τ
ϕ✝ : τ → α → β
s s₁ s₂ : Set α
α' : Type u_1
β' : Type u_2
inst✝ : TopologicalSpace β'
f : Filter τ
ϕ : τ → α → β
ϕ' : τ → α' → β'
ga : α → α'
s' : Set α'
hs : MapsTo ga s s'
gb : β → β'
hg : ∀ᶠ (t : τ) in f, EqOn (gb ∘ ϕ t) (ϕ' t ∘ ga) s
hgc : Continuous gb
⊢ MapsTo gb (ω f ϕ s) (ω f ϕ' s')

tactic: intro y hy u hu
state_before: τ : Type u_3
α : Type u_4
β : Type u_5
ι : Type ?u.24430
inst✝¹ : TopologicalSpace β
f✝ : Filter τ
ϕ✝ : τ → α → β
s s₁ s₂ : Set α
α' : Type u_1
β' : Type u_2
inst✝ : TopologicalSpace β'
f : Filter τ
ϕ : τ → α → β
ϕ' : τ → α' → β'
ga : α → α'
s' : Set α'
hs : MapsTo ga s s'
gb : β → β'
hg : ∀ᶠ (t : τ) in f, EqOn (gb ∘ ϕ t) (ϕ' t ∘ ga) s
hgc : Continuous gb
⊢ ∀ ⦃x : β⦄,
    (∀ (i : Set τ), i ∈ f → x ∈ closure (image2 ϕ i s)) → ∀ (i : Set τ), i ∈ f → gb x ∈ closure (image2 ϕ' i s')

tactic: refine' map_mem_closure hgc (hy _ (inter_mem hu hg)) (forall_image2_iff.2 fun t ht x hx ↦ _)
state_before: τ : Type u_3
α : Type u_4
β : Type u_5
ι : Type ?u.24430
inst✝¹ : TopologicalSpace β
f✝ : Filter τ
ϕ✝ : τ → α → β
s s₁ s₂ : Set α
α' : Type u_1
β' : Type u_2
inst✝ : TopologicalSpace β'
f : Filter τ
ϕ : τ → α → β
ϕ' : τ → α' → β'
ga : α → α'
s' : Set α'
hs : MapsTo ga s s'
gb : β → β'
hg : ∀ᶠ (t : τ) in f, EqOn (gb ∘ ϕ t) (ϕ' t ∘ ga) s
hgc : Continuous gb
y : β
hy : ∀ (i : Set τ), i ∈ f → y ∈ closure (image2 ϕ i s)
u : Set τ
hu : u ∈ f
⊢ gb y ∈ closure (image2 ϕ' u s')

tactic: calc
  gb (ϕ t x) = ϕ' t (ga x) := ht.2 hx
  _ ∈ image2 ϕ' u s' := mem_image2_of_mem ht.1 (hs hx)
state_before: τ : Type u_3
α : Type u_4
β : Type u_5
ι : Type ?u.24430
inst✝¹ : TopologicalSpace β
f✝ : Filter τ
ϕ✝ : τ → α → β
s s₁ s₂ : Set α
α' : Type u_1
β' : Type u_2
inst✝ : TopologicalSpace β'
f : Filter τ
ϕ : τ → α → β
ϕ' : τ → α' → β'
ga : α → α'
s' : Set α'
hs : MapsTo ga s s'
gb : β → β'
hg : ∀ᶠ (t : τ) in f, EqOn (gb ∘ ϕ t) (ϕ' t ∘ ga) s
hgc : Continuous gb
y : β
hy : ∀ (i : Set τ), i ∈ f → y ∈ closure (image2 ϕ i s)
u : Set τ
hu : u ∈ f
t : τ
ht : t ∈ u ∩ {x | (fun t => EqOn (gb ∘ ϕ t) (ϕ' t ∘ ga) s) x}
x : α
hx : x ∈ s
⊢ gb (ϕ t x) ∈ image2 ϕ' u s'
Theorem: Array.get?_set_eq
File: Std/Data/Array/Lemmas.lean

tactic: simp [getElem?_pos, i.2]
state_before: α : Type u_1
a : Array α
i : Fin (size a)
v : α
⊢ (set a i v)[i.val]? = some v
Theorem: TensorProduct.directSumRight_symm_lof_tmul
File: Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean

tactic: rw [LinearEquiv.symm_apply_eq, directSumRight_tmul_lof]
state_before: R : Type u
inst✝¹⁰ : CommRing R
ι₁ : Type v₁
ι₂ : Type v₂
inst✝⁹ : DecidableEq ι₁
inst✝⁸ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁷ : (i₁ : ι₁) → AddCommGroup (M₁ i₁)
inst✝⁶ : AddCommGroup M₁'
inst✝⁵ : (i₂ : ι₂) → AddCommGroup (M₂ i₂)
inst✝⁴ : AddCommGroup M₂'
inst✝³ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝² : Module R M₁'
inst✝¹ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝ : Module R M₂'
x : M₁'
i : ι₂
y : M₂ i
⊢ ↑(LinearEquiv.symm (directSumRight R M₁' M₂)) (↑(lof R ι₂ (fun i => M₁' ⊗[R] M₂ i) i) (x ⊗ₜ[R] y)) =
    x ⊗ₜ[R] ↑(lof R ι₂ M₂ i) y
Theorem: Fin.cast_last
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [coe_cast, val_last, val_last, Nat.succ_injective h]
state_before: n m n' : ℕ
h : n + 1 = n' + 1
⊢ ↑(↑(cast h) (last n)) = ↑(last n')
Theorem: CategoryTheory.Limits.biproduct.lift_matrix
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: ext
state_before: C : Type u
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
J : Type
inst✝³ : Fintype J
f✝ : J → C
inst✝² : HasBiproduct f✝
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
P : C
x : (j : J) → P ⟶ f j
m : (j : J) → (k : K) → f j ⟶ g k
⊢ lift x ≫ matrix m = lift fun k => ∑ j : J, x j ≫ m j k

tactic: simp
state_before: case w
C : Type u
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
J : Type
inst✝³ : Fintype J
f✝ : J → C
inst✝² : HasBiproduct f✝
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
P : C
x : (j : J) → P ⟶ f j
m : (j : J) → (k : K) → f j ⟶ g k
j✝ : K
⊢ (lift x ≫ matrix m) ≫ π (fun k => g k) j✝ = (lift fun k => ∑ j : J, x j ≫ m j k) ≫ π (fun k => g k) j✝
Theorem: Set.iUnion_eq_univ_iff
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [eq_univ_iff_forall, mem_iUnion]
state_before: α : Type u_1
β : Type ?u.127762
γ : Type ?u.127765
ι : Sort u_2
ι' : Sort ?u.127771
ι₂ : Sort ?u.127774
κ : ι → Sort ?u.127779
κ₁ : ι → Sort ?u.127784
κ₂ : ι → Sort ?u.127789
κ' : ι' → Sort ?u.127794
f : ι → Set α
⊢ (⋃ (i : ι), f i) = univ ↔ ∀ (x : α), ∃ i, x ∈ f i
Theorem: Seminorm.ball_add_ball_subset
File: Mathlib/Analysis/Seminorm.lean

tactic: rintro x ⟨y₁, y₂, hy₁, hy₂, rfl⟩
state_before: R : Type ?u.874093
R' : Type ?u.874096
𝕜 : Type u_1
𝕜₂ : Type ?u.874102
𝕜₃ : Type ?u.874105
𝕝 : Type ?u.874108
E : Type u_2
E₂ : Type ?u.874114
E₃ : Type ?u.874117
F : Type ?u.874120
G : Type ?u.874123
ι : Type ?u.874126
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x y : E
r : ℝ
p : Seminorm 𝕜 E
r₁ r₂ : ℝ
x₁ x₂ : E
⊢ ball p x₁ r₁ + ball p x₂ r₂ ⊆ ball p (x₁ + x₂) (r₁ + r₂)

tactic: rw [mem_ball, add_sub_add_comm]
state_before: case intro.intro.intro.intro
R : Type ?u.874093
R' : Type ?u.874096
𝕜 : Type u_1
𝕜₂ : Type ?u.874102
𝕜₃ : Type ?u.874105
𝕝 : Type ?u.874108
E : Type u_2
E₂ : Type ?u.874114
E₃ : Type ?u.874117
F : Type ?u.874120
G : Type ?u.874123
ι : Type ?u.874126
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x y : E
r : ℝ
p : Seminorm 𝕜 E
r₁ r₂ : ℝ
x₁ x₂ y₁ y₂ : E
hy₁ : y₁ ∈ ball p x₁ r₁
hy₂ : y₂ ∈ ball p x₂ r₂
⊢ (fun x x_1 => x + x_1) y₁ y₂ ∈ ball p (x₁ + x₂) (r₁ + r₂)

tactic: exact (map_add_le_add p _ _).trans_lt (add_lt_add hy₁ hy₂)
state_before: case intro.intro.intro.intro
R : Type ?u.874093
R' : Type ?u.874096
𝕜 : Type u_1
𝕜₂ : Type ?u.874102
𝕜₃ : Type ?u.874105
𝕝 : Type ?u.874108
E : Type u_2
E₂ : Type ?u.874114
E₃ : Type ?u.874117
F : Type ?u.874120
G : Type ?u.874123
ι : Type ?u.874126
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p✝ : Seminorm 𝕜 E
x y : E
r : ℝ
p : Seminorm 𝕜 E
r₁ r₂ : ℝ
x₁ x₂ y₁ y₂ : E
hy₁ : y₁ ∈ ball p x₁ r₁
hy₂ : y₂ ∈ ball p x₂ r₂
⊢ ↑p (y₁ - x₁ + (y₂ - x₂)) < r₁ + r₂
Theorem: Odd.add_even
File: Mathlib/Algebra/Parity.lean

tactic: rw [add_comm]
state_before: F : Type ?u.82975
α : Type u_1
β : Type ?u.82981
R : Type ?u.82984
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : α
hm : Odd m
hn : Even n
⊢ Odd (m + n)

tactic: exact hn.add_odd hm
state_before: F : Type ?u.82975
α : Type u_1
β : Type ?u.82981
R : Type ?u.82984
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : α
hm : Odd m
hn : Even n
⊢ Odd (n + m)
Theorem: Set.einfsep_lt_top
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simp_rw [einfsep, iInf_lt_iff]
state_before: α : Type u_1
β : Type ?u.8730
inst✝ : EDist α
x y : α
s t : Set α
⊢ einfsep s < ⊤ ↔ ∃ x x_1 y x_2 _hxy, edist x y < ⊤
Theorem: intervalIntegral.integral_hasStrictDerivAt_of_tendsto_ae_left
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa only [← integral_symm] using
  (integral_hasStrictDerivAt_of_tendsto_ae_right hf.symm hmeas ha).neg
state_before: ι : Type ?u.1680719
𝕜 : Type ?u.1680722
E : Type u_1
F : Type ?u.1680728
A : Type ?u.1680731
inst✝⁴ : NormedAddCommGroup E
inst✝³ : CompleteSpace E
inst✝² : NormedSpace ℝ E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u v ua ub va vb : ι → ℝ
inst✝¹ : FTCFilter a la la'
inst✝ : FTCFilter b lb lb'
hf : IntervalIntegrable f volume a b
hmeas : StronglyMeasurableAtFilter f (𝓝 a)
ha : Tendsto f (𝓝 a ⊓ Measure.ae volume) (𝓝 c)
⊢ HasStrictDerivAt (fun u => ∫ (x : ℝ) in u..b, f x) (-c) a
Theorem: Part.ext'
File: Mathlib/Data/Part.lean

tactic: have t : od = pd := propext H1
state_before: α : Type u_1
β : Type ?u.1433
γ : Type ?u.1436
od : Prop
o : od → α
pd : Prop
p : pd → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := pd, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := pd, get := p }.Dom),
    get { Dom := od, get := o } h₁ = get { Dom := pd, get := p } h₂
⊢ { Dom := od, get := o } = { Dom := pd, get := p }

tactic: cases t
state_before: α : Type u_1
β : Type ?u.1433
γ : Type ?u.1436
od : Prop
o : od → α
pd : Prop
p : pd → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := pd, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := pd, get := p }.Dom),
    get { Dom := od, get := o } h₁ = get { Dom := pd, get := p } h₂
t : od = pd
⊢ { Dom := od, get := o } = { Dom := pd, get := p }

tactic: rw [show o = p from funext fun p => H2 p p]
state_before: case refl
α : Type u_1
β : Type ?u.1433
γ : Type ?u.1436
od : Prop
o p : od → α
H1 : { Dom := od, get := o }.Dom ↔ { Dom := od, get := p }.Dom
H2 :
  ∀ (h₁ : { Dom := od, get := o }.Dom) (h₂ : { Dom := od, get := p }.Dom),
    get { Dom := od, get := o } h₁ = get { Dom := od, get := p } h₂
⊢ { Dom := od, get := o } = { Dom := od, get := p }
Theorem: Nat.coprime_of_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: rw [coprime_iff_gcd_eq_one]
state_before: m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
⊢ coprime m n

tactic: by_contra g2
state_before: m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
⊢ gcd m n = 1

tactic: obtain ⟨p, hp, hpdvd⟩ := exists_prime_and_dvd g2
state_before: m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
g2 : ¬gcd m n = 1
⊢ False

tactic: apply H p hp <;> apply dvd_trans hpdvd
state_before: case intro.intro
m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
g2 : ¬gcd m n = 1
p : ℕ
hp : Prime p
hpdvd : p ∣ gcd m n
⊢ False

tactic: exact gcd_dvd_left _ _
state_before: case intro.intro.a
m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
g2 : ¬gcd m n = 1
p : ℕ
hp : Prime p
hpdvd : p ∣ gcd m n
⊢ gcd m n ∣ m

tactic: exact gcd_dvd_right _ _
state_before: case intro.intro.a
m n : ℕ
H : ∀ (k : ℕ), Prime k → k ∣ m → ¬k ∣ n
g2 : ¬gcd m n = 1
p : ℕ
hp : Prime p
hpdvd : p ∣ gcd m n
⊢ gcd m n ∣ n
Theorem: Finsupp.single_apply_left
File: Mathlib/Data/Finsupp/Defs.lean

tactic: classical simp only [single_apply, hf.eq_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.38931
ι : Type ?u.38934
M : Type u_3
M' : Type ?u.38940
N : Type ?u.38943
P : Type ?u.38946
G : Type ?u.38949
H : Type ?u.38952
R : Type ?u.38955
S : Type ?u.38958
inst✝ : Zero M
a a' : α
b : M
f : α → β
hf : Injective f
x z : α
y : M
⊢ ↑(single (f x) y) (f z) = ↑(single x y) z

tactic: simp only [single_apply, hf.eq_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.38931
ι : Type ?u.38934
M : Type u_3
M' : Type ?u.38940
N : Type ?u.38943
P : Type ?u.38946
G : Type ?u.38949
H : Type ?u.38952
R : Type ?u.38955
S : Type ?u.38958
inst✝ : Zero M
a a' : α
b : M
f : α → β
hf : Injective f
x z : α
y : M
⊢ ↑(single (f x) y) (f z) = ↑(single x y) z
Theorem: Orthonormal.isHilbertSum
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: convert hsp
state_before: ι : Type u_3
𝕜 : Type u_1
inst✝⁴ : IsROrC 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type ?u.653291
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
v : ι → E
hv : Orthonormal 𝕜 v
hsp : ⊤ ≤ topologicalClosure (span 𝕜 (Set.range v))
⊢ ⊤ ≤ topologicalClosure (⨆ (i : ι), LinearMap.range (LinearIsometry.toSpanSingleton 𝕜 E (_ : ‖v i‖ = 1)).toLinearMap)

tactic: simp [← LinearMap.span_singleton_eq_range, ← Submodule.span_iUnion]
state_before: case h.e'_4.h.e'_9
ι : Type u_3
𝕜 : Type u_1
inst✝⁴ : IsROrC 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type ?u.653291
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
v : ι → E
hv : Orthonormal 𝕜 v
hsp : ⊤ ≤ topologicalClosure (span 𝕜 (Set.range v))
⊢ (⨆ (i : ι), LinearMap.range (LinearIsometry.toSpanSingleton 𝕜 E (_ : ‖v i‖ = 1)).toLinearMap) = span 𝕜 (Set.range v)
Theorem: EMetric.continuous_infEdist_hausdorffEdist
File: Mathlib/Topology/MetricSpace/Closeds.lean

tactic: refine' continuous_of_le_add_edist 2 (by simp) _
state_before: α : Type u
inst✝ : EMetricSpace α
s : Set α
⊢ Continuous fun p => infEdist p.fst ↑p.snd

tactic: rintro ⟨x, s⟩ ⟨y, t⟩
state_before: α : Type u
inst✝ : EMetricSpace α
s : Set α
⊢ ∀ (x y : α × Closeds α), infEdist x.fst ↑x.snd ≤ infEdist y.fst ↑y.snd + 2 * edist x y

tactic: calc
  infEdist x s ≤ infEdist x t + hausdorffEdist (t : Set α) s :=
    infEdist_le_infEdist_add_hausdorffEdist
  _ ≤ infEdist y t + edist x y + hausdorffEdist (t : Set α) s :=
    (add_le_add_right infEdist_le_infEdist_add_edist _)
  _ = infEdist y t + (edist x y + hausdorffEdist (s : Set α) t) := by
    rw [add_assoc, hausdorffEdist_comm]
  _ ≤ infEdist y t + (edist (x, s) (y, t) + edist (x, s) (y, t)) :=
    (add_le_add_left (add_le_add (le_max_left _ _) (le_max_right _ _)) _)
  _ = infEdist y t + 2 * edist (x, s) (y, t) := by rw [← mul_two, mul_comm]
state_before: case mk.mk
α : Type u
inst✝ : EMetricSpace α
s✝ : Set α
x : α
s : Closeds α
y : α
t : Closeds α
⊢ infEdist (x, s).fst ↑(x, s).snd ≤ infEdist (y, t).fst ↑(y, t).snd + 2 * edist (x, s) (y, t)

tactic: simp
state_before: α : Type u
inst✝ : EMetricSpace α
s : Set α
⊢ 2 ≠ ⊤

tactic: rw [add_assoc, hausdorffEdist_comm]
state_before: α : Type u
inst✝ : EMetricSpace α
s✝ : Set α
x : α
s : Closeds α
y : α
t : Closeds α
⊢ infEdist y ↑t + edist x y + hausdorffEdist ↑t ↑s = infEdist y ↑t + (edist x y + hausdorffEdist ↑s ↑t)

tactic: rw [← mul_two, mul_comm]
state_before: α : Type u
inst✝ : EMetricSpace α
s✝ : Set α
x : α
s : Closeds α
y : α
t : Closeds α
⊢ infEdist y ↑t + (edist (x, s) (y, t) + edist (x, s) (y, t)) = infEdist y ↑t + 2 * edist (x, s) (y, t)
Theorem: MvPolynomial.vars_monomial
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical rw [vars_def, degrees_monomial_eq _ _ h, Finsupp.toFinset_toMultiset]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.127739
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
h : r ≠ 0
⊢ vars (↑(monomial s) r) = s.support

tactic: rw [vars_def, degrees_monomial_eq _ _ h, Finsupp.toFinset_toMultiset]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.127739
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
h : r ≠ 0
⊢ vars (↑(monomial s) r) = s.support
Theorem: Real.Angle.coe_toReal
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ ↑(toReal θ) = θ

tactic: exact coe_toIocMod _ _
state_before: case h
x✝ : ℝ
⊢ ↑(toReal ↑x✝) = ↑x✝
Theorem: PadicInt.norm_units
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: simp
state_before: p : ℕ
hp : Fact (Nat.Prime p)
u : ℤ_[p]ˣ
⊢ IsUnit ↑u
Theorem: MeasureTheory.Measure.count_apply
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [count, sum_apply, hs, dirac_apply', ← tsum_subtype s (1 : α → ℝ≥0∞), Pi.one_apply]
state_before: α : Type u_1
β : Type ?u.367980
γ : Type ?u.367983
δ : Type ?u.367986
ι : Type ?u.367989
R : Type ?u.367992
R' : Type ?u.367995
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
hs : MeasurableSet s
⊢ ↑↑count s = ∑' (i : ↑s), 1
Theorem: Int.card_Ico_of_le
File: Mathlib/Data/Int/Interval.lean

tactic: rw [card_Ico, toNat_sub_of_le h]
state_before: a b : ℤ
h : a ≤ b
⊢ ↑(card (Ico a b)) = b - a
Theorem: IsUnit.mem_submonoid_iff
File: Mathlib/GroupTheory/Submonoid/Basic.lean

tactic: change a ∈ setOf IsUnit ↔ IsUnit a
state_before: M✝ : Type ?u.38952
N : Type ?u.38955
A : Type ?u.38958
inst✝² : Monoid M✝
inst✝¹ : Monoid N
s : Set M✝
M : Type u_1
inst✝ : Monoid M
a : M
⊢ a ∈ submonoid M ↔ IsUnit a

tactic: rw [Set.mem_setOf_eq]
state_before: M✝ : Type ?u.38952
N : Type ?u.38955
A : Type ?u.38958
inst✝² : Monoid M✝
inst✝¹ : Monoid N
s : Set M✝
M : Type u_1
inst✝ : Monoid M
a : M
⊢ a ∈ setOf IsUnit ↔ IsUnit a
Theorem: CategoryTheory.Limits.inr_zeroCoprodIso_hom
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: dsimp [zeroCoprodIso, binaryCofanZeroLeft]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ coprod.inr ≫ (zeroCoprodIso X).hom = 𝟙 X

tactic: simp
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ coprod.inr ≫
      (colimit.isoColimitCocone { cocone := BinaryCofan.mk 0 (𝟙 X), isColimit := binaryCofanZeroLeftIsColimit X }).hom =
    𝟙 X
Theorem: PosNum.cast_inj
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_nat m, ← cast_to_nat n, Nat.cast_inj, to_nat_inj]
state_before: α : Type u_1
inst✝¹ : AddMonoidWithOne α
inst✝ : CharZero α
m n : PosNum
⊢ ↑m = ↑n ↔ m = n
Theorem: FirstOrder.Language.Formula.realize_equal
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp [Term.equal, Realize]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.245966
P : Type ?u.245969
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
t₁ t₂ : Term L α
x : α → M
⊢ Realize (Term.equal t₁ t₂) x ↔ Term.realize x t₁ = Term.realize x t₂
Theorem: MeasureTheory.measure_diff_lt_of_lt_add
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [measure_diff hst hs hs']
state_before: α : Type u_1
β : Type ?u.24581
γ : Type ?u.24584
δ : Type ?u.24587
ι : Type ?u.24590
R : Type ?u.24593
R' : Type ?u.24596
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
hs : MeasurableSet s
hst : s ⊆ t
hs' : ↑↑μ s ≠ ⊤
ε : ℝ≥0∞
h : ↑↑μ t < ↑↑μ s + ε
⊢ ↑↑μ (t \ s) < ε

tactic: rw [add_comm] at h
state_before: α : Type u_1
β : Type ?u.24581
γ : Type ?u.24584
δ : Type ?u.24587
ι : Type ?u.24590
R : Type ?u.24593
R' : Type ?u.24596
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
hs : MeasurableSet s
hst : s ⊆ t
hs' : ↑↑μ s ≠ ⊤
ε : ℝ≥0∞
h : ↑↑μ t < ↑↑μ s + ε
⊢ ↑↑μ t - ↑↑μ s < ε

tactic: exact ENNReal.sub_lt_of_lt_add (measure_mono hst) h
state_before: α : Type u_1
β : Type ?u.24581
γ : Type ?u.24584
δ : Type ?u.24587
ι : Type ?u.24590
R : Type ?u.24593
R' : Type ?u.24596
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
hs : MeasurableSet s
hst : s ⊆ t
hs' : ↑↑μ s ≠ ⊤
ε : ℝ≥0∞
h : ↑↑μ t < ε + ↑↑μ s
⊢ ↑↑μ t - ↑↑μ s < ε
Theorem: Real.geom_mean_le_arith_mean2_weighted
File: Mathlib/Analysis/MeanInequalities.lean

tactic: assumption
state_before: ι : Type u
s : Finset ι
w₁ w₂ p₁ p₂ : ℝ
hw₁ : 0 ≤ w₁
hw₂ : 0 ≤ w₂
hp₁ : 0 ≤ p₁
hp₂ : 0 ≤ p₂
hw : w₁ + w₂ = 1
⊢ ↑({ val := w₁, property := hw₁ } + { val := w₂, property := hw₂ }) = ↑1
Theorem: AffineSubspace.WOppSide.map
File: Mathlib/Analysis/Convex/Side.lean

tactic: rcases h with ⟨p₁, hp₁, p₂, hp₂, h⟩
state_before: R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
h : WOppSide s x y
f : P →ᵃ[R] P'
⊢ WOppSide (AffineSubspace.map f s) (↑f x) (↑f y)

tactic: refine' ⟨f p₁, mem_map_of_mem f hp₁, f p₂, mem_map_of_mem f hp₂, _⟩
state_before: case intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)
⊢ WOppSide (AffineSubspace.map f s) (↑f x) (↑f y)

tactic: simp_rw [← linearMap_vsub]
state_before: case intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)
⊢ SameRay R (↑f x -ᵥ ↑f p₁) (↑f p₂ -ᵥ ↑f y)

tactic: exact h.map f.linear
state_before: case intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)
⊢ SameRay R (↑f.linear (x -ᵥ p₁)) (↑f.linear (p₂ -ᵥ y))
Theorem: Stream'.Seq.exists_of_mem_map
File: Mathlib/Data/Seq/Seq.lean

tactic: match s with
| ⟨g, al⟩ =>
let ⟨o, om, oe⟩ := @Stream'.exists_of_mem_map _ _ (Option.map f) (some b) g h
cases' o with a
. injection oe
. injection oe with h' ; exact ⟨a, om, h'⟩
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Seq α
h : b ∈ map f s
⊢ ∃ a, a ∈ s ∧ f a = b

tactic: let ⟨o, om, oe⟩ := @Stream'.exists_of_mem_map _ _ (Option.map f) (some b) g h
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Seq α
g : Stream' (Option α)
al : IsSeq g
h : b ∈ map f { val := g, property := al }
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

tactic: cases' o with a
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Seq α
g : Stream' (Option α)
al : IsSeq g
h : b ∈ map f { val := g, property := al }
o : Option α
om : o ∈ g
oe : Option.map f o = some b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

tactic: . injection oe
state_before: case none
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Seq α
g : Stream' (Option α)
al : IsSeq g
h : b ∈ map f { val := g, property := al }
om : none ∈ g
oe : Option.map f none = some b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Seq α
g : Stream' (Option α)
al : IsSeq g
h : b ∈ map f { val := g, property := al }
a : α
om : some a ∈ g
oe : Option.map f (some a) = some b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

tactic: . injection oe with h' ; exact ⟨a, om, h'⟩
state_before: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Seq α
g : Stream' (Option α)
al : IsSeq g
h : b ∈ map f { val := g, property := al }
a : α
om : some a ∈ g
oe : Option.map f (some a) = some b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

tactic: injection oe
state_before: case none
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Seq α
g : Stream' (Option α)
al : IsSeq g
h : b ∈ map f { val := g, property := al }
om : none ∈ g
oe : Option.map f none = some b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

tactic: injection oe with h'
state_before: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Seq α
g : Stream' (Option α)
al : IsSeq g
h : b ∈ map f { val := g, property := al }
a : α
om : some a ∈ g
oe : Option.map f (some a) = some b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

tactic: exact ⟨a, om, h'⟩
state_before: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
s : Seq α
g : Stream' (Option α)
al : IsSeq g
h : b ∈ map f { val := g, property := al }
a : α
om : some a ∈ g
h' : f a = b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b
Theorem: Nat.ArithmeticFunction.moebius_apply_one
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp
state_before: R : Type ?u.580222
⊢ ↑μ 1 = 1
Theorem: MvPolynomial.bind₁_monomial
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: simp only [monomial_eq, AlgHom.map_mul, bind₁_C_right, Finsupp.prod, AlgHom.map_prod,
  AlgHom.map_pow, bind₁_X_right]
state_before: σ : Type u_3
τ : Type u_1
R : Type u_2
S : Type ?u.1212003
T : Type ?u.1212006
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ f : σ → MvPolynomial τ R
d : σ →₀ ℕ
r : R
⊢ ↑(bind₁ f) (↑(monomial d) r) = ↑C r * ∏ i in d.support, f i ^ ↑d i