tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.isSeparator_sigma
File: Mathlib/CategoryTheory/Generator.lean

tactic: refine'
  ⟨fun h X Y u v huv => _, fun h =>
    (isSeparator_def _).2 fun X Y u v huv => h _ _ fun Z hZ g => _⟩
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
β : Type w
f : β → C
inst✝ : HasCoproduct f
⊢ IsSeparator (∐ f) ↔ IsSeparating (Set.range f)

tactic: refine' h.def _ _ fun g => colimit.hom_ext fun b => _
state_before: case refine'_1
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
β : Type w
f : β → C
inst✝ : HasCoproduct f
h : IsSeparator (∐ f)
X Y : C
u v : X ⟶ Y
huv : ∀ (G : C), G ∈ Set.range f → ∀ (h : G ⟶ X), h ≫ u = h ≫ v
⊢ u = v

tactic: simpa using huv (f b.as) (by simp) (colimit.ι (Discrete.functor f) _ ≫ g)
state_before: case refine'_1
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
β : Type w
f : β → C
inst✝ : HasCoproduct f
h : IsSeparator (∐ f)
X Y : C
u v : X ⟶ Y
huv : ∀ (G : C), G ∈ Set.range f → ∀ (h : G ⟶ X), h ≫ u = h ≫ v
g : ∐ f ⟶ X
b : Discrete β
⊢ colimit.ι (Discrete.functor f) b ≫ g ≫ u = colimit.ι (Discrete.functor f) b ≫ g ≫ v

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
β : Type w
f : β → C
inst✝ : HasCoproduct f
h : IsSeparator (∐ f)
X Y : C
u v : X ⟶ Y
huv : ∀ (G : C), G ∈ Set.range f → ∀ (h : G ⟶ X), h ≫ u = h ≫ v
g : ∐ f ⟶ X
b : Discrete β
⊢ f b.as ∈ Set.range f

tactic: obtain ⟨b, rfl⟩ := Set.mem_range.1 hZ
state_before: case refine'_2
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
β : Type w
f : β → C
inst✝ : HasCoproduct f
h : IsSeparating (Set.range f)
X Y : C
u v : X ⟶ Y
huv : ∀ (h : ∐ f ⟶ X), h ≫ u = h ≫ v
Z : C
hZ : Z ∈ Set.range f
g : Z ⟶ X
⊢ g ≫ u = g ≫ v

tactic: classical simpa using Sigma.ι f b ≫= huv (Sigma.desc (Pi.single b g))
state_before: case refine'_2.intro
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
β : Type w
f : β → C
inst✝ : HasCoproduct f
h : IsSeparating (Set.range f)
X Y : C
u v : X ⟶ Y
huv : ∀ (h : ∐ f ⟶ X), h ≫ u = h ≫ v
b : β
hZ : f b ∈ Set.range f
g : f b ⟶ X
⊢ g ≫ u = g ≫ v

tactic: simpa using Sigma.ι f b ≫= huv (Sigma.desc (Pi.single b g))
state_before: case refine'_2.intro
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
β : Type w
f : β → C
inst✝ : HasCoproduct f
h : IsSeparating (Set.range f)
X Y : C
u v : X ⟶ Y
huv : ∀ (h : ∐ f ⟶ X), h ≫ u = h ≫ v
b : β
hZ : f b ∈ Set.range f
g : f b ⟶ X
⊢ g ≫ u = g ≫ v
Theorem: BoxIntegral.Box.splitLower_eq_self
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: simp [splitLower, update_eq_iff]
state_before: ι : Type u_1
M : Type ?u.5739
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ splitLower I i x = ↑I ↔ upper I i ≤ x
Theorem: MvPolynomial.aeval_algebraMap_apply
File: Mathlib/RingTheory/MvPolynomial/Tower.lean

tactic: rw [aeval_def, aeval_def, ← coe_eval₂Hom, ← coe_eval₂Hom, map_eval₂Hom, ←
  IsScalarTower.algebraMap_eq]
