tasksource/leandojo huggingface dataset:
Theorem: disjoint_nested_nhds
File: Mathlib/Topology/Separation.lean

tactic: rcases t2_separation h with ⟨U₁, U₂, U₁_op, U₂_op, x_in, y_in, H⟩
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T3Space α
x y : α
h : x ≠ y
⊢ ∃ U₁,
    U₁ ∈ 𝓝 x ∧
      ∃ V₁,
        V₁ ∈ 𝓝 x ∧
          ∃ U₂,
            U₂ ∈ 𝓝 y ∧
              ∃ V₂, V₂ ∈ 𝓝 y ∧ IsClosed V₁ ∧ IsClosed V₂ ∧ IsOpen U₁ ∧ IsOpen U₂ ∧ V₁ ⊆ U₁ ∧ V₂ ⊆ U₂ ∧ Disjoint U₁ U₂

tactic: rcases exists_mem_nhds_isClosed_subset (U₁_op.mem_nhds x_in) with ⟨V₁, V₁_in, V₁_closed, h₁⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T3Space α
x y : α
h : x ≠ y
U₁ U₂ : Set α
U₁_op : IsOpen U₁
U₂_op : IsOpen U₂
x_in : x ∈ U₁
y_in : y ∈ U₂
H : Disjoint U₁ U₂
⊢ ∃ U₁,
    U₁ ∈ 𝓝 x ∧
      ∃ V₁,
        V₁ ∈ 𝓝 x ∧
          ∃ U₂,
            U₂ ∈ 𝓝 y ∧
              ∃ V₂, V₂ ∈ 𝓝 y ∧ IsClosed V₁ ∧ IsClosed V₂ ∧ IsOpen U₁ ∧ IsOpen U₂ ∧ V₁ ⊆ U₁ ∧ V₂ ⊆ U₂ ∧ Disjoint U₁ U₂

tactic: rcases exists_mem_nhds_isClosed_subset (U₂_op.mem_nhds y_in) with ⟨V₂, V₂_in, V₂_closed, h₂⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T3Space α
x y : α
h : x ≠ y
U₁ U₂ : Set α
U₁_op : IsOpen U₁
U₂_op : IsOpen U₂
x_in : x ∈ U₁
y_in : y ∈ U₂
H : Disjoint U₁ U₂
V₁ : Set α
V₁_in : V₁ ∈ 𝓝 x
V₁_closed : IsClosed V₁
h₁ : V₁ ⊆ U₁
⊢ ∃ U₁,
    U₁ ∈ 𝓝 x ∧
      ∃ V₁,
        V₁ ∈ 𝓝 x ∧
          ∃ U₂,
            U₂ ∈ 𝓝 y ∧
              ∃ V₂, V₂ ∈ 𝓝 y ∧ IsClosed V₁ ∧ IsClosed V₂ ∧ IsOpen U₁ ∧ IsOpen U₂ ∧ V₁ ⊆ U₁ ∧ V₂ ⊆ U₂ ∧ Disjoint U₁ U₂

tactic: exact ⟨U₁, mem_of_superset V₁_in h₁, V₁, V₁_in, U₂, mem_of_superset V₂_in h₂, V₂, V₂_in,
  V₁_closed, V₂_closed, U₁_op, U₂_op, h₁, h₂, H⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T3Space α
x y : α
h : x ≠ y
U₁ U₂ : Set α
U₁_op : IsOpen U₁
U₂_op : IsOpen U₂
x_in : x ∈ U₁
y_in : y ∈ U₂
H : Disjoint U₁ U₂
V₁ : Set α
V₁_in : V₁ ∈ 𝓝 x
V₁_closed : IsClosed V₁
h₁ : V₁ ⊆ U₁
V₂ : Set α
V₂_in : V₂ ∈ 𝓝 y
V₂_closed : IsClosed V₂
h₂ : V₂ ⊆ U₂
⊢ ∃ U₁,
    U₁ ∈ 𝓝 x ∧
      ∃ V₁,
        V₁ ∈ 𝓝 x ∧
          ∃ U₂,
            U₂ ∈ 𝓝 y ∧
              ∃ V₂, V₂ ∈ 𝓝 y ∧ IsClosed V₁ ∧ IsClosed V₂ ∧ IsOpen U₁ ∧ IsOpen U₂ ∧ V₁ ⊆ U₁ ∧ V₂ ⊆ U₂ ∧ Disjoint U₁ U₂
