tasksource/leandojo huggingface dataset:
Theorem: measurable_liminf'
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: simp_rw [hu.toHasBasis.liminf_eq_iSup_iInf]
state_before: α : Type u_4
β : Type ?u.1636243
γ : Type ?u.1636246
γ₂ : Type ?u.1636249
δ : Type u_3
ι✝ : Sort y
s✝ t u✝ : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
ι' : Type u_2
f : ι → δ → α
u : Filter ι
hf : ∀ (i : ι), Measurable (f i)
p : ι' → Prop
s : ι' → Set ι
hu : HasCountableBasis u p s
hs : ∀ (i : ι'), Set.Countable (s i)
⊢ Measurable fun x => liminf (fun i => f i x) u

tactic: refine' measurable_biSup _ hu.countable _
state_before: α : Type u_4
β : Type ?u.1636243
γ : Type ?u.1636246
γ₂ : Type ?u.1636249
δ : Type u_3
ι✝ : Sort y
s✝ t u✝ : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
ι' : Type u_2
f : ι → δ → α
u : Filter ι
hf : ∀ (i : ι), Measurable (f i)
p : ι' → Prop
s : ι' → Set ι
hu : HasCountableBasis u p s
hs : ∀ (i : ι'), Set.Countable (s i)
⊢ Measurable fun x => ⨆ (i : ι') (_ : p i), ⨅ (a : ι) (_ : a ∈ s i), f a x

tactic: exact fun i => measurable_biInf _ (hs i) hf
state_before: α : Type u_4
β : Type ?u.1636243
γ : Type ?u.1636246
γ₂ : Type ?u.1636249
δ : Type u_3
ι✝ : Sort y
s✝ t u✝ : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
ι' : Type u_2
f : ι → δ → α
u : Filter ι
hf : ∀ (i : ι), Measurable (f i)
p : ι' → Prop
s : ι' → Set ι
hu : HasCountableBasis u p s
hs : ∀ (i : ι'), Set.Countable (s i)
⊢ ∀ (i : ι'), Measurable fun x => ⨅ (a : ι) (_ : a ∈ s i), f a x
Theorem: IsROrC.norm_coe_norm
File: Mathlib/Analysis/NormedSpace/IsROrC.lean

tactic: simp
state_before: 𝕜 : Type u_1
inst✝¹ : IsROrC 𝕜
E : Type u_2
inst✝ : NormedAddCommGroup E
z : E
⊢ ‖↑‖z‖‖ = ‖z‖
Theorem: Filter.tendsto_iSup
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Tendsto, map_iSup, iSup_le_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.316422
ι : Sort x
f : α → β
x : ι → Filter α
y : Filter β
⊢ Tendsto f (⨆ (i : ι), x i) y ↔ ∀ (i : ι), Tendsto f (x i) y
Theorem: Set.univ_pi_nonempty_iff
File: Mathlib/Data/Set/Prod.lean

tactic: simp [Classical.skolem, Set.Nonempty]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.119820
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ Set.Nonempty (pi univ t) ↔ ∀ (i : ι), Set.Nonempty (t i)
Theorem: LieAlgebra.Orthogonal.soIndefiniteEquiv_apply
File: Mathlib/Algebra/Lie/Classical.lean

tactic: rw [soIndefiniteEquiv, LieEquiv.trans_apply, LieEquiv.ofEq_apply,
  skewAdjointMatricesLieSubalgebraEquiv_apply]
state_before: n : Type ?u.71302
p : Type u_1
q : Type u_2
l : Type ?u.71311
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
A : { x // x ∈ so' p q R }
⊢ ↑(↑(soIndefiniteEquiv p q R hi) A) = (Pso p q R i)⁻¹ ⬝ ↑A ⬝ Pso p q R i
Theorem: Polynomial.scaleRoots_ne_zero
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

tactic: intro h
state_before: A : Type ?u.25744
K : Type ?u.25747
R : Type u_1
S : Type ?u.25753
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : R[X]
hp : p ≠ 0
s : R
⊢ scaleRoots p s ≠ 0

tactic: have : p.coeff p.natDegree ≠ 0 := mt leadingCoeff_eq_zero.mp hp
state_before: A : Type ?u.25744
K : Type ?u.25747
R : Type u_1
S : Type ?u.25753
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : R[X]
hp : p ≠ 0
s : R
h : scaleRoots p s = 0
⊢ False

tactic: have : (scaleRoots p s).coeff p.natDegree = 0 :=
  congr_fun (congr_arg (coeff : R[X] → ℕ → R) h) p.natDegree
state_before: A : Type ?u.25744
K : Type ?u.25747
R : Type u_1
S : Type ?u.25753
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : R[X]
hp : p ≠ 0
s : R
h : scaleRoots p s = 0
this : coeff p (natDegree p) ≠ 0
⊢ False

tactic: rw [coeff_scaleRoots_natDegree] at this
state_before: A : Type ?u.25744
K : Type ?u.25747
R : Type u_1
S : Type ?u.25753
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : R[X]
hp : p ≠ 0
s : R
h : scaleRoots p s = 0
this✝ : coeff p (natDegree p) ≠ 0
this : coeff (scaleRoots p s) (natDegree p) = 0
⊢ False

tactic: contradiction
state_before: A : Type ?u.25744
K : Type ?u.25747
R : Type u_1
S : Type ?u.25753
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : R[X]
hp : p ≠ 0
s : R
h : scaleRoots p s = 0
this✝ : coeff p (natDegree p) ≠ 0
this : leadingCoeff p = 0
⊢ False
Theorem: contDiffOn_top
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp only [le_top, forall_prop_of_true]
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
⊢ (∀ (m : ℕ), ↑m ≤ ⊤ → ContDiffOn 𝕜 (↑m) f s) ↔ ∀ (n : ℕ), ContDiffOn 𝕜 (↑n) f s
Theorem: Codisjoint.himp_inf_cancel_right
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [himp_inf_distrib, himp_self, top_inf_eq, h.himp_eq_left]
state_before: ι : Type ?u.74181
α : Type u_1
β : Type ?u.74187
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
h : Codisjoint a b
⊢ a ⇨ a ⊓ b = b
Theorem: Ordnode.balanceR_eq_balance'
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [← dual_dual (balanceR l x r), dual_balanceR,
  balanceL_eq_balance' hr.dual hl.dual sr.dual sl.dual (balance_sz_dual H), ← dual_balance',
  dual_dual]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : Balanced l
hr : Balanced r
sl : Sized l
sr : Sized r
H : (∃ l', Raised (size l) l' ∧ BalancedSz l' (size r)) ∨ ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r'
⊢ balanceR l x r = balance' l x r
Theorem: CategoryTheory.rightUnitor_inv_braiding
File: Mathlib/CategoryTheory/Monoidal/Braided.lean

tactic: apply (cancel_mono (λ_ X).hom).1
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (ρ_ X).inv ≫ (β_ X (𝟙_ C)).hom = (λ_ X).inv

tactic: simp only [assoc, braiding_leftUnitor, Iso.inv_hom_id]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ ((ρ_ X).inv ≫ (β_ X (𝟙_ C)).hom) ≫ (λ_ X).hom = (λ_ X).inv ≫ (λ_ X).hom
Theorem: LocallyConstant.comap_id
File: Mathlib/Topology/LocallyConstant/Basic.lean

tactic: ext
state_before: X : Type u_1
Y : Type ?u.32577
Z : Type u_2
α : Type ?u.32583
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
⊢ comap id = id

tactic: simp only [continuous_id, id.def, Function.comp.right_id, coe_comap]
state_before: case h.h
X : Type u_1
Y : Type ?u.32577
Z : Type u_2
α : Type ?u.32583
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝¹ : LocallyConstant X Z
x✝ : X
⊢ ↑(comap id x✝¹) x✝ = ↑(id x✝¹) x✝
Theorem: continuousSMul_induced
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: let _ : TopologicalSpace M₁ := t.induced f
state_before: ι : Type ?u.48066
R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M₁
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₁
inst✝¹ : Module R M₂
u : TopologicalSpace R
t : TopologicalSpace M₂
inst✝ : ContinuousSMul R M₂
f : M₁ →ₗ[R] M₂
⊢ ContinuousSMul R M₁

tactic: refine' ⟨continuous_induced_rng.2 _⟩
state_before: ι : Type ?u.48066
R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M₁
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₁
inst✝¹ : Module R M₂
u : TopologicalSpace R
t : TopologicalSpace M₂
inst✝ : ContinuousSMul R M₂
f : M₁ →ₗ[R] M₂
x✝ : TopologicalSpace M₁ := TopologicalSpace.induced (↑f) t
⊢ ContinuousSMul R M₁

tactic: simp_rw [Function.comp, f.map_smul]
state_before: ι : Type ?u.48066
R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M₁
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₁
inst✝¹ : Module R M₂
u : TopologicalSpace R
t : TopologicalSpace M₂
inst✝ : ContinuousSMul R M₂
f : M₁ →ₗ[R] M₂
x✝ : TopologicalSpace M₁ := TopologicalSpace.induced (↑f) t
⊢ Continuous (↑f ∘ fun p => p.fst • p.snd)

tactic: exact continuous_fst.smul (continuous_induced_dom.comp continuous_snd)
state_before: ι : Type ?u.48066
R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M₁
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₁
inst✝¹ : Module R M₂
u : TopologicalSpace R
t : TopologicalSpace M₂
inst✝ : ContinuousSMul R M₂
f : M₁ →ₗ[R] M₂
x✝ : TopologicalSpace M₁ := TopologicalSpace.induced (↑f) t
⊢ Continuous fun x => x.fst • ↑f x.snd
Theorem: iteratedDerivWithin_one
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: simp only [iteratedDerivWithin, iteratedFDerivWithin_one_apply h]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.32314
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
h : UniqueDiffWithinAt 𝕜 s x
⊢ iteratedDerivWithin 1 f s x = derivWithin f s x

tactic: rfl
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.32314
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
h : UniqueDiffWithinAt 𝕜 s x
⊢ ↑(fderivWithin 𝕜 f s x) 1 = derivWithin f s x
Theorem: Finset.sum_multiset_singleton
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp only [sum_eq_multiset_sum, Multiset.sum_map_singleton]
state_before: ι : Type ?u.92407
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
s : Finset α
⊢ ∑ x in s, {x} = s.val
Theorem: nhdsContainBoxes_of_compact
File: Mathlib/Topology/SubsetProperties.lean

tactic: simpa
state_before: α : Type u
β : Type v
ι : Type ?u.58082
π : ι → Type ?u.58087
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t✝ s : Set α
hs : IsCompact s
t : Set β
H : ∀ (x : α), x ∈ s → NhdsContainBoxes {x} t
n : Set (α × β)
hn : IsOpen n
hp : s ×ˢ t ⊆ n
x✝ : ↑s
x : α
hx : x ∈ s
⊢ {x} ⊆ s

tactic: simpa using (h ⟨x, hx⟩).2.2.1
state_before: α : Type u
β : Type v
ι : Type ?u.58082
π : ι → Type ?u.58087
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t✝ s : Set α
hs : IsCompact s
t : Set β
H : ∀ (x : α), x ∈ s → NhdsContainBoxes {x} t
n : Set (α × β)
hn : IsOpen n
hp : s ×ˢ t ⊆ n
this : ∀ (x : ↑s), ∃ uv, IsOpen uv.fst ∧ IsOpen uv.snd ∧ {↑x} ⊆ uv.fst ∧ t ⊆ uv.snd ∧ uv.fst ×ˢ uv.snd ⊆ n
uvs : ↑s → Set α × Set β
h :
  ∀ (x : ↑s),
    IsOpen (uvs x).fst ∧ IsOpen (uvs x).snd ∧ {↑x} ⊆ (uvs x).fst ∧ t ⊆ (uvs x).snd ∧ (uvs x).fst ×ˢ (uvs x).snd ⊆ n
x : α
hx : x ∈ s
⊢ x ∈ (uvs { val := x, property := hx }).fst

tactic: simpa using hx'
state_before: α : Type u
β : Type v
ι : Type ?u.58082
π : ι → Type ?u.58087
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s✝ t✝ s : Set α
hs : IsCompact s
t : Set β
H : ∀ (x : α), x ∈ s → NhdsContainBoxes {x} t
n : Set (α × β)
hn : IsOpen n
hp : s ×ˢ t ⊆ n
this✝² : ∀ (x : ↑s), ∃ uv, IsOpen uv.fst ∧ IsOpen uv.snd ∧ {↑x} ⊆ uv.fst ∧ t ⊆ uv.snd ∧ uv.fst ×ˢ uv.snd ⊆ n
uvs : ↑s → Set α × Set β
h :
  ∀ (x : ↑s),
    IsOpen (uvs x).fst ∧ IsOpen (uvs x).snd ∧ {↑x} ⊆ (uvs x).fst ∧ t ⊆ (uvs x).snd ∧ (uvs x).fst ×ˢ (uvs x).snd ⊆ n
us_cover : s ⊆ ⋃ (i : ↑s), (uvs i).fst
s0 : Finset ↑s
s0_cover : s ⊆ ⋃ (i : ↑s) (_ : i ∈ s0), (uvs i).fst
u : Set α := ⋃ (i : ↑s) (_ : i ∈ s0), (uvs i).fst
v : Set β := ⋂ (i : ↑s) (_ : i ∈ s0), (uvs i).snd
this✝¹ : IsOpen u
this✝ : IsOpen v
this : t ⊆ v
x✝¹ : α × β
x' : α
y' : β
x✝ : (x', y') ∈ u ×ˢ v
hx' : (x', y').fst ∈ u
hy' : (x', y').snd ∈ v
⊢ ∃ i, i ∈ s0 ∧ x' ∈ (uvs i).fst
Theorem: Quiver.Path.eq_of_length_zero
File: Mathlib/Combinatorics/Quiver/Path.lean

tactic: cases p
state_before: V : Type u
inst✝ : Quiver V
a b c d : V
p : Path a b
hzero : length p = 0
⊢ a = b

tactic: rfl
state_before: case nil
V : Type u
inst✝ : Quiver V
a c d : V
hzero : length nil = 0
⊢ a = a

tactic: cases Nat.succ_ne_zero _ hzero
state_before: case cons
V : Type u
inst✝ : Quiver V
a b c d b✝ : V
a✝¹ : Path a b✝
a✝ : b✝ ⟶ b
hzero : length (cons a✝¹ a✝) = 0
⊢ a = b
Theorem: Fin.castLE_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: simp [eq_iff_veq]
state_before: n✝ m✝ n m : ℕ
h : Nat.succ n ≤ Nat.succ m
⊢ ↑(castLE h) 0 = 0
Theorem: Part.Fix.exists_fix_le_approx
File: Mathlib/Control/LawfulFix.lean

tactic: by_cases hh : ∃ i b, b ∈ approx f i x
state_before: α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
⊢ ∃ i, Part.fix (↑f) x ≤ approx (↑f) i x

tactic: rcases hh with ⟨i, b, hb⟩
state_before: case pos
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
hh : ∃ i b, b ∈ approx (↑f) i x
⊢ ∃ i, Part.fix (↑f) x ≤ approx (↑f) i x

tactic: exists i
state_before: case pos.intro.intro
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
i : ℕ
b : β x
hb : b ∈ approx (↑f) i x
⊢ ∃ i, Part.fix (↑f) x ≤ approx (↑f) i x

tactic: intro b' h'
state_before: case pos.intro.intro
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
i : ℕ
b : β x
hb : b ∈ approx (↑f) i x
⊢ Part.fix (↑f) x ≤ approx (↑f) i x

tactic: have hb' := approx_le_fix f i _ _ hb
state_before: case pos.intro.intro
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
i : ℕ
b : β x
hb : b ∈ approx (↑f) i x
b' : β x
h' : b' ∈ Part.fix (↑f) x
⊢ b' ∈ approx (↑f) i x

tactic: obtain rfl := Part.mem_unique h' hb'
state_before: case pos.intro.intro
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
i : ℕ
b : β x
hb : b ∈ approx (↑f) i x
b' : β x
h' : b' ∈ Part.fix (↑f) x
hb' : b ∈ Part.fix (↑f) x
⊢ b' ∈ approx (↑f) i x

tactic: exact hb
state_before: case pos.intro.intro
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
i : ℕ
b' : β x
h' : b' ∈ Part.fix (↑f) x
hb : b' ∈ approx (↑f) i x
hb' : b' ∈ Part.fix (↑f) x
⊢ b' ∈ approx (↑f) i x

tactic: simp only [not_exists] at hh
state_before: case neg
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
hh : ¬∃ i b, b ∈ approx (↑f) i x
⊢ ∃ i, Part.fix (↑f) x ≤ approx (↑f) i x

tactic: exists 0
state_before: case neg
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
hh : ∀ (x_1 : ℕ) (x_2 : β x), ¬x_2 ∈ approx (↑f) x_1 x
⊢ ∃ i, Part.fix (↑f) x ≤ approx (↑f) i x

tactic: intro b' h'
state_before: case neg
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
hh : ∀ (x_1 : ℕ) (x_2 : β x), ¬x_2 ∈ approx (↑f) x_1 x
⊢ Part.fix (↑f) x ≤ approx (↑f) 0 x

tactic: simp only [mem_iff f] at h'
state_before: case neg
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
hh : ∀ (x_1 : ℕ) (x_2 : β x), ¬x_2 ∈ approx (↑f) x_1 x
b' : β x
h' : b' ∈ Part.fix (↑f) x
⊢ b' ∈ approx (↑f) 0 x

tactic: cases' h' with i h'
state_before: case neg
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
hh : ∀ (x_1 : ℕ) (x_2 : β x), ¬x_2 ∈ approx (↑f) x_1 x
b' : β x
h' : ∃ i, b' ∈ approx (↑f) i x
⊢ b' ∈ approx (↑f) 0 x

tactic: cases hh _ _ h'
state_before: case neg.intro
α : Type u_2
β : α → Type u_1
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : α
hh : ∀ (x_1 : ℕ) (x_2 : β x), ¬x_2 ∈ approx (↑f) x_1 x
b' : β x
i : ℕ
h' : b' ∈ approx (↑f) i x
⊢ b' ∈ approx (↑f) 0 x
Theorem: Relation.ReflTransGen.trans_induction_on
File: Mathlib/Logic/Relation.lean

tactic: induction h
state_before: α : Type u_1
β : Type ?u.17364
γ : Type ?u.17367
δ : Type ?u.17370
r : α → α → Prop
a✝ b✝ c d : α
P : {a b : α} → ReflTransGen r a b → Prop
a b : α
h : ReflTransGen r a b
ih₁ : ∀ (a : α), P (_ : ReflTransGen r a a)
ih₂ : ∀ {a b : α} (h : r a b), P (_ : ReflTransGen r a b)
ih₃ : ∀ {a b c : α} (h₁ : ReflTransGen r a b) (h₂ : ReflTransGen r b c), P h₁ → P h₂ → P (_ : ReflTransGen r a c)
⊢ P h

tactic: case refl => exact ih₁ a
state_before: case refl
α : Type u_1
β : Type ?u.17364
γ : Type ?u.17367
δ : Type ?u.17370
r : α → α → Prop
a✝ b✝ c d : α
P : {a b : α} → ReflTransGen r a b → Prop
a b : α
ih₁ : ∀ (a : α), P (_ : ReflTransGen r a a)
ih₂ : ∀ {a b : α} (h : r a b), P (_ : ReflTransGen r a b)
ih₃ : ∀ {a b c : α} (h₁ : ReflTransGen r a b) (h₂ : ReflTransGen r b c), P h₁ → P h₂ → P (_ : ReflTransGen r a c)
⊢ P (_ : ReflTransGen r a a)

case tail
α : Type u_1
β : Type ?u.17364
γ : Type ?u.17367
δ : Type ?u.17370
r : α → α → Prop
a✝² b✝¹ c d : α
P : {a b : α} → ReflTransGen r a b → Prop
a b : α
ih₁ : ∀ (a : α), P (_ : ReflTransGen r a a)
ih₂ : ∀ {a b : α} (h : r a b), P (_ : ReflTransGen r a b)
ih₃ : ∀ {a b c : α} (h₁ : ReflTransGen r a b) (h₂ : ReflTransGen r b c), P h₁ → P h₂ → P (_ : ReflTransGen r a c)
b✝ c✝ : α
a✝¹ : ReflTransGen r a b✝
a✝ : r b✝ c✝
a_ih✝ : P a✝¹
⊢ P (_ : ReflTransGen r a c✝)

tactic: case tail b c hab hbc ih => exact ih₃ hab (single hbc) ih (ih₂ hbc)
state_before: case tail
α : Type u_1
β : Type ?u.17364
γ : Type ?u.17367
δ : Type ?u.17370
r : α → α → Prop
a✝² b✝¹ c d : α
P : {a b : α} → ReflTransGen r a b → Prop
a b : α
ih₁ : ∀ (a : α), P (_ : ReflTransGen r a a)
ih₂ : ∀ {a b : α} (h : r a b), P (_ : ReflTransGen r a b)
ih₃ : ∀ {a b c : α} (h₁ : ReflTransGen r a b) (h₂ : ReflTransGen r b c), P h₁ → P h₂ → P (_ : ReflTransGen r a c)
b✝ c✝ : α
a✝¹ : ReflTransGen r a b✝
a✝ : r b✝ c✝
a_ih✝ : P a✝¹
⊢ P (_ : ReflTransGen r a c✝)

tactic: exact ih₁ a
state_before: α : Type u_1
β : Type ?u.17364
γ : Type ?u.17367
δ : Type ?u.17370
r : α → α → Prop
a✝ b✝ c d : α
P : {a b : α} → ReflTransGen r a b → Prop
a b : α
ih₁ : ∀ (a : α), P (_ : ReflTransGen r a a)
ih₂ : ∀ {a b : α} (h : r a b), P (_ : ReflTransGen r a b)
ih₃ : ∀ {a b c : α} (h₁ : ReflTransGen r a b) (h₂ : ReflTransGen r b c), P h₁ → P h₂ → P (_ : ReflTransGen r a c)
⊢ P (_ : ReflTransGen r a a)

tactic: exact ih₃ hab (single hbc) ih (ih₂ hbc)
state_before: α : Type u_1
β : Type ?u.17364
γ : Type ?u.17367
δ : Type ?u.17370
r : α → α → Prop
a✝ b✝¹ c✝ d : α
P : {a b : α} → ReflTransGen r a b → Prop
a b✝ : α
ih₁ : ∀ (a : α), P (_ : ReflTransGen r a a)
ih₂ : ∀ {a b : α} (h : r a b), P (_ : ReflTransGen r a b)
ih₃ : ∀ {a b c : α} (h₁ : ReflTransGen r a b) (h₂ : ReflTransGen r b c), P h₁ → P h₂ → P (_ : ReflTransGen r a c)
b c : α
hab : ReflTransGen r a b
hbc : r b c
ih : P hab
⊢ P (_ : ReflTransGen r a c)
Theorem: CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_hom_π
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

tactic: dsimp [limitObjIsoLimitCompEvaluation]
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : HasLimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (limitObjIsoLimitCompEvaluation F k).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j = (limit.π F j).app k

tactic: simp
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : HasLimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (preservesLimitIso ((evaluation K C).obj k) F).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j = (limit.π F j).app k
Theorem: Nat.eq_zero_or_eq_succ_pred
File: Std/Data/Nat/Lemmas.lean

tactic: cases n <;> simp
state_before: n : Nat
⊢ n = 0 ∨ n = succ (pred n)
Theorem: List.reverseAux_reverseAux_nil
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as generalizing bs with
| nil => rfl
| cons a as ih => simp [reverseAux, ih]
state_before: α : Type u
β : Type v
γ : Type w
as bs : List α
⊢ reverseAux (reverseAux as bs) nil = reverseAux bs as

tactic: rfl
state_before: case nil
α : Type u
β : Type v
γ : Type w
bs : List α
⊢ reverseAux (reverseAux nil bs) nil = reverseAux bs nil

tactic: simp [reverseAux, ih]
state_before: case cons
α : Type u
β : Type v
γ : Type w
a : α
as : List α
ih : ∀ (bs : List α), reverseAux (reverseAux as bs) nil = reverseAux bs as
bs : List α
⊢ reverseAux (reverseAux (a :: as) bs) nil = reverseAux bs (a :: as)
Theorem: IsUnit.mul_div_cancel
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [div_eq_mul_inv, h.mul_inv_cancel_right]
state_before: F : Type ?u.53935
G : Type ?u.53938
α : Type u_1
M : Type ?u.53944
N : Type ?u.53947
inst✝ : DivisionMonoid α
a✝ b c : α
h : IsUnit b
a : α
⊢ a * b / b = a
Theorem: CategoryTheory.Limits.limit_obj_ext
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

tactic: apply (cancel_mono (limitObjIsoLimitCompEvaluation H k).hom).1
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
⊢ f = g

tactic: ext j
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
⊢ f ≫ (limitObjIsoLimitCompEvaluation H k).hom = g ≫ (limitObjIsoLimitCompEvaluation H k).hom

tactic: simpa using w j
state_before: case w
C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
j : J
⊢ (f ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j =
    (g ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j
Theorem: List.filterMap_cons_some
File: Std/Data/List/Lemmas.lean

tactic: simp only [filterMap, h]
state_before: α : Type u_1
β : Type u_2
f : α → Option β
a : α
l : List α
b : β
h : f a = some b
⊢ filterMap f (a :: l) = b :: filterMap f l
Theorem: Filter.eventually_imp_distrib_right
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [imp_iff_not_or, eventually_or_distrib_right, not_frequently]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.169127
ι : Sort x
f : Filter α
p : α → Prop
q : Prop
⊢ (∀ᶠ (x : α) in f, p x → q) ↔ (∃ᶠ (x : α) in f, p x) → q