tasksource/leandojo huggingface dataset:
Theorem: aemeasurable_zero_measure
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

tactic: nontriviality α
state_before: ι : Type ?u.311031
α : Type u_1
β : Type u_2
γ : Type ?u.311040
δ : Type ?u.311043
R : Type ?u.311046
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : MeasureTheory.Measure α
⊢ AEMeasurable f

tactic: inhabit α
state_before: ι : Type ?u.311031
α : Type u_1
β : Type u_2
γ : Type ?u.311040
δ : Type ?u.311043
R : Type ?u.311046
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : MeasureTheory.Measure α
✝ : Nontrivial α
⊢ AEMeasurable f

tactic: exact ⟨fun _ => f default, measurable_const, rfl⟩
state_before: ι : Type ?u.311031
α : Type u_1
β : Type u_2
γ : Type ?u.311040
δ : Type ?u.311043
R : Type ?u.311046
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : MeasureTheory.Measure α
✝ : Nontrivial α
inhabited_h : Inhabited α
⊢ AEMeasurable f
Theorem: ClosedEmbedding.sigmaCompactSpace
File: Mathlib/Topology/SubsetProperties.lean

tactic: rw [← preimage_iUnion, iUnion_compactCovering, preimage_univ]
state_before: α : Type u
β : Type v
ι : Type ?u.162597
π : ι → Type ?u.162602
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : SigmaCompactSpace α
e : β → α
he : ClosedEmbedding e
⊢ (⋃ (n : ℕ), (fun n => e ⁻¹' compactCovering α n) n) = univ
Theorem: uniformContinuous_iInf_rng
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: delta UniformContinuous
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
f : α → β
u₁ : UniformSpace α
u₂ : ι → UniformSpace β
h : ∀ (i : ι), UniformContinuous f
⊢ UniformContinuous f

tactic: rwa [iInf_uniformity, tendsto_iInf]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
f : α → β
u₁ : UniformSpace α
u₂ : ι → UniformSpace β
h : ∀ (i : ι), UniformContinuous f
⊢ Tendsto (fun x => (f x.fst, f x.snd)) (𝓤 α) (𝓤 β)
Theorem: circleIntegral.integral_sub_zpow_of_undef
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: rcases eq_or_ne R 0 with (rfl | h0)
state_before: E : Type ?u.619077
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
n : ℤ
c w : ℂ
R : ℝ
hn : n < 0
hw : w ∈ sphere c (Abs.abs R)
⊢ (∮ (z : ℂ) in C(c, R), (z - w) ^ n) = 0

tactic: apply integral_radius_zero
state_before: case inl
E : Type ?u.619077
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
n : ℤ
c w : ℂ
hn : n < 0
hw : w ∈ sphere c (Abs.abs 0)
⊢ (∮ (z : ℂ) in C(c, 0), (z - w) ^ n) = 0

tactic: apply integral_undef
state_before: case inr
E : Type ?u.619077
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
n : ℤ
c w : ℂ
R : ℝ
hn : n < 0
hw : w ∈ sphere c (Abs.abs R)
h0 : R ≠ 0
⊢ (∮ (z : ℂ) in C(c, R), (z - w) ^ n) = 0

tactic: simpa [circleIntegrable_sub_zpow_iff, *, not_or]
state_before: case inr.hf
E : Type ?u.619077
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
n : ℤ
c w : ℂ
R : ℝ
hn : n < 0
hw : w ∈ sphere c (Abs.abs R)
h0 : R ≠ 0
⊢ ¬CircleIntegrable (fun z => (z - w) ^ n) c R
Theorem: Finset.min_eq_top
File: Mathlib/Data/Finset/Lattice.lean

tactic: let ⟨a, ha⟩ := min_of_nonempty H
state_before: F : Type ?u.325221
α : Type u_1
β : Type ?u.325227
γ : Type ?u.325230
ι : Type ?u.325233
κ : Type ?u.325236
inst✝ : LinearOrder α
s : Finset α
h : Finset.min s = ⊤
H : Finset.Nonempty s
⊢ s = ∅

tactic: rw [h] at ha
state_before: F : Type ?u.325221
α : Type u_1
β : Type ?u.325227
γ : Type ?u.325230
ι : Type ?u.325233
κ : Type ?u.325236
inst✝ : LinearOrder α
s : Finset α
h : Finset.min s = ⊤
H : Finset.Nonempty s
a : α
ha : Finset.min s = ↑a
⊢ s = ∅

tactic: cases ha
state_before: F : Type ?u.325221
α : Type u_1
β : Type ?u.325227
γ : Type ?u.325230
ι : Type ?u.325233
κ : Type ?u.325236
inst✝ : LinearOrder α
s : Finset α
h : Finset.min s = ⊤
H : Finset.Nonempty s
a : α
ha : ⊤ = ↑a
⊢ s = ∅
Theorem: SetLike.algebraMap_mem_graded
File: Mathlib/Algebra/DirectSum/Internal.lean

tactic: rw [Algebra.algebraMap_eq_smul_one]
state_before: ι : Type u_1
σ : Type ?u.3281
S : Type u_2
R : Type u_3
inst✝⁴ : Zero ι
inst✝³ : CommSemiring S
inst✝² : Semiring R
inst✝¹ : Algebra S R
A : ι → Submodule S R
inst✝ : GradedOne A
s : S
⊢ ↑(algebraMap S R) s ∈ A 0

tactic: exact (A 0).smul_mem s <| SetLike.one_mem_graded _
state_before: ι : Type u_1
σ : Type ?u.3281
S : Type u_2
R : Type u_3
inst✝⁴ : Zero ι
inst✝³ : CommSemiring S
inst✝² : Semiring R
inst✝¹ : Algebra S R
A : ι → Submodule S R
inst✝ : GradedOne A
s : S
⊢ s • 1 ∈ A 0
Theorem: VectorBundleCore.coordChange_linear_comp
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: ext v
state_before: R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.380014
inst✝⁸ : NontriviallyNormedField R
inst✝⁷ : (x : B) → AddCommMonoid (E x)
inst✝⁶ : (x : B) → Module R (E x)
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace R F
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
i j k : ι
x : B
hx : x ∈ baseSet Z i ∩ baseSet Z j ∩ baseSet Z k
⊢ ContinuousLinearMap.comp (coordChange Z j k x) (coordChange Z i j x) = coordChange Z i k x

tactic: exact Z.coordChange_comp i j k x hx v
state_before: case h
R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.380014
inst✝⁸ : NontriviallyNormedField R
inst✝⁷ : (x : B) → AddCommMonoid (E x)
inst✝⁶ : (x : B) → Module R (E x)
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace R F
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
i j k : ι
x : B
hx : x ∈ baseSet Z i ∩ baseSet Z j ∩ baseSet Z k
v : F
⊢ ↑(ContinuousLinearMap.comp (coordChange Z j k x) (coordChange Z i j x)) v = ↑(coordChange Z i k x) v
Theorem: lowerCentralSeries_nilpotencyClass
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: rw [← lowerCentralSeries_length_eq_nilpotencyClass]
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
hG : Group.IsNilpotent G
⊢ lowerCentralSeries G (nilpotencyClass G) = ⊥

tactic: exact Nat.find_spec (nilpotent_iff_lowerCentralSeries.mp hG)
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
hG : Group.IsNilpotent G
⊢ lowerCentralSeries G (Nat.find (_ : ∃ n, lowerCentralSeries G n = ⊥)) = ⊥
Theorem: Pi.basisFun_det
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: ext M
state_before: R : Type u_1
inst✝⁸ : CommRing R
M : Type ?u.2737751
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type ?u.2738336
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_2
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e : Basis ι R M
A : Type ?u.2739356
inst✝¹ : CommRing A
inst✝ : Module A M
⊢ Basis.det (basisFun R ι) = detRowAlternating

tactic: rw [Basis.det_apply, Basis.coePiBasisFun.toMatrix_eq_transpose, det_transpose]
state_before: case H
R : Type u_1
inst✝⁸ : CommRing R
M✝ : Type ?u.2737751
inst✝⁷ : AddCommGroup M✝
inst✝⁶ : Module R M✝
M' : Type ?u.2738336
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_2
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e : Basis ι R M✝
A : Type ?u.2739356
inst✝¹ : CommRing A
inst✝ : Module A M✝
M : ι → ι → R
⊢ ↑(Basis.det (basisFun R ι)) M = ↑detRowAlternating M
Theorem: Nat.ofDigits_append
File: Mathlib/Data/Nat/Digits.lean

tactic: induction' l1 with hd tl IH
state_before: n b : ℕ
l1 l2 : List ℕ
⊢ ofDigits b (l1 ++ l2) = ofDigits b l1 + b ^ List.length l1 * ofDigits b l2

tactic: simp [ofDigits]
state_before: case nil
n b : ℕ
l2 : List ℕ
⊢ ofDigits b ([] ++ l2) = ofDigits b [] + b ^ List.length [] * ofDigits b l2

tactic: rw [ofDigits, List.cons_append, ofDigits, IH, List.length_cons, pow_succ']
state_before: case cons
n b : ℕ
l2 : List ℕ
hd : ℕ
tl : List ℕ
IH : ofDigits b (tl ++ l2) = ofDigits b tl + b ^ List.length tl * ofDigits b l2
⊢ ofDigits b (hd :: tl ++ l2) = ofDigits b (hd :: tl) + b ^ List.length (hd :: tl) * ofDigits b l2

tactic: ring
state_before: case cons
n b : ℕ
l2 : List ℕ
hd : ℕ
tl : List ℕ
IH : ofDigits b (tl ++ l2) = ofDigits b tl + b ^ List.length tl * ofDigits b l2
⊢ ↑hd + b * (ofDigits b tl + b ^ List.length tl * ofDigits b l2) =
    ↑hd + b * ofDigits b tl + b * b ^ List.length tl * ofDigits b l2
Theorem: Filter.limsSup_bot
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.82848
γ : Type ?u.82851
ι : Type ?u.82854
inst✝ : CompleteLattice α
⊢ ⊥ ∈ {a | ∀ᶠ (n : α) in ⊥, n ≤ a}
Theorem: InnerProductGeometry.norm_div_sin_angle_add_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rcases h0 with (h0 | h0)
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x = 0 ∨ y ≠ 0
⊢ ‖y‖ / Real.sin (angle x (x + y)) = ‖x + y‖

tactic: rw [sin_angle_add_of_inner_eq_zero h (Or.inr h0), div_div_eq_mul_div, mul_comm, div_eq_mul_inv,
  mul_inv_cancel_right₀ (norm_ne_zero_iff.2 h0)]
state_before: case inr
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : y ≠ 0
⊢ ‖y‖ / Real.sin (angle x (x + y)) = ‖x + y‖

tactic: simp [h0]
state_before: case inl
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x = 0
⊢ ‖y‖ / Real.sin (angle x (x + y)) = ‖x + y‖
Theorem: Filter.map_eq_map_iff_of_injOn
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [le_antisymm_iff, map_le_map_iff_of_injOn hsf hsg hm,
  map_le_map_iff_of_injOn hsg hsf hm]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.261626
ι : Sort x
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f g : Filter α
m : α → β
s : Set α
hsf : s ∈ f
hsg : s ∈ g
hm : InjOn m s
⊢ map m f = map m g ↔ f = g
Theorem: Nat.Primrec.swap
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: n : ℕ
⊢ Nat.pair (unpair n).snd (unpair n).fst = unpaired (swap Nat.pair) n
Theorem: coe_lowerClosure
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.126298
γ : Type ?u.126301
ι : Sort ?u.126304
κ : ι → Sort ?u.126309
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
⊢ ↑(lowerClosure s) = ⋃ (a : α) (_ : a ∈ s), Iic a

tactic: simp
state_before: case h
α : Type u_1
β : Type ?u.126298
γ : Type ?u.126301
ι : Sort ?u.126304
κ : ι → Sort ?u.126309
inst✝¹ : Preorder α
inst✝ : Preorder β
s✝ t : Set α
x : α
s : Set α
x✝ : α
⊢ x✝ ∈ ↑(lowerClosure s) ↔ x✝ ∈ ⋃ (a : α) (_ : a ∈ s), Iic a
Theorem: List.card_map_le
File: Mathlib/Data/List/Card.lean

tactic: induction as with
| nil => simp
| cons a as ih =>
  cases Decidable.em (f a ∈ map f as) with
  | inl h =>
    rw [map, card_cons_of_mem h]
    apply Nat.le_trans ih (card_le_card_cons ..)
  | inr h =>
    have : a ∉ as := fun h'' ↦ h (mem_map_of_mem _ h'')
    rw [map, card_cons_of_not_mem h, card_cons_of_not_mem this]
    exact Nat.add_le_add_right ih _
state_before: α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
as : List α
⊢ card (map f as) ≤ card as

tactic: simp
state_before: case nil
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
⊢ card (map f []) ≤ card []

tactic: cases Decidable.em (f a ∈ map f as) with
| inl h =>
  rw [map, card_cons_of_mem h]
  apply Nat.le_trans ih (card_le_card_cons ..)
| inr h =>
  have : a ∉ as := fun h'' ↦ h (mem_map_of_mem _ h'')
  rw [map, card_cons_of_not_mem h, card_cons_of_not_mem this]
  exact Nat.add_le_add_right ih _
state_before: case cons
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
a : α
as : List α
ih : card (map f as) ≤ card as
⊢ card (map f (a :: as)) ≤ card (a :: as)

tactic: rw [map, card_cons_of_mem h]
state_before: case cons.inl
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
a : α
as : List α
ih : card (map f as) ≤ card as
h : f a ∈ map f as
⊢ card (map f (a :: as)) ≤ card (a :: as)

tactic: apply Nat.le_trans ih (card_le_card_cons ..)
state_before: case cons.inl
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
a : α
as : List α
ih : card (map f as) ≤ card as
h : f a ∈ map f as
⊢ card (map f as) ≤ card (a :: as)

tactic: have : a ∉ as := fun h'' ↦ h (mem_map_of_mem _ h'')
state_before: case cons.inr
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
a : α
as : List α
ih : card (map f as) ≤ card as
h : ¬f a ∈ map f as
⊢ card (map f (a :: as)) ≤ card (a :: as)

tactic: rw [map, card_cons_of_not_mem h, card_cons_of_not_mem this]
state_before: case cons.inr
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
a : α
as : List α
ih : card (map f as) ≤ card as
h : ¬f a ∈ map f as
this : ¬a ∈ as
⊢ card (map f (a :: as)) ≤ card (a :: as)

tactic: exact Nat.add_le_add_right ih _
state_before: case cons.inr
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
a : α
as : List α
ih : card (map f as) ≤ card as
h : ¬f a ∈ map f as
this : ¬a ∈ as
⊢ card (map f as) + 1 ≤ card as + 1
Theorem: HomogeneousLocalization.intCast_val
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean

tactic: cases n <;> simp [Int.castDef, zero_val, one_val, *]
state_before: ι : Type u_2
R : Type u_3
A : Type u_1
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
n : ℤ
⊢ val (Int.castDef n) = ↑n
Theorem: List.set_eq_setTR
File: Std/Data/List/Basic.lean

tactic: funext α l n a
state_before: ⊢ @set = @setTR

tactic: simp [setTR]
state_before: case h.h.h.h
α : Type u_1
l : List α
n : Nat
a : α
⊢ set l n a = setTR l n a

tactic: let rec go (acc) : ∀ xs n, l = acc.data ++ xs →
  setTR.go l a xs n acc = acc.data ++ xs.set n a
| [], _ => fun h => by simp [setTR.go, set, h]
| x::xs, 0 => by simp [setTR.go, set]
| x::xs, n+1 => fun h => by simp [setTR.go, set]; rw [go _ xs]; {simp}; simp [h]
state_before: case h.h.h.h
α : Type u_1
l : List α
n : Nat
a : α
⊢ set l n a = setTR.go l a l n #[]

tactic: exact (go #[] _ _ rfl).symm
state_before: case h.h.h.h
α : Type u_1
l : List α
n : Nat
a : α
⊢ set l n a = setTR.go l a l n #[]

tactic: simp [setTR.go, set, h]
state_before: α : Type u_1
l : List α
n : Nat
a : α
acc : Array α
x✝ : Nat
h : l = acc.data ++ []
⊢ setTR.go l a [] x✝ acc = acc.data ++ set [] x✝ a

tactic: simp [setTR.go, set]
state_before: α : Type u_1
l : List α
n : Nat
a : α
acc : Array α
x : α
xs : List α
⊢ l = acc.data ++ x :: xs → setTR.go l a (x :: xs) 0 acc = acc.data ++ set (x :: xs) 0 a

tactic: simp [setTR.go, set]
state_before: α : Type u_1
l : List α
n✝ : Nat
a : α
acc : Array α
x : α
xs : List α
n : Nat
h : l = acc.data ++ x :: xs
⊢ setTR.go l a (x :: xs) (n + 1) acc = acc.data ++ set (x :: xs) (n + 1) a

tactic: rw [go _ xs]
state_before: α : Type u_1
l : List α
n✝ : Nat
a : α
acc : Array α
x : α
xs : List α
n : Nat
h : l = acc.data ++ x :: xs
⊢ setTR.go l a xs n (Array.push acc x) = acc.data ++ x :: set xs n a

tactic: {simp}
state_before: α : Type u_1
l : List α
n✝ : Nat
a : α
acc : Array α
x : α
xs : List α
n : Nat
h : l = acc.data ++ x :: xs
⊢ (Array.push acc x).data ++ set xs n a = acc.data ++ x :: set xs n a

case a
α : Type u_1
l : List α
n✝ : Nat
a : α
acc : Array α
x : α
xs : List α
n : Nat
h : l = acc.data ++ x :: xs
⊢ l = (Array.push acc x).data ++ xs

tactic: simp [h]
state_before: case a
α : Type u_1
l : List α
n✝ : Nat
a : α
acc : Array α
x : α
xs : List α
n : Nat
h : l = acc.data ++ x :: xs
⊢ l = (Array.push acc x).data ++ xs
Theorem: ENNReal.rpow_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases' lt_or_le 0 p with hp_pos hp_nonpos
state_before: p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
⊢ 0 < x ^ p

tactic: exact rpow_pos_of_nonneg hx_pos (le_of_lt hp_pos)
state_before: case inl
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
hp_pos : 0 < p
⊢ 0 < x ^ p

tactic: rw [← neg_neg p, rpow_neg, ENNReal.inv_pos]
state_before: case inr
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
hp_nonpos : p ≤ 0
⊢ 0 < x ^ p

tactic: exact rpow_ne_top_of_nonneg (Right.nonneg_neg_iff.mpr hp_nonpos) hx_ne_top
state_before: case inr
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
hp_nonpos : p ≤ 0
⊢ x ^ (-p) ≠ ⊤
Theorem: exists_lt_of_lt_csSup'
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: contrapose! h
state_before: α : Type u_1
β : Type ?u.82988
γ : Type ?u.82991
ι : Sort ?u.82994
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set α
a : α
h : a < sSup s
⊢ ∃ b, b ∈ s ∧ a < b

tactic: exact csSup_le' h
state_before: α : Type u_1
β : Type ?u.82988
γ : Type ?u.82991
ι : Sort ?u.82994
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set α
a : α
h : ∀ (b : α), b ∈ s → b ≤ a
⊢ sSup s ≤ a
Theorem: Finset.card_le_card_image₂_left
File: Mathlib/Data/Finset/NAry.lean

tactic: obtain ⟨a, ha⟩ := hs
state_before: α : Type u_1
α' : Type ?u.54713
β : Type u_2
β' : Type ?u.54719
γ : Type u_3
γ' : Type ?u.54725
δ : Type ?u.54728
δ' : Type ?u.54731
ε : Type ?u.54734
ε' : Type ?u.54737
ζ : Type ?u.54740
ζ' : Type ?u.54743
ν : Type ?u.54746
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
s : Finset α
hs : Finset.Nonempty s
hf : ∀ (a : α), Injective (f a)
⊢ card t ≤ card (image₂ f s t)

tactic: rw [← card_image₂_singleton_left _ (hf a)]
state_before: case intro
α : Type u_1
α' : Type ?u.54713
β : Type u_2
β' : Type ?u.54719
γ : Type u_3
γ' : Type ?u.54725
δ : Type ?u.54728
δ' : Type ?u.54731
ε : Type ?u.54734
ε' : Type ?u.54737
ζ : Type ?u.54740
ζ' : Type ?u.54743
ν : Type ?u.54746
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t t' : Finset β
u u' : Finset γ
a✝ a' : α
b b' : β
c : γ
s : Finset α
hf : ∀ (a : α), Injective (f a)
a : α
ha : a ∈ s
⊢ card t ≤ card (image₂ f s t)

tactic: exact card_le_of_subset (image₂_subset_right <| singleton_subset_iff.2 ha)
state_before: case intro
α : Type u_1
α' : Type ?u.54713
β : Type u_2
β' : Type ?u.54719
γ : Type u_3
γ' : Type ?u.54725
δ : Type ?u.54728
δ' : Type ?u.54731
ε : Type ?u.54734
ε' : Type ?u.54737
ζ : Type ?u.54740
ζ' : Type ?u.54743
ν : Type ?u.54746
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t t' : Finset β
u u' : Finset γ
a✝ a' : α
b b' : β
c : γ
s : Finset α
hf : ∀ (a : α), Injective (f a)
a : α
ha : a ∈ s
⊢ card (image₂ f {a} t) ≤ card (image₂ f s t)
Theorem: Filter.map₂_left
File: Mathlib/Order/Filter/NAry.lean

tactic: ext u
state_before: α : Type u_2
α' : Type ?u.30077
β : Type u_1
β' : Type ?u.30083
γ : Type ?u.30086
γ' : Type ?u.30089
δ : Type ?u.30092
δ' : Type ?u.30095
ε : Type ?u.30098
ε' : Type ?u.30101
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h✝ h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
h : NeBot g
⊢ map₂ (fun x x_1 => x) f g = f

tactic: refine' ⟨_, fun hu => ⟨_, _, hu, univ_mem, (image2_left <| h.nonempty_of_mem univ_mem).subset⟩⟩
state_before: case a
α : Type u_2
α' : Type ?u.30077
β : Type u_1
β' : Type ?u.30083
γ : Type ?u.30086
γ' : Type ?u.30089
δ : Type ?u.30092
δ' : Type ?u.30095
ε : Type ?u.30098
ε' : Type ?u.30101
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h✝ h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u✝ : Set γ
v : Set δ
a : α
b : β
c : γ
h : NeBot g
u : Set α
⊢ u ∈ map₂ (fun x x_1 => x) f g ↔ u ∈ f

tactic: rintro ⟨s, t, hs, ht, hu⟩
state_before: case a
α : Type u_2
α' : Type ?u.30077
β : Type u_1
β' : Type ?u.30083
γ : Type ?u.30086
γ' : Type ?u.30089
δ : Type ?u.30092
δ' : Type ?u.30095
ε : Type ?u.30098
ε' : Type ?u.30101
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h✝ h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u✝ : Set γ
v : Set δ
a : α
b : β
c : γ
h : NeBot g
u : Set α
⊢ u ∈ map₂ (fun x x_1 => x) f g → u ∈ f

tactic: rw [image2_left (h.nonempty_of_mem ht)] at hu
state_before: case a.intro.intro.intro.intro
α : Type u_2
α' : Type ?u.30077
β : Type u_1
β' : Type ?u.30083
γ : Type ?u.30086
γ' : Type ?u.30089
δ : Type ?u.30092
δ' : Type ?u.30095
ε : Type ?u.30098
ε' : Type ?u.30101
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h✝ h₁ h₂ : Filter γ
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
u✝ : Set γ
v : Set δ
a : α
b : β
c : γ
h : NeBot g
u s : Set α
t : Set β
hs : s ∈ f
ht : t ∈ g
hu : image2 (fun x x_1 => x) s t ⊆ u
⊢ u ∈ f

tactic: exact mem_of_superset hs hu
state_before: case a.intro.intro.intro.intro
α : Type u_2
α' : Type ?u.30077
β : Type u_1
β' : Type ?u.30083
γ : Type ?u.30086
γ' : Type ?u.30089
δ : Type ?u.30092
δ' : Type ?u.30095
ε : Type ?u.30098
ε' : Type ?u.30101
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h✝ h₁ h₂ : Filter γ
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
u✝ : Set γ
v : Set δ
a : α
b : β
c : γ
h : NeBot g
u s : Set α
t : Set β
hs : s ∈ f
ht : t ∈ g
hu : s ⊆ u
⊢ u ∈ f
Theorem: CategoryTheory.Limits.kernel_map_comp_kernelSubobjectIso_inv
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: aesop_cat
state_before: C : Type u
inst✝³ : Category C
X Y Z : C
inst✝² : HasZeroMorphisms C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
sq : Arrow.mk f ⟶ Arrow.mk f'
⊢ kernel.map f f' sq.left sq.right (_ : (Arrow.mk f).hom ≫ (𝟭 C).map sq.right = (𝟭 C).map sq.left ≫ (Arrow.mk f').hom) ≫
      (kernelSubobjectIso f').inv =
    (kernelSubobjectIso f).inv ≫ kernelSubobjectMap sq
Theorem: Set.inv_subset
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [← inv_subset_inv, inv_inv]
state_before: F : Type ?u.6517
α : Type u_1
β : Type ?u.6523
γ : Type ?u.6526
inst✝ : InvolutiveInv α
s t : Set α
a : α
⊢ s⁻¹ ⊆ t ↔ s ⊆ t⁻¹