tasksource/leandojo huggingface dataset:
Theorem: ContinuousMultilinearMap.le_op_norm_mul_pow_of_le
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: simpa only [Fintype.card_fin] using
  f.le_op_norm_mul_pow_card_of_le m fun i => (norm_le_pi_norm m i).trans hm
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei✝ : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁹ : Fintype ι
inst✝¹⁸ : Fintype ι'
inst✝¹⁷ : NontriviallyNormedField 𝕜
inst✝¹⁶ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁵ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹⁴ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝¹³ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝¹² : (i : ι') → NormedAddCommGroup (E' i)
inst✝¹¹ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝¹⁰ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei✝ i)
inst✝⁹ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei✝ i)
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
inst✝⁶ : NormedAddCommGroup G'
inst✝⁵ : NormedSpace 𝕜 G'
c : 𝕜
f✝ g : ContinuousMultilinearMap 𝕜 E G
m✝ : (i : ι) → E i
𝕜' : Type ?u.527868
inst✝⁴ : NormedField 𝕜'
inst✝³ : NormedSpace 𝕜' G
inst✝² : SMulCommClass 𝕜 𝕜' G
Ei : Fin n → Type u_1
inst✝¹ : (i : Fin n) → NormedAddCommGroup (Ei i)
inst✝ : (i : Fin n) → NormedSpace 𝕜 (Ei i)
f : ContinuousMultilinearMap 𝕜 Ei G
m : (i : Fin n) → Ei i
b : ℝ
hm : ‖m‖ ≤ b
⊢ ‖↑f m‖ ≤ ‖f‖ * b ^ n
Theorem: Prod.map_surjective
File: Mathlib/Data/Prod/Basic.lean

tactic: inhabit δ
state_before: α : Type u_4
β : Type u_3
γ : Type u_1
δ : Type u_2
inst✝¹ : Nonempty γ
inst✝ : Nonempty δ
f : α → γ
g : β → δ
h : Surjective (map f g)
c : γ
⊢ ∃ a, f a = c

tactic: obtain ⟨⟨a, b⟩, h⟩ := h (c, default)
state_before: α : Type u_4
β : Type u_3
γ : Type u_1
δ : Type u_2
inst✝¹ : Nonempty γ
inst✝ : Nonempty δ
f : α → γ
g : β → δ
h : Surjective (map f g)
c : γ
inhabited_h : Inhabited δ
⊢ ∃ a, f a = c

tactic: exact ⟨a, congr_arg Prod.fst h⟩
state_before: case intro.mk
α : Type u_4
β : Type u_3
γ : Type u_1
δ : Type u_2
inst✝¹ : Nonempty γ
inst✝ : Nonempty δ
f : α → γ
g : β → δ
h✝ : Surjective (map f g)
c : γ
inhabited_h : Inhabited δ
a : α
b : β
h : map f g (a, b) = (c, default)
⊢ ∃ a, f a = c

tactic: inhabit γ
state_before: α : Type u_4
β : Type u_3
γ : Type u_1
δ : Type u_2
inst✝¹ : Nonempty γ
inst✝ : Nonempty δ
f : α → γ
g : β → δ
h : Surjective (map f g)
d : δ
⊢ ∃ a, g a = d

tactic: obtain ⟨⟨a, b⟩, h⟩ := h (default, d)
state_before: α : Type u_4
β : Type u_3
γ : Type u_1
δ : Type u_2
inst✝¹ : Nonempty γ
inst✝ : Nonempty δ
f : α → γ
g : β → δ
h : Surjective (map f g)
d : δ
inhabited_h : Inhabited γ
⊢ ∃ a, g a = d

tactic: exact ⟨b, congr_arg Prod.snd h⟩
state_before: case intro.mk
α : Type u_4
β : Type u_3
γ : Type u_1
δ : Type u_2
inst✝¹ : Nonempty γ
inst✝ : Nonempty δ
f : α → γ
g : β → δ
h✝ : Surjective (map f g)
d : δ
inhabited_h : Inhabited γ
a : α
b : β
h : map f g (a, b) = (default, d)
⊢ ∃ a, g a = d
Theorem: MvPolynomial.expand_comp_bind₁
File: Mathlib/Data/MvPolynomial/Expand.lean

