tasksource/leandojo huggingface dataset:
Theorem: List.trop_sum
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: induction' l with hd tl IH
state_before: R : Type u_1
S : Type ?u.11
inst✝ : AddMonoid R
l : List R
⊢ trop (sum l) = prod (map trop l)

tactic: simp
state_before: case nil
R : Type u_1
S : Type ?u.11
inst✝ : AddMonoid R
⊢ trop (sum []) = prod (map trop [])

tactic: simp [← IH]
state_before: case cons
R : Type u_1
S : Type ?u.11
inst✝ : AddMonoid R
hd : R
tl : List R
IH : trop (sum tl) = prod (map trop tl)
⊢ trop (sum (hd :: tl)) = prod (map trop (hd :: tl))
Theorem: ContinuousMap.continuous_curry
File: Mathlib/Topology/CompactOpen.lean

tactic: apply continuous_of_continuous_uncurry
state_before: α : Type u_2
β : Type u_1
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : LocallyCompactSpace (α × β)
⊢ Continuous curry

tactic: apply continuous_of_continuous_uncurry
state_before: case h
α : Type u_2
β : Type u_1
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : LocallyCompactSpace (α × β)
⊢ Continuous (Function.uncurry fun x y => ↑(curry x) y)

tactic: rw [← (Homeomorph.prodAssoc _ _ _).symm.comp_continuous_iff']
state_before: case h.h
α : Type u_2
β : Type u_1
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : LocallyCompactSpace (α × β)
⊢ Continuous (Function.uncurry fun x y => ↑(Function.uncurry (fun x y => ↑(curry x) y) x) y)

tactic: exact continuous_eval'
state_before: case h.h
α : Type u_2
β : Type u_1
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : LocallyCompactSpace (α × β)
⊢ Continuous
    ((Function.uncurry fun x y => ↑(Function.uncurry (fun x y => ↑(curry x) y) x) y) ∘
      ↑(Homeomorph.symm (Homeomorph.prodAssoc C(α × β, γ) α β)))
Theorem: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom_comp
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
j : J
⊢ (conePointsIsoOfNatIso P Q w).hom ≫ t.π.app j = s.π.app j ≫ w.hom.app j
Theorem: intervalIntegral.integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa [integral_const]
  using measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae hab hmeas_a hmeas_b
    ha_lim hb_lim hua hva hub hvb
state_before: ι : Type u_2
𝕜 : Type ?u.1622147
E : Type u_1
F : Type ?u.1622153
A : Type ?u.1622156
inst✝⁴ : NormedAddCommGroup E
inst✝³ : CompleteSpace E
inst✝² : NormedSpace ℝ E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u v ua ub va vb : ι → ℝ
inst✝¹ : FTCFilter a la la'
inst✝ : FTCFilter b lb lb'
hab : IntervalIntegrable f volume a b
hmeas_a : StronglyMeasurableAtFilter f la'
hmeas_b : StronglyMeasurableAtFilter f lb'
ha_lim : Tendsto f (la' ⊓ Measure.ae volume) (𝓝 ca)
hb_lim : Tendsto f (lb' ⊓ Measure.ae volume) (𝓝 cb)
hua : Tendsto ua lt la
hva : Tendsto va lt la
hub : Tendsto ub lt lb
hvb : Tendsto vb lt lb
⊢ (fun t =>
      ((∫ (x : ℝ) in va t..vb t, f x) - ∫ (x : ℝ) in ua t..ub t, f x) -
        ((vb t - ub t) • cb - (va t - ua t) • ca)) =o[lt]
    fun t => ‖va t - ua t‖ + ‖vb t - ub t‖
Theorem: Polynomial.degree_cubic_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simpa only [add_assoc] using
  degree_add_le_of_degree_le (degree_C_mul_X_pow_le 3 a)
    (le_trans degree_quadratic_le <| WithBot.coe_le_coe.mpr <| Nat.le_succ 2)
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.1218360
⊢ degree (↑C a * X ^ 3 + ↑C b * X ^ 2 + ↑C c * X + ↑C d) ≤ 3
Theorem: Cardinal.nat_le_lift_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_natCast.{v,u}, lift_le]
state_before: α β : Type u
n : ℕ
a : Cardinal
⊢ ↑n ≤ lift a ↔ ↑n ≤ a
Theorem: CategoryTheory.Adjunction.homEquiv_id
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X✝ : C
Y Y' : D
X : C
⊢ ↑(homEquiv adj X (F.obj X)) (𝟙 (F.obj X)) = adj.unit.app X
Theorem: nonPrincipals_eq_empty_iff
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: simp [Set.eq_empty_iff_forall_not_mem, isPrincipalIdealRing_iff, nonPrincipals_def]
state_before: R : Type u
M : Type v
inst✝ : CommRing R
⊢ nonPrincipals R = ∅ ↔ IsPrincipalIdealRing R
Theorem: PrimeMultiset.prod_sup
File: Mathlib/Data/PNat/Factors.lean

tactic: let n := u.prod
state_before: u v : PrimeMultiset
⊢ prod (u ⊔ v) = PNat.lcm (prod u) (prod v)

tactic: let m := v.prod
state_before: u v : PrimeMultiset
n : ℕ+ := prod u
⊢ prod (u ⊔ v) = PNat.lcm (prod u) (prod v)

tactic: change (u ⊔ v).prod = PNat.lcm n m
state_before: u v : PrimeMultiset
n : ℕ+ := prod u
m : ℕ+ := prod v
⊢ prod (u ⊔ v) = PNat.lcm (prod u) (prod v)

tactic: have : u = n.factorMultiset := u.factorMultiset_prod.symm
state_before: u v : PrimeMultiset
n : ℕ+ := prod u
m : ℕ+ := prod v
⊢ prod (u ⊔ v) = PNat.lcm n m

tactic: rw [this]
state_before: u v : PrimeMultiset
n : ℕ+ := prod u
m : ℕ+ := prod v
this : u = PNat.factorMultiset n
⊢ prod (u ⊔ v) = PNat.lcm n m

tactic: have : v = m.factorMultiset := v.factorMultiset_prod.symm
state_before: u v : PrimeMultiset
n : ℕ+ := prod u
m : ℕ+ := prod v
this : u = PNat.factorMultiset n
⊢ prod (PNat.factorMultiset n ⊔ v) = PNat.lcm n m

tactic: rw [this]
state_before: u v : PrimeMultiset
n : ℕ+ := prod u
m : ℕ+ := prod v
this✝ : u = PNat.factorMultiset n
this : v = PNat.factorMultiset m
⊢ prod (PNat.factorMultiset n ⊔ v) = PNat.lcm n m

tactic: rw [← PNat.factorMultiset_lcm n m, PNat.prod_factorMultiset]
state_before: u v : PrimeMultiset
n : ℕ+ := prod u
m : ℕ+ := prod v
this✝ : u = PNat.factorMultiset n
this : v = PNat.factorMultiset m
⊢ prod (PNat.factorMultiset n ⊔ PNat.factorMultiset m) = PNat.lcm n m
Theorem: Cardinal.lift_mk_le_lift_mk_mul_of_lift_mk_preimage_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [Equiv.image_eq_preimage]
state_before: α✝ β✝ α : Type u
β : Type v
c : Cardinal
f : α → β
hf : ∀ (b : β), lift (#↑(f ⁻¹' {b})) ≤ c
b : β
⊢ ↑(↑Equiv.ulift '' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})

tactic: have : FunLike.coe (Equiv.symm (Equiv.ulift (α := α))) = ULift.up (α := α) := rfl
state_before: α✝ β✝ α : Type u
β : Type v
c : Cardinal
f : α → β
hf : ∀ (b : β), lift (#↑(f ⁻¹' {b})) ≤ c
b : β
⊢ ↑(↑Equiv.ulift.symm ⁻¹' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})

tactic: rw [this]
state_before: α✝ β✝ α : Type u
β : Type v
c : Cardinal
f : α → β
hf : ∀ (b : β), lift (#↑(f ⁻¹' {b})) ≤ c
b : β
this : ↑Equiv.ulift.symm = ULift.up
⊢ ↑(↑Equiv.ulift.symm ⁻¹' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})

tactic: simp only [preimage, mem_singleton_iff, ULift.up_inj, mem_setOf_eq, coe_setOf]
state_before: α✝ β✝ α : Type u
β : Type v
c : Cardinal
f : α → β
hf : ∀ (b : β), lift (#↑(f ⁻¹' {b})) ≤ c
b : β
this : ↑Equiv.ulift.symm = ULift.up
⊢ ↑(ULift.up ⁻¹' ((fun x => { down := f x.down }) ⁻¹' {{ down := b }})) ≃ ↑(f ⁻¹' {b})

tactic: exact Equiv.refl _
state_before: α✝ β✝ α : Type u
β : Type v
c : Cardinal
f : α → β
hf : ∀ (b : β), lift (#↑(f ⁻¹' {b})) ≤ c
b : β
this : ↑Equiv.ulift.symm = ULift.up
⊢ { x // f x = b } ≃ { x // f x = b }
Theorem: tendsto_Ioo_atTop
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [← comap_coe_Ioo_nhdsWithin_Iio, tendsto_comap_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Ioo a b)
⊢ Tendsto f l atTop ↔ Tendsto (fun x => ↑(f x)) l (𝓝[Iio b] b)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f✝ : α → β
f : β → ↑(Ioo a b)
⊢ Tendsto (Subtype.val ∘ f) l (𝓝[Iio b] b) ↔ Tendsto (fun x => ↑(f x)) l (𝓝[Iio b] b)
Theorem: InnerProductGeometry.angle_smul_right_of_pos
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: unfold angle
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
r : ℝ
hr : 0 < r
⊢ angle x (r • y) = angle x y

tactic: rw [inner_smul_right, norm_smul, Real.norm_eq_abs, abs_of_nonneg (le_of_lt hr), ← mul_assoc,
  mul_comm _ r, mul_assoc, mul_div_mul_left _ _ (ne_of_gt hr)]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
r : ℝ
hr : 0 < r
⊢ arccos (inner x (r • y) / (‖x‖ * ‖r • y‖)) = arccos (inner x y / (‖x‖ * ‖y‖))
Theorem: Nat.Primrec.id
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: n : ℕ
⊢ Nat.pair (unpair n).fst (unpair n).snd = id n
Theorem: convexIndependent_set_iff_not_mem_convexHull_diff
File: Mathlib/Analysis/Convex/Independent.lean

tactic: rw [convexIndependent_set_iff_inter_convexHull_subset]
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.41306
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t s : Set E
⊢ ConvexIndependent 𝕜 Subtype.val ↔ ∀ (x : E), x ∈ s → ¬x ∈ ↑(convexHull 𝕜).toOrderHom (s \ {x})

tactic: constructor
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.41306
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t s : Set E
⊢ (∀ (t : Set E), t ⊆ s → s ∩ ↑(convexHull 𝕜).toOrderHom t ⊆ t) ↔
    ∀ (x : E), x ∈ s → ¬x ∈ ↑(convexHull 𝕜).toOrderHom (s \ {x})

tactic: rintro hs x hxs hx
state_before: case mp
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.41306
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t s : Set E
⊢ (∀ (t : Set E), t ⊆ s → s ∩ ↑(convexHull 𝕜).toOrderHom t ⊆ t) →
    ∀ (x : E), x ∈ s → ¬x ∈ ↑(convexHull 𝕜).toOrderHom (s \ {x})

tactic: exact (hs _ (Set.diff_subset _ _) ⟨hxs, hx⟩).2 (Set.mem_singleton _)
state_before: case mp
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.41306
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t s : Set E
hs : ∀ (t : Set E), t ⊆ s → s ∩ ↑(convexHull 𝕜).toOrderHom t ⊆ t
x : E
hxs : x ∈ s
hx : x ∈ ↑(convexHull 𝕜).toOrderHom (s \ {x})
⊢ False

tactic: rintro hs t ht x ⟨hxs, hxt⟩
state_before: case mpr
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.41306
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t s : Set E
⊢ (∀ (x : E), x ∈ s → ¬x ∈ ↑(convexHull 𝕜).toOrderHom (s \ {x})) →
    ∀ (t : Set E), t ⊆ s → s ∩ ↑(convexHull 𝕜).toOrderHom t ⊆ t

tactic: by_contra h
state_before: case mpr.intro
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.41306
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t✝ s : Set E
hs : ∀ (x : E), x ∈ s → ¬x ∈ ↑(convexHull 𝕜).toOrderHom (s \ {x})
t : Set E
ht : t ⊆ s
x : E
hxs : x ∈ s
hxt : x ∈ ↑(convexHull 𝕜).toOrderHom t
⊢ x ∈ t

tactic: exact hs _ hxs (convexHull_mono (Set.subset_diff_singleton ht h) hxt)
state_before: case mpr.intro
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.41306
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t✝ s : Set E
hs : ∀ (x : E), x ∈ s → ¬x ∈ ↑(convexHull 𝕜).toOrderHom (s \ {x})
t : Set E
ht : t ⊆ s
x : E
hxs : x ∈ s
hxt : x ∈ ↑(convexHull 𝕜).toOrderHom t
h : ¬x ∈ t
⊢ False
Theorem: Basis.repr_self_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rw [repr_self, Finsupp.single_apply]
state_before: ι : Type u_1
ι' : Type ?u.32722
R : Type u_2
R₂ : Type ?u.32728
K : Type ?u.32731
M : Type u_3
M' : Type ?u.32737
M'' : Type ?u.32740
V : Type u
V' : Type ?u.32745
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
j : ι
inst✝ : Decidable (i = j)
⊢ ↑(↑b.repr (↑b i)) j = if i = j then 1 else 0
Theorem: Matrix.mul_nonsing_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: cases (A.isUnit_iff_isUnit_det.mpr h).nonempty_invertible
state_before: l : Type ?u.190911
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
⊢ A ⬝ A⁻¹ = 1

tactic: rw [← invOf_eq_nonsing_inv, Matrix.mul_invOf_self]
state_before: case intro
l : Type ?u.190911
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
val✝ : Invertible A
⊢ A ⬝ A⁻¹ = 1
Theorem: PosNum.size_eq_natSize
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [size, succ_to_nat, natSize, size_eq_natSize n]
state_before: α : Type ?u.333835
n : PosNum
⊢ ↑(size (bit0 n)) = natSize (bit0 n)

tactic: rw [size, succ_to_nat, natSize, size_eq_natSize n]
state_before: α : Type ?u.333835
n : PosNum
⊢ ↑(size (bit1 n)) = natSize (bit1 n)
Theorem: ContinuousMap.tendsto_iff_forall_compact_tendstoUniformlyOn'
File: Mathlib/Topology/UniformSpace/CompactConvergence.lean

tactic: simp only [(hasBasis_nhds_compactConvergence f).tendsto_right_iff, TendstoUniformlyOn, and_imp,
  Prod.forall]
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
⊢ Tendsto F p (𝓝 f) ↔ ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => ↑(F i) a) (↑f) p K

tactic: refine' forall_congr' fun K => _
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
⊢ (∀ (a : Set α) (b : Set (β × β)), IsCompact a → b ∈ 𝓤 β → ∀ᶠ (x : ι) in p, F x ∈ compactConvNhd a b f) ↔
    ∀ (K : Set α), IsCompact K → ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∀ᶠ (n : ι) in p, ∀ (x : α), x ∈ K → (↑f x, ↑(F n) x) ∈ u

tactic: rw [forall_swap]
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
K : Set α
⊢ (∀ (b : Set (β × β)), IsCompact K → b ∈ 𝓤 β → ∀ᶠ (x : ι) in p, F x ∈ compactConvNhd K b f) ↔
    IsCompact K → ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∀ᶠ (n : ι) in p, ∀ (x : α), x ∈ K → (↑f x, ↑(F n) x) ∈ u

tactic: exact forall₃_congr fun _hK V _hV => Iff.rfl
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K✝ : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
K : Set α
⊢ (IsCompact K → ∀ (x : Set (β × β)), x ∈ 𝓤 β → ∀ᶠ (x_1 : ι) in p, F x_1 ∈ compactConvNhd K x f) ↔
    IsCompact K → ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∀ᶠ (n : ι) in p, ∀ (x : α), x ∈ K → (↑f x, ↑(F n) x) ∈ u
Theorem: thickenedIndicatorAux_le_one
File: Mathlib/Topology/MetricSpace/ThickenedIndicator.lean

tactic: apply @tsub_le_self _ _ _ _ (1 : ℝ≥0∞)
state_before: α : Type u_1
inst✝ : PseudoEMetricSpace α
δ : ℝ
E : Set α
x : α
⊢ thickenedIndicatorAux δ E x ≤ 1
Theorem: MeasureTheory.liminf_ae_eq_of_forall_ae_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp_rw [ae_eq_set] at h⊢
state_before: α : Type u_1
β : Type ?u.78167
γ : Type ?u.78170
δ : Type ?u.78173
ι : Type ?u.78176
R : Type ?u.78179
R' : Type ?u.78182
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), s n =ᵐ[μ] t
⊢ liminf s atTop =ᵐ[μ] t

tactic: constructor
state_before: α : Type u_1
β : Type ?u.78167
γ : Type ?u.78170
δ : Type ?u.78173
ι : Type ?u.78176
R : Type ?u.78179
R' : Type ?u.78182
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ ↑↑μ (liminf s atTop \ t) = 0 ∧ ↑↑μ (t \ liminf s atTop) = 0

tactic: rw [atTop.liminf_sdiff s t]
state_before: case left
α : Type u_1
β : Type ?u.78167
γ : Type ?u.78170
δ : Type ?u.78173
ι : Type ?u.78176
R : Type ?u.78179
R' : Type ?u.78182
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ ↑↑μ (liminf s atTop \ t) = 0

tactic: apply measure_liminf_eq_zero
state_before: case left
α : Type u_1
β : Type ?u.78167
γ : Type ?u.78170
δ : Type ?u.78173
ι : Type ?u.78176
R : Type ?u.78179
R' : Type ?u.78182
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ ↑↑μ (liminf (fun b => s b \ t) atTop) = 0

tactic: simp [h]
state_before: case left.h
α : Type u_1
β : Type ?u.78167
γ : Type ?u.78170
δ : Type ?u.78173
ι : Type ?u.78176
R : Type ?u.78179
R' : Type ?u.78182
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ (∑' (i : ℕ), ↑↑μ (s i \ t)) ≠ ⊤

tactic: rw [atTop.sdiff_liminf s t]
state_before: case right
α : Type u_1
β : Type ?u.78167
γ : Type ?u.78170
δ : Type ?u.78173
ι : Type ?u.78176
R : Type ?u.78179
R' : Type ?u.78182
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ ↑↑μ (t \ liminf s atTop) = 0

tactic: apply measure_limsup_eq_zero
state_before: case right
α : Type u_1
β : Type ?u.78167
γ : Type ?u.78170
δ : Type ?u.78173
ι : Type ?u.78176
R : Type ?u.78179
R' : Type ?u.78182
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ ↑↑μ (limsup (fun b => t \ s b) atTop) = 0

tactic: simp [h]
state_before: case right.hs
α : Type u_1
β : Type ?u.78167
γ : Type ?u.78170
δ : Type ?u.78173
ι : Type ?u.78176
R : Type ?u.78179
R' : Type ?u.78182
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ (∑' (i : ℕ), ↑↑μ (t \ s i)) ≠ ⊤
Theorem: IsSelfAdjoint.star_iff
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simpa only [IsSelfAdjoint, star_star] using eq_comm
state_before: R : Type u_1
A : Type ?u.498
inst✝ : InvolutiveStar R
x : R
⊢ IsSelfAdjoint (star x) ↔ IsSelfAdjoint x
Theorem: CategoryTheory.Limits.biproduct.desc_eq
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: ext j
state_before: C : Type u
inst✝³ : Category C
inst✝² : Preadditive C
J : Type
inst✝¹ : Fintype J
f : J → C
inst✝ : HasBiproduct f
T : C
g : (j : J) → f j ⟶ T
⊢ desc g = ∑ j : J, π f j ≫ g j

tactic: simp [comp_sum, biproduct.ι_π_assoc, dite_comp]
state_before: case w
C : Type u
inst✝³ : Category C
inst✝² : Preadditive C
J : Type
inst✝¹ : Fintype J
f : J → C
inst✝ : HasBiproduct f
T : C
g : (j : J) → f j ⟶ T
j : J
⊢ ι (fun b => f b) j ≫ desc g = ι (fun b => f b) j ≫ ∑ j : J, π f j ≫ g j
Theorem: AlgebraicTopology.DoldKan.Γ₀.Obj.map_epi_on_summand_id
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

tactic: simpa only [Γ₀.Obj.map_on_summand K (Splitting.IndexSet.id (op Δ)) e.op
    (rfl : e ≫ 𝟙 Δ = e ≫ 𝟙 Δ),
  Γ₀.Obj.Termwise.mapMono_id] using id_comp _
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : Preadditive C
K K' : ChainComplex C ℕ
f : K ⟶ K'
Δ✝ Δ'✝ Δ'' : SimplexCategory
inst✝¹ : HasFiniteCoproducts C
Δ Δ' : SimplexCategory
e : Δ' ⟶ Δ
inst✝ : Epi e
⊢ Splitting.ιSummand (splitting K) (Splitting.IndexSet.id Δ.op) ≫ (obj K).map e.op =
    Splitting.ιSummand (splitting K) (Splitting.IndexSet.mk e)
Theorem: div_lt_self_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: simp only [div_eq_mul_inv, mul_lt_iff_lt_one_left', Left.inv_lt_one_iff]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a✝ b✝ c d a b : α
⊢ a / b < a ↔ 1 < b
Theorem: SimpleGraph.IsSRGWith.card_neighborFinset_union_eq
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

tactic: apply Nat.add_right_cancel (m := Fintype.card (G.commonNeighbors v w))
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : IsSRGWith G n k ℓ μ
⊢ Finset.card (neighborFinset G v ∪ neighborFinset G w) = 2 * k - Fintype.card ↑(commonNeighbors G v w)

tactic: rw [Nat.sub_add_cancel, ← Set.toFinset_card]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : IsSRGWith G n k ℓ μ
⊢ Finset.card (neighborFinset G v ∪ neighborFinset G w) + Fintype.card ↑(commonNeighbors G v w) =
    2 * k - Fintype.card ↑(commonNeighbors G v w) + Fintype.card ↑(commonNeighbors G v w)

tactic: simp [commonNeighbors, @Set.toFinset_inter _ _ _ _ _ _ (_),
  ← neighborFinset_def, Finset.card_union_add_card_inter, card_neighborFinset_eq_degree,
  h.regular.degree_eq, two_mul]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : IsSRGWith G n k ℓ μ
⊢ Finset.card (neighborFinset G v ∪ neighborFinset G w) + Finset.card (Set.toFinset (commonNeighbors G v w)) = 2 * k

tactic: apply le_trans (card_commonNeighbors_le_degree_left _ _ _)
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : IsSRGWith G n k ℓ μ
⊢ Fintype.card ↑(commonNeighbors G v w) ≤ 2 * k

tactic: simp [h.regular.degree_eq, two_mul]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
v w : V
h : IsSRGWith G n k ℓ μ
⊢ degree G v ≤ 2 * k
Theorem: IsCompact.union
File: Mathlib/Topology/SubsetProperties.lean

tactic: rw [union_eq_iUnion]
state_before: α : Type u
β : Type v
ι : Type ?u.35600
π : ι → Type ?u.35605
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
hs : IsCompact s
ht : IsCompact t
⊢ IsCompact (s ∪ t)

tactic: exact isCompact_iUnion fun b => by cases b <;> assumption
state_before: α : Type u
β : Type v
ι : Type ?u.35600
π : ι → Type ?u.35605
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
hs : IsCompact s
ht : IsCompact t
⊢ IsCompact (⋃ (b : Bool), bif b then s else t)

tactic: cases b <;> assumption
state_before: α : Type u
β : Type v
ι : Type ?u.35600
π : ι → Type ?u.35605
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
hs : IsCompact s
ht : IsCompact t
b : Bool
⊢ IsCompact (bif b then s else t)