tasksource/leandojo huggingface dataset:
Theorem: Filter.mem_iInf_of_finite
File: Mathlib/Order/Filter/Basic.lean

tactic: refine' ⟨exists_iInter_of_mem_iInf, _⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
δ : Type ?u.76872
ι✝ : Sort x
f✝ g : Filter α✝
s✝ t : Set α✝
ι : Type u_1
inst✝ : Finite ι
α : Type u_2
f : ι → Filter α
s : Set α
⊢ (s ∈ ⨅ (i : ι), f i) ↔ ∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ (i : ι), t i

tactic: rintro ⟨t, ht, rfl⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
δ : Type ?u.76872
ι✝ : Sort x
f✝ g : Filter α✝
s✝ t : Set α✝
ι : Type u_1
inst✝ : Finite ι
α : Type u_2
f : ι → Filter α
s : Set α
⊢ (∃ t, (∀ (i : ι), t i ∈ f i) ∧ s = ⋂ (i : ι), t i) → s ∈ ⨅ (i : ι), f i

tactic: exact iInter_mem.2 fun i => mem_iInf_of_mem i (ht i)
state_before: case intro.intro
α✝ : Type u
β : Type v
γ : Type w
δ : Type ?u.76872
ι✝ : Sort x
f✝ g : Filter α✝
s t✝ : Set α✝
ι : Type u_1
inst✝ : Finite ι
α : Type u_2
f : ι → Filter α
t : ι → Set α
ht : ∀ (i : ι), t i ∈ f i
⊢ (⋂ (i : ι), t i) ∈ ⨅ (i : ι), f i
Theorem: EMetric.diam_le_iff
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp only [diam, iSup_le_iff]
state_before: α : Type u
β : Type v
X : Type ?u.283736
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
d : ℝ≥0∞
⊢ diam s ≤ d ↔ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → edist x y ≤ d
Theorem: Set.Finite.summable
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: have := hs.toFinset.summable f
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.35832
δ : Type ?u.35835
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b : α
s✝ : Finset β
s : Set β
hs : Set.Finite s
f : β → α
⊢ Summable (f ∘ Subtype.val)

tactic: rwa [hs.coe_toFinset] at this
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.35832
δ : Type ?u.35835
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b : α
s✝ : Finset β
s : Set β
hs : Set.Finite s
f : β → α
this : Summable (f ∘ Subtype.val)
⊢ Summable (f ∘ Subtype.val)
Theorem: RatFunc.intDegree_zero
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [intDegree, num_zero, natDegree_zero, denom_zero, natDegree_one, sub_self]
state_before: K : Type u
inst✝ : Field K
⊢ intDegree 0 = 0
Theorem: Real.tan_add
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: simpa only [← Complex.ofReal_inj, Complex.ofReal_sub, Complex.ofReal_add, Complex.ofReal_div,
  Complex.ofReal_mul, Complex.ofReal_tan] using
  @Complex.tan_add (x : ℂ) (y : ℂ) (by convert h <;> norm_cast)
state_before: x y : ℝ
h :
  ((∀ (k : ℤ), x ≠ (2 * ↑k + 1) * π / 2) ∧ ∀ (l : ℤ), y ≠ (2 * ↑l + 1) * π / 2) ∨
    (∃ k, x = (2 * ↑k + 1) * π / 2) ∧ ∃ l, y = (2 * ↑l + 1) * π / 2
⊢ tan (x + y) = (tan x + tan y) / (1 - tan x * tan y)

tactic: convert h <;> norm_cast
state_before: x y : ℝ
h :
  ((∀ (k : ℤ), x ≠ (2 * ↑k + 1) * π / 2) ∧ ∀ (l : ℤ), y ≠ (2 * ↑l + 1) * π / 2) ∨
    (∃ k, x = (2 * ↑k + 1) * π / 2) ∧ ∃ l, y = (2 * ↑l + 1) * π / 2