tactic: apply algHom_ext
state_before: σ : Type u_3
τ : Type u_1
R : Type u_2
S : Type ?u.129297
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : ℕ
f : σ → MvPolynomial τ R
⊢ AlgHom.comp (expand p) (bind₁ f) = bind₁ fun i => ↑(expand p) (f i)

tactic: intro i
state_before: case hf
σ : Type u_3
τ : Type u_1
R : Type u_2
S : Type ?u.129297
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : ℕ
f : σ → MvPolynomial τ R
⊢ ∀ (i : σ), ↑(AlgHom.comp (expand p) (bind₁ f)) (X i) = ↑(bind₁ fun i => ↑(expand p) (f i)) (X i)

tactic: simp only [AlgHom.comp_apply, bind₁_X_right]
state_before: case hf
σ : Type u_3
τ : Type u_1
R : Type u_2
S : Type ?u.129297
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : ℕ
f : σ → MvPolynomial τ R
i : σ
⊢ ↑(AlgHom.comp (expand p) (bind₁ f)) (X i) = ↑(bind₁ fun i => ↑(expand p) (f i)) (X i)
Theorem: Int.div_eq_of_eq_mul_left
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, H2]
state_before: a b c : Int
H1 : b ≠ 0
H2 : a = c * b
⊢ a = b * c
Theorem: UpperSet.compl_iInf₂
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [UpperSet.compl_iInf]
state_before: α : Type u_1
β : Type ?u.85665
γ : Type ?u.85668
ι : Sort u_2
κ : ι → Sort u_3
inst✝ : LE α
s t : UpperSet α
a : α
f : (i : ι) → κ i → UpperSet α
⊢ compl (⨅ (i : ι) (j : κ i), f i j) = ⨅ (i : ι) (j : κ i), compl (f i j)
Theorem: Equiv.prod_assoc_preimage
File: Mathlib/Logic/Equiv/Set.lean

tactic: ext
state_before: α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
⊢ ↑(prodAssoc α β γ) ⁻¹' s ×ˢ t ×ˢ u = (s ×ˢ t) ×ˢ u

tactic: simp [and_assoc]
state_before: case h
α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
x✝ : (α × β) × γ
⊢ x✝ ∈ ↑(prodAssoc α β γ) ⁻¹' s ×ˢ t ×ˢ u ↔ x✝ ∈ (s ×ˢ t) ×ˢ u
Theorem: ShrinkingLemma.PartialRefinement.mem_find_carrier_iff
File: Mathlib/Topology/ShrinkingLemma.lean

tactic: rw [find]
state_before: ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
⊢ i ∈ (find c ne i).carrier ↔ i ∈ chainSupCarrier c

tactic: split_ifs with h
state_before: ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
⊢ i ∈ (if hi : ∃ v, v ∈ c ∧ i ∈ v.carrier then Exists.choose hi else Set.Nonempty.some ne).carrier ↔
    i ∈ chainSupCarrier c

tactic: have := h.choose_spec
state_before: case inl
ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
h : ∃ v, v ∈ c ∧ i ∈ v.carrier
⊢ i ∈ (Exists.choose h).carrier ↔ i ∈ chainSupCarrier c

tactic: exact iff_of_true this.2 (mem_iUnion₂.2 ⟨_, this.1, this.2⟩)
state_before: case inl
ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
h : ∃ v, v ∈ c ∧ i ∈ v.carrier
this : Exists.choose h ∈ c ∧ i ∈ (Exists.choose h).carrier
⊢ i ∈ (Exists.choose h).carrier ↔ i ∈ chainSupCarrier c

tactic: push_neg at h
state_before: case inr
ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
h : ¬∃ v, v ∈ c ∧ i ∈ v.carrier
⊢ i ∈ (Set.Nonempty.some ne).carrier ↔ i ∈ chainSupCarrier c

