tasksource/leandojo huggingface dataset:
Theorem: Metric.exists_continuous_nNReal_forall_closedBall_subset
File: Mathlib/Topology/MetricSpace/PartitionOfUnity.lean

tactic: rcases EMetric.exists_continuous_nNReal_forall_closedBall_subset hK hU hKU hfin with ⟨δ, hδ0, hδ⟩
state_before: ι : Type u_2
X : Type u_1
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
⊢ ∃ δ, (∀ (x : X), 0 < ↑δ x) ∧ ∀ (i : ι) (x : X), x ∈ K i → closedBall x ↑(↑δ x) ⊆ U i

tactic: refine' ⟨δ, hδ0, fun i x hx => _⟩
state_before: case intro.intro
ι : Type u_2
X : Type u_1
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ0 : ∀ (x : X), 0 < ↑δ x
hδ : ∀ (i : ι) (x : X), x ∈ K i → EMetric.closedBall x ↑(↑δ x) ⊆ U i
⊢ ∃ δ, (∀ (x : X), 0 < ↑δ x) ∧ ∀ (i : ι) (x : X), x ∈ K i → closedBall x ↑(↑δ x) ⊆ U i

tactic: rw [← emetric_closedBall_nnreal]
state_before: case intro.intro
ι : Type u_2
X : Type u_1
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ0 : ∀ (x : X), 0 < ↑δ x
hδ : ∀ (i : ι) (x : X), x ∈ K i → EMetric.closedBall x ↑(↑δ x) ⊆ U i
i : ι
x : X
hx : x ∈ K i
⊢ closedBall x ↑(↑δ x) ⊆ U i

tactic: exact hδ i x hx
state_before: case intro.intro
ι : Type u_2
X : Type u_1
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ0 : ∀ (x : X), 0 < ↑δ x
hδ : ∀ (i : ι) (x : X), x ∈ K i → EMetric.closedBall x ↑(↑δ x) ⊆ U i
i : ι
x : X
hx : x ∈ K i
⊢ EMetric.closedBall x ↑(↑δ x) ⊆ U i
Theorem: MeasureTheory.VectorMeasure.AbsolutelyContinuous.sub
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: intro s hs
state_before: α : Type u_2
β : Type ?u.632866
m : MeasurableSpace α
L : Type ?u.632872
M✝ : Type ?u.632875
N : Type u_3
inst✝⁸ : AddCommMonoid L
inst✝⁷ : TopologicalSpace L
inst✝⁶ : AddCommMonoid M✝
inst✝⁵ : TopologicalSpace M✝
inst✝⁴ : AddCommMonoid N
inst✝³ : TopologicalSpace N
v : VectorMeasure α M✝
w✝ : VectorMeasure α N
M : Type u_1
inst✝² : AddCommGroup M
inst✝¹ : TopologicalSpace M
inst✝ : TopologicalAddGroup M
v₁ v₂ : VectorMeasure α M
w : VectorMeasure α N
hv₁ : v₁ ≪ᵥ w
hv₂ : v₂ ≪ᵥ w
⊢ v₁ - v₂ ≪ᵥ w

tactic: rw [sub_apply, hv₁ hs, hv₂ hs, zero_sub, neg_zero]
state_before: α : Type u_2
β : Type ?u.632866
m : MeasurableSpace α
L : Type ?u.632872
M✝ : Type ?u.632875
N : Type u_3
inst✝⁸ : AddCommMonoid L
inst✝⁷ : TopologicalSpace L
inst✝⁶ : AddCommMonoid M✝
inst✝⁵ : TopologicalSpace M✝
inst✝⁴ : AddCommMonoid N
inst✝³ : TopologicalSpace N
v : VectorMeasure α M✝
w✝ : VectorMeasure α N
M : Type u_1
inst✝² : AddCommGroup M
inst✝¹ : TopologicalSpace M
inst✝ : TopologicalAddGroup M
v₁ v₂ : VectorMeasure α M
w : VectorMeasure α N
hv₁ : v₁ ≪ᵥ w
hv₂ : v₂ ≪ᵥ w
s : Set α
hs : ↑w s = 0
⊢ ↑(v₁ - v₂) s = 0
Theorem: LinearOrderedField.coe_lt_inducedMap_iff
File: Mathlib/Algebra/Order/CompleteField.lean

tactic: refine ⟨fun h => ?_, fun hq => ?_⟩
state_before: F : Type ?u.20995
α : Type u_2
β : Type u_1
γ : Type ?u.21004
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
⊢ ↑q < inducedMap α β a ↔ ↑q < a