state_before: R : Type u_2
A : Type u_4
B : Type u_3
σ : Type u_1
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : CommSemiring B
inst✝³ : Algebra R A
inst✝² : Algebra A B
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R A B
x : σ → A
p : MvPolynomial σ R
⊢ ↑(aeval (↑(algebraMap A B) ∘ x)) p = ↑(algebraMap A B) (↑(aeval x) p)

tactic: simp only [Function.comp]
state_before: R : Type u_2
A : Type u_4
B : Type u_3
σ : Type u_1
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : CommSemiring B
inst✝³ : Algebra R A
inst✝² : Algebra A B
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R A B
x : σ → A
p : MvPolynomial σ R
⊢ ↑(eval₂Hom (algebraMap R B) (↑(algebraMap A B) ∘ x)) p =
    ↑(eval₂Hom (algebraMap R B) fun i => ↑(algebraMap A B) (x i)) p
Theorem: Equiv.Perm.mem_support_cycleOf_iff'
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [mem_support_cycleOf_iff, and_iff_left (mem_support.2 hx)]
state_before: ι : Type ?u.2518697
α : Type u_1
β : Type ?u.2518703
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hx : ↑f x ≠ x
⊢ y ∈ support (cycleOf f x) ↔ SameCycle f x y
Theorem: MeasureTheory.Measure.haarMeasure_apply
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: change ((haarContent K₀).outerMeasure K₀)⁻¹ * (haarContent K₀).measure s = _
state_before: G : Type u_1
inst✝⁵ : Group G
inst✝⁴ : TopologicalSpace G
inst✝³ : T2Space G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
s : Set G
hs : MeasurableSet s
⊢ ↑↑(haarMeasure K₀) s = ↑(Content.outerMeasure (haarContent K₀)) s / ↑(Content.outerMeasure (haarContent K₀)) ↑K₀

tactic: simp only [hs, div_eq_mul_inv, mul_comm, Content.measure_apply]
state_before: G : Type u_1
inst✝⁵ : Group G
inst✝⁴ : TopologicalSpace G
inst✝³ : T2Space G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
s : Set G
hs : MeasurableSet s
⊢ (↑(Content.outerMeasure (haarContent K₀)) ↑K₀)⁻¹ * ↑↑(Content.measure (haarContent K₀)) s =
    ↑(Content.outerMeasure (haarContent K₀)) s / ↑(Content.outerMeasure (haarContent K₀)) ↑K₀
Theorem: Option.map₂_none_right
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> rfl
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
f✝ : α → β → γ
a✝ : Option α
b : Option β
c : Option γ
f : α → β → γ
a : Option α
⊢ map₂ f a none = none
Theorem: abs_sub_round_div_natCast_eq
File: Mathlib/Algebra/Order/Floor.lean

tactic: rcases n.eq_zero_or_pos with (rfl | hn)
state_before: F : Type ?u.288255
α : Type u_1
β : Type ?u.288261
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m n : ℕ
⊢ abs (↑m / ↑n - ↑(round (↑m / ↑n))) = ↑(min (m % n) (n - m % n)) / ↑n

tactic: have hn' : 0 < (n : α) := by
  norm_cast
state_before: case inr
F : Type ?u.288255
α : Type u_1
β : Type ?u.288261
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m n : ℕ
hn : n > 0
⊢ abs (↑m / ↑n - ↑(round (↑m / ↑n))) = ↑(min (m % n) (n - m % n)) / ↑n

tactic: rw [abs_sub_round_eq_min, Nat.cast_min, ← min_div_div_right hn'.le,
  fract_div_natCast_eq_div_natCast_mod, Nat.cast_sub (m.mod_lt hn).le, sub_div, div_self hn'.ne']
state_before: case inr
F : Type ?u.288255
α : Type u_1
β : Type ?u.288261
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m n : ℕ
hn : n > 0
hn' : 0 < ↑n
⊢ abs (↑m / ↑n - ↑(round (↑m / ↑n))) = ↑(min (m % n) (n - m % n)) / ↑n

