tasksource/leandojo huggingface dataset:
Theorem: WithBot.coe_le_iff
File: Mathlib/Order/WithBot.lean

tactic: simp [some_eq_coe]
state_before: α : Type u_1
β : Type ?u.11671
γ : Type ?u.11674
δ : Type ?u.11677
a b : α
inst✝ : LE α
x : α
⊢ ↑a ≤ Option.some x ↔ ∃ b, Option.some x = ↑b ∧ a ≤ b

tactic: simp [none_eq_bot]
state_before: α : Type u_1
β : Type ?u.11671
γ : Type ?u.11674
δ : Type ?u.11677
a b : α
inst✝ : LE α
⊢ ¬∃ b, none = ↑b ∧ a ≤ b
Theorem: finrank_eq_one_iff'
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [finrank_eq_one_iff PUnit.{u+1}, Basis.basis_singleton_iff PUnit]
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ finrank K V = 1 ↔ ∃ v _n, ∀ (w : V), ∃ c, c • v = w
Theorem: MeasureTheory.measure_union_add_inter
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← measure_inter_add_diff (s ∪ t) ht, Set.union_inter_cancel_right, union_diff_right, ←
  measure_inter_add_diff s ht]
state_before: α : Type u_1
β : Type ?u.5141
γ : Type ?u.5144
δ : Type ?u.5147
ι : Type ?u.5150
R : Type ?u.5153
R' : Type ?u.5156
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
ht : MeasurableSet t
⊢ ↑↑μ (s ∪ t) + ↑↑μ (s ∩ t) = ↑↑μ s + ↑↑μ t

tactic: ac_rfl
state_before: α : Type u_1
β : Type ?u.5141
γ : Type ?u.5144
δ : Type ?u.5147
ι : Type ?u.5150
R : Type ?u.5153
R' : Type ?u.5156
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t s : Set α
ht : MeasurableSet t
⊢ ↑↑μ t + ↑↑μ (s \ t) + ↑↑μ (s ∩ t) = ↑↑μ (s ∩ t) + ↑↑μ (s \ t) + ↑↑μ t
Theorem: add_eq_left_iff_le
File: Mathlib/Algebra/Order/Kleene.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.19220
ι : Type ?u.19223
π : ι → Type ?u.19228
inst✝ : IdemSemiring α
a b c : α
⊢ a + b = a ↔ b ≤ a
Theorem: tendsto_rpow_div
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: convert tendsto_rpow_div_mul_add (1 : ℝ) _ (0 : ℝ) zero_ne_one
state_before: ⊢ Tendsto (fun x => x ^ (1 / x)) atTop (𝓝 1)

tactic: funext
state_before: case h.e'_3.h.h.e'_6.h.e'_6
x✝ : ℝ
⊢ x✝ = 1 * x✝ + 0

tactic: congr 2
state_before: case h.e'_3.h.h.e'_6.h.e'_6
x✝ : ℝ
⊢ x✝ = 1 * x✝ + 0

tactic: ring
state_before: case h.e'_3.h.h.e'_6.h.e'_6
x✝ : ℝ
⊢ x✝ = 1 * x✝ + 0
Theorem: Nat.succ_sub
File: Std/Data/Nat/Lemmas.lean

tactic: let ⟨k, hk⟩ := Nat.le.dest h
state_before: m n : Nat
h : n ≤ m
⊢ succ m - n = succ (m - n)

tactic: rw [← hk, Nat.add_sub_cancel_left, ← add_succ, Nat.add_sub_cancel_left]
state_before: m n : Nat
h : n ≤ m
k : Nat
hk : n + k = m
⊢ succ m - n = succ (m - n)
Theorem: Set.preimage_eq_preimage
File: Mathlib/Data/Set/Image.lean