tactic: rw [← inducedMap_rat α] at h
state_before: case refine_1
F : Type ?u.20995
α : Type u_2
β : Type u_1
γ : Type ?u.21004
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
h : ↑q < inducedMap α β a
⊢ ↑q < a

tactic: exact (inducedMap_mono α β).reflect_lt h
state_before: case refine_1
F : Type ?u.20995
α : Type u_2
β : Type u_1
γ : Type ?u.21004
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
h : inducedMap α β ↑q < inducedMap α β a
⊢ ↑q < a

tactic: obtain ⟨q', hq, hqa⟩ := exists_rat_btwn hq
state_before: case refine_2
F : Type ?u.20995
α : Type u_2
β : Type u_1
γ : Type ?u.21004
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
hq : ↑q < a
⊢ ↑q < inducedMap α β a

tactic: apply lt_csSup_of_lt (cutMap_bddAbove β a) (coe_mem_cutMap_iff.mpr hqa)
state_before: case refine_2.intro.intro
F : Type ?u.20995
α : Type u_2
β : Type u_1
γ : Type ?u.21004
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
hq✝ : ↑q < a
q' : ℚ
hq : ↑q < ↑q'
hqa : ↑q' < a
⊢ ↑q < inducedMap α β a

tactic: exact_mod_cast hq
state_before: case refine_2.intro.intro
F : Type ?u.20995
α : Type u_2
β : Type u_1
γ : Type ?u.21004
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
hq✝ : ↑q < a
q' : ℚ
hq : ↑q < ↑q'
hqa : ↑q' < a
⊢ ↑q < ↑q'
Theorem: intervalIntegral.integral_zero
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp [intervalIntegral]
state_before: ι : Type ?u.9461654
𝕜 : Type ?u.9461657
E : Type u_1
F : Type ?u.9461663
A : Type ?u.9461666
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
⊢ (∫ (x : ℝ) in a..b, 0 ∂μ) = 0
Theorem: Primrec.list_findIdx₁
File: Mathlib/Computability/Primrec.lean

tactic: simp [List.findIdx_cons]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.156112
δ : Type ?u.156115
σ : Type ?u.156118
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
p : α → β → Bool
hp : Primrec₂ p
a : β
l : List β
n : α
⊢ (bif p (id n) a then 0 else Nat.succ (List.findIdx (p n) l)) = List.findIdx (p n) (a :: l)
Theorem: Set.preimage_swap_prod
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.30243
δ : Type ?u.30246
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
a : α
b : β
s : Set α
t : Set β
⊢ Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s

tactic: simp [and_comm]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.30243
δ : Type ?u.30246
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
a : α
b : β
s : Set α
t : Set β
x : β
y : α
⊢ (x, y) ∈ Prod.swap ⁻¹' s ×ˢ t ↔ (x, y) ∈ t ×ˢ s
Theorem: Nat.Linear.Poly.denote_insertSorted
File: src/lean/Init/Data/Nat/Linear.lean

tactic: match p with
| [] => simp
| (k', v') :: p => by_cases h : Nat.blt v v' <;> simp [h, denote_insertSorted]
state_before: ctx : Context
k : Nat
v : Var
p : Poly
⊢ denote ctx (insertSorted k v p) = denote ctx p + k * Var.denote ctx v

tactic: simp
state_before: ctx : Context
k : Nat
v : Var
p : Poly
⊢ denote ctx (insertSorted k v []) = denote ctx [] + k * Var.denote ctx v

tactic: by_cases h : Nat.blt v v' <;> simp [h, denote_insertSorted]
state_before: ctx : Context
k : Nat
v : Var
p✝ : Poly
k' : Nat
v' : Var
p : List (Nat × Var)
⊢ denote ctx (insertSorted k v ((k', v') :: p)) = denote ctx ((k', v') :: p) + k * Var.denote ctx v
Theorem: Algebra.TensorProduct.one_mul
File: Mathlib/RingTheory/TensorProduct.lean

tactic: refine TensorProduct.induction_on x ?_ ?_ ?_ <;> simp (config := { contextual := true })
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v₁
inst✝³ : Semiring A
inst✝² : Algebra R A
B : Type v₂
inst✝¹ : Semiring B
inst✝ : Algebra R B
x : A ⊗[R] B
⊢ ↑(↑mul (1 ⊗ₜ[R] 1)) x = x
Theorem: Set.image_sup_prod
File: Mathlib/Data/Set/Sups.lean