tactic: simp
state_before: case inl
F : Type ?u.288255
α : Type u_1
β : Type ?u.288261
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m : ℕ
⊢ abs (↑m / ↑0 - ↑(round (↑m / ↑0))) = ↑(min (m % 0) (0 - m % 0)) / ↑0

tactic: norm_cast
state_before: F : Type ?u.288255
α : Type u_1
β : Type ?u.288261
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
m n : ℕ
hn : n > 0
⊢ 0 < ↑n
Theorem: Cardinal.summable_cantor_function
File: Mathlib/Data/Real/Cardinality.lean

tactic: apply (summable_geometric_of_lt_1 h1 h2).summable_of_eq_zero_or_self
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
⊢ Summable (cantorFunctionAux c f)

tactic: intro n
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
⊢ ∀ (b : ℕ), cantorFunctionAux c f b = 0 ∨ cantorFunctionAux c f b = c ^ b

tactic: cases h : f n <;> simp [h]
state_before: c : ℝ
f✝ g : ℕ → Bool
n✝ : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
n : ℕ
⊢ cantorFunctionAux c f n = 0 ∨ cantorFunctionAux c f n = c ^ n
Theorem: PartENat.coe_lt_iff
File: Mathlib/Data/Nat/PartENat.lean

tactic: rw [← some_eq_natCast]
state_before: n : ℕ
x : PartENat
⊢ ↑n < x ↔ ∀ (h : x.Dom), n < Part.get x h

tactic: simp only [lt_def, exists_prop_of_true, dom_some, forall_true_iff]
state_before: n : ℕ
x : PartENat
⊢ ↑n < x ↔ ∀ (h : x.Dom), n < Part.get x h

tactic: rfl
state_before: n : ℕ
x : PartENat
⊢ (∀ (hy : x.Dom), Part.get ↑n (_ : (↑n).Dom) < Part.get x hy) ↔ ∀ (h : x.Dom), n < Part.get x h
Theorem: SimpleGraph.Walk.support_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> cases p' <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
p' : Walk G v w
⊢ support (append p p') = support p ++ List.tail (support p')
Theorem: Finset.ssubset_iff_exists_cons_subset
File: Mathlib/Data/Finset/Basic.lean

tactic: refine' ⟨fun h => _, fun ⟨a, ha, h⟩ => ssubset_of_ssubset_of_subset (ssubset_cons _) h⟩
state_before: α : Type u_1
β : Type ?u.39958
γ : Type ?u.39961
s t : Finset α
a b : α
⊢ s ⊂ t ↔ ∃ a h, cons a s h ⊆ t

tactic: obtain ⟨a, hs, ht⟩ := not_subset.1 h.2
state_before: α : Type u_1
β : Type ?u.39958
γ : Type ?u.39961
s t : Finset α
a b : α
h : s ⊂ t
⊢ ∃ a h, cons a s h ⊆ t

tactic: exact ⟨a, ht, cons_subset.2 ⟨hs, h.subset⟩⟩
state_before: case intro.intro
α : Type u_1
β : Type ?u.39958
γ : Type ?u.39961
s t : Finset α
a✝ b : α
h : s ⊂ t
a : α
hs : a ∈ t
ht : ¬a ∈ s
⊢ ∃ a h, cons a s h ⊆ t
Theorem: MvPFunctor.comp.get_map
File: Mathlib/Data/PFunctor/Multivariate/Basic.lean

tactic: rfl
state_before: n m : ℕ
P : MvPFunctor n
Q : Fin2 n → MvPFunctor m
α β : TypeVec m
f : α ⟹ β
x : Obj (comp P Q) α
⊢ get (f <$$> x) = (fun i x => f <$$> x) <$$> get x
Theorem: ApproximatesLinearOn.map_nhds_eq
File: Mathlib/Analysis/Calculus/Inverse.lean

tactic: refine'
  le_antisymm ((hf.continuousOn x (mem_of_mem_nhds hs)).continuousAt hs) (le_map fun t ht => _)
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type ?u.313471
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.313574
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f : E → F
s : Set E
c : ℝ≥0
f' : E →L[𝕜] F
hf : ApproximatesLinearOn f f' s c
f'symm : ContinuousLinearMap.NonlinearRightInverse f'
x : E
hs : s ∈ 𝓝 x
hc : Subsingleton F ∨ c < f'symm.nnnorm⁻¹
⊢ map f (𝓝 x) = 𝓝 (f x)