tactic: rw [← image_preimage_eq s hf, ← image_preimage_eq t hf, eq]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.51778
ι : Sort ?u.51781
ι' : Sort ?u.51784
f✝ : α → β
s t : Set α
f : β → α
hf : Surjective f
eq : f ⁻¹' s = f ⁻¹' t
⊢ s = t
Theorem: MeasureTheory.iSup_lintegral_measurable_le_eq_lintegral
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: apply le_antisymm
state_before: α : Type u_1
β : Type ?u.71667
γ : Type ?u.71670
δ : Type ?u.71673
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
⊢ (⨆ (g : α → ℝ≥0∞) (_ : Measurable g) (_ : g ≤ f), ∫⁻ (a : α), g a ∂μ) = ∫⁻ (a : α), f a ∂μ

tactic: exact iSup_le fun i => iSup_le fun _ => iSup_le fun h'i => lintegral_mono h'i
state_before: case a
α : Type u_1
β : Type ?u.71667
γ : Type ?u.71670
δ : Type ?u.71673
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
⊢ (⨆ (g : α → ℝ≥0∞) (_ : Measurable g) (_ : g ≤ f), ∫⁻ (a : α), g a ∂μ) ≤ ∫⁻ (a : α), f a ∂μ

tactic: rw [lintegral]
state_before: case a
α : Type u_1
β : Type ?u.71667
γ : Type ?u.71670
δ : Type ?u.71673
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
⊢ (∫⁻ (a : α), f a ∂μ) ≤ ⨆ (g : α → ℝ≥0∞) (_ : Measurable g) (_ : g ≤ f), ∫⁻ (a : α), g a ∂μ

tactic: refine' iSup₂_le fun i hi => le_iSup₂_of_le i i.measurable <| le_iSup_of_le hi _
state_before: case a
α : Type u_1
β : Type ?u.71667
γ : Type ?u.71670
δ : Type ?u.71673
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
⊢ (⨆ (g : α →ₛ ℝ≥0∞) (_ : ↑g ≤ fun a => f a), SimpleFunc.lintegral g μ) ≤
    ⨆ (g : α → ℝ≥0∞) (_ : Measurable g) (_ : g ≤ f), ∫⁻ (a : α), g a ∂μ

tactic: exact le_of_eq (i.lintegral_eq_lintegral _).symm
state_before: case a
α : Type u_1
β : Type ?u.71667
γ : Type ?u.71670
δ : Type ?u.71673
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
i : α →ₛ ℝ≥0∞
hi : ↑i ≤ fun a => f a
⊢ SimpleFunc.lintegral i μ ≤ ∫⁻ (a : α), ↑i a ∂μ
Theorem: List.prod_isUnit_iff
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: refine' ⟨fun h => _, prod_isUnit⟩
state_before: ι : Type ?u.50139
α✝ : Type ?u.50142
M : Type ?u.50145
N : Type ?u.50148
P : Type ?u.50151
M₀ : Type ?u.50154
G : Type ?u.50157
R : Type ?u.50160
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_1
inst✝ : CommMonoid α
L : List α
⊢ IsUnit (prod L) ↔ ∀ (m : α), m ∈ L → IsUnit m

tactic: induction' L with m L ih
state_before: ι : Type ?u.50139
α✝ : Type ?u.50142
M : Type ?u.50145
N : Type ?u.50148
P : Type ?u.50151
M₀ : Type ?u.50154
G : Type ?u.50157
R : Type ?u.50160
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_1
inst✝ : CommMonoid α
L : List α
h : IsUnit (prod L)
⊢ ∀ (m : α), m ∈ L → IsUnit m

tactic: rw [prod_cons, IsUnit.mul_iff] at h
state_before: case cons
ι : Type ?u.50139
α✝ : Type ?u.50142
M : Type ?u.50145
N : Type ?u.50148
P : Type ?u.50151
M₀ : Type ?u.50154
G : Type ?u.50157
R : Type ?u.50160
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_1
inst✝ : CommMonoid α
L✝ : List α
h✝ : IsUnit (prod L✝)
m : α
L : List α
ih : IsUnit (prod L) → ∀ (m : α), m ∈ L → IsUnit m
h : IsUnit (prod (m :: L))
⊢ ∀ (m_1 : α), m_1 ∈ m :: L → IsUnit m_1