tactic: rw [← this]
state_before: α : Type u_1
inst✝ : SemilatticeSup α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Set α
a b c : α
s t : Set α
this : (uncurry fun x x_1 => x ⊔ x_1) '' s ×ˢ t = image2 (fun x x_1 => x ⊔ x_1) s t
⊢ image2 (fun x x_1 => x ⊔ x_1) s t = s ⊻ t

tactic: exact image_uncurry_prod _ _ _
state_before: α : Type u_1
inst✝ : SemilatticeSup α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Set α
a b c : α
s t : Set α
this : (uncurry fun x x_1 => x ⊔ x_1) '' s ×ˢ t = image2 (fun x x_1 => x ⊔ x_1) s t
⊢ (uncurry fun x x_1 => x ⊔ x_1) '' s ×ˢ t = s ⊻ t

tactic: simp only [ge_iff_le, image_uncurry_prod]
state_before: α : Type u_1
inst✝ : SemilatticeSup α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Set α
a b c : α
s t : Set α
⊢ (uncurry fun x x_1 => x ⊔ x_1) '' s ×ˢ t = image2 (fun x x_1 => x ⊔ x_1) s t
Theorem: sdiff_le_iff_left
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sdiff_le_iff, sup_idem]
state_before: ι : Type ?u.90112
α : Type u_1
β : Type ?u.90118
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a \ b ≤ b ↔ a ≤ b
Theorem: Std.RBNode.WF.out
File: Std/Data/RBMap/WF.lean

tactic: induction h with
| mk o h => exact ⟨o, _, _, h⟩
| insert _ ih => have ⟨o, _, _, h⟩ := ih; exact ⟨o.insert, h.insert⟩
| erase _ ih => have ⟨o, _, _, h⟩ := ih; exact ⟨o.erase, _, h.erase⟩
state_before: α : Type u_1
cmp : α → α → Ordering
t : RBNode α
h : WF cmp t
⊢ Ordered cmp t ∧ ∃ c n, Balanced t c n

tactic: exact ⟨o, _, _, h⟩
state_before: case mk
α : Type u_1
cmp : α → α → Ordering
t t✝ : RBNode α
c✝ : RBColor
n✝ : Nat
o : Ordered cmp t✝
h : Balanced t✝ c✝ n✝
⊢ Ordered cmp t✝ ∧ ∃ c n, Balanced t✝ c n

tactic: have ⟨o, _, _, h⟩ := ih
state_before: case insert
α : Type u_1
cmp : α → α → Ordering
t t✝ : RBNode α
a✝¹ : α
a✝ : WF cmp t✝
ih : Ordered cmp t✝ ∧ ∃ c n, Balanced t✝ c n
⊢ Ordered cmp (RBNode.insert cmp t✝ a✝¹) ∧ ∃ c n, Balanced (RBNode.insert cmp t✝ a✝¹) c n

tactic: exact ⟨o.insert, h.insert⟩
state_before: case insert
α : Type u_1
cmp : α → α → Ordering
t t✝ : RBNode α
a✝¹ : α
a✝ : WF cmp t✝
ih : Ordered cmp t✝ ∧ ∃ c n, Balanced t✝ c n
o : Ordered cmp t✝
w✝¹ : RBColor
w✝ : Nat
h : Balanced t✝ w✝¹ w✝
⊢ Ordered cmp (RBNode.insert cmp t✝ a✝¹) ∧ ∃ c n, Balanced (RBNode.insert cmp t✝ a✝¹) c n

tactic: have ⟨o, _, _, h⟩ := ih
state_before: case erase
α : Type u_1
cmp : α → α → Ordering
t t✝ : RBNode α
cut✝ : α → Ordering
a✝ : WF cmp t✝
ih : Ordered cmp t✝ ∧ ∃ c n, Balanced t✝ c n
⊢ Ordered cmp (RBNode.erase cut✝ t✝) ∧ ∃ c n, Balanced (RBNode.erase cut✝ t✝) c n