⊢ ((∀ (k : ℤ), ↑x ≠ (2 * ↑k + 1) * ↑π / 2) ∧ ∀ (l : ℤ), ↑y ≠ (2 * ↑l + 1) * ↑π / 2) ∨
    (∃ k, ↑x = (2 * ↑k + 1) * ↑π / 2) ∧ ∃ l, ↑y = (2 * ↑l + 1) * ↑π / 2
Theorem: Finset.univ_filter_mem_range
File: Mathlib/Data/Fintype/Basic.lean

tactic: letI : DecidablePred (fun y => ∃ x, f x = y) := by simpa using ‹_›
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.29339
inst✝³ : Fintype α
s t : Finset α
f : α → β
inst✝² : Fintype β
inst✝¹ : DecidablePred fun y => y ∈ Set.range f
inst✝ : DecidableEq β
⊢ filter (fun y => y ∈ Set.range f) univ = image f univ

tactic: exact univ_filter_exists f
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.29339
inst✝³ : Fintype α
s t : Finset α
f : α → β
inst✝² : Fintype β
inst✝¹ : DecidablePred fun y => y ∈ Set.range f
inst✝ : DecidableEq β
this : DecidablePred fun y => ∃ x, f x = y := inst✝¹
⊢ filter (fun y => y ∈ Set.range f) univ = image f univ

tactic: simpa using ‹_›
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.29339
inst✝³ : Fintype α
s t : Finset α
f : α → β
inst✝² : Fintype β
inst✝¹ : DecidablePred fun y => y ∈ Set.range f
inst✝ : DecidableEq β
⊢ DecidablePred fun y => ∃ x, f x = y
Theorem: ConvexOn.lt_left_of_right_lt
File: Mathlib/Analysis/Convex/Function.lean

tactic: obtain ⟨a, b, ha, hb, hab, rfl⟩ := hz
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.610093
α : Type ?u.610096
β : Type u_3
ι : Type ?u.610102
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y z : E
hx : x ∈ s
hy : y ∈ s
hz : z ∈ openSegment 𝕜 x y
hyz : f y < f z
⊢ f z < f x

tactic: exact hf.lt_left_of_right_lt' hx hy ha hb hab hyz
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.610093
α : Type ?u.610096
β : Type u_3
ι : Type ?u.610102
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
hx : x ∈ s
hy : y ∈ s
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hyz : f y < f (a • x + b • y)
⊢ f (a • x + b • y) < f x
Theorem: uniformContinuousOn_iff_restrict
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: delta UniformContinuousOn UniformContinuous
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.149530
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
⊢ UniformContinuousOn f s ↔ UniformContinuous (restrict s f)

tactic: rw [← map_uniformity_set_coe, tendsto_map'_iff]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.149530
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
⊢ Tendsto (fun x => (f x.fst, f x.snd)) (𝓤 α ⊓ 𝓟 (s ×ˢ s)) (𝓤 β) ↔
    Tendsto (fun x => (restrict s f x.fst, restrict s f x.snd)) (𝓤 ↑s) (𝓤 β)

tactic: rfl
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.149530
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
⊢ Tendsto ((fun x => (f x.fst, f x.snd)) ∘ Prod.map Subtype.val Subtype.val) (𝓤 ↑s) (𝓤 β) ↔
    Tendsto (fun x => (restrict s f x.fst, restrict s f x.snd)) (𝓤 ↑s) (𝓤 β)
Theorem: ciSup_unique
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: have : ∀ i, s i = s default := fun i => congr_arg s (Unique.eq_default i)
state_before: α : Type u_2
β : Type ?u.59227
γ : Type ?u.59230
ι : Sort u_1
inst✝¹ : ConditionallyCompleteLattice α
s✝ t : Set α
a b : α
inst✝ : Unique ι
s : ι → α
⊢ (⨆ (i : ι), s i) = s default

tactic: simp only [this, ciSup_const]
state_before: α : Type u_2
β : Type ?u.59227
γ : Type ?u.59230
ι : Sort u_1
inst✝¹ : ConditionallyCompleteLattice α
s✝ t : Set α
a b : α
inst✝ : Unique ι
s : ι → α
this : ∀ (i : ι), s i = s default
⊢ (⨆ (i : ι), s i) = s default
Theorem: Real.lt_logb_iff_rpow_lt_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← rpow_lt_rpow_left_iff_of_base_lt_one b_pos b_lt_one, rpow_logb b_pos (b_ne_one b_lt_one) hy]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hy : 0 < y
⊢ x < logb b y ↔ y < b ^ x
Theorem: differentiableAt_euclidean
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: rw [← (EuclideanSpace.equiv ι 𝕜).comp_differentiableAt_iff, differentiableAt_pi]
state_before: 𝕜 : Type u_1
ι : Type u_3
H : Type u_2
inst✝³ : IsROrC 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ DifferentiableAt 𝕜 f y ↔ ∀ (i : ι), DifferentiableAt 𝕜 (fun x => f x i) y