tactic: exact fun m' h' => Or.elim (eq_or_mem_of_mem_cons h') (fun H => H.substr h.1) fun H => ih h.2 _ H
state_before: case cons
ι : Type ?u.50139
α✝ : Type ?u.50142
M : Type ?u.50145
N : Type ?u.50148
P : Type ?u.50151
M₀ : Type ?u.50154
G : Type ?u.50157
R : Type ?u.50160
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_1
inst✝ : CommMonoid α
L✝ : List α
h✝ : IsUnit (prod L✝)
m : α
L : List α
ih : IsUnit (prod L) → ∀ (m : α), m ∈ L → IsUnit m
h : IsUnit m ∧ IsUnit (prod L)
⊢ ∀ (m_1 : α), m_1 ∈ m :: L → IsUnit m_1

tactic: exact fun m' h' => False.elim (not_mem_nil m' h')
state_before: case nil
ι : Type ?u.50139
α✝ : Type ?u.50142
M : Type ?u.50145
N : Type ?u.50148
P : Type ?u.50151
M₀ : Type ?u.50154
G : Type ?u.50157
R : Type ?u.50160
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_1
inst✝ : CommMonoid α
L : List α
h✝ : IsUnit (prod L)
h : IsUnit (prod [])
⊢ ∀ (m : α), m ∈ [] → IsUnit m
Theorem: ENNReal.le_inv_iff_mul_le
File: Mathlib/Data/Real/ENNReal.lean

tactic: right
state_before: case ht
α : Type ?u.294981
β : Type ?u.294984
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ b ≠ ⊤ ∨ 1 ≠ ⊤

tactic: simp
state_before: case ht.h
α : Type ?u.294981
β : Type ?u.294984
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ 1 ≠ ⊤
Theorem: MeasureTheory.VectorMeasure.of_nonpos_disjoint_union_eq_zero
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [of_union h hA₁ hB₁] at hAB
state_before: α : Type u_1
β : Type ?u.43464
m : MeasurableSpace α
M : Type ?u.43470
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
s : SignedMeasure α
A B : Set α
h : Disjoint A B
hA₁ : MeasurableSet A
hB₁ : MeasurableSet B
hA₂ : ↑s A ≤ 0
hB₂ : ↑s B ≤ 0
hAB : ↑s (A ∪ B) = 0
⊢ ↑s A = 0

tactic: linarith
state_before: α : Type u_1
β : Type ?u.43464
m : MeasurableSpace α
M : Type ?u.43470
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
s : SignedMeasure α
A B : Set α
h : Disjoint A B
hA₁ : MeasurableSet A
hB₁ : MeasurableSet B
hA₂ : ↑s A ≤ 0
hB₂ : ↑s B ≤ 0
hAB : ↑s A + ↑s B = 0
⊢ ↑s A = 0
Theorem: Finset.subset_product_image_fst
File: Mathlib/Data/Finset/Prod.lean

tactic: simp (config := { contextual := true }) [mem_image]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1583
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝ : DecidableEq α
i : α
⊢ i ∈ image Prod.fst (s ×ˢ t) → i ∈ s
Theorem: Subgroup.isComplement_singleton_left
File: Mathlib/GroupTheory/Complement.lean

tactic: refine'
  ⟨fun h => top_le_iff.mp fun x _ => _, fun h => (congr_arg _ h).mpr isComplement_singleton_top⟩
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
g : G
⊢ IsComplement {g} S ↔ S = ⊤

tactic: obtain ⟨⟨⟨z, rfl : z = g⟩, y, _⟩, hy⟩ := h.2 (g * x)
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
g : G
h : IsComplement {g} S
x : G
x✝ : x ∈ ⊤
⊢ x ∈ S

tactic: rwa [← mul_left_cancel hy]
state_before: case intro.mk.mk.mk
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
x : G
x✝ : x ∈ ⊤
z : G
h : IsComplement {z} S
y : G
property✝ : y ∈ S
hy : (fun x => ↑x.fst * ↑x.snd) ({ val := z, property := (_ : z = z) }, { val := y, property := property✝ }) = z * x
⊢ x ∈ S
Theorem: Filter.map_prod_map_coprod_le
File: Mathlib/Order/Filter/Prod.lean

tactic: intro s
state_before: α : Type ?u.62585
β : Type ?u.62588
γ : Type ?u.62591
δ : Type ?u.62594
ι : Sort ?u.62597
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
⊢ map (Prod.map m₁ m₂) (Filter.coprod f₁ f₂) ≤ Filter.coprod (map m₁ f₁) (map m₂ f₂)

tactic: simp only [mem_map, mem_coprod_iff]
state_before: α : Type ?u.62585
β : Type ?u.62588
γ : Type ?u.62591
δ : Type ?u.62594
ι : Sort ?u.62597
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
s : Set (β₁ × β₂)
⊢ s ∈ Filter.coprod (map m₁ f₁) (map m₂ f₂) → s ∈ map (Prod.map m₁ m₂) (Filter.coprod f₁ f₂)

tactic: rintro ⟨⟨u₁, hu₁, h₁⟩, u₂, hu₂, h₂⟩
state_before: α : Type ?u.62585
β : Type ?u.62588
γ : Type ?u.62591
δ : Type ?u.62594
ι : Sort ?u.62597
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
s : Set (β₁ × β₂)
⊢ ((∃ t₁, m₁ ⁻¹' t₁ ∈ f₁ ∧ Prod.fst ⁻¹' t₁ ⊆ s) ∧ ∃ t₂, m₂ ⁻¹' t₂ ∈ f₂ ∧ Prod.snd ⁻¹' t₂ ⊆ s) →
    (∃ t₁, t₁ ∈ f₁ ∧ Prod.fst ⁻¹' t₁ ⊆ Prod.map m₁ m₂ ⁻¹' s) ∧ ∃ t₂, t₂ ∈ f₂ ∧ Prod.snd ⁻¹' t₂ ⊆ Prod.map m₁ m₂ ⁻¹' s

tactic: refine' ⟨⟨m₁ ⁻¹' u₁, hu₁, fun _ hx => h₁ _⟩, ⟨m₂ ⁻¹' u₂, hu₂, fun _ hx => h₂ _⟩⟩ <;> convert hx
state_before: case intro.intro.intro.intro.intro
α : Type ?u.62585
β : Type ?u.62588
γ : Type ?u.62591
δ : Type ?u.62594
ι : Sort ?u.62597
f : Filter α
g : Filter β
α₁ : Type u
α₂ : Type v
β₁ : Type w
β₂ : Type x
f₁ : Filter α₁
f₂ : Filter α₂
m₁ : α₁ → β₁
m₂ : α₂ → β₂
s : Set (β₁ × β₂)
u₁ : Set β₁
hu₁ : m₁ ⁻¹' u₁ ∈ f₁
h₁ : Prod.fst ⁻¹' u₁ ⊆ s
u₂ : Set β₂
hu₂ : m₂ ⁻¹' u₂ ∈ f₂
h₂ : Prod.snd ⁻¹' u₂ ⊆ s
⊢ (∃ t₁, t₁ ∈ f₁ ∧ Prod.fst ⁻¹' t₁ ⊆ Prod.map m₁ m₂ ⁻¹' s) ∧ ∃ t₂, t₂ ∈ f₂ ∧ Prod.snd ⁻¹' t₂ ⊆ Prod.map m₁ m₂ ⁻¹' s
Theorem: Set.chainHeight_dual
File: Mathlib/Order/Height.lean

tactic: rw [chainHeight_le_chainHeight_iff]
state_before: case a
α : Type u_1
β : Type ?u.31224
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
⊢ chainHeight s ≤ chainHeight (↑ofDual ⁻¹' s)

tactic: rintro l ⟨h₁, h₂⟩
state_before: case a
α : Type u_1
β : Type ?u.31224
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l : List α
a : α
⊢ ∀ (l : List α), l ∈ subchain s → ∃ l', l' ∈ subchain (↑ofDual ⁻¹' s) ∧ length l = length l'

tactic: exact ⟨l.reverse, ⟨chain'_reverse.mpr h₁, fun i h ↦ h₂ i ((mem_reverse i l).mp h)⟩,
  (length_reverse _).symm⟩
state_before: case a.intro
α : Type u_1
β : Type ?u.31224
inst✝¹ : LT α
inst✝ : LT β
s t : Set α
l✝ : List α
a : α
l : List α
h₁ : Chain' (fun x x_1 => x < x_1) l
h₂ : ∀ (i : α), i ∈ l → i ∈ s
⊢ ∃ l', l' ∈ subchain (↑ofDual ⁻¹' s) ∧ length l = length l'
Theorem: Quiver.Symmetrify.lift_reverse
File: Mathlib/Combinatorics/Quiver/Symmetric.lean

tactic: dsimp [Symmetrify.lift]
state_before: U : Type ?u.7670
V : Type u_2
W : Type ?u.7676
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_1
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
f : X ⟶ Y
⊢ (lift φ).map (reverse f) = reverse ((lift φ).map f)

tactic: cases f
state_before: U : Type ?u.7670
V : Type u_2
W : Type ?u.7676
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_1
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
f : X ⟶ Y
⊢ (match Sum.swap f with
    | Sum.inl g => φ.map g
    | Sum.inr g => reverse (φ.map g)) =
    reverse
      (match f with
      | Sum.inl g => φ.map g
      | Sum.inr g => reverse (φ.map g))

tactic: simp only
state_before: case inl
U : Type ?u.7670
V : Type u_2
W : Type ?u.7676
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_1
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
val✝ : X ⟶ Y
⊢ (match Sum.swap (Sum.inl val✝) with
    | Sum.inl g => φ.map g
    | Sum.inr g => reverse (φ.map g)) =
    reverse
      (match Sum.inl val✝ with
      | Sum.inl g => φ.map g
      | Sum.inr g => reverse (φ.map g))

tactic: rfl
state_before: case inl
U : Type ?u.7670
V : Type u_2
W : Type ?u.7676
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_1
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
val✝ : X ⟶ Y
⊢ (match Sum.swap (Sum.inl val✝) with
    | Sum.inl g => φ.map g
    | Sum.inr g => reverse (φ.map g)) =
    reverse (φ.map val✝)

tactic: simp only [reverse_reverse]
state_before: case inr
U : Type ?u.7670
V : Type u_2
W : Type ?u.7676
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_1
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
val✝ : Y ⟶ X
⊢ (match Sum.swap (Sum.inr val✝) with
    | Sum.inl g => φ.map g
    | Sum.inr g => reverse (φ.map g)) =
    reverse
      (match Sum.inr val✝ with
      | Sum.inl g => φ.map g
      | Sum.inr g => reverse (φ.map g))

tactic: rfl
state_before: case inr
U : Type ?u.7670
V : Type u_2
W : Type ?u.7676
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
V' : Type u_1
inst✝ : Quiver V'
h : HasInvolutiveReverse V'
φ : V ⥤q V'
X Y : Symmetrify V
val✝ : Y ⟶ X
⊢ (match Sum.swap (Sum.inr val✝) with
    | Sum.inl g => φ.map g
    | Sum.inr g => reverse (φ.map g)) =
    φ.map val✝
Theorem: Quaternion.star_mul_self
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [star_comm_self, self_mul_star]
state_before: S : Type ?u.748412
T : Type ?u.748415
R : Type u_1
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ star a * a = ↑(↑normSq a)
Theorem: SimpleGraph.dist_comm
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

tactic: by_cases h : G.Reachable u v
state_before: V : Type u_1
G : SimpleGraph V
u v : V
⊢ dist G u v = dist G v u

tactic: apply le_antisymm (dist_comm_aux h) (dist_comm_aux h.symm)
state_before: case pos
V : Type u_1
G : SimpleGraph V
u v : V
h : Reachable G u v
⊢ dist G u v = dist G v u

tactic: have h' : ¬G.Reachable v u := fun h' => absurd h'.symm h
state_before: case neg
V : Type u_1
G : SimpleGraph V
u v : V
h : ¬Reachable G u v
⊢ dist G u v = dist G v u

tactic: simp [h, h', dist_eq_zero_of_not_reachable]
state_before: case neg
V : Type u_1
G : SimpleGraph V
u v : V
h : ¬Reachable G u v
h' : ¬Reachable G v u
⊢ dist G u v = dist G v u
Theorem: ConvexOn.average_mem_epigraph
File: Mathlib/Analysis/Convex/Integral.lean

tactic: have ht_mem : ∀ᵐ x ∂μ, (f x, g (f x)) ∈ {p : E × ℝ | p.1 ∈ s ∧ g p.1 ≤ p.2} :=
  hfs.mono fun x hx => ⟨hx, le_rfl⟩
state_before: α : Type u_1
E : Type u_2
F : Type ?u.608928
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : MeasureTheory.Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : IsFiniteMeasure μ
hg : ConvexOn ℝ s g
hgc : ContinuousOn g s
hsc : IsClosed s
hμ : μ ≠ 0
hfs : ∀ᵐ (x : α) ∂μ, f x ∈ s
hfi : Integrable f
hgi : Integrable (g ∘ f)
⊢ (⨍ (x : α), f x ∂μ, ⨍ (x : α), g (f x) ∂μ) ∈ {p | p.fst ∈ s ∧ g p.fst ≤ p.snd}

tactic: exact average_pair hfi hgi ▸
  hg.convex_epigraph.average_mem (hsc.epigraph hgc) hμ ht_mem (hfi.prod_mk hgi)
state_before: α : Type u_1
E : Type u_2
F : Type ?u.608928
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ : MeasureTheory.Measure α
s : Set E
t : Set α
f : α → E
g : E → ℝ
C : ℝ
inst✝ : IsFiniteMeasure μ
hg : ConvexOn ℝ s g
hgc : ContinuousOn g s
hsc : IsClosed s
hμ : μ ≠ 0
hfs : ∀ᵐ (x : α) ∂μ, f x ∈ s
hfi : Integrable f
hgi : Integrable (g ∘ f)
ht_mem : ∀ᵐ (x : α) ∂μ, (f x, g (f x)) ∈ {p | p.fst ∈ s ∧ g p.fst ≤ p.snd}
⊢ (⨍ (x : α), f x ∂μ, ⨍ (x : α), g (f x) ∂μ) ∈ {p | p.fst ∈ s ∧ g p.fst ≤ p.snd}
Theorem: FiniteDimensional.finrank_pos_iff
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← finrank_eq_rank]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ 0 < finrank K V ↔ 0 < Module.rank K V

tactic: norm_cast
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ 0 < finrank K V ↔ 0 < ↑(finrank K V)
Theorem: LinearMap.sum_repr_mul_repr_mulₛₗ
File: Mathlib/LinearAlgebra/Basis/Bilinear.lean

tactic: conv_rhs => rw [← b₁.total_repr x, ← b₂.total_repr y]
state_before: ι₁ : Type u_8
ι₂ : Type u_9
R : Type u_1
R₂ : Type u_2
S : Type u_6
S₂ : Type u_7
M : Type u_3
N : Type u_5
P : Type u_4
Mₗ : Type ?u.19146
Nₗ : Type ?u.19149
Pₗ : Type ?u.19152
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : CommSemiring S
inst✝¹⁵ : CommSemiring R₂
inst✝¹⁴ : CommSemiring S₂
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Mₗ
inst✝⁹ : AddCommMonoid Nₗ
inst✝⁸ : AddCommMonoid Pₗ
inst✝⁷ : Module R M
inst✝⁶ : Module S N
inst✝⁵ : Module R₂ P
inst✝⁴ : Module S₂ P
inst✝³ : Module R Mₗ
inst✝² : Module R Nₗ
inst✝¹ : Module R Pₗ
inst✝ : SMulCommClass S₂ R₂ P
ρ₁₂ : R →+* R₂
σ₁₂ : S →+* S₂
b₁ : Basis ι₁ R M
b₂ : Basis ι₂ S N
b₁' : Basis ι₁ R Mₗ
b₂' : Basis ι₂ R Nₗ
B : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P
x : M
y : N
⊢ (Finsupp.sum (↑b₁.repr x) fun i xi =>
      Finsupp.sum (↑b₂.repr y) fun j yj => ↑ρ₁₂ xi • ↑σ₁₂ yj • ↑(↑B (↑b₁ i)) (↑b₂ j)) =
    ↑(↑B x) y

tactic: simp_rw [Finsupp.total_apply, Finsupp.sum, map_sum₂, map_sum, LinearMap.map_smulₛₗ₂,
  LinearMap.map_smulₛₗ]
state_before: ι₁ : Type u_8
ι₂ : Type u_9
R : Type u_1
R₂ : Type u_2
S : Type u_6
S₂ : Type u_7
M : Type u_3
N : Type u_5
P : Type u_4
Mₗ : Type ?u.19146
Nₗ : Type ?u.19149
Pₗ : Type ?u.19152
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : CommSemiring S
inst✝¹⁵ : CommSemiring R₂
inst✝¹⁴ : CommSemiring S₂
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Mₗ
inst✝⁹ : AddCommMonoid Nₗ
inst✝⁸ : AddCommMonoid Pₗ
inst✝⁷ : Module R M
inst✝⁶ : Module S N
inst✝⁵ : Module R₂ P
inst✝⁴ : Module S₂ P
inst✝³ : Module R Mₗ
inst✝² : Module R Nₗ
inst✝¹ : Module R Pₗ
inst✝ : SMulCommClass S₂ R₂ P
ρ₁₂ : R →+* R₂
σ₁₂ : S →+* S₂
b₁ : Basis ι₁ R M
b₂ : Basis ι₂ S N
b₁' : Basis ι₁ R Mₗ
b₂' : Basis ι₂ R Nₗ
B : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P
x : M
y : N
⊢ (Finsupp.sum (↑b₁.repr x) fun i xi =>
      Finsupp.sum (↑b₂.repr y) fun j yj => ↑ρ₁₂ xi • ↑σ₁₂ yj • ↑(↑B (↑b₁ i)) (↑b₂ j)) =
    ↑(↑B (↑(Finsupp.total ι₁ M R ↑b₁) (↑b₁.repr x))) (↑(Finsupp.total ι₂ N S ↑b₂) (↑b₂.repr y))
Theorem: Set.pi_update_of_not_mem
File: Mathlib/Data/Set/Prod.lean

tactic: rw [update_noteq]
state_before: ι : Type u_1
α : ι → Type u_3
β : ι → Type u_2
s s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
hi : ¬i ∈ s
f : (j : ι) → α j
a : α i
t : (j : ι) → α j → Set (β j)
j : ι
hj : j ∈ s
⊢ t j (update f i a j) = t j (f j)

tactic: exact fun h => hi (h ▸ hj)
state_before: case h
ι : Type u_1
α : ι → Type u_3
β : ι → Type u_2
s s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
inst✝ : DecidableEq ι
hi : ¬i ∈ s
f : (j : ι) → α j
a : α i
t : (j : ι) → α j → Set (β j)
j : ι
hj : j ∈ s
⊢ j ≠ i
Theorem: FirstOrder.Language.Formula.realize_graph
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp only [Formula.graph, Term.realize, realize_equal, Fin.cons_zero, Fin.cons_succ]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.246639
P : Type ?u.246642
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
f : Functions L n
x : Fin n → M
y : M
⊢ Realize (graph f) (cons y x) ↔ funMap f x = y

tactic: rw [eq_comm]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.246639
P : Type ?u.246642
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
f : Functions L n
x : Fin n → M
y : M
⊢ (y = funMap f fun i => x i) ↔ funMap f x = y
Theorem: CantorScheme.map_mem
File: Mathlib/Topology/MetricSpace/CantorScheme.lean

tactic: have := x.property.some_mem
state_before: β : Type u_1
α : Type u_2
A : List β → Set α
x : ↑(inducedMap A).fst
n : ℕ
⊢ Sigma.snd (inducedMap A) x ∈ A (res (↑x) n)

tactic: rw [mem_iInter] at this
state_before: β : Type u_1
α : Type u_2
A : List β → Set α
x : ↑(inducedMap A).fst
n : ℕ
this : Set.Nonempty.some (_ : ↑x ∈ (inducedMap A).fst) ∈ ⋂ (n : ℕ), A (res (↑x) n)
⊢ Sigma.snd (inducedMap A) x ∈ A (res (↑x) n)

tactic: exact this n
state_before: β : Type u_1
α : Type u_2
A : List β → Set α
x : ↑(inducedMap A).fst
n : ℕ
this : ∀ (i : ℕ), Set.Nonempty.some (_ : ↑x ∈ (inducedMap A).fst) ∈ A (res (↑x) i)
⊢ Sigma.snd (inducedMap A) x ∈ A (res (↑x) n)
Theorem: FreeMonoid.mrange_lift
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: rw [mrange_eq_map, ← FreeMonoid.closure_range_of, map_mclosure, ← Set.range_comp,
  FreeMonoid.lift_comp_of]
state_before: M : Type u_2
A : Type ?u.75236
B : Type ?u.75239
inst✝ : Monoid M
α : Type u_1
f : α → M
⊢ mrange (↑FreeMonoid.lift f) = closure (Set.range f)
Theorem: StrictMonoOn.Iic_union_Ici
File: Mathlib/Order/Monotone/Union.lean

tactic: rw [← strictMonoOn_univ, ← @Iic_union_Ici _ _ a]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
h₁ : StrictMonoOn f (Iic a)
h₂ : StrictMonoOn f (Ici a)
⊢ StrictMono f

tactic: exact StrictMonoOn.union h₁ h₂ isGreatest_Iic isLeast_Ici
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
h₁ : StrictMonoOn f (Iic a)
h₂ : StrictMonoOn f (Ici a)
⊢ StrictMonoOn f (Iic a ∪ Ici a)
Theorem: isConnected_connectedComponentIn_iff
File: Mathlib/Topology/Connected.lean

tactic: simp_rw [← connectedComponentIn_nonempty_iff, IsConnected, isPreconnected_connectedComponentIn,
  and_true_iff]
state_before: α : Type u
β : Type v
ι : Type ?u.54113
π : ι → Type ?u.54118
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ IsConnected (connectedComponentIn F x) ↔ x ∈ F
Theorem: TopologicalSpace.isSeparable_iUnion
File: Mathlib/Topology/Bases.lean

tactic: choose c hc h'c using hs
state_before: α : Type u
t : TopologicalSpace α
ι : Type u_1
inst✝ : Countable ι
s : ι → Set α
hs : ∀ (i : ι), IsSeparable (s i)
⊢ IsSeparable (⋃ (i : ι), s i)

tactic: refine' ⟨⋃ i, c i, countable_iUnion hc, iUnion_subset_iff.2 fun i => _⟩
state_before: α : Type u
t : TopologicalSpace α
ι : Type u_1
inst✝ : Countable ι
s c : ι → Set α
hc : ∀ (i : ι), Set.Countable (c i)
h'c : ∀ (i : ι), s i ⊆ closure (c i)
⊢ IsSeparable (⋃ (i : ι), s i)

tactic: exact (h'c i).trans (closure_mono (subset_iUnion _ i))
state_before: α : Type u
t : TopologicalSpace α
ι : Type u_1
inst✝ : Countable ι
s c : ι → Set α
hc : ∀ (i : ι), Set.Countable (c i)
h'c : ∀ (i : ι), s i ⊆ closure (c i)
i : ι
⊢ s i ⊆ closure (⋃ (i : ι), c i)
Theorem: FiniteDimensional.finrank_matrix
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: simp [finrank]
state_before: R : Type u
M : Type v
N : Type w
inst✝¹¹ : Ring R
inst✝¹⁰ : StrongRankCondition R
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
inst✝⁷ : Module.Free R M
inst✝⁶ : Module.Finite R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : Module.Free R N
inst✝² : Module.Finite R N
m : Type u_1
n : Type u_2
inst✝¹ : Fintype m
inst✝ : Fintype n
⊢ finrank R (Matrix m n R) = card m * card n