tactic: exact ⟨o.erase, _, h.erase⟩
state_before: case erase
α : Type u_1
cmp : α → α → Ordering
t t✝ : RBNode α
cut✝ : α → Ordering
a✝ : WF cmp t✝
ih : Ordered cmp t✝ ∧ ∃ c n, Balanced t✝ c n
o : Ordered cmp t✝
w✝¹ : RBColor
w✝ : Nat
h : Balanced t✝ w✝¹ w✝
⊢ Ordered cmp (RBNode.erase cut✝ t✝) ∧ ∃ c n, Balanced (RBNode.erase cut✝ t✝) c n
Theorem: PythagoreanTriple.symm
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: rwa [pythagoreanTriple_comm]
state_before: x y z : ℤ
h : PythagoreanTriple x y z
⊢ PythagoreanTriple y x z
Theorem: List.head!_eq_head?
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> rfl
state_before: ι : Type ?u.41398
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
l : List α
⊢ head! l = Option.iget (head? l)
Theorem: List.sublists'_cons
File: Mathlib/Data/List/Sublists.lean

tactic: simp [sublists'_eq_sublists'Aux, foldr_cons, sublists'Aux_eq_map]
state_before: α : Type u
β : Type v
γ : Type w
a : α
l : List α
⊢ sublists' (a :: l) = sublists' l ++ map (cons a) (sublists' l)
Theorem: if_false_right_eq_and
File: Mathlib/Init/IteSimp.lean

tactic: by_cases p <;> simp [h]
state_before: p : Prop
h : Decidable p
q : Prop
⊢ (if p then q else False) = (p ∧ q)
Theorem: LipschitzWith.prod_mk_left
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [max_eq_right zero_le_one] using (LipschitzWith.const a).prod LipschitzWith.id
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ≥0∞
a : α
⊢ LipschitzWith 1 (Prod.mk a)
Theorem: MeasureTheory.SimpleFunc.integrable_approxOn_range
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: simp
state_before: α : Type ?u.1025603
β : Type ?u.1025606
ι : Type ?u.1025609
E : Type ?u.1025612
F : Type ?u.1025615
𝕜 : Type ?u.1025618
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : BorelSpace E
f : β → E
μ : Measure β
fmeas : Measurable f
inst✝ : SeparableSpace ↑(Set.range f ∪ {0})
hf : Integrable f
n : ℕ
⊢ 0 ∈ Set.range f ∪ {0}
Theorem: EMetric.preimage_mul_right_ball
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: rw [div_eq_mul_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoEMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoEMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ≥0∞
⊢ (fun x => x * a) ⁻¹' ball b r = ball (b / a) r

tactic: exact preimage_smul_ball (MulOpposite.op a) b r
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoEMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoEMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ≥0∞
⊢ (fun x => x * a) ⁻¹' ball b r = ball (b * a⁻¹) r
Theorem: Finsupp.filter_eq_zero_iff
File: Mathlib/Data/Finsupp/Basic.lean

tactic: simp only [FunLike.ext_iff, filter_eq_indicator, zero_apply, Set.indicator_apply_eq_zero,
  Set.mem_setOf_eq]
state_before: α : Type u_1
β : Type ?u.358141
γ : Type ?u.358144
ι : Type ?u.358147
M : Type u_2
M' : Type ?u.358153
N : Type ?u.358156
P : Type ?u.358159
G : Type ?u.358162
H : Type ?u.358165
R : Type ?u.358168
S : Type ?u.358171
inst✝ : Zero M
p : α → Prop
f : α →₀ M
⊢ filter p f = 0 ↔ ∀ (x : α), p x → ↑f x = 0
Theorem: Set.one_mem_centralizer
File: Mathlib/GroupTheory/Subsemigroup/Centralizer.lean

tactic: simp [mem_centralizer_iff]
state_before: M : Type u_1
S T : Set M
inst✝ : MulOneClass M
⊢ 1 ∈ centralizer S
Theorem: bernstein.probability
File: Mathlib/Analysis/SpecialFunctions/Bernstein.lean

tactic: have := bernsteinPolynomial.sum ℝ n
state_before: n : ℕ
x : ↑I
⊢ ∑ k : Fin (n + 1), ↑(bernstein n ↑k) x = 1

tactic: apply_fun fun p => Polynomial.aeval (x : ℝ) p at this
state_before: n : ℕ
x : ↑I
this : ∑ ν in Finset.range (n + 1), bernsteinPolynomial ℝ n ν = 1
⊢ ∑ k : Fin (n + 1), ↑(bernstein n ↑k) x = 1

tactic: simp [AlgHom.map_sum, Finset.sum_range] at this
state_before: n : ℕ
x : ↑I
this : ↑(Polynomial.aeval ↑x) (∑ ν in Finset.range (n + 1), bernsteinPolynomial ℝ n ν) = ↑(Polynomial.aeval ↑x) 1
⊢ ∑ k : Fin (n + 1), ↑(bernstein n ↑k) x = 1

tactic: exact this
state_before: n : ℕ
x : ↑I
this : ∑ x_1 : Fin (n + 1), Polynomial.eval (↑x) (bernsteinPolynomial ℝ n ↑x_1) = 1
⊢ ∑ k : Fin (n + 1), ↑(bernstein n ↑k) x = 1
Theorem: Polynomial.support_X
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [← pow_one X, support_X_pow H 1]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
H : ¬1 = 0
⊢ support X = {1}
Theorem: Finset.zero_mem_smul_finset_iff
File: Mathlib/Data/Finset/Pointwise.lean

tactic: rw [← mem_coe, coe_smul_finset, Set.zero_mem_smul_set_iff ha, mem_coe]
state_before: F : Type ?u.935966
α : Type u_1
β : Type u_2
γ : Type ?u.935975
inst✝⁴ : Zero α
inst✝³ : Zero β
inst✝² : SMulWithZero α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
inst✝ : NoZeroSMulDivisors α β
a : α
ha : a ≠ 0
⊢ 0 ∈ a • t ↔ 0 ∈ t
Theorem: TopCat.pullback_map_embedding_of_embeddings
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: refine'
  embedding_of_embedding_compose (ContinuousMap.continuous_toFun _)
    (show Continuous (prod.lift pullback.fst pullback.snd : pullback g₁ g₂ ⟶ Y ⨯ Z) from
      ContinuousMap.continuous_toFun _)
    _
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ((forget TopCat).map i₁)
H₂ : Embedding ((forget TopCat).map i₂)
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding ((forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂))

tactic: suffices
  Embedding (prod.lift pullback.fst pullback.snd ≫ Limits.prod.map i₁ i₂ : pullback f₁ f₂ ⟶ _) by
  simpa [← coe_comp] using this
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ((forget TopCat).map i₁)
H₂ : Embedding ((forget TopCat).map i₂)
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding
    ((forget TopCat).map (prod.lift pullback.fst pullback.snd) ∘
      (forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂))

tactic: rw [coe_comp]
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ((forget TopCat).map i₁)
H₂ : Embedding ((forget TopCat).map i₂)
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding ((forget TopCat).map (prod.lift pullback.fst pullback.snd ≫ prod.map i₁ i₂))

tactic: refine Embedding.comp (embedding_prod_map H₁ H₂) (embedding_pullback_to_prod _ _)
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ((forget TopCat).map i₁)
H₂ : Embedding ((forget TopCat).map i₂)
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
⊢ Embedding ((forget TopCat).map (prod.map i₁ i₂) ∘ (forget TopCat).map (prod.lift pullback.fst pullback.snd))

tactic: simpa [← coe_comp] using this
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z✝ W X Y Z S T : TopCat
f₁ : W ⟶ S
f₂ : X ⟶ S
g₁ : Y ⟶ T
g₂ : Z ⟶ T
i₁ : W ⟶ Y
i₂ : X ⟶ Z
H₁ : Embedding ((forget TopCat).map i₁)
H₂ : Embedding ((forget TopCat).map i₂)
i₃ : S ⟶ T
eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁
eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂
this : Embedding ((forget TopCat).map (prod.lift pullback.fst pullback.snd ≫ prod.map i₁ i₂))
⊢ Embedding
    ((forget TopCat).map (prod.lift pullback.fst pullback.snd) ∘
      (forget TopCat).map (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂))
Theorem: ComputablePred.computable_iff_re_compl_re'
File: Mathlib/Computability/Halting.lean

tactic: classical exact computable_iff_re_compl_re
state_before: α : Type u_1
σ : Type ?u.313648
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
p : α → Prop
⊢ ComputablePred p ↔ RePred p ∧ RePred fun a => ¬p a

tactic: exact computable_iff_re_compl_re
state_before: α : Type u_1
σ : Type ?u.313648
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
p : α → Prop
⊢ ComputablePred p ↔ RePred p ∧ RePred fun a => ¬p a
Theorem: nnnorm_eq_zero'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [← NNReal.coe_eq_zero, coe_nnnorm', norm_eq_zero'']
state_before: 𝓕 : Type ?u.1228006
𝕜 : Type ?u.1228009
α : Type ?u.1228012
ι : Type ?u.1228015
κ : Type ?u.1228018
E : Type u_1
F : Type ?u.1228024
G : Type ?u.1228027
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
⊢ ‖a‖₊ = 0 ↔ a = 1
Theorem: MeasureTheory.memℒp_two_iff_integrable_sq_norm
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: rw [← memℒp_one_iff_integrable]
state_before: α : Type u_1
F : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → F
hf : AEStronglyMeasurable f μ
⊢ Memℒp f 2 ↔ Integrable fun x => ‖f x‖ ^ 2

tactic: convert (memℒp_norm_rpow_iff hf two_ne_zero ENNReal.two_ne_top).symm
state_before: α : Type u_1
F : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → F
hf : AEStronglyMeasurable f μ
⊢ Memℒp f 2 ↔ Memℒp (fun x => ‖f x‖ ^ 2) 1

tactic: simp
state_before: case h.e'_2.h.e'_5.h
α : Type u_1
F : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → F
hf : AEStronglyMeasurable f μ
x✝ : α
⊢ ‖f x✝‖ ^ 2 = ‖f x✝‖ ^ ENNReal.toReal 2

tactic: rw [div_eq_mul_inv, ENNReal.mul_inv_cancel two_ne_zero ENNReal.two_ne_top]
state_before: case h.e'_2.h.e'_6
α : Type u_1
F : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → F
hf : AEStronglyMeasurable f μ
⊢ 1 = 2 / 2
Theorem: decide_False'
File: Mathlib/Init/Logic.lean

tactic: simp
state_before: a b c d : Prop
p : ?m.25417
h : Decidable False
⊢ decide False = false
Theorem: Finset.sigmaLift_eq_empty
File: Mathlib/Data/Finset/Sigma.lean

tactic: simp_rw [sigmaLift]
state_before: ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ sigmaLift f a b = ∅ ↔ ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅

tactic: split_ifs with h
state_before: ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ (if h : a.fst = b.fst then map (Embedding.sigmaMk b.fst) (f (h ▸ a.snd) b.snd) else ∅) = ∅ ↔
    ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅

tactic: . simp [h, forall_prop_of_true h]
state_before: case inl
ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
h : a.fst = b.fst
⊢ map (Embedding.sigmaMk b.fst) (f (h ▸ a.snd) b.snd) = ∅ ↔ ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅

case inr
ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
h : ¬a.fst = b.fst
⊢ ∅ = ∅ ↔ ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅

tactic: . simp [h, forall_prop_of_false h]
state_before: case inr
ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
h : ¬a.fst = b.fst
⊢ ∅ = ∅ ↔ ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅

tactic: simp [h, forall_prop_of_true h]
state_before: case inl
ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
h : a.fst = b.fst
⊢ map (Embedding.sigmaMk b.fst) (f (h ▸ a.snd) b.snd) = ∅ ↔ ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅

tactic: simp [h, forall_prop_of_false h]
state_before: case inr
ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
h : ¬a.fst = b.fst
⊢ ∅ = ∅ ↔ ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅
Theorem: Valuation.Integers.one_of_isUnit
File: Mathlib/RingTheory/Valuation/Integers.lean

tactic: rw [← v.map_one, ← (algebraMap O R).map_one, ← u.mul_inv, ← mul_one (v (algebraMap O R x)), hu,
  (algebraMap O R).map_mul, v.map_mul]
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : Integers v O
x : O
hx : IsUnit x
u : Oˣ
hu : ↑u = x
⊢ 1 ≤ ↑v (↑(algebraMap O R) x)

tactic: exact mul_le_mul_left' (hv.2 (u⁻¹ : Units O)) _
state_before: R : Type u
Γ₀ : Type v
inst✝⁵ : CommRing R
inst✝⁴ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
O : Type w
inst✝³ : CommRing O
inst✝² : Algebra O R
inst✝¹ : CommRing O
inst✝ : Algebra O R
hv : Integers v O
x : O
hx : IsUnit x
u : Oˣ
hu : ↑u = x
⊢ ↑v (↑(algebraMap O R) x) * ↑v (↑(algebraMap O R) ↑u⁻¹) ≤ ↑v (↑(algebraMap O R) x) * 1
Theorem: BoundedContinuousFunction.norm_le
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: simpa using @dist_le _ _ _ _ f 0 _ C0
state_before: F : Type ?u.999867
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
C0 : 0 ≤ C
⊢ ‖f‖ ≤ C ↔ ∀ (x : α), ‖↑f x‖ ≤ C