tasksource/leandojo huggingface dataset:
Theorem: Filter.isCobounded_principal
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [IsCobounded, subset_def]
state_before: α : Type u_1
β : Type ?u.24269
γ : Type ?u.24272
ι : Type ?u.24275
r : α → α → Prop
f g : Filter α
s : Set α
⊢ IsCobounded r (𝓟 s) ↔ ∃ b, ∀ (a : α), (∀ (x : α), x ∈ s → r x a) → r b a
Theorem: Finset.pow_subset_pow
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp [pow_zero]
state_before: F : Type ?u.302112
α : Type u_1
β : Type ?u.302118
γ : Type ?u.302121
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n : ℕ
hst : s ⊆ t
⊢ s ^ 0 ⊆ t ^ 0

tactic: rw [pow_succ]
state_before: F : Type ?u.302112
α : Type u_1
β : Type ?u.302118
γ : Type ?u.302121
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s ^ (n + 1) ⊆ t ^ (n + 1)

tactic: exact mul_subset_mul hst (pow_subset_pow hst n)
state_before: F : Type ?u.302112
α : Type u_1
β : Type ?u.302118
γ : Type ?u.302121
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n✝ : ℕ
hst : s ⊆ t
n : ℕ
⊢ s * s ^ n ⊆ t ^ (n + 1)
Theorem: convexHull_sub
File: Mathlib/Analysis/Convex/Combination.lean

tactic: simp_rw [sub_eq_add_neg, convexHull_add, convexHull_neg]
state_before: R : Type u_2
E : Type u_1
F : Type ?u.413908
ι : Type ?u.413911
ι' : Type ?u.413914
α : Type ?u.413917
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s✝ : Set E
i j : ι
c : R
t✝ : Finset ι
w : ι → R
z : ι → E
s t : Set E
⊢ ↑(convexHull R).toOrderHom (s - t) = ↑(convexHull R).toOrderHom s - ↑(convexHull R).toOrderHom t
Theorem: Ideal.homogeneousHull_mono
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: apply Ideal.span_mono
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.210738
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I✝ I J : Ideal A
I_le_J : I ≤ J
⊢ homogeneousHull 𝒜 I ≤ homogeneousHull 𝒜 J

tactic: rintro r ⟨hr1, ⟨x, hx⟩, rfl⟩
state_before: case a
ι : Type u_2
σ : Type u_3
R : Type ?u.210738
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I✝ I J : Ideal A
I_le_J : I ≤ J
⊢ {r | ∃ i x, ↑(↑(↑(decompose 𝒜) ↑x) i) = r} ⊆ {r | ∃ i x, ↑(↑(↑(decompose 𝒜) ↑x) i) = r}

tactic: refine' ⟨hr1, ⟨⟨x, I_le_J hx⟩, rfl⟩⟩
state_before: case a.intro.intro.mk
ι : Type u_2
σ : Type u_3
R : Type ?u.210738
A : Type u_1
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I✝ I J : Ideal A
I_le_J : I ≤ J
hr1 : ι
x : A
hx : x ∈ I
⊢ ↑(↑(↑(decompose 𝒜) ↑{ val := x, property := hx }) hr1) ∈ {r | ∃ i x, ↑(↑(↑(decompose 𝒜) ↑x) i) = r}
Theorem: Nat.psub_eq_some
File: Mathlib/Data/Nat/PSub.lean

tactic: simp [eq_comm]
state_before: m k : ℕ
⊢ psub m 0 = some k ↔ k + 0 = m

tactic: apply Option.bind_eq_some.trans
state_before: m n k : ℕ
⊢ psub m (n + 1) = some k ↔ k + (n + 1) = m

tactic: simp only [psub_eq_some, ppred_eq_some]
state_before: m n k : ℕ
⊢ (∃ a, psub m (Nat.add n 0) = some a ∧ ppred a = some k) ↔ k + (n + 1) = m