tactic: rfl
state_before: 𝕜 : Type u_1
ι : Type u_3
H : Type u_2
inst✝³ : IsROrC 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ (∀ (i : ι), DifferentiableAt 𝕜 (fun x => (↑(EuclideanSpace.equiv ι 𝕜) ∘ f) x i) y) ↔
    ∀ (i : ι), DifferentiableAt 𝕜 (fun x => f x i) y
Theorem: Nat.bit0_div_bit0
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [bit0_eq_two_mul m, ← Nat.div_div_eq_div_mul, bit0_div_two]
state_before: m n : ℕ
⊢ bit0 n / bit0 m = n / m
Theorem: Metric.ball_eq_ball'
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: ext
state_before: α : Type u
β : Type v
X : Type ?u.28557
ι : Type ?u.28560
inst✝ : PseudoMetricSpace α
x✝ y z : α
δ ε✝ ε₁ ε₂ : ℝ
s : Set α
ε : ℝ
x : α
⊢ UniformSpace.ball x {p | dist p.fst p.snd < ε} = ball x ε

tactic: simp [dist_comm, UniformSpace.ball]
state_before: case h
α : Type u
β : Type v
X : Type ?u.28557
ι : Type ?u.28560
inst✝ : PseudoMetricSpace α
x✝¹ y z : α
δ ε✝ ε₁ ε₂ : ℝ
s : Set α
ε : ℝ
x x✝ : α
⊢ x✝ ∈ UniformSpace.ball x {p | dist p.fst p.snd < ε} ↔ x✝ ∈ ball x ε
Theorem: Int.emod_add_emod
File: Std/Data/Int/DivMod.lean

tactic: have := (add_mul_emod_self_left (m % n + k) n (m / n)).symm
state_before: m n k : Int
⊢ (m % n + k) % n = (m + k) % n