Theorem: Subspace.forall_mem_dualAnnihilator_apply_eq_zero_iff
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [← SetLike.ext_iff.mp dualAnnihilator_dualCoannihilator_eq v, mem_dualCoannihilator]
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
v : V
⊢ (∀ (φ : Module.Dual K V), φ ∈ dualAnnihilator W → ↑φ v = 0) ↔ v ∈ W
Theorem: Polynomial.degree_div_le
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp [hq]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : q = 0
⊢ degree (p / q) ≤ degree p

tactic: rw [div_def, mul_comm, degree_mul_leadingCoeff_inv _ hq]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : ¬q = 0
⊢ degree (p / q) ≤ degree p

tactic: exact degree_divByMonic_le _ _
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : ¬q = 0
⊢ degree (p /ₘ (q * ↑C (leadingCoeff q)⁻¹)) ≤ degree p
Theorem: OrthonormalBasis.det_to_matrix_orthonormalBasis_of_same_orientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

tactic: apply (e.det_to_matrix_orthonormalBasis_real f).resolve_right
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
h : Basis.orientation (OrthonormalBasis.toBasis e) = Basis.orientation (OrthonormalBasis.toBasis f)
⊢ ↑(Basis.det (OrthonormalBasis.toBasis e)) ↑f = 1

tactic: have : 0 < e.toBasis.det f := by
  rw [e.toBasis.orientation_eq_iff_det_pos] at h
  simpa using h
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
h : Basis.orientation (OrthonormalBasis.toBasis e) = Basis.orientation (OrthonormalBasis.toBasis f)
⊢ ¬↑(Basis.det (OrthonormalBasis.toBasis e)) ↑f = -1

tactic: linarith
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
h : Basis.orientation (OrthonormalBasis.toBasis e) = Basis.orientation (OrthonormalBasis.toBasis f)
this : 0 < ↑(Basis.det (OrthonormalBasis.toBasis e)) ↑f
⊢ ¬↑(Basis.det (OrthonormalBasis.toBasis e)) ↑f = -1

tactic: rw [e.toBasis.orientation_eq_iff_det_pos] at h
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
h : Basis.orientation (OrthonormalBasis.toBasis e) = Basis.orientation (OrthonormalBasis.toBasis f)
⊢ 0 < ↑(Basis.det (OrthonormalBasis.toBasis e)) ↑f

tactic: simpa using h
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
h : 0 < ↑(Basis.det (OrthonormalBasis.toBasis e)) ↑(OrthonormalBasis.toBasis f)
⊢ 0 < ↑(Basis.det (OrthonormalBasis.toBasis e)) ↑f
Theorem: Colex.empty_toColex_le
File: Mathlib/Combinatorics/Colex.lean

tactic: rcases A.eq_empty_or_nonempty with (rfl | hA)
state_before: α : Type u_1
inst✝ : LinearOrder α
A : Finset α
⊢ toColex ∅ ≤ toColex A

tactic: simp
state_before: case inl
α : Type u_1
inst✝ : LinearOrder α
⊢ toColex ∅ ≤ toColex ∅

tactic: apply (empty_toColex_lt hA).le
state_before: case inr
α : Type u_1
inst✝ : LinearOrder α
A : Finset α
hA : Finset.Nonempty A
⊢ toColex ∅ ≤ toColex A
Theorem: mem_vectorSpan_pair_rev
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [vectorSpan_pair_rev, Submodule.mem_span_singleton]
state_before: k : Type u_2
V : Type u_1
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.376057
p₁ p₂ : P
v : V
⊢ v ∈ vectorSpan k {p₁, p₂} ↔ ∃ r, r • (p₂ -ᵥ p₁) = v
Theorem: Equiv.Perm.exists_fixed_point_of_prime
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: classical
  contrapose! hα
  simp_rw [← mem_support, ← Finset.eq_univ_iff_forall] at hα
  exact Nat.modEq_zero_iff_dvd.1 ((congr_arg _ (Finset.card_eq_zero.2 (compl_eq_bot.2 hα))).mp
    (card_compl_support_modEq hσ).symm)
state_before: α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
hα : ¬p ∣ Fintype.card α
σ : Perm α
hσ : σ ^ p ^ n = 1
⊢ ∃ a, ↑σ a = a