tactic: refine iff_of_false (h _ ne.some_mem) ?_
state_before: case inr
ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
h : ∀ (v : PartialRefinement u s), v ∈ c → ¬i ∈ v.carrier
⊢ i ∈ (Set.Nonempty.some ne).carrier ↔ i ∈ chainSupCarrier c

tactic: simpa only [chainSupCarrier, mem_iUnion₂, not_exists]
state_before: case inr
ι : Type u_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
u : ι → Set X
s : Set X
c : Set (PartialRefinement u s)
i : ι
ne : Set.Nonempty c
h : ∀ (v : PartialRefinement u s), v ∈ c → ¬i ∈ v.carrier
⊢ ¬i ∈ chainSupCarrier c
Theorem: Ordnode.dual_node'
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: simp [node', add_comm]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
⊢ dual (node' l x r) = node' (dual r) x (dual l)
Theorem: Set.Ioo_inter_Ioc_of_left_le
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [inter_comm, Ioc_inter_Ioo_of_right_le h, max_comm]
state_before: α : Type u_1
β : Type ?u.196535
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
h : b₁ ≤ b₂
⊢ Ioo a₁ b₁ ∩ Ioc a₂ b₂ = Ioo (max a₁ a₂) b₁
Theorem: Polynomial.natDegree_monomial
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: split_ifs with hr
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
inst✝ : DecidableEq R
i : ℕ
r : R
⊢ natDegree (↑(monomial i) r) = if r = 0 then 0 else i

tactic: simp [hr]
state_before: case inl
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
inst✝ : DecidableEq R
i : ℕ
r : R
hr : r = 0
⊢ natDegree (↑(monomial i) r) = 0

tactic: rw [← C_mul_X_pow_eq_monomial, natDegree_C_mul_X_pow i r hr]
state_before: case inr
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
inst✝ : DecidableEq R
i : ℕ
r : R
hr : ¬r = 0
⊢ natDegree (↑(monomial i) r) = i
Theorem: Int.add_left_cancel
File: Std/Data/Int/Lemmas.lean

tactic: have h₁ : -a + (a + b) = -a + (a + c) := by rw [h]
state_before: a b c : Int
h : a + b = a + c
⊢ b = c

tactic: simp [← Int.add_assoc, Int.add_left_neg, Int.zero_add] at h₁
state_before: a b c : Int
h : a + b = a + c
h₁ : -a + (a + b) = -a + (a + c)
⊢ b = c

tactic: exact h₁
state_before: a b c : Int
h : a + b = a + c
h₁ : b = c
⊢ b = c

tactic: rw [h]
state_before: a b c : Int
h : a + b = a + c
⊢ -a + (a + b) = -a + (a + c)
Theorem: List.Func.eq_get_of_mem
File: Mathlib/Data/List/Func.lean

tactic: cases h
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a : α
h : a ∈ []
⊢ ∃ n, a = get n []

tactic: rw [mem_cons] at h
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a b : α
as : List α
h : a ∈ b :: as
⊢ ∃ n, a = get n (b :: as)

tactic: cases h with
| inl h => exact ⟨0, h⟩
| inr h =>
  rcases eq_get_of_mem h with ⟨n, h⟩
  exact ⟨n + 1, h⟩
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a b : α
as : List α
h : a = b ∨ a ∈ as
⊢ ∃ n, a = get n (b :: as)

tactic: exact ⟨0, h⟩
state_before: case inl
α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a b : α
as : List α
h : a = b
⊢ ∃ n, a = get n (b :: as)

tactic: rcases eq_get_of_mem h with ⟨n, h⟩
state_before: case inr
α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a b : α
as : List α
h : a ∈ as
⊢ ∃ n, a = get n (b :: as)

tactic: exact ⟨n + 1, h⟩
state_before: case inr.intro
α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a b : α
as : List α
h✝ : a ∈ as
n : ℕ
h : a = get n as
⊢ ∃ n, a = get n (b :: as)
Theorem: Equiv.Perm.toCycle_eq_toList
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: have key : (Finset.univ : Finset α).val = x ::ₘ Finset.univ.val.erase x := by simp
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : IsCycle f
x : α
hx : ↑f x ≠ x
⊢ toCycle f hf = ↑(toList f x)

tactic: rw [toCycle, key]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : IsCycle f
x : α
hx : ↑f x ≠ x
key : Finset.univ.val = x ::ₘ Multiset.erase Finset.univ.val x
⊢ toCycle f hf = ↑(toList f x)

tactic: simp [hx]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : IsCycle f
x : α
hx : ↑f x ≠ x
key : Finset.univ.val = x ::ₘ Multiset.erase Finset.univ.val x
⊢ Multiset.recOn (x ::ₘ Multiset.erase Finset.univ.val x) (Quot.mk Setoid.r [])
      (fun x x_1 l => if ↑f x = x then l else ↑(toList f x))
      (_ :
        ∀ (x y : α),
          Multiset α →
            ∀ (s : Cycle α),
              HEq (if ↑f x = x then if ↑f y = y then s else ↑(toList f y) else ↑(toList f x))
                (if ↑f y = y then if ↑f x = x then s else ↑(toList f x) else ↑(toList f y))) =
    ↑(toList f x)

tactic: simp
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
hf : IsCycle f
x : α
hx : ↑f x ≠ x
⊢ Finset.univ.val = x ::ₘ Multiset.erase Finset.univ.val x
Theorem: AddLECancellable.tsub_right_inj
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: simp_rw [le_antisymm_iff, ha.tsub_le_tsub_iff_left hb hba, ha.tsub_le_tsub_iff_left hc hca,
  and_comm]
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
hb : AddLECancellable b
hc : AddLECancellable c
hba : b ≤ a
hca : c ≤ a
⊢ a - b = a - c ↔ b = c
Theorem: Basis.parallelepiped_basisFun
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: refine' Eq.trans _ ((uIcc_of_le _).trans (Set.pi_univ_Icc _ _).symm)
state_before: ι : Type u_1
inst✝ : Fintype ι
⊢ ↑(parallelepiped (Pi.basisFun ℝ ι)) = ↑(PositiveCompacts.piIcc01 ι)

tactic: classical convert parallelepiped_single (ι := ι) 1
state_before: case refine'_1
ι : Type u_1
inst✝ : Fintype ι
⊢ ↑(parallelepiped (Pi.basisFun ℝ ι)) = uIcc (fun i => 0) fun i => 1

tactic: convert parallelepiped_single (ι := ι) 1
state_before: case refine'_1
ι : Type u_1
inst✝ : Fintype ι
⊢ ↑(parallelepiped (Pi.basisFun ℝ ι)) = uIcc (fun i => 0) fun i => 1

tactic: exact zero_le_one
state_before: case refine'_2
ι : Type u_1
inst✝ : Fintype ι
⊢ (fun i => 0) ≤ fun i => 1
Theorem: Set.ncard_le_ncard_diff_add_ncard
File: Mathlib/Data/Set/Ncard.lean

tactic: cases' s.finite_or_infinite with h h
state_before: α : Type u_1
β : Type ?u.124878
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
ht : autoParam (Set.Finite t) _auto✝
⊢ ncard s ≤ ncard (s \ t) + ncard t

tactic: convert Nat.zero_le _
state_before: case inr
α : Type u_1
β : Type ?u.124878
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
ht : autoParam (Set.Finite t) _auto✝
h : Set.Infinite s
⊢ ncard s ≤ ncard (s \ t) + ncard t

tactic: rw [h.ncard]
state_before: case h.e'_3
α : Type u_1
β : Type ?u.124878
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
ht : autoParam (Set.Finite t) _auto✝
h : Set.Infinite s
⊢ ncard s = 0

tactic: rw [← diff_inter_self_eq_diff, ← ncard_diff_add_ncard_eq_ncard (inter_subset_right t s) h,
  add_le_add_iff_left]
state_before: case inl
α : Type u_1
β : Type ?u.124878
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
ht : autoParam (Set.Finite t) _auto✝
h : Set.Finite s
⊢ ncard s ≤ ncard (s \ t) + ncard t

tactic: apply ncard_inter_le_ncard_left _ _ ht
state_before: case inl
α : Type u_1
β : Type ?u.124878
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
ht : autoParam (Set.Finite t) _auto✝
h : Set.Finite s
⊢ ncard (t ∩ s) ≤ ncard t
Theorem: CategoryTheory.Idempotents.Karoubi.coe_p
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: rfl
state_before: C : Type u_2
inst✝ : Category C
X : C
⊢ (mk X (𝟙 X)).p = 𝟙 X
Theorem: Finset.max_of_mem
File: Mathlib/Data/Finset/Lattice.lean

tactic: obtain ⟨b, h, _⟩ := le_sup (α := WithBot α) h _ rfl
state_before: F : Type ?u.313391
α : Type u_1
β : Type ?u.313397
γ : Type ?u.313400
ι : Type ?u.313403
κ : Type ?u.313406
inst✝ : LinearOrder α
s : Finset α
a : α
h : a ∈ s
⊢ ∃ b, Finset.max s = ↑b

tactic: exact ⟨b, h⟩
state_before: case intro.intro
F : Type ?u.313391
α : Type u_1
β : Type ?u.313397
γ : Type ?u.313400
ι : Type ?u.313403
κ : Type ?u.313406
inst✝ : LinearOrder α
s : Finset α
a : α
h✝ : a ∈ s
b : α
h : b ∈ sup s some
right✝ : a ≤ b
⊢ ∃ b, Finset.max s = ↑b
Theorem: mem_const_vsub_affineSegment
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [← affineSegment_const_vsub_image, (vsub_right_injective p).mem_set_image]
state_before: R : Type u_3
V : Type u_1
V' : Type ?u.53134
P : Type u_2
P' : Type ?u.53140
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z p : P
⊢ p -ᵥ z ∈ affineSegment R (p -ᵥ x) (p -ᵥ y) ↔ z ∈ affineSegment R x y
Theorem: FirstOrder.Language.BoundedFormula.ex_semanticallyEquivalent_not_all_not
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: simp
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ✝ ψ : BoundedFormula L α n
φ : BoundedFormula L α (n + 1)
M : Theory.ModelType T
v : α → ↑M
xs : Fin n → ↑M
⊢ Realize (∃'φ ⇔ ∼(∀'∼φ)) v xs
Theorem: ProbabilityTheory.kernel.integral_deterministic'
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [kernel.deterministic_apply, integral_dirac' _ _ hf]
state_before: α : Type u_2
β : Type u_3
ι : Type ?u.400065
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : β → E
g : α → β
a : α
hg : Measurable g
hf : StronglyMeasurable f
⊢ (∫ (x : β), f x ∂↑(deterministic g hg) a) = f (g a)
Theorem: disjoint_nhds_nhds_iff_not_specializes
File: Mathlib/Topology/Separation.lean

tactic: rw [← nhdsSet_singleton, disjoint_nhdsSet_nhds, specializes_iff_mem_closure]
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a✝ : α
s : Set α
a b : α
⊢ Disjoint (𝓝 a) (𝓝 b) ↔ ¬a ⤳ b
Theorem: isCompact_singleton
File: Mathlib/Topology/SubsetProperties.lean

tactic: simpa only [principal_singleton] using pure_le_nhds a
state_before: α : Type u
β : Type v
ι : Type ?u.30840
π : ι → Type ?u.30845
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
a : α
f : Filter α
hf : NeBot f
hfa : f ≤ 𝓟 {a}
⊢ 𝓟 {a} ≤ 𝓝 a
Theorem: cyclesMap_id
File: Mathlib/Algebra/Homology/Homology.lean

tactic: dsimp only [cyclesMap]
state_before: ι : Type u_1
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasKernels V
C₁ C₂ C₃ : HomologicalComplex V c
f : C₁ ⟶ C₂
i : ι
⊢ cyclesMap (𝟙 C₁) i = 𝟙 (Subobject.underlying.obj (cycles C₁ i))

tactic: simp
state_before: ι : Type u_1
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasKernels V
C₁ C₂ C₃ : HomologicalComplex V c
f : C₁ ⟶ C₂
i : ι
⊢ Subobject.factorThru (cycles C₁ i) (Subobject.arrow (cycles C₁ i) ≫ Hom.f (𝟙 C₁) i)
      (_ : Subobject.Factors (kernelSubobject (dFrom C₁ i)) (Subobject.arrow (cycles C₁ i) ≫ Hom.f (𝟙 C₁) i)) =
    𝟙 (Subobject.underlying.obj (cycles C₁ i))
Theorem: LinearOrderedField.inducedMap_add
File: Mathlib/Algebra/Order/CompleteField.lean

tactic: rw [inducedMap, cutMap_add]
state_before: F : Type ?u.24201
α : Type u_2
β : Type u_1
γ : Type ?u.24210
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
x y : α
⊢ inducedMap α β (x + y) = inducedMap α β x + inducedMap α β y

tactic: exact csSup_add (cutMap_nonempty β x) (cutMap_bddAbove β x) (cutMap_nonempty β y)
  (cutMap_bddAbove β y)
state_before: F : Type ?u.24201
α : Type u_2
β : Type u_1
γ : Type ?u.24210
inst✝³ : LinearOrderedField α
inst✝² : ConditionallyCompleteLinearOrderedField β
inst✝¹ : ConditionallyCompleteLinearOrderedField γ
inst✝ : Archimedean α
a : α
b : β
q : ℚ
x y : α
⊢ sSup (cutMap β x + cutMap β y) = inducedMap α β x + inducedMap α β y
Theorem: Finset.Nonempty.of_disjSups_left
File: Mathlib/Data/Finset/Sups.lean

tactic: simp_rw [Finset.Nonempty, mem_disjSups]
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ Finset.Nonempty (s ○ t) → Finset.Nonempty s

tactic: exact fun ⟨_, a, ha, _⟩ => ⟨a, ha⟩
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ (∃ x a, a ∈ s ∧ ∃ b, b ∈ t ∧ Disjoint a b ∧ a ⊔ b = x) → ∃ x, x ∈ s
Theorem: NNReal.div_le_of_le_mul
File: Mathlib/Data/Real/NNReal.lean

tactic: simp [h0]
state_before: a b c : ℝ≥0
h : a ≤ b * c
h0 : c = 0
⊢ a / c ≤ b
Theorem: Ordnode.Valid'.node4L_lemma₄
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: linarith
state_before: α : Type ?u.286751
inst✝ : Preorder α
a b c d : ℕ
lr₁ : 3 * a ≤ b + c + 1 + d
mr₂ : b + c + 1 ≤ 3 * d
mm₁ : b ≤ 3 * c
⊢ a + b + 1 ≤ 3 * (c + d + 1)
Theorem: ext_nat''
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: apply FunLike.ext
state_before: α : Type ?u.48928
β : Type ?u.48931
A : Type u_2
F : Type u_1
inst✝¹ : MulZeroOneClass A
inst✝ : MonoidWithZeroHomClass F ℕ A
f g : F
h_pos : ∀ {n : ℕ}, 0 < n → ↑f n = ↑g n
⊢ f = g

tactic: rintro (_ | n)
state_before: case h
α : Type ?u.48928
β : Type ?u.48931
A : Type u_2
F : Type u_1
inst✝¹ : MulZeroOneClass A
inst✝ : MonoidWithZeroHomClass F ℕ A
f g : F
h_pos : ∀ {n : ℕ}, 0 < n → ↑f n = ↑g n
⊢ ∀ (x : ℕ), ↑f x = ↑g x

tactic: simp [map_zero f, map_zero g]
state_before: case h.zero
α : Type ?u.48928
β : Type ?u.48931
A : Type u_2
F : Type u_1
inst✝¹ : MulZeroOneClass A
inst✝ : MonoidWithZeroHomClass F ℕ A
f g : F
h_pos : ∀ {n : ℕ}, 0 < n → ↑f n = ↑g n
⊢ ↑f Nat.zero = ↑g Nat.zero

tactic: exact h_pos n.succ_pos
state_before: case h.succ
α : Type ?u.48928
β : Type ?u.48931
A : Type u_2
F : Type u_1
inst✝¹ : MulZeroOneClass A
inst✝ : MonoidWithZeroHomClass F ℕ A
f g : F
h_pos : ∀ {n : ℕ}, 0 < n → ↑f n = ↑g n
n : ℕ
⊢ ↑f (Nat.succ n) = ↑g (Nat.succ n)
Theorem: UniqueFactorizationMonoid.ne_zero_of_mem_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: intro ha
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
p a : α
h : p ∈ factors a
⊢ a ≠ 0

tactic: rw [factors, dif_pos ha] at h
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
p a : α
h : p ∈ factors a
ha : a = 0
⊢ False

tactic: exact Multiset.not_mem_zero _ h
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
p a : α
h : p ∈ 0
ha : a = 0
⊢ False
Theorem: SeparationQuotient.preimage_image_mk_open
File: Mathlib/Topology/Inseparable.lean

tactic: refine' Subset.antisymm _ (subset_preimage_image _ _)
state_before: X : Type u_1
Y : Type ?u.48324
Z : Type ?u.48327
α : Type ?u.48330
ι : Type ?u.48333
π : ι → Type ?u.48338
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
hs : IsOpen s
⊢ mk ⁻¹' (mk '' s) = s

tactic: rintro x ⟨y, hys, hxy⟩
state_before: X : Type u_1
Y : Type ?u.48324
Z : Type ?u.48327
α : Type ?u.48330
ι : Type ?u.48333
π : ι → Type ?u.48338
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
hs : IsOpen s
⊢ mk ⁻¹' (mk '' s) ⊆ s

tactic: exact ((mk_eq_mk.1 hxy).mem_open_iff hs).1 hys
state_before: case intro.intro
X : Type u_1
Y : Type ?u.48324
Z : Type ?u.48327
α : Type ?u.48330
ι : Type ?u.48333
π : ι → Type ?u.48338
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
hs : IsOpen s
x y : X
hys : y ∈ s
hxy : mk y = mk x
⊢ x ∈ s
Theorem: Nat.gcd_eq_zero_iff
File: Std/Data/Nat/Gcd.lean

tactic: simp [h]
state_before: i j : Nat
h : i = 0 ∧ j = 0
⊢ gcd i j = 0
Theorem: IsPiSystem.insert_empty
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: intro s hs t ht hst
state_before: α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
⊢ IsPiSystem (insert ∅ S)

tactic: cases' hs with hs hs
state_before: α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s : Set α
hs : s ∈ insert ∅ S
t : Set α
ht : t ∈ insert ∅ S
hst : Set.Nonempty (s ∩ t)
⊢ s ∩ t ∈ insert ∅ S

tactic: simp [hs]
state_before: case inl
α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s t : Set α
ht : t ∈ insert ∅ S
hst : Set.Nonempty (s ∩ t)
hs : s = ∅
⊢ s ∩ t ∈ insert ∅ S

tactic: cases' ht with ht ht
state_before: case inr
α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s t : Set α
ht : t ∈ insert ∅ S
hst : Set.Nonempty (s ∩ t)
hs : s ∈ S
⊢ s ∩ t ∈ insert ∅ S

tactic: simp [ht]
state_before: case inr.inl
α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s t : Set α
hst : Set.Nonempty (s ∩ t)
hs : s ∈ S
ht : t = ∅
⊢ s ∩ t ∈ insert ∅ S

tactic: exact Set.mem_insert_of_mem _ (h_pi s hs t ht hst)
state_before: case inr.inr
α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s t : Set α
hst : Set.Nonempty (s ∩ t)
hs : s ∈ S
ht : t ∈ S
⊢ s ∩ t ∈ insert ∅ S