tactic: have : f '' (s ∩ t) ∈ 𝓝 (f x) :=
  (hf.mono_set (inter_subset_left s t)).image_mem_nhds f'symm (inter_mem hs ht) hc
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type ?u.313471
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.313574
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f : E → F
s : Set E
c : ℝ≥0
f' : E →L[𝕜] F
hf : ApproximatesLinearOn f f' s c
f'symm : ContinuousLinearMap.NonlinearRightInverse f'
x : E
hs : s ∈ 𝓝 x
hc : Subsingleton F ∨ c < f'symm.nnnorm⁻¹
t : Set E
ht : t ∈ 𝓝 x
⊢ f '' t ∈ 𝓝 (f x)

tactic: exact mem_of_superset this (image_subset _ (inter_subset_right _ _))
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type ?u.313471
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.313574
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f : E → F
s : Set E
c : ℝ≥0
f' : E →L[𝕜] F
hf : ApproximatesLinearOn f f' s c
f'symm : ContinuousLinearMap.NonlinearRightInverse f'
x : E
hs : s ∈ 𝓝 x
hc : Subsingleton F ∨ c < f'symm.nnnorm⁻¹
t : Set E
ht : t ∈ 𝓝 x
this : f '' (s ∩ t) ∈ 𝓝 (f x)
⊢ f '' t ∈ 𝓝 (f x)
Theorem: same_sub_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: simpa only [← @div_self _ _ b h] using (div_sub_div_same b a b).symm
state_before: α : Type ?u.39711
β : Type ?u.39714
K : Type u_1
inst✝ : DivisionRing K
a✝ b✝ c d a b : K
h : b ≠ 0
⊢ (b - a) / b = 1 - a / b
Theorem: Filter.bind_mono
File: Mathlib/Order/Filter/Basic.lean

tactic: refine' le_trans (fun s hs => _) (join_mono <| map_mono hf)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.298298
ι : Sort x
f₁ f₂ : Filter α
g₁ g₂ : α → Filter β
hf : f₁ ≤ f₂
hg : g₁ ≤ᶠ[f₁] g₂
⊢ bind f₁ g₁ ≤ bind f₂ g₂

