tasksource/leandojo huggingface dataset:
Theorem: Function.Semiconj.symm_adjoint
File: Mathlib/Order/SemiconjSup.lean

tactic: refine' fun y => (hg' _).unique _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4510
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ↑fa ↑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
⊢ Semiconj g' ↑fb ↑fa

tactic: rw [← fa.surjective.image_preimage { x | g x ≤ fb y }, preimage_setOf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4510
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ↑fa ↑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
y : β
⊢ IsLUB {x | g x ≤ ↑fb y} (↑fa (g' y))

tactic: simp only [h.eq, fb.le_iff_le, fa.leftOrdContinuous (hg' _)]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4510
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ↑fa ↑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
y : β
⊢ IsLUB (↑fa '' {a | g (↑fa a) ≤ ↑fb y}) (↑fa (g' y))
Theorem: List.zip_map
File: Mathlib/Data/List/Zip.lean

tactic: simp only [map, zip_nil_right]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type ?u.21794
f : α → γ
g : β → δ
l₁ : List α
⊢ zip (map f l₁) (map g []) = map (Prod.map f g) (zip l₁ [])

tactic: simp only [map, zip_cons_cons, zip_map, Prod.map]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type ?u.21794
f : α → γ
g : β → δ
a : α
l₁ : List α
b : β
l₂ : List β
⊢ zip (map f (a :: l₁)) (map g (b :: l₂)) = map (Prod.map f g) (zip (a :: l₁) (b :: l₂))

tactic: constructor
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type ?u.21794
f : α → γ
g : β → δ
a : α
l₁ : List α
b : β
l₂ : List β
⊢ (f a, g b) :: map (fun x => (f x.fst, g x.snd)) (zip l₁ l₂) =
    (f a, g b) :: map (fun x => (f x.fst, g x.snd)) (zipWith Prod.mk l₁ l₂)
Theorem: Ordinal.opow_dvd_opow
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rw [← opow_add, Ordinal.add_sub_cancel_of_le h]
state_before: a b c : Ordinal
h : b ≤ c
⊢ a ^ c = a ^ b * a ^ (c - b)
Theorem: HasDerivAt.smul_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: rw [← hasDerivWithinAt_univ] at *
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasDerivAt c c' x
f : F
⊢ HasDerivAt (fun y => c y • f) (c' • f) x

tactic: exact hc.smul_const f
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasDerivWithinAt c c' univ x
f : F
⊢ HasDerivWithinAt (fun y => c y • f) (c' • f) univ x
Theorem: finprod_mem_pair
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [finprod_mem_insert, finprod_mem_singleton]
state_before: α : Type u_1
β : Type ?u.349608
ι : Type ?u.349611
G : Type ?u.349614
M : Type u_2
N : Type ?u.349620
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
h : a ≠ b
⊢ (∏ᶠ (i : α) (_ : i ∈ {a, b}), f i) = f a * f b

tactic: exacts [h, finite_singleton b]
state_before: case h
α : Type u_1
β : Type ?u.349608
ι : Type ?u.349611
G : Type ?u.349614
M : Type u_2
N : Type ?u.349620
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
h : a ≠ b
⊢ ¬a ∈ {b}

case hs
α : Type u_1
β : Type ?u.349608
ι : Type ?u.349611
G : Type ?u.349614
M : Type u_2
N : Type ?u.349620
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
h : a ≠ b
⊢ Set.Finite {b}
Theorem: Matrix.isHermitian_mul_conjTranspose_self
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: rw [IsHermitian, conjTranspose_mul, conjTranspose_conjTranspose]
state_before: α : Type u_3
β : Type ?u.24296
m : Type u_2
n : Type u_1
A✝ : Matrix n n α
inst✝⁴ : NonUnitalSemiring α
inst✝³ : StarRing α
inst✝² : NonUnitalSemiring β
inst✝¹ : StarRing β
inst✝ : Fintype n
A : Matrix m n α
⊢ IsHermitian (A ⬝ Aᴴ)
Theorem: Zsqrtd.norm_conj
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: rw [norm_eq_mul_conj, star_star, mul_comm, norm_eq_mul_conj]
state_before: d : ℤ
x : ℤ√d
⊢ ↑(norm (star x)) = ↑(norm x)
Theorem: continuousWithinAt_univ
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [ContinuousAt, ContinuousWithinAt, nhdsWithin_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.305991
δ : Type ?u.305994
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
x : α
⊢ ContinuousWithinAt f univ x ↔ ContinuousAt f x
Theorem: ApproximatesLinearOn.approximatesLinearOn_iff_lipschitzOnWith
File: Mathlib/Analysis/Calculus/Inverse.lean

tactic: have : ∀ x y, f x - f y - f' (x - y) = (f - f') x - (f - f') y := fun x y ↦ by
  simp only [map_sub, Pi.sub_apply]; abel
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.26755
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.26858
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f✝ : E → F
f'✝ : E →L[𝕜] F
s✝ t : Set E
c✝ c' : ℝ≥0
f : E → F
f' : E →L[𝕜] F
s : Set E
c : ℝ≥0
⊢ ApproximatesLinearOn f f' s c ↔ LipschitzOnWith c (f - ↑f') s

tactic: simp only [this, lipschitzOnWith_iff_norm_sub_le, ApproximatesLinearOn]
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.26755
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.26858
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f✝ : E → F
f'✝ : E →L[𝕜] F
s✝ t : Set E
c✝ c' : ℝ≥0
f : E → F
f' : E →L[𝕜] F
s : Set E
c : ℝ≥0
this : ∀ (x y : E), f x - f y - ↑f' (x - y) = (f - ↑f') x - (f - ↑f') y
⊢ ApproximatesLinearOn f f' s c ↔ LipschitzOnWith c (f - ↑f') s

tactic: simp only [map_sub, Pi.sub_apply]
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.26755
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.26858
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f✝ : E → F
f'✝ : E →L[𝕜] F
s✝ t : Set E
c✝ c' : ℝ≥0
f : E → F
f' : E →L[𝕜] F
s : Set E
c : ℝ≥0
x y : E
⊢ f x - f y - ↑f' (x - y) = (f - ↑f') x - (f - ↑f') y

tactic: abel
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.26755
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.26858
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f✝ : E → F
f'✝ : E →L[𝕜] F
s✝ t : Set E
c✝ c' : ℝ≥0
f : E → F
f' : E →L[𝕜] F
s : Set E
c : ℝ≥0
x y : E
⊢ f x - f y - (↑f' x - ↑f' y) = f x - ↑f' x - (f y - ↑f' y)
Theorem: Stream'.WSeq.cons_congr
File: Mathlib/Data/Seq/WSeq.lean

tactic: unfold Equiv
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
a : α
h : s ~ʷ t
⊢ cons a s ~ʷ cons a t

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
a : α
h : s ~ʷ t
⊢ LiftRel (fun x x_1 => x = x_1) (cons a s) (cons a t)

tactic: exact h
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
a : α
h : s ~ʷ t
⊢ LiftRel (fun x x_1 => x = x_1) s t
Theorem: CategoryTheory.IsIso.of_isIso_comp_left
File: Mathlib/CategoryTheory/Iso.lean

tactic: rw [← id_comp g, ← inv_hom_id f, assoc]
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : IsIso f
inst✝ : IsIso (f ≫ g)
⊢ IsIso g

tactic: infer_instance
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : IsIso f
inst✝ : IsIso (f ≫ g)
⊢ IsIso (inv f ≫ f ≫ g)
Theorem: LinearMap.mulLeft_mul
File: Mathlib/Algebra/Algebra/Bilinear.lean

tactic: ext
state_before: R : Type u_2
A : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : NonUnitalSemiring A
inst✝² : Module R A
inst✝¹ : SMulCommClass R A A
inst✝ : IsScalarTower R A A
a b : A
⊢ mulLeft R (a * b) = comp (mulLeft R a) (mulLeft R b)

tactic: simp only [mulLeft_apply, comp_apply, mul_assoc]
state_before: case h
R : Type u_2
A : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : NonUnitalSemiring A
inst✝² : Module R A
inst✝¹ : SMulCommClass R A A
inst✝ : IsScalarTower R A A
a b x✝ : A
⊢ ↑(mulLeft R (a * b)) x✝ = ↑(comp (mulLeft R a) (mulLeft R b)) x✝
Theorem: GaloisConnection.l_sup
File: Mathlib/Order/GaloisConnection.lean

tactic: simp only [image_pair, isLUB_pair]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.16640
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
l : α → β
u : β → α
gc : GaloisConnection l u
⊢ IsLUB (l '' {a₁, a₂}) (l a₁ ⊔ l a₂)
Theorem: EuclideanGeometry.reflection_orthogonal_vadd
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: rw [reflection_apply, orthogonalProjection_vadd_eq_self hp hv, vsub_vadd_eq_vsub_sub]
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
hp : p ∈ s
v : V
hv : v ∈ (direction s)ᗮ
⊢ ↑(reflection s) (v +ᵥ p) = -v +ᵥ p

tactic: simp
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
hp : p ∈ s
v : V
hv : v ∈ (direction s)ᗮ
⊢ ↑{ val := p, property := hp } -ᵥ p - v +ᵥ ↑{ val := p, property := hp } = -v +ᵥ p
Theorem: MeasureTheory.exists_pos_preimage_ball
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← preimage_iUnion, Metric.iUnion_ball_nat, preimage_univ]
state_before: α : Type u_2
β : Type ?u.837525
γ : Type ?u.837528
δ : Type u_1
ι : Type ?u.837534
R : Type ?u.837537
R' : Type ?u.837540
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : PseudoMetricSpace δ
f : α → δ
x : δ
hμ : μ ≠ 0
⊢ (⋃ (i : ℕ), f ⁻¹' Metric.ball x ↑i) = univ
Theorem: FreimanHom.cancel_left_on
File: Mathlib/Algebra/Hom/Freiman.lean

tactic: simp [hg.cancel_left hf₁ hf₂]
state_before: F : Type ?u.53167
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.53179
G : Type ?u.53182
inst✝⁵ : FunLike F α fun x => β
inst✝⁴ : CommMonoid α
inst✝³ : CommMonoid β
inst✝² : CommMonoid γ
inst✝¹ : CommMonoid δ
inst✝ : CommGroup G
A : Set α
B : Set β
C : Set γ
n : ℕ
a b c d : α
g : B →*[n] γ
f₁ f₂ : A →*[n] β
hg : Set.InjOn (↑g) B
hf₁ : Set.MapsTo (↑f₁) A B
hf₂ : Set.MapsTo (↑f₂) A B
⊢ Set.EqOn (↑(FreimanHom.comp g f₁ hf₁)) (↑(FreimanHom.comp g f₂ hf₂)) A ↔ Set.EqOn (↑f₁) (↑f₂) A
Theorem: SimplicialObject.Splitting.ιSummand_comp_d_comp_πSummand_eq_zero
File: Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean

tactic: rw [A.eqId_iff_mono] at hA
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
j k : ℕ
A : IndexSet [j].op
hA : ¬IndexSet.EqId A
⊢ ιSummand s A ≫ HomologicalComplex.d K[X] j k ≫ πSummand s (IndexSet.id [k].op) = 0

tactic: rw [← assoc, ← s.comp_PInfty_eq_zero_iff, assoc, ← PInfty.comm j k, s.ιSummand_eq, assoc,
  degeneracy_comp_PInfty_assoc X j A.e hA, zero_comp, comp_zero]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
j k : ℕ
A : IndexSet [j].op
hA : ¬Mono (IndexSet.e A)
⊢ ιSummand s A ≫ HomologicalComplex.d K[X] j k ≫ πSummand s (IndexSet.id [k].op) = 0
Theorem: Finsupp.supported_empty
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: ext
state_before: α : Type u_1
M : Type u_2
N : Type ?u.86392
P : Type ?u.86395
R : Type u_3
S : Type ?u.86401
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
l : α →₀ M
h : l ∈ supported M R ∅
⊢ l = 0

tactic: simp_all [mem_supported']
state_before: case h
α : Type u_1
M : Type u_2
N : Type ?u.86392
P : Type ?u.86395
R : Type u_3
S : Type ?u.86401
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
l : α →₀ M
h : l ∈ supported M R ∅
a✝ : α
⊢ ↑l a✝ = ↑0 a✝
Theorem: UniformFun.gc
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: intro 𝓐 𝓕
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.20997
ι : Type ?u.21000
s s' : Set α
x : α
p : Filter ι
g : ι → α
⊢ GaloisConnection (fun 𝓐 => map (UniformFun.phi α β) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α β 𝓕

tactic: symm
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.20997
ι : Type ?u.21000
s s' : Set α
x : α
p : Filter ι
g : ι → α
𝓐 : Filter ((α →ᵤ β) × (α →ᵤ β))
𝓕 : Filter (β × β)
⊢ (fun 𝓐 => map (UniformFun.phi α β) (𝓐 ×ˢ ⊤)) 𝓐 ≤ 𝓕 ↔ 𝓐 ≤ (fun 𝓕 => UniformFun.filter α β 𝓕) 𝓕

tactic: calc
  𝓐 ≤ UniformFun.filter α β 𝓕 ↔ (UniformFun.basis α β 𝓕).sets ⊆ 𝓐.sets :=
    by rw [UniformFun.filter, ← FilterBasis.generate, le_generate_iff]
  _ ↔ ∀ U ∈ 𝓕, UniformFun.gen α β U ∈ 𝓐 := image_subset_iff
  _ ↔ ∀ U ∈ 𝓕,
        { uv | ∀ x, (uv, x) ∈ { t : ((α →ᵤ β) × (α →ᵤ β)) × α | (t.1.1 t.2, t.1.2 t.2) ∈ U } } ∈
          𝓐 :=
    Iff.rfl
  _ ↔ ∀ U ∈ 𝓕,
        { uvx : ((α →ᵤ β) × (α →ᵤ β)) × α | (uvx.1.1 uvx.2, uvx.1.2 uvx.2) ∈ U } ∈
          𝓐 ×ˢ (⊤ : Filter α) :=
    forall₂_congr fun U _hU => mem_prod_top.symm
  _ ↔ lower_adjoint 𝓐 ≤ 𝓕 := Iff.rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.20997
ι : Type ?u.21000
s s' : Set α
x : α
p : Filter ι
g : ι → α
𝓐 : Filter ((α →ᵤ β) × (α →ᵤ β))
𝓕 : Filter (β × β)
⊢ 𝓐 ≤ (fun 𝓕 => UniformFun.filter α β 𝓕) 𝓕 ↔ (fun 𝓐 => map (UniformFun.phi α β) (𝓐 ×ˢ ⊤)) 𝓐 ≤ 𝓕

tactic: rw [UniformFun.filter, ← FilterBasis.generate, le_generate_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.20997
ι : Type ?u.21000
s s' : Set α
x : α
p : Filter ι
g : ι → α
𝓐 : Filter ((α →ᵤ β) × (α →ᵤ β))
𝓕 : Filter (β × β)
⊢ 𝓐 ≤ UniformFun.filter α β 𝓕 ↔ (UniformFun.basis α β 𝓕).sets ⊆ 𝓐.sets
Theorem: exists_clopen_of_totally_separated
File: Mathlib/Topology/Connected.lean

tactic: obtain ⟨U, V, hU, hV, Ux, Vy, f, disj⟩ :=
  TotallySeparatedSpace.isTotallySeparated_univ x (Set.mem_univ x) y (Set.mem_univ y) hxy
state_before: α✝ : Type u
β : Type v
ι : Type ?u.136399
π : ι → Type ?u.136404
inst✝² : TopologicalSpace α✝
s t u v : Set α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : TotallySeparatedSpace α
x y : α
hxy : x ≠ y
⊢ ∃ U, IsClopen U ∧ x ∈ U ∧ y ∈ Uᶜ

tactic: have clopen_U := isClopen_inter_of_disjoint_cover_clopen isClopen_univ f hU hV disj
state_before: case intro.intro.intro.intro.intro.intro.intro
α✝ : Type u
β : Type v
ι : Type ?u.136399
π : ι → Type ?u.136404
inst✝² : TopologicalSpace α✝
s t u v : Set α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : TotallySeparatedSpace α
x y : α
hxy : x ≠ y
U V : Set α
hU : IsOpen U
hV : IsOpen V
Ux : x ∈ U
Vy : y ∈ V
f : univ ⊆ U ∪ V
disj : Disjoint U V
⊢ ∃ U, IsClopen U ∧ x ∈ U ∧ y ∈ Uᶜ

tactic: rw [univ_inter _] at clopen_U
state_before: case intro.intro.intro.intro.intro.intro.intro
α✝ : Type u
β : Type v
ι : Type ?u.136399
π : ι → Type ?u.136404
inst✝² : TopologicalSpace α✝
s t u v : Set α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : TotallySeparatedSpace α
x y : α
hxy : x ≠ y
U V : Set α
hU : IsOpen U
hV : IsOpen V
Ux : x ∈ U
Vy : y ∈ V
f : univ ⊆ U ∪ V
disj : Disjoint U V
clopen_U : IsClopen (univ ∩ U)
⊢ ∃ U, IsClopen U ∧ x ∈ U ∧ y ∈ Uᶜ

tactic: rw [← Set.subset_compl_iff_disjoint_right, subset_compl_comm] at disj
state_before: case intro.intro.intro.intro.intro.intro.intro
α✝ : Type u
β : Type v
ι : Type ?u.136399
π : ι → Type ?u.136404
inst✝² : TopologicalSpace α✝
s t u v : Set α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : TotallySeparatedSpace α
x y : α
hxy : x ≠ y
U V : Set α
hU : IsOpen U
hV : IsOpen V
Ux : x ∈ U
Vy : y ∈ V
f : univ ⊆ U ∪ V
disj : Disjoint U V
clopen_U : IsClopen U
⊢ ∃ U, IsClopen U ∧ x ∈ U ∧ y ∈ Uᶜ

tactic: exact ⟨U, clopen_U, Ux, disj Vy⟩
state_before: case intro.intro.intro.intro.intro.intro.intro
α✝ : Type u
β : Type v
ι : Type ?u.136399
π : ι → Type ?u.136404
inst✝² : TopologicalSpace α✝
s t u v : Set α✝
α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : TotallySeparatedSpace α
x y : α
hxy : x ≠ y
U V : Set α
hU : IsOpen U
hV : IsOpen V
Ux : x ∈ U
Vy : y ∈ V
f : univ ⊆ U ∪ V
disj : V ⊆ Uᶜ
clopen_U : IsClopen U
⊢ ∃ U, IsClopen U ∧ x ∈ U ∧ y ∈ Uᶜ
Theorem: padicValInt_mul_eq_succ
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [padicValInt.mul ha (Int.coe_nat_ne_zero.mpr hp.out.ne_zero)]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : ℤ
ha : a ≠ 0
⊢ padicValInt p (a * ↑p) = padicValInt p a + 1

tactic: simp only [eq_self_iff_true, padicValInt.of_nat, padicValNat_self]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : ℤ
ha : a ≠ 0
⊢ padicValInt p a + padicValInt p ↑p = padicValInt p a + 1
Theorem: CategoryTheory.Limits.IsZero.obj
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean

tactic: let G : C ⥤ D := (CategoryTheory.Functor.const C).obj 0
state_before: C : Type u
inst✝² : Category C
D : Type u'
inst✝¹ : Category D
inst✝ : HasZeroObject D
F : C ⥤ D
hF : IsZero F
X : C
⊢ IsZero (F.obj X)

tactic: have hG : IsZero G := Functor.isZero _ fun _ => isZero_zero _
state_before: C : Type u
inst✝² : Category C
D : Type u'
inst✝¹ : Category D
inst✝ : HasZeroObject D
F : C ⥤ D
hF : IsZero F
X : C
G : C ⥤ D := (Functor.const C).obj 0
⊢ IsZero (F.obj X)

tactic: let e : F ≅ G := hF.iso hG
state_before: C : Type u
inst✝² : Category C
D : Type u'
inst✝¹ : Category D
inst✝ : HasZeroObject D
F : C ⥤ D
hF : IsZero F
X : C
G : C ⥤ D := (Functor.const C).obj 0
hG : IsZero G
⊢ IsZero (F.obj X)

tactic: exact (isZero_zero _).of_iso (e.app X)
state_before: C : Type u
inst✝² : Category C
D : Type u'
inst✝¹ : Category D
inst✝ : HasZeroObject D
F : C ⥤ D
hF : IsZero F
X : C
G : C ⥤ D := (Functor.const C).obj 0
hG : IsZero G
e : F ≅ G := iso hF hG
⊢ IsZero (F.obj X)
Theorem: Con.lift_comp_mk'
File: Mathlib/GroupTheory/Congruence.lean

tactic: ext
state_before: M : Type u_1
N : Type ?u.60480
P : Type u_2
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x y : M
f : M →* P
H : c ≤ ker f
⊢ MonoidHom.comp (lift c f H) (mk' c) = f

tactic: rfl
state_before: case h
M : Type u_1
N : Type ?u.60480
P : Type u_2
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x y : M
f : M →* P
H : c ≤ ker f
x✝ : M
⊢ ↑(MonoidHom.comp (lift c f H) (mk' c)) x✝ = ↑f x✝
Theorem: Nat.image_sub_const_Ico
File: Mathlib/Data/Nat/Interval.lean

tactic: ext x
state_before: a b c : ℕ
h : c ≤ a
⊢ image (fun x => x - c) (Ico a b) = Ico (a - c) (b - c)

tactic: rw [mem_image]
state_before: case a
a b c : ℕ
h : c ≤ a
x : ℕ
⊢ x ∈ image (fun x => x - c) (Ico a b) ↔ x ∈ Ico (a - c) (b - c)

tactic: constructor
state_before: case a
a b c : ℕ
h : c ≤ a
x : ℕ
⊢ (∃ a_1, a_1 ∈ Ico a b ∧ a_1 - c = x) ↔ x ∈ Ico (a - c) (b - c)

tactic: rintro ⟨x, hx, rfl⟩
state_before: case a.mp
a b c : ℕ
h : c ≤ a
x : ℕ
⊢ (∃ a_1, a_1 ∈ Ico a b ∧ a_1 - c = x) → x ∈ Ico (a - c) (b - c)

tactic: rw [mem_Ico] at hx⊢
state_before: case a.mp.intro.intro
a b c : ℕ
h : c ≤ a
x : ℕ
hx : x ∈ Ico a b
⊢ x - c ∈ Ico (a - c) (b - c)

tactic: exact ⟨tsub_le_tsub_right hx.1 _, tsub_lt_tsub_right_of_le (h.trans hx.1) hx.2⟩
state_before: case a.mp.intro.intro
a b c : ℕ
h : c ≤ a
x : ℕ
hx : a ≤ x ∧ x < b
⊢ a - c ≤ x - c ∧ x - c < b - c

tactic: rintro h
state_before: case a.mpr
a b c : ℕ
h : c ≤ a
x : ℕ
⊢ x ∈ Ico (a - c) (b - c) → ∃ a_2, a_2 ∈ Ico a b ∧ a_2 - c = x

tactic: refine' ⟨x + c, _, add_tsub_cancel_right _ _⟩
state_before: case a.mpr
a b c : ℕ
h✝ : c ≤ a
x : ℕ
h : x ∈ Ico (a - c) (b - c)
⊢ ∃ a_1, a_1 ∈ Ico a b ∧ a_1 - c = x

tactic: rw [mem_Ico] at h⊢
state_before: case a.mpr
a b c : ℕ
h✝ : c ≤ a
x : ℕ
h : x ∈ Ico (a - c) (b - c)
⊢ x + c ∈ Ico a b

tactic: exact ⟨tsub_le_iff_right.1 h.1, lt_tsub_iff_right.1 h.2⟩
state_before: case a.mpr
a b c : ℕ
h✝ : c ≤ a
x : ℕ
h : a - c ≤ x ∧ x < b - c
⊢ a ≤ x + c ∧ x + c < b
Theorem: Finset.mem_fin
File: Mathlib/Data/Finset/Image.lean

tactic: simp [Finset.fin, ha, and_comm]
state_before: α : Type ?u.136300
β : Type ?u.136303
γ : Type ?u.136306
n : ℕ
s : Finset ℕ
a : ℕ
ha : a < n
⊢ { val := a, isLt := ha } ∈ Finset.fin n s ↔ ↑{ val := a, isLt := ha } ∈ s
Theorem: CircleDeg1Lift.translate_iterate
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: rw [← coe_pow, ← Units.val_pow_eq_pow_val, translate_pow]
state_before: f g : CircleDeg1Lift
x : ℝ
n : ℕ
⊢ ↑↑(↑translate (↑Multiplicative.ofAdd x))^[n] = ↑↑(↑translate (↑Multiplicative.ofAdd (↑n * x)))
Theorem: StrictAntiOn.strictConcaveOn_of_deriv
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: simpa only [← deriv.neg] using h_anti.neg
state_before: E : Type ?u.448822
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.448918
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
h_anti : StrictAntiOn (deriv f) (interior D)
⊢ StrictMonoOn (deriv (-f)) (interior D)
Theorem: List.append_ne_nil_of_ne_nil_left
File: Std/Data/List/Lemmas.lean

tactic: simp_all
state_before: α : Type u_1
s t : List α
⊢ s ≠ [] → s ++ t ≠ []
Theorem: WithTop.isGLB_sInf
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: by_cases hs : BddBelow s
state_before: α : Type u_1
β : Type ?u.92784
γ : Type ?u.92787
ι : Sort ?u.92790
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
⊢ IsGLB s (sInf s)

tactic: exact isGLB_sInf' hs
state_before: case pos
α : Type u_1
β : Type ?u.92784
γ : Type ?u.92787
ι : Sort ?u.92790
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : BddBelow s
⊢ IsGLB s (sInf s)

tactic: exfalso
state_before: case neg
α : Type u_1
β : Type ?u.92784
γ : Type ?u.92787
ι : Sort ?u.92790
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : ¬BddBelow s
⊢ IsGLB s (sInf s)

tactic: apply hs
state_before: case neg.h
α : Type u_1
β : Type ?u.92784
γ : Type ?u.92787
ι : Sort ?u.92790
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : ¬BddBelow s
⊢ False

tactic: use ⊥
state_before: case neg.h
α : Type u_1
β : Type ?u.92784
γ : Type ?u.92787
ι : Sort ?u.92790
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : ¬BddBelow s
⊢ BddBelow s

tactic: intro _ _
state_before: case neg.h
α : Type u_1
β : Type ?u.92784
γ : Type ?u.92787
ι : Sort ?u.92790
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : ¬BddBelow s
⊢ ⊥ ∈ lowerBounds s

tactic: exact bot_le
state_before: case neg.h
α : Type u_1
β : Type ?u.92784
γ : Type ?u.92787
ι : Sort ?u.92790
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : ¬BddBelow s
a✝¹ : WithTop α
a✝ : a✝¹ ∈ s
⊢ ⊥ ≤ a✝¹
Theorem: PGame.neg_le_zero_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [neg_le_iff, neg_zero]
state_before: x : PGame
⊢ -x ≤ 0 ↔ 0 ≤ x