tactic: simp [add_comm, add_left_comm, Nat.succ_eq_add_one]
state_before: m n k : ℕ
⊢ (∃ a, a + Nat.add n 0 = m ∧ succ k = a) ↔ k + (n + 1) = m
Theorem: UniformSpace.SeparationQuotient.map_mk
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: rw [map, lift_mk (uniformContinuous_quotient_mk'.comp h)]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : UniformContinuous f
a : α
⊢ map f (Quotient.mk (separationSetoid α) a) = Quotient.mk (separationSetoid β) (f a)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : UniformContinuous f
a : α
⊢ (Quotient.mk' ∘ f) a = Quotient.mk (separationSetoid β) (f a)
Theorem: Finset.max_erase_ne_self
File: Mathlib/Data/Finset/Lattice.lean

tactic: by_cases s0 : (s.erase x).Nonempty
state_before: F : Type ?u.372851
α : Type u_1
β : Type ?u.372857
γ : Type ?u.372860
ι : Type ?u.372863
κ : Type ?u.372866
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
⊢ Finset.max (erase s x) ≠ ↑x

tactic: refine' ne_of_eq_of_ne (coe_max' s0).symm _
state_before: case pos
F : Type ?u.372851
α : Type u_1
β : Type ?u.372857
γ : Type ?u.372860
ι : Type ?u.372863
κ : Type ?u.372866
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
s0 : Finset.Nonempty (erase s x)
⊢ Finset.max (erase s x) ≠ ↑x

tactic: exact WithBot.coe_eq_coe.not.mpr (max'_erase_ne_self _)
state_before: case pos
F : Type ?u.372851
α : Type u_1
β : Type ?u.372857
γ : Type ?u.372860
ι : Type ?u.372863
κ : Type ?u.372866
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
s0 : Finset.Nonempty (erase s x)
⊢ ↑(max' (erase s x) s0) ≠ ↑x

tactic: rw [not_nonempty_iff_eq_empty.mp s0, max_empty]
state_before: case neg
F : Type ?u.372851
α : Type u_1
β : Type ?u.372857
γ : Type ?u.372860
ι : Type ?u.372863
κ : Type ?u.372866
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
s0 : ¬Finset.Nonempty (erase s x)
⊢ Finset.max (erase s x) ≠ ↑x

tactic: exact WithBot.bot_ne_coe
state_before: case neg
F : Type ?u.372851
α : Type u_1
β : Type ?u.372857
γ : Type ?u.372860
ι : Type ?u.372863
κ : Type ?u.372866
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset α
s0 : ¬Finset.Nonempty (erase s x)
⊢ ⊥ ≠ ↑x
Theorem: Function.Involutive.iterate_even
File: Mathlib/Data/Nat/Parity.lean

tactic: rcases hn with ⟨m, rfl⟩
state_before: α : Type u_1
f : α → α
n : ℕ
hf : Involutive f
hn : Even n
⊢ f^[n] = id

tactic: rw [← two_mul, hf.iterate_two_mul]
state_before: case intro
α : Type u_1
f : α → α
hf : Involutive f
m : ℕ
⊢ f^[m + m] = id
Theorem: MulOneClass.ext
File: Mathlib/Algebra/Group/Defs.lean

tactic: rintro @⟨⟨one₁⟩, ⟨mul₁⟩, one_mul₁, mul_one₁⟩ @⟨⟨one₂⟩, ⟨mul₂⟩, one_mul₂, mul_one₂⟩ ⟨rfl⟩
state_before: G : Type ?u.36374
M : Type u
⊢ ∀ ⦃m₁ m₂ : MulOneClass M⦄, Mul.mul = Mul.mul → m₁ = m₂

tactic: suffices one₁ = one₂ by cases this; rfl
state_before: case mk.mk.mk.mk.mk.mk.refl
G : Type ?u.36374
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one₂ : M
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
⊢ mk one_mul₁ mul_one₁ = mk one_mul₂ mul_one₂

tactic: exact (one_mul₂ one₁).symm.trans (mul_one₁ one₂)
state_before: case mk.mk.mk.mk.mk.mk.refl
G : Type ?u.36374
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one₂ : M
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
⊢ one₁ = one₂

tactic: cases this
state_before: G : Type ?u.36374
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one₂ : M
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
this : one₁ = one₂
⊢ mk one_mul₁ mul_one₁ = mk one_mul₂ mul_one₂

tactic: rfl
state_before: case refl
G : Type ?u.36374
M : Type u
one₁ : M
mul₁ : M → M → M
one_mul₁ : ∀ (a : M), 1 * a = a
mul_one₁ : ∀ (a : M), a * 1 = a
one_mul₂ : ∀ (a : M), 1 * a = a
mul_one₂ : ∀ (a : M), a * 1 = a
⊢ mk one_mul₁ mul_one₁ = mk one_mul₂ mul_one₂
Theorem: MeasureTheory.snormEssSup_eq_zero_iff
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [EventuallyEq, snormEssSup]
state_before: α : Type u_1
E : Type ?u.2318609
F : Type u_2
G : Type ?u.2318615
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
⊢ snormEssSup f μ = 0 ↔ f =ᵐ[μ] 0
Theorem: IsRingHom.comp
File: Mathlib/Deprecated/Ring.lean

tactic: simp [map_add hf]
state_before: α : Type u
β : Type v
inst✝² : Ring α
inst✝¹ : Ring β
f : α → β
hf✝ : IsRingHom f
x✝ y✝ : α
hf : IsRingHom f
γ : Type u_1
inst✝ : Ring γ
g : β → γ
hg : IsRingHom g
x y : α
⊢ (g ∘ f) (x + y) = (g ∘ f) x + (g ∘ f) y

tactic: rw [map_add hg]
state_before: α : Type u
β : Type v
inst✝² : Ring α
inst✝¹ : Ring β
f : α → β
hf✝ : IsRingHom f
x✝ y✝ : α
hf : IsRingHom f
γ : Type u_1
inst✝ : Ring γ
g : β → γ
hg : IsRingHom g
x y : α
⊢ g (f x + f y) = g (f x) + g (f y)

tactic: simp [map_mul hf]
state_before: α : Type u
β : Type v
inst✝² : Ring α
inst✝¹ : Ring β
f : α → β
hf✝ : IsRingHom f
x✝ y✝ : α
hf : IsRingHom f
γ : Type u_1
inst✝ : Ring γ
g : β → γ
hg : IsRingHom g
x y : α
⊢ (g ∘ f) (x * y) = (g ∘ f) x * (g ∘ f) y

tactic: rw [map_mul hg]
state_before: α : Type u
β : Type v
inst✝² : Ring α
inst✝¹ : Ring β
f : α → β
hf✝ : IsRingHom f
x✝ y✝ : α
hf : IsRingHom f
γ : Type u_1
inst✝ : Ring γ
g : β → γ
hg : IsRingHom g
x y : α
⊢ g (f x * f y) = g (f x) * g (f y)

tactic: simp [map_one hf]
state_before: α : Type u
β : Type v
inst✝² : Ring α
inst✝¹ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
γ : Type u_1
inst✝ : Ring γ
g : β → γ
hg : IsRingHom g
⊢ (g ∘ f) 1 = 1

tactic: exact map_one hg
state_before: α : Type u
β : Type v
inst✝² : Ring α
inst✝¹ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
γ : Type u_1
inst✝ : Ring γ
g : β → γ
hg : IsRingHom g
⊢ g 1 = 1
Theorem: Set.exists_ne_of_one_lt_ncard
File: Mathlib/Data/Set/Ncard.lean

tactic: have hsf := (Finite_of_ncard_ne_zero (zero_lt_one.trans hs).ne.symm)
state_before: α : Type u_1
β : Type ?u.159008
s t : Set α
a✝ b x y : α
f : α → β
hs : 1 < ncard s
a : α
⊢ ∃ b, b ∈ s ∧ b ≠ a

tactic: rw [ncard_eq_toFinset_card _ hsf] at hs
state_before: α : Type u_1
β : Type ?u.159008
s t : Set α
a✝ b x y : α
f : α → β
hs : 1 < ncard s
a : α
hsf : Set.Finite s
⊢ ∃ b, b ∈ s ∧ b ≠ a

tactic: simpa only [Finite.mem_toFinset] using Finset.exists_ne_of_one_lt_card hs a
state_before: α : Type u_1
β : Type ?u.159008
s t : Set α
a✝ b x y : α
f : α → β
a : α
hsf : Set.Finite s
hs : 1 < Finset.card (Finite.toFinset hsf)
⊢ ∃ b, b ∈ s ∧ b ≠ a
Theorem: Primrec.nat_le
File: Mathlib/Computability/Primrec.lean

tactic: dsimp [swap]
state_before: α : Type ?u.129087
β : Type ?u.129090
γ : Type ?u.129093
δ : Type ?u.129096
σ : Type ?u.129099
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
p : ℕ × ℕ
⊢ (Nat.casesOn ((fun x x_1 => x - x_1) p.fst p.snd) true fun b => false) =
    (fun a b => decide ((fun x x_1 => x ≤ x_1) a b)) p.fst p.snd

tactic: cases' e : p.1 - p.2 with n
state_before: α : Type ?u.129087
β : Type ?u.129090
γ : Type ?u.129093
δ : Type ?u.129096
σ : Type ?u.129099
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
p : ℕ × ℕ
⊢ Nat.rec true (fun n n_ih => false) (p.fst - p.snd) = decide (p.fst ≤ p.snd)

tactic: simp [tsub_eq_zero_iff_le.1 e]
state_before: case zero
α : Type ?u.129087
β : Type ?u.129090
γ : Type ?u.129093
δ : Type ?u.129096
σ : Type ?u.129099
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
p : ℕ × ℕ
e : p.fst - p.snd = Nat.zero
⊢ Nat.rec true (fun n n_ih => false) Nat.zero = decide (p.fst ≤ p.snd)

tactic: simp [not_le.2 (Nat.lt_of_sub_eq_succ e)]
state_before: case succ
α : Type ?u.129087
β : Type ?u.129090
γ : Type ?u.129093
δ : Type ?u.129096
σ : Type ?u.129099
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
p : ℕ × ℕ
n : ℕ
e : p.fst - p.snd = Nat.succ n
⊢ Nat.rec true (fun n n_ih => false) (Nat.succ n) = decide (p.fst ≤ p.snd)
Theorem: Subring.mem_sSup_of_directedOn
File: Mathlib/RingTheory/Subring/Basic.lean

tactic: haveI : Nonempty S := Sne.to_subtype
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
S : Set (Subring R)
Sne : Set.Nonempty S
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ sSup S ↔ ∃ s, s ∈ S ∧ x ∈ s

tactic: simp only [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val, SetCoe.exists, Subtype.coe_mk,
  exists_prop]
state_before: R : Type u
S✝ : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S✝
inst✝ : Ring T
S : Set (Subring R)
Sne : Set.Nonempty S
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : R
this : Nonempty ↑S
⊢ x ∈ sSup S ↔ ∃ s, s ∈ S ∧ x ∈ s
Theorem: Polynomial.splits_of_degree_le_one
File: Mathlib/Data/Polynomial/Splits.lean

tactic: push_neg at hif
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : degree f ≤ 1
hif : ¬degree (map i f) ≤ 0
⊢ Splits i f

tactic: rw [← Order.succ_le_iff, ← WithBot.coe_zero, WithBot.succ_coe, Nat.succ_eq_succ] at hif
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : degree f ≤ 1
hif : 0 < degree (map i f)
⊢ Splits i f

tactic: exact splits_of_map_degree_eq_one i (le_antisymm ((degree_map_le i _).trans hf) hif)
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : degree f ≤ 1
hif✝ : 0 < degree (map i f)
hif : ↑(Nat.succ 0) ≤ degree (map i f)
⊢ Splits i f
Theorem: Finsupp.prod_finset_sum_index
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: rw [prod_cons, ih, sum_cons, prod_add_index' h_zero h_add]
state_before: α : Type u_4
ι : Type u_3
γ : Type ?u.544772
A : Type ?u.544775
B : Type ?u.544778
C : Type ?u.544781
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝¹ : Finset α
f : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.547911
M : Type u_1
M' : Type ?u.547917
N : Type u_2
P : Type ?u.547923
G : Type ?u.547926
H : Type ?u.547929
R : Type ?u.547932
S : Type ?u.547935
inst✝¹ : AddCommMonoid M
inst✝ : CommMonoid N
s✝ : Finset ι
g : ι → α →₀ M
h : α → M → N
h_zero : ∀ (a : α), h a 0 = 1
h_add : ∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ * h a b₂
a : ι
s : Finset ι
has : ¬a ∈ s
ih : ∏ i in s, prod (g i) h = prod (∑ i in s, g i) h
⊢ ∏ i in cons a s has, prod (g i) h = prod (∑ i in cons a s has, g i) h
Theorem: Matrix.cons_sub
File: Mathlib/Data/Fin/VecNotation.lean

tactic: ext i
state_before: α : Type u
m n o : ℕ
m' : Type ?u.66213
n' : Type ?u.66216
o' : Type ?u.66219
inst✝ : Sub α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
⊢ vecCons x v - w = vecCons (x - vecHead w) (v - vecTail w)

tactic: refine' Fin.cases _ _ i <;> simp [vecHead, vecTail]
state_before: case h
α : Type u
m n o : ℕ
m' : Type ?u.66213
n' : Type ?u.66216
o' : Type ?u.66219
inst✝ : Sub α
x : α
v : Fin n → α
w : Fin (Nat.succ n) → α
i : Fin (Nat.succ n)
⊢ (vecCons x v - w) i = vecCons (x - vecHead w) (v - vecTail w) i
Theorem: AEMeasurable.ennreal_tsum
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: simp_rw [ENNReal.tsum_eq_iSup_sum]
state_before: α : Type u_2
β : Type ?u.2930876
γ : Type ?u.2930879
γ₂ : Type ?u.2930882
δ : Type ?u.2930885
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_1
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
μ : MeasureTheory.Measure α
h : ∀ (i : ι), AEMeasurable (f i)
⊢ AEMeasurable fun x => ∑' (i : ι), f i x

tactic: apply aemeasurable_iSup
state_before: α : Type u_2
β : Type ?u.2930876
γ : Type ?u.2930879
γ₂ : Type ?u.2930882
δ : Type ?u.2930885
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_1
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
μ : MeasureTheory.Measure α
h : ∀ (i : ι), AEMeasurable (f i)
⊢ AEMeasurable fun x => ⨆ (s : Finset ι), ∑ i in s, f i x

tactic: exact fun s => Finset.aemeasurable_sum s fun i _ => h i
state_before: case hf
α : Type u_2
β : Type ?u.2930876
γ : Type ?u.2930879
γ₂ : Type ?u.2930882
δ : Type ?u.2930885
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_1
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
μ : MeasureTheory.Measure α
h : ∀ (i : ι), AEMeasurable (f i)
⊢ ∀ (i : Finset ι), AEMeasurable fun b => ∑ i in i, f i b
Theorem: Primrec.fin_val_iff
File: Mathlib/Computability/Primrec.lean

tactic: letI : Primcodable { a // id a < n } := Primcodable.subtype (nat_lt.comp .id (const _))
state_before: α : Type u_1
β : Type ?u.358941
γ : Type ?u.358944
σ : Type ?u.358947
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : α → Fin n
⊢ (Primrec fun a => ↑(f a)) ↔ Primrec f

tactic: exact (Iff.trans (by rfl) subtype_val_iff).trans (of_equiv_iff _)
state_before: α : Type u_1
β : Type ?u.358941
γ : Type ?u.358944
σ : Type ?u.358947
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : α → Fin n
this : Primcodable { a // id a < n } := Primcodable.subtype (_ : PrimrecPred fun a => id a < n)
⊢ (Primrec fun a => ↑(f a)) ↔ Primrec f

tactic: rfl
state_before: α : Type u_1
β : Type ?u.358941
γ : Type ?u.358944
σ : Type ?u.358947
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : α → Fin n
this : Primcodable { a // id a < n } := Primcodable.subtype (_ : PrimrecPred fun a => id a < n)
⊢ (Primrec fun a => ↑(f a)) ↔ Primrec fun a => ↑(↑Fin.equivSubtype (f a))
Theorem: CategoryTheory.Discrete.natIso_app
File: Mathlib/CategoryTheory/DiscreteCategory.lean

tactic: aesop_cat
state_before: α : Type u₁
C : Type u₂
inst✝ : Category C
I : Type u₁
F G : Discrete I ⥤ C
f : (i : Discrete I) → F.obj i ≅ G.obj i
i : Discrete I
⊢ (natIso f).app i = f i
Theorem: AdjoinRoot.quotMapOfEquivQuotMapCMapSpanMk_symm_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [quotMapOfEquivQuotMapCMapSpanMk, Ideal.quotEquivOfEq_symm]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
I : Ideal R
f : R[X]
x : AdjoinRoot f
⊢ ↑(RingEquiv.symm (quotMapOfEquivQuotMapCMapSpanMk I f))
      (↑(Ideal.Quotient.mk (Ideal.map (Ideal.Quotient.mk (span {f})) (Ideal.map C I))) x) =
    ↑(Ideal.Quotient.mk (Ideal.map (of f) I)) x

tactic: exact Ideal.quotEquivOfEq_mk _ _
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
I : Ideal R
f : R[X]
x : AdjoinRoot f
⊢ ↑(quotEquivOfEq (_ : Ideal.map (Ideal.Quotient.mk (span {f})) (Ideal.map C I) = Ideal.map (of f) I))
      (↑(Ideal.Quotient.mk (Ideal.map (Ideal.Quotient.mk (span {f})) (Ideal.map C I))) x) =
    ↑(Ideal.Quotient.mk (Ideal.map (of f) I)) x
Theorem: DirectSum.IsInternal.subordinateOrthonormalBasis_subordinate
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: simpa only [DirectSum.IsInternal.subordinateOrthonormalBasis, OrthonormalBasis.coe_reindex,
  DirectSum.IsInternal.subordinateOrthonormalBasisIndex] using
  hV.collectedOrthonormalBasis_mem hV' (fun i => stdOrthonormalBasis 𝕜 (V i))
    ((hV.sigmaOrthonormalBasisIndexEquiv hn hV').symm a)
state_before: ι : Type u_3
ι' : Type ?u.1701933
𝕜 : Type u_1
inst✝¹¹ : IsROrC 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : InnerProductSpace 𝕜 E
E' : Type ?u.1701962
inst✝⁸ : NormedAddCommGroup E'
inst✝⁷ : InnerProductSpace 𝕜 E'
F : Type ?u.1701980
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : InnerProductSpace ℝ F
F' : Type ?u.1702000
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : InnerProductSpace ℝ F'
inst✝² : Fintype ι
v : Set E
A : ι → Submodule 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 E
n : ℕ
hn : finrank 𝕜 E = n
inst✝ : DecidableEq ι
V : ι → Submodule 𝕜 E
hV : IsInternal V
a : Fin n
hV' : OrthogonalFamily 𝕜 (fun i => { x // x ∈ V i }) fun i => subtypeₗᵢ (V i)
⊢ ↑(subordinateOrthonormalBasis hn hV hV') a ∈ V (subordinateOrthonormalBasisIndex hn hV a hV')
Theorem: Finset.weightedVSubOfPoint_filter_of_ne
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [weightedVSubOfPoint_apply, weightedVSubOfPoint_apply, sum_filter_of_ne]
state_before: k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.128800
s₂ : Finset ι₂
w : ι → k
p : ι → P
b : P
pred : ι → Prop
inst✝ : DecidablePred pred
h : ∀ (i : ι), i ∈ s → w i ≠ 0 → pred i
⊢ ↑(weightedVSubOfPoint (filter pred s) p b) w = ↑(weightedVSubOfPoint s p b) w

tactic: intro i hi hne
state_before: k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.128800
s₂ : Finset ι₂
w : ι → k
p : ι → P
b : P
pred : ι → Prop
inst✝ : DecidablePred pred
h : ∀ (i : ι), i ∈ s → w i ≠ 0 → pred i
⊢ ∀ (x : ι), x ∈ s → w x • (p x -ᵥ b) ≠ 0 → pred x

tactic: refine' h i hi _
state_before: k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.128800
s₂ : Finset ι₂
w : ι → k
p : ι → P
b : P
pred : ι → Prop
inst✝ : DecidablePred pred
h : ∀ (i : ι), i ∈ s → w i ≠ 0 → pred i
i : ι
hi : i ∈ s
hne : w i • (p i -ᵥ b) ≠ 0
⊢ pred i

tactic: intro hw
state_before: k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.128800
s₂ : Finset ι₂
w : ι → k
p : ι → P
b : P
pred : ι → Prop
inst✝ : DecidablePred pred
h : ∀ (i : ι), i ∈ s → w i ≠ 0 → pred i
i : ι
hi : i ∈ s
hne : w i • (p i -ᵥ b) ≠ 0
⊢ w i ≠ 0

tactic: simp [hw] at hne
state_before: k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.128800
s₂ : Finset ι₂
w : ι → k
p : ι → P
b : P
pred : ι → Prop
inst✝ : DecidablePred pred
h : ∀ (i : ι), i ∈ s → w i ≠ 0 → pred i
i : ι
hi : i ∈ s
hne : w i • (p i -ᵥ b) ≠ 0
hw : w i = 0
⊢ False
Theorem: MetricSpace.replaceBornology_eq
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: ext
state_before: α✝ : Type u
β : Type v
X : Type ?u.563888
ι : Type ?u.563891
inst✝¹ : PseudoMetricSpace α✝
γ : Type w
inst✝ : MetricSpace γ
α : Type u_1
m : MetricSpace α
B : Bornology α
H : ∀ (s : Set α), IsBounded s ↔ IsBounded s
⊢ replaceBornology m H = m

tactic: rfl
state_before: case h.dist.h.h
α✝ : Type u
β : Type v
X : Type ?u.563888
ι : Type ?u.563891
inst✝¹ : PseudoMetricSpace α✝
γ : Type w
inst✝ : MetricSpace γ
α : Type u_1
m : MetricSpace α
B : Bornology α
H : ∀ (s : Set α), IsBounded s ↔ IsBounded s
x✝¹ x✝ : α
⊢ dist x✝¹ x✝ = dist x✝¹ x✝
Theorem: List.Perm.join
File: Mathlib/Data/List/Perm.lean

tactic: simpa only [join, append_assoc] using perm_append_comm.append_right _
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
l₁ l₂ : List (List α)
h : l₁ ~ l₂
x₁ x₂ : List α
xs : List (List α)
⊢ List.join (x₂ :: x₁ :: xs) ~ List.join (x₁ :: x₂ :: xs)
Theorem: Int.negSucc_emod
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.sub_sub, Int.add_comm]
state_before: m : Nat
b : Int
bpos : 0 < b
⊢ -[m+1] % b = b - 1 - ↑m % b

tactic: match b, eq_succ_of_zero_lt bpos with
| _, ⟨n, rfl⟩ => rfl
state_before: m : Nat
b : Int
bpos : 0 < b
⊢ -[m+1] % b = b - (↑m % b + 1)

tactic: rfl
state_before: m : Nat
b : Int
n : Nat
bpos : 0 < ↑(succ n)
⊢ -[m+1] % ↑(succ n) = ↑(succ n) - (↑m % ↑(succ n) + 1)
Theorem: Fin.snoc_last
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [snoc]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (↑castSucc i)
i : Fin n
y : α (↑castSucc i)
z : α (last n)
⊢ snoc p x (last n) = x
Theorem: Metric.closedBall_diff_ball
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [← ball_union_sphere, Set.union_diff_cancel_left sphere_disjoint_ball.symm.le_bot]
state_before: α : Type u
β : Type v
X : Type ?u.38232
ι : Type ?u.38235
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ closedBall x ε \ ball x ε = sphere x ε