tactic: simp only [mem_join, mem_bind', mem_map] at hs ⊢
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.298298
ι : Sort x
f₁ f₂ : Filter α
g₁ g₂ : α → Filter β
hf : f₁ ≤ f₂
hg : g₁ ≤ᶠ[f₁] g₂
s : Set β
hs : s ∈ join (map g₂ f₁)
⊢ s ∈ bind f₁ g₁

tactic: filter_upwards [hg, hs] with _ hx hs using hx hs
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.298298
ι : Sort x
f₁ f₂ : Filter α
g₁ g₂ : α → Filter β
hf : f₁ ≤ f₂
hg : g₁ ≤ᶠ[f₁] g₂
s : Set β
hs : g₂ ⁻¹' {t | s ∈ t} ∈ f₁
⊢ {a | s ∈ g₁ a} ∈ f₁
Theorem: Reflexive.rel_of_ne_imp
File: Mathlib/Logic/Relation.lean

tactic: by_cases hxy : x = y
state_before: α : Type u_1
β : Type ?u.98
γ : Type ?u.101
δ : Type ?u.104
r : α → α → Prop
h : Reflexive r
x y : α
hr : x ≠ y → r x y
⊢ r x y

tactic: exact hxy ▸ h x
state_before: case pos
α : Type u_1
β : Type ?u.98
γ : Type ?u.101
δ : Type ?u.104
r : α → α → Prop
h : Reflexive r
x y : α
hr : x ≠ y → r x y
hxy : x = y
⊢ r x y

tactic: exact hr hxy
state_before: case neg
α : Type u_1
β : Type ?u.98
γ : Type ?u.101
δ : Type ?u.104
r : α → α → Prop
h : Reflexive r
x y : α
hr : x ≠ y → r x y
hxy : ¬x = y
⊢ r x y
Theorem: CategoryTheory.Coverage.toGrothendieck_eq_sInf
File: Mathlib/CategoryTheory/Sites/Coverage.lean

tactic: apply le_antisymm
state_before: C : Type u_1
inst✝ : Category C
K : Coverage C
⊢ toGrothendieck C K = sInf {J | K ≤ ofGrothendieck C J}

tactic: apply le_sInf
state_before: case a
C : Type u_1
inst✝ : Category C
K : Coverage C
⊢ toGrothendieck C K ≤ sInf {J | K ≤ ofGrothendieck C J}

tactic: intro J hJ
state_before: case a.a
C : Type u_1
inst✝ : Category C
K : Coverage C
⊢ ∀ (b : GrothendieckTopology C), b ∈ {J | K ≤ ofGrothendieck C J} → toGrothendieck C K ≤ b

tactic: intro X S hS
state_before: case a.a
C : Type u_1
inst✝ : Category C
K : Coverage C
J : GrothendieckTopology C
hJ : J ∈ {J | K ≤ ofGrothendieck C J}
⊢ toGrothendieck C K ≤ J

tactic: induction hS with
| of X S hS => apply hJ ; assumption
| top => apply J.top_mem
| transitive X R S _ _ H1 H2 => exact J.transitive H1 _ H2
state_before: case a.a
C : Type u_1
inst✝ : Category C
K : Coverage C
J : GrothendieckTopology C
hJ : J ∈ {J | K ≤ ofGrothendieck C J}
X : C
S : Sieve X
hS : S ∈ GrothendieckTopology.sieves (toGrothendieck C K) X
⊢ S ∈ GrothendieckTopology.sieves J X

tactic: apply hJ
state_before: case a.a.of
C : Type u_1
inst✝ : Category C
K : Coverage C
J : GrothendieckTopology C
hJ : J ∈ {J | K ≤ ofGrothendieck C J}
X✝ : C
S✝ : Sieve X✝
X : C
S : Presieve X
hS : S ∈ covering K X
⊢ Sieve.generate S ∈ GrothendieckTopology.sieves J X

tactic: assumption
state_before: case a.a.of.a
C : Type u_1
inst✝ : Category C
K : Coverage C
J : GrothendieckTopology C
hJ : J ∈ {J | K ≤ ofGrothendieck C J}
X✝ : C
S✝ : Sieve X✝
X : C
S : Presieve X
hS : S ∈ covering K X
⊢ S ∈ covering K X

tactic: apply J.top_mem
state_before: case a.a.top
C : Type u_1
inst✝ : Category C
K : Coverage C
J : GrothendieckTopology C
hJ : J ∈ {J | K ≤ ofGrothendieck C J}
X : C
S : Sieve X
X✝ : C
⊢ ⊤ ∈ GrothendieckTopology.sieves J X✝

tactic: exact J.transitive H1 _ H2
state_before: case a.a.transitive
C : Type u_1
inst✝ : Category C
K : Coverage C
J : GrothendieckTopology C
hJ : J ∈ {J | K ≤ ofGrothendieck C J}
X✝ : C
S✝ : Sieve X✝
X : C
R S : Sieve X
a✝¹ : saturate K X R
a✝ : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, R.arrows f → saturate K Y (Sieve.pullback f S)
H1 : R ∈ GrothendieckTopology.sieves J X
H2 : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, R.arrows f → Sieve.pullback f S ∈ GrothendieckTopology.sieves J Y
⊢ S ∈ GrothendieckTopology.sieves J X

tactic: apply sInf_le
state_before: case a
C : Type u_1
inst✝ : Category C
K : Coverage C
⊢ sInf {J | K ≤ ofGrothendieck C J} ≤ toGrothendieck C K

tactic: intro X S hS
state_before: case a.a
C : Type u_1
inst✝ : Category C
K : Coverage C
⊢ toGrothendieck C K ∈ {J | K ≤ ofGrothendieck C J}

tactic: apply saturate.of _ _ hS
state_before: case a.a
C : Type u_1
inst✝ : Category C
K : Coverage C
X : C
S : Presieve X
hS : S ∈ covering K X
⊢ S ∈ covering (ofGrothendieck C (toGrothendieck C K)) X
Theorem: padicNormE.mul
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simp [Norm.norm, map_mul]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
⊢ ‖q * r‖ = ‖q‖ * ‖r‖
Theorem: Set.iUnion_setOf
File: Mathlib/Data/Set/Lattice.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.65233
γ : Type ?u.65236
ι : Sort u_2
ι' : Sort ?u.65242
ι₂ : Sort ?u.65245
κ : ι → Sort ?u.65250
κ₁ : ι → Sort ?u.65255
κ₂ : ι → Sort ?u.65260
κ' : ι' → Sort ?u.65265
P : ι → α → Prop
⊢ (⋃ (i : ι), {x | P i x}) = {x | ∃ i, P i x}

tactic: exact mem_iUnion
state_before: case h
α : Type u_1
β : Type ?u.65233
γ : Type ?u.65236
ι : Sort u_2
ι' : Sort ?u.65242
ι₂ : Sort ?u.65245
κ : ι → Sort ?u.65250
κ₁ : ι → Sort ?u.65255
κ₂ : ι → Sort ?u.65260
κ' : ι' → Sort ?u.65265
P : ι → α → Prop
x✝ : α
⊢ (x✝ ∈ ⋃ (i : ι), {x | P i x}) ↔ x✝ ∈ {x | ∃ i, P i x}
Theorem: neg_abs_le_self
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: cases' le_total 0 a with h h
state_before: α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
⊢ -abs a ≤ a

tactic: calc
  -|a| = -a := congr_arg Neg.neg (abs_of_nonneg h)
  _ ≤ 0 := neg_nonpos.mpr h
  _ ≤ a := h
state_before: case inl
α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
h : 0 ≤ a
⊢ -abs a ≤ a

tactic: calc
  -|a| = - -a := congr_arg Neg.neg (abs_of_nonpos h)
  _ ≤ a := (neg_neg a).le
state_before: case inr
α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
h : a ≤ 0
⊢ -abs a ≤ a
Theorem: Real.log_two_lt_d9
File: Mathlib/Data/Complex/ExponentialBounds.lean

tactic: norm_num
state_before: ⊢ 1 / 10 ^ 10 + 287209 / 414355 < 0.6931471808
Theorem: Multiset.filter_add_filter
File: Mathlib/Data/Multiset/Basic.lean

tactic: by_cases p a <;> by_cases q a <;> simp [*]
state_before: α : Type u_1
β : Type ?u.268298
γ : Type ?u.268301
p : α → Prop
inst✝¹ : DecidablePred p
q : α → Prop
inst✝ : DecidablePred q
s✝ : Multiset α
a : α
s : Multiset α
IH : filter p s + filter q s = filter (fun a => p a ∨ q a) s + filter (fun a => p a ∧ q a) s
⊢ filter p (a ::ₘ s) + filter q (a ::ₘ s) =
    filter (fun a => p a ∨ q a) (a ::ₘ s) + filter (fun a => p a ∧ q a) (a ::ₘ s)
Theorem: Inducing.prod_map
File: Mathlib/Topology/Constructions.lean

tactic: simp_rw [Prod.map, nhds_prod_eq, hf.nhds_eq_comap,
hg.nhds_eq_comap, prod_comap_comap_eq]
state_before: α : Type u
β : Type v
γ : Type u_1
δ : Type u_2
ε : Type ?u.64695
ζ : Type ?u.64698
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
f : α → β
g : γ → δ
hf : Inducing f
hg : Inducing g
x✝ : α × γ
a : α
b : γ
⊢ 𝓝 (a, b) = comap (Prod.map f g) (𝓝 (Prod.map f g (a, b)))
Theorem: QuotientGroup.rightRel_apply
File: Mathlib/GroupTheory/Coset.lean

tactic: simp only [mul_inv_eq_iff_eq_mul, Subgroup.coe_inv, eq_inv_mul_iff_mul_eq]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ (∃ a, ↑a * y = x) ↔ ∃ a, y * x⁻¹ = ↑a⁻¹

tactic: simp [exists_inv_mem_iff_exists_mem]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ (∃ a, y * x⁻¹ = ↑a⁻¹) ↔ y * x⁻¹ ∈ s
Theorem: Submodule.finrank_quotient_add_finrank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: have := rank_quotient_add_rank s
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
⊢ finrank K (V ⧸ s) + finrank K { x // x ∈ s } = finrank K V

tactic: rw [← finrank_eq_rank, ← finrank_eq_rank, ← finrank_eq_rank] at this
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
this : Module.rank K (V ⧸ s) + Module.rank K { x // x ∈ s } = Module.rank K V
⊢ finrank K (V ⧸ s) + finrank K { x // x ∈ s } = finrank K V

tactic: exact_mod_cast this
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s : Submodule K V
this : ↑(finrank K (V ⧸ s)) + ↑(finrank K { x // x ∈ s }) = ↑(finrank K V)
⊢ finrank K (V ⧸ s) + finrank K { x // x ∈ s } = finrank K V
Theorem: Metric.isBounded_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [isBounded_def, ← Filter.mem_sets, @PseudoMetricSpace.cobounded_sets α, mem_setOf_eq,
  compl_compl]
state_before: α : Type u
β : Type v
X : Type ?u.46280
ι : Type ?u.46283
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ s : Set α
⊢ IsBounded s ↔ ∃ C, ∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → dist x y ≤ C
Theorem: EuclideanGeometry.orthogonalProjection_vsub_orthogonalProjection
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: apply orthogonalProjection_mem_subspace_orthogonalComplement_eq_zero
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : P
⊢ ↑(_root_.orthogonalProjection (direction s)) (p -ᵥ ↑(↑(orthogonalProjection s) p)) = 0

tactic: intro c hc
state_before: case hv
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : P
⊢ p -ᵥ ↑(↑(orthogonalProjection s) p) ∈ (direction s)ᗮ

tactic: rw [← neg_vsub_eq_vsub_rev, inner_neg_right,
  orthogonalProjection_vsub_mem_direction_orthogonal s p c hc, neg_zero]
state_before: case hv
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : P
c : V
hc : c ∈ direction s
⊢ inner c (p -ᵥ ↑(↑(orthogonalProjection s) p)) = 0
Theorem: CategoryTheory.hasFiniteCoproducts_of_has_binary_and_initial
File: Mathlib/CategoryTheory/Limits/Constructions/FiniteProductsOfBinaryProducts.lean

tactic: refine' ⟨fun n => ⟨fun K => _⟩⟩
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
⊢ HasFiniteCoproducts C

tactic: letI := hasCoproduct_fin n fun n => K.obj ⟨n⟩
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
K : Discrete (Fin n) ⥤ C
⊢ HasColimit K

tactic: let that : K ≅ Discrete.functor fun n => K.obj ⟨n⟩ := Discrete.natIso fun ⟨i⟩ => Iso.refl _
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
K : Discrete (Fin n) ⥤ C
this : HasCoproduct fun n_1 => K.obj { as := n_1 } := CategoryTheory.hasCoproduct_fin n fun n_1 => K.obj { as := n_1 }
⊢ HasColimit K

tactic: apply @hasColimitOfIso _ _ _ _ _ _ this that
state_before: J : Type v
inst✝⁴ : SmallCategory J
C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
n : ℕ
K : Discrete (Fin n) ⥤ C
this : HasCoproduct fun n_1 => K.obj { as := n_1 } := CategoryTheory.hasCoproduct_fin n fun n_1 => K.obj { as := n_1 }
that : K ≅ Discrete.functor fun n_1 => K.obj { as := n_1 } :=
  Discrete.natIso fun x =>
    match x with
    | { as := i } => Iso.refl (K.obj { as := i })
⊢ HasColimit K