tactic: contrapose! hα
state_before: α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
hα : ¬p ∣ Fintype.card α
σ : Perm α
hσ : σ ^ p ^ n = 1
⊢ ∃ a, ↑σ a = a

tactic: simp_rw [← mem_support, ← Finset.eq_univ_iff_forall] at hα
state_before: α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
σ : Perm α
hσ : σ ^ p ^ n = 1
hα : ∀ (a : α), ↑σ a ≠ a
⊢ p ∣ Fintype.card α

tactic: exact Nat.modEq_zero_iff_dvd.1 ((congr_arg _ (Finset.card_eq_zero.2 (compl_eq_bot.2 hα))).mp
  (card_compl_support_modEq hσ).symm)
state_before: α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
σ : Perm α
hσ : σ ^ p ^ n = 1
hα : support σ = Finset.univ
⊢ p ∣ Fintype.card α
Theorem: Polynomial.coeff_update_ne
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [p.coeff_update_apply, if_neg h]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
i : ℕ
h : i ≠ n
⊢ coeff (update p n a) i = coeff p i
Theorem: collinear_insert_insert_insert_of_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [collinear_insert_iff_of_mem_affineSpan
    ((AffineSubspace.le_def' _ _).1
      (affineSpan_mono k ((Set.subset_insert _ _).trans (Set.subset_insert _ _))) _ h₁),
  collinear_insert_iff_of_mem_affineSpan
    ((AffineSubspace.le_def' _ _).1 (affineSpan_mono k (Set.subset_insert _ _)) _ h₂),
  collinear_insert_iff_of_mem_affineSpan h₃]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.326734
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ Collinear k {p₁, p₂, p₃, p₄, p₅}

tactic: exact collinear_pair _ _ _
state_before: k : Type u_2
V : Type u_3
P : Type u_1
ι : Type ?u.326734
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ p₅ : P
h₁ : p₁ ∈ affineSpan k {p₄, p₅}
h₂ : p₂ ∈ affineSpan k {p₄, p₅}
h₃ : p₃ ∈ affineSpan k {p₄, p₅}
⊢ Collinear k {p₄, p₅}
Theorem: Right.inv_lt_one_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_right a, inv_mul_self, one_mul]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a⁻¹ < 1 ↔ 1 < a
Theorem: Ideal.inertiaDeg_of_subsingleton
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: have := Ideal.Quotient.subsingleton_iff.mp hQ
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hp : IsMaximal p
hQ : Subsingleton (S ⧸ P)
⊢ inertiaDeg f p P = 0

tactic: subst this
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hp : IsMaximal p
hQ : Subsingleton (S ⧸ P)
this : P = ⊤
⊢ inertiaDeg f p P = 0

tactic: exact dif_neg fun h => hp.ne_top <| h.symm.trans comap_top
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
hp : IsMaximal p
hQ : Subsingleton (S ⧸ ⊤)
⊢ inertiaDeg f p ⊤ = 0
Theorem: Int.sub_sub_self
File: Std/Data/Int/Lemmas.lean

tactic: simp [Int.sub_eq_add_neg, ← Int.add_assoc]
state_before: a b : Int
⊢ a - (a - b) = b
Theorem: CategoryTheory.eq_whisker'
File: Mathlib/Tactic/CategoryTheory/Reassoc.lean

tactic: rw [w]
state_before: C : Type u_2
inst✝ : Category C
X Y : C
f g : X ⟶ Y
w : f = g
Z : C
h : Y ⟶ Z
⊢ f ≫ h = g ≫ h
Theorem: LieIdeal.comap_bracket_incl
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: conv_rhs =>
  congr
  next => skip
  rw [← I.incl_idealRange]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ ⁅comap (incl I) I₁, comap (incl I) I₂⁆ = comap (incl I) ⁅I ⊓ I₁, I ⊓ I₂⁆

tactic: rw [comap_bracket_eq]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ ⁅comap (incl I) I₁, comap (incl I) I₂⁆ =
    comap (incl I) ⁅LieHom.idealRange (incl I) ⊓ I₁, LieHom.idealRange (incl I) ⊓ I₂⁆

tactic: simp only [ker_incl, sup_bot_eq]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ ⁅comap (incl I) I₁, comap (incl I) I₂⁆ = ⁅comap (incl I) I₁, comap (incl I) I₂⁆ ⊔ LieHom.ker (incl I)

R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ LieHom.IsIdealMorphism (incl I)

tactic: exact I.incl_isIdealMorphism
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
I₁ I₂ : LieIdeal R L
⊢ LieHom.IsIdealMorphism (incl I)
Theorem: Set.iInter₂_union
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [iInter_union]
state_before: α : Type u_1
β : Type ?u.117477
γ : Type ?u.117480
ι : Sort u_2
ι' : Sort ?u.117486
ι₂ : Sort ?u.117489
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.117499
κ₂ : ι → Sort ?u.117504
κ' : ι' → Sort ?u.117509
s : (i : ι) → κ i → Set α
t : Set α
⊢ (⋂ (i : ι) (j : κ i), s i j) ∪ t = ⋂ (i : ι) (j : κ i), s i j ∪ t
Theorem: CategoryTheory.GradedObject.comapEq_trans
File: Mathlib/CategoryTheory/GradedObject.lean

tactic: aesop_cat
state_before: C : Type u
inst✝ : Category C
β γ : Type w
f g h : β → γ
k : f = g
l : g = h
⊢ comapEq C (_ : f = h) = comapEq C k ≪≫ comapEq C l
Theorem: List.untrop_prod
File: Mathlib/Algebra/Tropical/BigOperators.lean

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

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

tactic: simp [← IH]
state_before: case cons
R : Type u_1
S : Type ?u.9353
inst✝ : AddMonoid R
hd : Tropical R
tl : List (Tropical R)
IH : untrop (prod tl) = sum (map untrop tl)
⊢ untrop (prod (hd :: tl)) = sum (map untrop (hd :: tl))
Theorem: MonoidHom.apply_mint
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [← zpowersHom_symm_apply, ← zpowersHom_apply, Equiv.apply_symm_apply]
state_before: α : Type ?u.347165
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Group M
f : Multiplicative ℤ →* M
n : Multiplicative ℤ
⊢ ↑f n = ↑f (↑Multiplicative.ofAdd 1) ^ ↑Multiplicative.toAdd n
Theorem: RatFunc.ofFractionRing_smul
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simp only [SMul.smul, HSMul.hSMul, RatFunc.smul]
state_before: K : Type u
inst✝¹ : CommRing K
R : Type u_1
inst✝ : SMul R (FractionRing K[X])
c : R
p : FractionRing K[X]
⊢ { toFractionRing := c • p } = c • { toFractionRing := p }
Theorem: MeasureTheory.OuterMeasure.pi_pi_le
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: cases' (pi univ s).eq_empty_or_nonempty with h h
state_before: ι : Type u_2
ι' : Type ?u.1844425
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
s : (i : ι) → Set (α i)
⊢ ↑(OuterMeasure.pi m) (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)

tactic: simp [h]
state_before: case inl
ι : Type u_2
ι' : Type ?u.1844425
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
s : (i : ι) → Set (α i)
h : Set.pi univ s = ∅
⊢ ↑(OuterMeasure.pi m) (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)

case inr
ι : Type u_2
ι' : Type ?u.1844425
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
s : (i : ι) → Set (α i)
h : Set.Nonempty (Set.pi univ s)
⊢ ↑(OuterMeasure.pi m) (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)

tactic: exact (boundedBy_le _).trans_eq (piPremeasure_pi h)
state_before: case inr
ι : Type u_2
ι' : Type ?u.1844425
α : ι → Type u_1
inst✝ : Fintype ι
m✝ m : (i : ι) → OuterMeasure (α i)
s : (i : ι) → Set (α i)
h : Set.Nonempty (Set.pi univ s)
⊢ ↑(OuterMeasure.pi m) (Set.pi univ s) ≤ ∏ i : ι, ↑(m i) (s i)
Theorem: ENNReal.iInter_Ioi_coe_nat
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [← compl_Iic, ← compl_iUnion, iUnion_Iic_coe_nat, compl_compl]
state_before: α : Type ?u.137733
β : Type ?u.137736
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ (⋂ (n : ℕ), Ioi ↑n) = {⊤}
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIso_hom_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta pullbackDiagonalMapIso
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (pullbackDiagonalMapIso f i i₁ i₂).hom ≫ snd = snd ≫ snd

tactic: simp
state_before: C : Type u_2
inst✝² : Category C
X Y Z : C
inst✝¹ : HasPullbacks C
U V₁ V₂ : C
f : X ⟶ Y
i : U ⟶ Y
i₁ : V₁ ⟶ pullback f i
i₂ : V₂ ⟶ pullback f i
inst✝ : HasPullback i₁ i₂
⊢ (Iso.mk (lift (snd ≫ fst) (snd ≫ snd) (_ : (snd ≫ fst) ≫ i₁ = (snd ≫ snd) ≫ i₂))
          (lift (fst ≫ i₁ ≫ fst)
            (map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
              (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd))
            (_ :
              (fst ≫ i₁ ≫ fst) ≫ diagonal f =
                map i₁ i₂ (i₁ ≫ snd) (i₂ ≫ snd) (𝟙 V₁) (𝟙 V₂) snd (_ : i₁ ≫ snd = 𝟙 V₁ ≫ i₁ ≫ snd)
                    (_ : i₂ ≫ snd = 𝟙 V₂ ≫ i₂ ≫ snd) ≫
                  map (i₁ ≫ snd) (i₂ ≫ snd) f f (i₁ ≫ fst) (i₂ ≫ fst) i (_ : (i₁ ≫ snd) ≫ i = (i₁ ≫ fst) ≫ f)
                    (_ : (i₂ ≫ snd) ≫ i = (i₂ ≫ fst) ≫ f)))).hom ≫
      snd =
    snd ≫ snd
Theorem: eventually_nhdsWithin_nhdsWithin
File: Mathlib/Topology/ContinuousOn.lean

tactic: refine' ⟨fun h => _, fun h => (eventually_nhds_nhdsWithin.2 h).filter_mono inf_le_left⟩
state_before: α : Type u_1
β : Type ?u.3293
γ : Type ?u.3296
δ : Type ?u.3299
inst✝ : TopologicalSpace α
a : α
s : Set α
p : α → Prop
⊢ (∀ᶠ (y : α) in 𝓝[s] a, ∀ᶠ (x : α) in 𝓝[s] y, p x) ↔ ∀ᶠ (x : α) in 𝓝[s] a, p x

tactic: simp only [eventually_nhdsWithin_iff] at h⊢
state_before: α : Type u_1
β : Type ?u.3293
γ : Type ?u.3296
δ : Type ?u.3299
inst✝ : TopologicalSpace α
a : α
s : Set α
p : α → Prop
h : ∀ᶠ (y : α) in 𝓝[s] a, ∀ᶠ (x : α) in 𝓝[s] y, p x
⊢ ∀ᶠ (x : α) in 𝓝[s] a, p x

tactic: exact h.mono fun x hx hxs => (hx hxs).self_of_nhds hxs
state_before: α : Type u_1
β : Type ?u.3293
γ : Type ?u.3296
δ : Type ?u.3299
inst✝ : TopologicalSpace α
a : α
s : Set α
p : α → Prop
h : ∀ᶠ (x : α) in 𝓝 a, x ∈ s → ∀ᶠ (x : α) in 𝓝 x, x ∈ s → p x
⊢ ∀ᶠ (x : α) in 𝓝 a, x ∈ s → p x
Theorem: CategoryTheory.MonoidalOfChosenFiniteProducts.leftUnitor_naturality
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean

tactic: dsimp [tensorHom]
state_before: C : Type u
inst✝ : Category C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
f : X₁ ⟶ X₂
⊢ tensorHom ℬ (𝟙 𝒯.cone.pt) f ≫ (BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt X₂).isLimit).hom =
    (BinaryFan.leftUnitor 𝒯.isLimit (ℬ 𝒯.cone.pt X₁).isLimit).hom ≫ f

tactic: simp
state_before: C : Type u
inst✝ : Category C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
f : X₁ ⟶ X₂
⊢ IsLimit.lift (ℬ 𝒯.cone.pt X₂).isLimit
        (BinaryFan.mk (BinaryFan.fst (ℬ 𝒯.cone.pt X₁).cone ≫ 𝟙 𝒯.cone.pt) (BinaryFan.snd (ℬ 𝒯.cone.pt X₁).cone ≫ f)) ≫
      BinaryFan.snd (ℬ 𝒯.cone.pt X₂).cone =
    BinaryFan.snd (ℬ 𝒯.cone.pt X₁).cone ≫ f
Theorem: Setoid.classes_ker_subset_fiber_set
File: Mathlib/Data/Setoid/Partition.lean

tactic: rintro s ⟨x, rfl⟩
state_before: α : Type u_2
β : Type u_1
f : α → β
⊢ classes (ker f) ⊆ Set.range fun y => {x | f x = y}

tactic: rw [Set.mem_range]
state_before: case intro
α : Type u_2
β : Type u_1
f : α → β
x : α
⊢ {x_1 | Rel (ker f) x_1 x} ∈ Set.range fun y => {x | f x = y}

tactic: exact ⟨f x, rfl⟩
state_before: case intro
α : Type u_2
β : Type u_1
f : α → β
x : α
⊢ ∃ y, {x | f x = y} = {x_1 | Rel (ker f) x_1 x}
Theorem: Real.sqrt_sq_eq_abs
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [sq, sqrt_mul_self_eq_abs]
state_before: x✝ y x : ℝ
⊢ sqrt (x ^ 2) = abs x
Theorem: LinearIndependent.repr_ker
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: rw [LinearIndependent.repr, LinearEquiv.ker]
state_before: ι : Type u'
ι' : Type ?u.440821
R : Type u_2
K : Type ?u.440827
M : Type u_1
M' : Type ?u.440833
M'' : Type ?u.440836
V : Type u
V' : Type ?u.440841
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
hv : LinearIndependent R v
⊢ LinearMap.ker (repr hv) = ⊥
Theorem: Polynomial.reflect_C
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: conv_lhs => rw [← mul_one (C r), ← pow_zero X, reflect_C_mul_X_pow, revAt_zero]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
r : R
N : ℕ
⊢ reflect N (↑C r) = ↑C r * X ^ N
Theorem: pochhammer_eval_succ
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: exact_mod_cast congr_arg Nat.cast (pochhammer_nat_eval_succ r n)
state_before: S : Type u_1
inst✝ : Semiring S
r✝ n✝ r n : ℕ
⊢ ↑n * eval (↑n + 1) (pochhammer S r) = (↑n + ↑r) * eval (↑n) (pochhammer S r)
Theorem: differentiableWithinAt_add_const_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa using h.add_const (-c)
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.199798
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.199893
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
h : DifferentiableWithinAt 𝕜 (fun y => f y + c) s x
⊢ DifferentiableWithinAt 𝕜 f s x
Theorem: PowerSeries.coeff_mul_one_sub_of_lt_order
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: simp [coeff_mul_of_lt_order h, mul_sub]
state_before: R✝ : Type ?u.4217836
inst✝¹ : Semiring R✝
φ✝ : PowerSeries R✝
R : Type u_1
inst✝ : CommRing R
φ ψ : PowerSeries R
n : ℕ
h : ↑n < order ψ
⊢ ↑(coeff R n) (φ * (1 - ψ)) = ↑(coeff R n) φ
Theorem: contDiffOn_euclidean
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: rw [← (EuclideanSpace.equiv ι 𝕜).comp_contDiffOn_iff, contDiffOn_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
n : ℕ∞
⊢ ContDiffOn 𝕜 n f t ↔ ∀ (i : ι), ContDiffOn 𝕜 n (fun x => f x i) t

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
n : ℕ∞
⊢ (∀ (i : ι), ContDiffOn 𝕜 n (fun x => (↑(EuclideanSpace.equiv ι 𝕜) ∘ f) x i) t) ↔
    ∀ (i : ι), ContDiffOn 𝕜 n (fun x => f x i) t
Theorem: Filter.tendsto_Ici_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [atTop_Ici_eq, tendsto_comap_iff]
state_before: ι : Type ?u.335766
ι' : Type ?u.335769
α : Type u_1
β : Type u_2
γ : Type ?u.335778
inst✝ : SemilatticeSup α
a : α
f : β → ↑(Ici a)
l : Filter β
⊢ Tendsto f l atTop ↔ Tendsto (fun x => ↑(f x)) l atTop

tactic: rfl
state_before: ι : Type ?u.335766
ι' : Type ?u.335769
α : Type u_1
β : Type u_2
γ : Type ?u.335778
inst✝ : SemilatticeSup α
a : α
f : β → ↑(Ici a)
l : Filter β
⊢ Tendsto (Subtype.val ∘ f) l atTop ↔ Tendsto (fun x => ↑(f x)) l atTop