tactic: rwa [Int.add_right_comm, emod_add_ediv] at this
state_before: m n k : Int
this : (m % n + k) % n = (m % n + k + n * (m / n)) % n
⊢ (m % n + k) % n = (m + k) % n
Theorem: MeasureTheory.norm_Lp_toLp_restrict_le
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [Lp.norm_def, Lp.norm_def, ENNReal.toReal_le_toReal (Lp.snorm_ne_top _) (Lp.snorm_ne_top _)]
state_before: α : Type u_1
β : Type ?u.334371
E : Type u_2
F : Type ?u.334377
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
𝕜 : Type ?u.334386
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : ℝ≥0∞
μ : Measure α
s : Set α
f : { x // x ∈ Lp E p }
⊢ ‖Memℒp.toLp ↑↑f (_ : Memℒp (↑↑f) p)‖ ≤ ‖f‖

tactic: refine' (le_of_eq _).trans (snorm_mono_measure _ Measure.restrict_le_self)
state_before: α : Type u_1
β : Type ?u.334371
E : Type u_2
F : Type ?u.334377
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
𝕜 : Type ?u.334386
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : ℝ≥0∞
μ : Measure α
s : Set α
f : { x // x ∈ Lp E p }
⊢ snorm (↑↑(Memℒp.toLp ↑↑f (_ : Memℒp (↑↑f) p))) p (Measure.restrict μ s) ≤ snorm (↑↑f) p μ

tactic: exact snorm_congr_ae (Memℒp.coeFn_toLp _)
state_before: case refine'_1
α : Type u_1
β : Type ?u.334371
E : Type u_2
F : Type ?u.334377
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
𝕜 : Type ?u.334386
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : ℝ≥0∞
μ : Measure α
s : Set α
f : { x // x ∈ Lp E p }
⊢ snorm (↑↑(Memℒp.toLp ↑↑f (_ : Memℒp (↑↑f) p))) p (Measure.restrict μ s) =
    snorm (↑↑f) p (Measure.restrict μ ?refine'_2)

case refine'_2
α : Type u_1
β : Type ?u.334371
E : Type u_2
F : Type ?u.334377
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
𝕜 : Type ?u.334386
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : ℝ≥0∞
μ : Measure α
s : Set α
f : { x // x ∈ Lp E p }
⊢ Set α
Theorem: EuclideanDomain.gcd_zero_left
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

tactic: rw [gcd]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a : R
⊢ gcd 0 a = a

tactic: exact if_pos rfl
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a : R
⊢ (fun b =>
        if a0 : 0 = 0 then b
        else
          let_fun x := (_ : b % 0 ≺ 0);
          gcd (b % 0) 0)
      a =
    a
Theorem: SimpleGraph.Subgraph.coe_deleteEdges_eq
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext ⟨v, hv⟩ ⟨w, hw⟩
state_before: ι : Sort ?u.246328
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ s : Set (Sym2 V)
⊢ Subgraph.coe (deleteEdges G' s) = SimpleGraph.deleteEdges (Subgraph.coe G') (Sym2.map Subtype.val ⁻¹' s)

tactic: simp
state_before: case Adj.h.mk.h.mk.a
ι : Sort ?u.246328
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s✝ s : Set (Sym2 V)
v : V
hv : v ∈ (deleteEdges G' s).verts
w : V
hw : w ∈ (deleteEdges G' s).verts
⊢ SimpleGraph.Adj (Subgraph.coe (deleteEdges G' s)) { val := v, property := hv } { val := w, property := hw } ↔
    SimpleGraph.Adj (SimpleGraph.deleteEdges (Subgraph.coe G') (Sym2.map Subtype.val ⁻¹' s))
      { val := v, property := hv } { val := w, property := hw }
Theorem: Module.Projective.of_basis
File: Mathlib/Algebra/Module/Projective.lean

tactic: use b.constr ℕ fun i => Finsupp.single (b i) (1 : R)
state_before: R : Type u_2
inst✝² : Ring R
P : Type u_3
inst✝¹ : AddCommGroup P
inst✝ : Module R P
ι : Type u_1
b : Basis ι R P
⊢ Projective R P

tactic: intro m
state_before: R : Type u_2
inst✝² : Ring R
P : Type u_3
inst✝¹ : AddCommGroup P
inst✝ : Module R P
ι : Type u_1
b : Basis ι R P
⊢ Function.LeftInverse ↑(Finsupp.total P P R id) ↑(↑(Basis.constr b ℕ) fun i => Finsupp.single (↑b i) 1)

tactic: simp only [b.constr_apply, mul_one, id.def, Finsupp.smul_single', Finsupp.total_single,
  LinearMap.map_finsupp_sum]
state_before: R : Type u_2
inst✝² : Ring R
P : Type u_3
inst✝¹ : AddCommGroup P
inst✝ : Module R P
ι : Type u_1
b : Basis ι R P
m : P
⊢ ↑(Finsupp.total P P R id) (↑(↑(Basis.constr b ℕ) fun i => Finsupp.single (↑b i) 1) m) = m

tactic: exact b.total_repr m
state_before: R : Type u_2
inst✝² : Ring R
P : Type u_3
inst✝¹ : AddCommGroup P
inst✝ : Module R P
ι : Type u_1
b : Basis ι R P
m : P
⊢ (sum (↑b.repr m) fun i d => d • ↑b i) = m
Theorem: CategoryTheory.Limits.colimit.pre_eq
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: aesop_cat
state_before: J : Type u₁
inst✝⁶ : Category J
K : Type u₂
inst✝⁵ : Category K
C : Type u
inst✝⁴ : Category C
F : J ⥤ C
inst✝³ : HasColimit F
E : K ⥤ J
inst✝² : HasColimit (E ⋙ F)
L : Type u₃
inst✝¹ : Category L
D : L ⥤ K
inst✝ : HasColimit (D ⋙ E ⋙ F)
s : ColimitCocone (E ⋙ F)
t : ColimitCocone F
⊢ pre F E = (isoColimitCocone s).hom ≫ IsColimit.desc s.isColimit (Cocone.whisker E t.cocone) ≫ (isoColimitCocone t).inv
Theorem: Submodule.torsionBy_le_torsionBy_of_dvd
File: Mathlib/Algebra/Module/Torsion.lean

tactic: rw [← torsionBySet_span_singleton_eq, ← torsionBySet_singleton_eq]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a✝ a b : R
dvd : a ∣ b
⊢ torsionBy R M a ≤ torsionBy R M b

tactic: apply torsionBySet_le_torsionBySet_of_subset
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a✝ a b : R
dvd : a ∣ b
⊢ torsionBySet R M ↑(span R {a}) ≤ torsionBySet R M {b}

tactic: rintro c (rfl : c = b)
state_before: case st
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a✝ a b : R
dvd : a ∣ b
⊢ {b} ⊆ ↑(span R {a})

tactic: exact Ideal.mem_span_singleton.mpr dvd
state_before: case st
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a✝ a c : R
dvd : a ∣ c
⊢ c ∈ ↑(span R {a})
Theorem: Equiv.conj_comp
File: Mathlib/Logic/Equiv/Defs.lean

tactic: apply arrowCongr_comp
state_before: α : Sort u
β : Sort v
γ : Sort w
e : α ≃ β
f₁ f₂ : α → α
⊢ ↑(conj e) (f₁ ∘ f₂) = ↑(conj e) f₁ ∘ ↑(conj e) f₂
Theorem: Fin.sizeOf
File: src/lean/Init/SizeOfLemmas.lean

tactic: cases a
state_before: n : Nat
a : Fin n
⊢ SizeOf.sizeOf a = a.val + 1

tactic: simp_arith
state_before: case mk
n val✝ : Nat
isLt✝ : val✝ < n
⊢ SizeOf.sizeOf { val := val✝, isLt := isLt✝ } = { val := val✝, isLt := isLt✝ }.val + 1
Theorem: TendstoUniformly.comp
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [tendstoUniformly_iff_tendstoUniformlyOnFilter] at h⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g✝ : ι → α
h : TendstoUniformly F f p
g : γ → α
⊢ TendstoUniformly (fun n => F n ∘ g) (f ∘ g) p

tactic: simpa [principal_univ, comap_principal] using h.comp g
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g✝ : ι → α
h : TendstoUniformlyOnFilter F f p ⊤
g : γ → α
⊢ TendstoUniformlyOnFilter (fun n => F n ∘ g) (f ∘ g) p ⊤
Theorem: Equiv.Perm.IsCycle.ne_one
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [hf, IsCycle] at h
state_before: ι : Type ?u.306885
α : Type u_1
β : Type ?u.306891
f g : Perm α
x y : α
h : IsCycle f
hf : f = 1
⊢ False
Theorem: CategoryTheory.MorphismProperty.monomorphisms.iff
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: rfl
state_before: C : Type u
inst✝¹ : Category C
D : Type ?u.59403
inst✝ : Category D
X Y : C
f : X ⟶ Y
⊢ monomorphisms C f ↔ Mono f
Theorem: OreLocalization.div_eq_one'
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: rw [OreLocalization.one_def, oreDiv_eq_iff]
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r : R
hr : r ∈ S
⊢ r /ₒ { val := r, property := hr } = 1

tactic: exact ⟨⟨r, hr⟩, 1, by simp, by simp⟩
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r : R
hr : r ∈ S
⊢ ∃ u v, 1 * ↑u = r * v ∧ ↑1 * ↑u = ↑{ val := r, property := hr } * v

tactic: simp
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r : R
hr : r ∈ S
⊢ 1 * ↑{ val := r, property := hr } = r * 1

tactic: simp
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r : R
hr : r ∈ S
⊢ ↑1 * ↑{ val := r, property := hr } = ↑{ val := r, property := hr } * 1
Theorem: Polynomial.divX_C
File: Mathlib/Data/Polynomial/Inductions.lean

tactic: simp [coeff_divX, coeff_C, Finsupp.single_eq_of_ne _]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
a : R
n : ℕ
⊢ coeff (divX (↑C a)) n = coeff 0 n
Theorem: inf_symmDiff_symmDiff
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_comm, symmDiff_symmDiff_inf]
state_before: ι : Type ?u.34523
α : Type u_1
β : Type ?u.34529
π : ι → Type ?u.34534
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ (a ⊓ b) ∆ (a ∆ b) = a ⊔ b
Theorem: Real.sqrt_inj
File: Mathlib/Data/Real/Sqrt.lean

tactic: simp [le_antisymm_iff, hx, hy]
state_before: x y : ℝ
hx : 0 ≤ x
hy : 0 ≤ y
⊢ sqrt x = sqrt y ↔ x = y
Theorem: IsOpenMap.preimage_frontier_eq_frontier_preimage
File: Mathlib/Topology/Maps.lean

tactic: simp only [frontier_eq_closure_inter_closure, preimage_inter, preimage_compl,
  hf.preimage_closure_eq_closure_preimage hfc]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.196791
δ : Type ?u.196794
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : IsOpenMap f
hfc : Continuous f
s : Set β
⊢ f ⁻¹' frontier s = frontier (f ⁻¹' s)
Theorem: Set.le_chainHeight_TFAE
File: Mathlib/Order/Height.lean

tactic: tfae_have 1 → 2
state_before: α : Type u_1
β : Type ?u.5660
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
⊢ TFAE [↑n ≤ chainHeight s, ∃ l, l ∈ subchain s ∧ length l = n, ∃ l, l ∈ subchain s ∧ n ≤ length l]

tactic: tfae_have 2 → 3
state_before: α : Type u_1
β : Type ?u.5660
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ chainHeight s → ∃ l, l ∈ subchain s ∧ length l = n
⊢ TFAE [↑n ≤ chainHeight s, ∃ l, l ∈ subchain s ∧ length l = n, ∃ l, l ∈ subchain s ∧ n ≤ length l]

tactic: tfae_have 3 → 1
state_before: α : Type u_1
β : Type ?u.5660
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ chainHeight s → ∃ l, l ∈ subchain s ∧ length l = n
tfae_2_to_3 : (∃ l, l ∈ subchain s ∧ length l = n) → ∃ l, l ∈ subchain s ∧ n ≤ length l
⊢ TFAE [↑n ≤ chainHeight s, ∃ l, l ∈ subchain s ∧ length l = n, ∃ l, l ∈ subchain s ∧ n ≤ length l]

tactic: tfae_finish
state_before: α : Type u_1
β : Type ?u.5660
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ chainHeight s → ∃ l, l ∈ subchain s ∧ length l = n
tfae_2_to_3 : (∃ l, l ∈ subchain s ∧ length l = n) → ∃ l, l ∈ subchain s ∧ n ≤ length l
tfae_3_to_1 : (∃ l, l ∈ subchain s ∧ n ≤ length l) → ↑n ≤ chainHeight s
⊢ TFAE [↑n ≤ chainHeight s, ∃ l, l ∈ subchain s ∧ length l = n, ∃ l, l ∈ subchain s ∧ n ≤ length l]

tactic: exact s.exists_chain_of_le_chainHeight
state_before: case tfae_1_to_2
α : Type u_1
β : Type ?u.5660
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
⊢ ↑n ≤ chainHeight s → ∃ l, l ∈ subchain s ∧ length l = n

tactic: rintro ⟨l, hls, he⟩
state_before: case tfae_2_to_3
α : Type u_1
β : Type ?u.5660
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ chainHeight s → ∃ l, l ∈ subchain s ∧ length l = n
⊢ (∃ l, l ∈ subchain s ∧ length l = n) → ∃ l, l ∈ subchain s ∧ n ≤ length l

tactic: exact ⟨l, hls, he.ge⟩
state_before: case tfae_2_to_3.intro.intro
α : Type u_1
β : Type ?u.5660
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l✝ : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ chainHeight s → ∃ l, l ∈ subchain s ∧ length l = n
l : List α
hls : l ∈ subchain s
he : length l = n
⊢ ∃ l, l ∈ subchain s ∧ n ≤ length l

tactic: rintro ⟨l, hs, hn⟩
state_before: case tfae_3_to_1
α : Type u_1
β : Type ?u.5660
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ chainHeight s → ∃ l, l ∈ subchain s ∧ length l = n
tfae_2_to_3 : (∃ l, l ∈ subchain s ∧ length l = n) → ∃ l, l ∈ subchain s ∧ n ≤ length l
⊢ (∃ l, l ∈ subchain s ∧ n ≤ length l) → ↑n ≤ chainHeight s

tactic: exact le_iSup₂_of_le l hs (WithTop.coe_le_coe.2 hn)
state_before: case tfae_3_to_1.intro.intro
α : Type u_1
β : Type ?u.5660
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l✝ : List α
a : α
n : ℕ
tfae_1_to_2 : ↑n ≤ chainHeight s → ∃ l, l ∈ subchain s ∧ length l = n
tfae_2_to_3 : (∃ l, l ∈ subchain s ∧ length l = n) → ∃ l, l ∈ subchain s ∧ n ≤ length l
l : List α
hs : l ∈ subchain s
hn : n ≤ length l
⊢ ↑n ≤ chainHeight s
Theorem: CategoryTheory.Bicategory.pentagon_hom_hom_inv_inv_hom
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv ((α_ f (g ≫ h) i).hom ≫ f ◁ (α_ g h i).hom ≫ (α_ f g (h ≫ i)).inv) =
    inv ((α_ f g h).inv ▷ i ≫ (α_ (f ≫ g) h i).hom)
Theorem: MvPowerSeries.constantCoeff_invOfUnit
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [← coeff_zero_eq_constantCoeff_apply, coeff_invOfUnit, if_pos rfl]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
u : Rˣ
⊢ ↑(constantCoeff σ R) (invOfUnit φ u) = ↑u⁻¹
Theorem: Finset.not_mem_sigmaLift_of_ne_right
File: Mathlib/Data/Finset/Sigma.lean

tactic: rw [mem_sigmaLift]
state_before: ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
h : b.fst ≠ x.fst
⊢ ¬x ∈ sigmaLift f a b

tactic: exact fun H => h H.snd.fst
state_before: ι : Type u_2
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_1
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
h : b.fst ≠ x.fst
⊢ ¬∃ ha hb, x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)
Theorem: SimplicialObject.Splitting.IndexSet.eqId_iff_len_le
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: rw [eqId_iff_len_eq]
state_before: C : Type ?u.4924
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ EqId A ↔ len Δ.unop ≤ len A.fst.unop

tactic: constructor
state_before: C : Type ?u.4924
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ len A.fst.unop = len Δ.unop ↔ len Δ.unop ≤ len A.fst.unop

tactic: intro h
state_before: case mp
C : Type ?u.4924
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ len A.fst.unop = len Δ.unop → len Δ.unop ≤ len A.fst.unop

tactic: rw [h]
state_before: case mp
C : Type ?u.4924
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
h : len A.fst.unop = len Δ.unop
⊢ len Δ.unop ≤ len A.fst.unop

tactic: exact le_antisymm (len_le_of_epi (inferInstance : Epi A.e))
state_before: case mpr
C : Type ?u.4924
inst✝ : Category C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ len Δ.unop ≤ len A.fst.unop → len A.fst.unop = len Δ.unop