tasksource/leandojo huggingface dataset:
Theorem: Commute.sum_right
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: obtain ⟨i, hi, rfl⟩ := Multiset.mem_map.mp hb
state_before: ι : Type ?u.819790
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : NonUnitalNonAssocSemiring β
s : Finset α
f : α → β
b✝ : β
h : ∀ (i : α), i ∈ s → Commute b✝ (f i)
b : β
hb : b ∈ Multiset.map (fun i => f i) s.val
⊢ Commute b✝ b

tactic: exact h _ hi
state_before: case intro.intro
ι : Type ?u.819790
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : NonUnitalNonAssocSemiring β
s : Finset α
f : α → β
b : β
h : ∀ (i : α), i ∈ s → Commute b (f i)
i : α
hi : i ∈ s.val
hb : f i ∈ Multiset.map (fun i => f i) s.val
⊢ Commute b (f i)
Theorem: ZFSet.sInter_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp
state_before: ⊢ ¬ZFSet.Nonempty ∅
Theorem: Ordnode.Sized.dual
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: simp [size_dual, add_comm]
state_before: α : Type u_1
l : Ordnode α
x✝ : α
r : Ordnode α
sl : Sized l
sr : Sized r
⊢ size l + size r + 1 = size (Ordnode.dual r) + size (Ordnode.dual l) + 1
Theorem: MeasureTheory.Measure.QuasiMeasurePreserving.liminf_preimage_iterate_ae_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← ae_eq_set_compl_compl, @Filter.liminf_compl (Set α)]
state_before: α : Type u_1
β : Type ?u.496746
γ : Type ?u.496749
δ : Type ?u.496752
ι : Type ?u.496755
R : Type ?u.496758
R' : Type ?u.496761
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μa μa' : Measure α
μb μb' : Measure β
μc : Measure γ
f✝ : α → β
f : α → α
hf : QuasiMeasurePreserving f
hs : f ⁻¹' s =ᵐ[μ] s
⊢ liminf (fun n => (preimage f^[n]) s) atTop =ᵐ[μ] s

tactic: rw [← ae_eq_set_compl_compl, ← preimage_compl] at hs
state_before: α : Type u_1
β : Type ?u.496746
γ : Type ?u.496749
δ : Type ?u.496752
ι : Type ?u.496755
R : Type ?u.496758
R' : Type ?u.496761
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μa μa' : Measure α
μb μb' : Measure β
μc : Measure γ
f✝ : α → β
f : α → α
hf : QuasiMeasurePreserving f
hs : f ⁻¹' s =ᵐ[μ] s
⊢ limsup (compl ∘ fun n => (preimage f^[n]) s) atTop =ᵐ[μ] sᶜ

tactic: convert hf.limsup_preimage_iterate_ae_eq hs
state_before: α : Type u_1
β : Type ?u.496746
γ : Type ?u.496749
δ : Type ?u.496752
ι : Type ?u.496755
R : Type ?u.496758
R' : Type ?u.496761
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μa μa' : Measure α
μb μb' : Measure β
μc : Measure γ
f✝ : α → β
f : α → α
hf : QuasiMeasurePreserving f
hs : f ⁻¹' sᶜ =ᵐ[μ] sᶜ
⊢ limsup (compl ∘ fun n => (preimage f^[n]) s) atTop =ᵐ[μ] sᶜ

tactic: ext1 n
state_before: case h.e'_4.h.e'_4.h
α : Type u_1
β : Type ?u.496746
γ : Type ?u.496749
δ : Type ?u.496752
ι : Type ?u.496755
R : Type ?u.496758
R' : Type ?u.496761
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μa μa' : Measure α
μb μb' : Measure β
μc : Measure γ
f✝ : α → β
f : α → α
hf : QuasiMeasurePreserving f
hs : f ⁻¹' sᶜ =ᵐ[μ] sᶜ
x✝ : ℕ
⊢ (compl ∘ fun n => (preimage f^[n]) s) x✝ = (preimage f^[x✝]) (sᶜ)

tactic: simp only [← Set.preimage_iterate_eq, comp_apply, preimage_compl]
state_before: case h.e'_4.h.e'_4.h.h
α : Type u_1
β : Type ?u.496746
γ : Type ?u.496749
δ : Type ?u.496752
ι : Type ?u.496755
R : Type ?u.496758
R' : Type ?u.496761
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μa μa' : Measure α
μb μb' : Measure β
μc : Measure γ
f✝ : α → β
f : α → α
hf : QuasiMeasurePreserving f
hs : f ⁻¹' sᶜ =ᵐ[μ] sᶜ
x✝ : ℕ
n : α
⊢ n ∈ (compl ∘ fun n => (preimage f^[n]) s) x✝ ↔ n ∈ (preimage f^[x✝]) (sᶜ)
Theorem: Polynomial.bernoulli_eval_zero
File: Mathlib/NumberTheory/BernoulliPolynomials.lean

tactic: rw [bernoulli, eval_finset_sum, sum_range_succ]
state_before: n : ℕ
⊢ eval 0 (bernoulli n) = _root_.bernoulli n

tactic: have : (∑ x : ℕ in range n, _root_.bernoulli x * n.choose x * 0 ^ (n - x)) = 0 := by
  apply sum_eq_zero <| fun x hx => _
  intros x hx
  have h : x  <  n := (mem_range.1 hx)
  simp [h]
state_before: n : ℕ
⊢ ∑ x in range n, eval 0 (↑(monomial (n - x)) (_root_.bernoulli x * ↑(Nat.choose n x))) +
      eval 0 (↑(monomial (n - n)) (_root_.bernoulli n * ↑(Nat.choose n n))) =
    _root_.bernoulli n

tactic: simp [this]
state_before: n : ℕ
this : ∑ x in range n, _root_.bernoulli x * ↑(Nat.choose n x) * 0 ^ (n - x) = 0
⊢ ∑ x in range n, eval 0 (↑(monomial (n - x)) (_root_.bernoulli x * ↑(Nat.choose n x))) +
      eval 0 (↑(monomial (n - n)) (_root_.bernoulli n * ↑(Nat.choose n n))) =
    _root_.bernoulli n

tactic: apply sum_eq_zero <| fun x hx => _
state_before: n : ℕ
⊢ ∑ x in range n, _root_.bernoulli x * ↑(Nat.choose n x) * 0 ^ (n - x) = 0

tactic: intros x hx
state_before: n : ℕ
⊢ ∀ (x : ℕ), x ∈ range n → _root_.bernoulli x * ↑(Nat.choose n x) * 0 ^ (n - x) = 0

tactic: have h : x  <  n := (mem_range.1 hx)
state_before: n x : ℕ
hx : x ∈ range n
⊢ _root_.bernoulli x * ↑(Nat.choose n x) * 0 ^ (n - x) = 0

tactic: simp [h]
state_before: n x : ℕ
hx : x ∈ range n
h : x < n
⊢ _root_.bernoulli x * ↑(Nat.choose n x) * 0 ^ (n - x) = 0
Theorem: Polynomial.derivative_int_cast_mul
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Ring R
n : ℤ
f : R[X]
⊢ ↑derivative (↑n * f) = ↑n * ↑derivative f
Theorem: MonoidHom.mker_inl
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: ext x
state_before: M : Type u_1
N : Type u_2
P : Type ?u.143655
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.143676
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.143700
mc : MonoidHomClass F M N
⊢ mker (inl M N) = ⊥

tactic: simp [mem_mker]
state_before: case h
M : Type u_1
N : Type u_2
P : Type ?u.143655
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.143676
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.143700
mc : MonoidHomClass F M N
x : M
⊢ x ∈ mker (inl M N) ↔ x ∈ ⊥
Theorem: isLowerSet_compl
File: Mathlib/Order/UpperLower/Basic.lean

tactic: convert h.compl
state_before: α : Type u_1
β : Type ?u.1894
γ : Type ?u.1897
ι : Sort ?u.1900
κ : ι → Sort ?u.1905
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
h : IsLowerSet (sᶜ)
⊢ IsUpperSet s

tactic: rw [compl_compl]
state_before: case h.e'_3
α : Type u_1
β : Type ?u.1894
γ : Type ?u.1897
ι : Sort ?u.1900
κ : ι → Sort ?u.1905
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
h : IsLowerSet (sᶜ)
⊢ s = sᶜᶜ
Theorem: SimpleGraph.isClique_iff_induce_eq
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: rw [isClique_iff]
state_before: α : Type u_1
G H : SimpleGraph α
s t : Set α
⊢ IsClique G s ↔ induce s G = ⊤

tactic: constructor
state_before: α : Type u_1
G H : SimpleGraph α
s t : Set α
⊢ Set.Pairwise s G.Adj ↔ induce s G = ⊤

tactic: intro h
state_before: case mp
α : Type u_1
G H : SimpleGraph α
s t : Set α
⊢ Set.Pairwise s G.Adj → induce s G = ⊤

tactic: ext ⟨v, hv⟩ ⟨w, hw⟩
state_before: case mp
α : Type u_1
G H : SimpleGraph α
s t : Set α
h : Set.Pairwise s G.Adj
⊢ induce s G = ⊤

tactic: simp only [comap_Adj, Subtype.coe_mk, top_adj, Ne.def, Subtype.mk_eq_mk]
state_before: case mp.Adj.h.mk.h.mk.a
α : Type u_1
G H : SimpleGraph α
s t : Set α
h : Set.Pairwise s G.Adj
v : α
hv : v ∈ s
w : α
hw : w ∈ s
⊢ Adj (induce s G) { val := v, property := hv } { val := w, property := hw } ↔
    Adj ⊤ { val := v, property := hv } { val := w, property := hw }

tactic: exact ⟨Adj.ne, h hv hw⟩
state_before: case mp.Adj.h.mk.h.mk.a
α : Type u_1
G H : SimpleGraph α
s t : Set α
h : Set.Pairwise s G.Adj
v : α
hv : v ∈ s
w : α
hw : w ∈ s
⊢ Adj G (↑(Function.Embedding.subtype fun x => x ∈ s) { val := v, property := hv })
      (↑(Function.Embedding.subtype fun x => x ∈ s) { val := w, property := hw }) ↔
    ¬v = w

tactic: intro h v hv w hw hne
state_before: case mpr
α : Type u_1
G H : SimpleGraph α
s t : Set α
⊢ induce s G = ⊤ → Set.Pairwise s G.Adj

tactic: have h2 : (G.induce s).Adj ⟨v, hv⟩ ⟨w, hw⟩ = _ := rfl
state_before: case mpr
α : Type u_1
G H : SimpleGraph α
s t : Set α
h : induce s G = ⊤
v : α
hv : v ∈ s
w : α
hw : w ∈ s
hne : v ≠ w
⊢ Adj G v w

tactic: conv_lhs at h2 => rw [h]
state_before: case mpr
α : Type u_1
G H : SimpleGraph α
s t : Set α
h : induce s G = ⊤
v : α
hv : v ∈ s
w : α
hw : w ∈ s
hne : v ≠ w
h2 :
  Adj (induce s G) { val := v, property := hv } { val := w, property := hw } =
    Adj (induce s G) { val := v, property := hv } { val := w, property := hw }
⊢ Adj G v w

tactic: simp only [top_adj, ne_eq, Subtype.mk.injEq, eq_iff_iff] at h2
state_before: case mpr
α : Type u_1
G H : SimpleGraph α
s t : Set α
h : induce s G = ⊤
v : α
hv : v ∈ s
w : α
hw : w ∈ s
hne : v ≠ w
h2 :
  Adj ⊤ { val := v, property := hv } { val := w, property := hw } =
    Adj (induce s G) { val := v, property := hv } { val := w, property := hw }
⊢ Adj G v w

tactic: exact h2.1 hne
state_before: case mpr
α : Type u_1
G H : SimpleGraph α
s t : Set α
h : induce s G = ⊤
v : α
hv : v ∈ s
w : α
hw : w ∈ s
hne : v ≠ w
h2 : ¬v = w ↔ Adj (induce s G) { val := v, property := hv } { val := w, property := hw }
⊢ Adj G v w
Theorem: CategoryTheory.Faithful.of_iso
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

tactic: rw [← NatIso.naturality_1 α.symm, h, NatIso.naturality_1 α.symm]
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
E : Type u₃
inst✝¹ : Category E
F F' : C ⥤ D
G : D ⥤ E
inst✝ : Faithful F
α : F ≅ F'
X✝ Y✝ : C
a₁✝ a₂✝ : X✝ ⟶ Y✝
h : F'.map a₁✝ = F'.map a₂✝
⊢ F.map a₁✝ = F.map a₂✝
Theorem: Filter.Tendsto.div
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: simpa only [div_eq_mul_inv] using hf.mul (hg.inv₀ hy)
state_before: α : Type u_1
β : Type ?u.23558
G₀ : Type u_2
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
f g : α → G₀
l : Filter α
a b : G₀
hf : Tendsto f l (𝓝 a)
hg : Tendsto g l (𝓝 b)
hy : b ≠ 0
⊢ Tendsto (f / g) l (𝓝 (a / b))
Theorem: ContDiffWithinAt.fderivWithin_right
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rw [preimage_id']
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1087342
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
hf : ContDiffWithinAt 𝕜 n f s x₀
hs : UniqueDiffOn 𝕜 s
hmn : m + 1 ≤ n
hx₀s : x₀ ∈ s
⊢ s ⊆ (fun x => x) ⁻¹' s
Theorem: Polynomial.rootMultiplicity_le_one_of_separable
File: Mathlib/FieldTheory/Separable.lean

tactic: by_cases hp : p = 0
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : Separable p
x : R
⊢ rootMultiplicity x p ≤ 1

tactic: rw [rootMultiplicity_eq_multiplicity, dif_neg hp, ← PartENat.coe_le_coe, PartENat.natCast_get,
  Nat.cast_one]
state_before: case neg
R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : Separable p
x : R
hp : ¬p = 0
⊢ rootMultiplicity x p ≤ 1

tactic: exact multiplicity_le_one_of_separable (not_isUnit_X_sub_C _) hsep
state_before: case neg
R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : Separable p
x : R
hp : ¬p = 0
⊢ multiplicity (X - ↑C x) p ≤ 1

tactic: simp [hp]
state_before: case pos
R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
p : R[X]
hsep : Separable p
x : R
hp : p = 0
⊢ rootMultiplicity x p ≤ 1
Theorem: IsNoetherianRing.isNilpotent_nilradical
File: Mathlib/RingTheory/Noetherian.lean

tactic: obtain ⟨n, hn⟩ := Ideal.exists_radical_pow_le_of_fg (⊥ : Ideal R) (IsNoetherian.noetherian _)
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsNoetherianRing R
⊢ IsNilpotent (nilradical R)

tactic: exact ⟨n, eq_bot_iff.mpr hn⟩
state_before: case intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsNoetherianRing R
n : ℕ
hn : Ideal.radical ⊥ ^ n ≤ ⊥
⊢ IsNilpotent (nilradical R)
Theorem: finrank_eq_zero_of_basis_imp_not_finite
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: obtain ⟨_, ⟨b⟩⟩ := (Module.free_iff_set K V).mp ‹_›
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : ∀ (s : Set V), Basis (↑s) K V → ¬Set.Finite s
⊢ finrank K V = 0

tactic: exact dif_neg fun rank_lt => h _ b (b.finite_index_of_rank_lt_aleph0 rank_lt)
state_before: case intro.intro
K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : StrongRankCondition K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
h : ∀ (s : Set V), Basis (↑s) K V → ¬Set.Finite s
w✝ : Set V
b : Basis (↑w✝) K V
⊢ finrank K V = 0
Theorem: Finset.Ioc_subset_Ioi_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simpa [← coe_subset] using Set.Ioc_subset_Ioi_self
state_before: ι : Type ?u.47227
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderTop α
⊢ Ioc a b ⊆ Ioi a
Theorem: eventually_countable_ball
File: Mathlib/Order/Filter/CountableInter.lean

tactic: simpa only [Filter.Eventually, setOf_forall] using
  @countable_bInter_mem _ l _ _ _ hS fun i hi => { x | p x i hi }
state_before: ι✝ : Sort ?u.1496
α : Type u_2
β : Type ?u.1502
l : Filter α
inst✝ : CountableInterFilter l
ι : Type u_1
S : Set ι
hS : Set.Countable S
p : α → (i : ι) → i ∈ S → Prop
⊢ (∀ᶠ (x : α) in l, ∀ (i : ι) (hi : i ∈ S), p x i hi) ↔ ∀ (i : ι) (hi : i ∈ S), ∀ᶠ (x : α) in l, p x i hi
Theorem: finprod_mem_inter_mulSupport_eq
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← finprod_mem_inter_mulSupport, h, finprod_mem_inter_mulSupport]
state_before: α : Type u_1
β : Type ?u.207591
ι : Type ?u.207594
G : Type ?u.207597
M : Type u_2
N : Type ?u.207603
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s t : Set α
h : s ∩ mulSupport f = t ∩ mulSupport f
⊢ (∏ᶠ (i : α) (_ : i ∈ s), f i) = ∏ᶠ (i : α) (_ : i ∈ t), f i
Theorem: isConj_one_right
File: Mathlib/Algebra/Group/Conj.lean

tactic: rw [h]
state_before: α : Type u
β : Type v
inst✝ : CancelMonoid α
a : α
h : a = 1
⊢ IsConj 1 a
Theorem: CategoryTheory.Limits.colimit_obj_ext
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

tactic: apply (cancel_epi (colimitObjIsoColimitCompEvaluation H k).inv).1
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
H : J ⥤ K ⥤ C
inst✝ : HasColimitsOfShape J C
k : K
W : C
f g : (colimit H).obj k ⟶ W
w : ∀ (j : J), (colimit.ι H j).app k ≫ f = (colimit.ι H j).app k ≫ g
⊢ f = g

tactic: ext j
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
H : J ⥤ K ⥤ C
inst✝ : HasColimitsOfShape J C
k : K
W : C
f g : (colimit H).obj k ⟶ W
w : ∀ (j : J), (colimit.ι H j).app k ≫ f = (colimit.ι H j).app k ≫ g
⊢ (colimitObjIsoColimitCompEvaluation H k).inv ≫ f = (colimitObjIsoColimitCompEvaluation H k).inv ≫ g

tactic: simpa using w j
state_before: case w
C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
H : J ⥤ K ⥤ C
inst✝ : HasColimitsOfShape J C
k : K
W : C
f g : (colimit H).obj k ⟶ W
w : ∀ (j : J), (colimit.ι H j).app k ≫ f = (colimit.ι H j).app k ≫ g
j : J
⊢ colimit.ι (H ⋙ (evaluation K C).obj k) j ≫ (colimitObjIsoColimitCompEvaluation H k).inv ≫ f =
    colimit.ι (H ⋙ (evaluation K C).obj k) j ≫ (colimitObjIsoColimitCompEvaluation H k).inv ≫ g
Theorem: wbtw_comm
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [Wbtw, Wbtw, affineSegment_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.145040
P : Type u_3
P' : Type ?u.145046
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
⊢ Wbtw R x y z ↔ Wbtw R z y x
Theorem: Sym.cons_of_coe_eq
File: Mathlib/Data/Sym/Basic.lean

tactic: cases v
state_before: α : Type u_1
β : Type ?u.15536
n n' m : ℕ
s : Sym α n
a✝ b a : α
v : Vector α n
⊢ ↑(a ::ₛ ofVector v) = ↑(ofVector (a ::ᵥ v))

tactic: rfl
state_before: case mk
α : Type u_1
β : Type ?u.15536
n n' m : ℕ
s : Sym α n
a✝ b a : α
val✝ : List α
property✝ : List.length val✝ = n
⊢ ↑(a ::ₛ ofVector { val := val✝, property := property✝ }) = ↑(ofVector (a ::ᵥ { val := val✝, property := property✝ }))
Theorem: lowerSemicontinuousWithinAt_sum
File: Mathlib/Topology/Semicontinuous.lean

tactic: induction' a using Finset.induction_on with i a ia IH
state_before: α : Type u_2
inst✝⁵ : TopologicalSpace α
β : Type ?u.104654
inst✝⁴ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_1
γ : Type u_3
inst✝³ : LinearOrderedAddCommMonoid γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTopology γ
inst✝ : ContinuousAdd γ
f : ι → α → γ
a : Finset ι
ha : ∀ (i : ι), i ∈ a → LowerSemicontinuousWithinAt (f i) s x
⊢ LowerSemicontinuousWithinAt (fun z => ∑ i in a, f i z) s x

tactic: exact lowerSemicontinuousWithinAt_const
state_before: case empty
α : Type u_2
inst✝⁵ : TopologicalSpace α
β : Type ?u.104654
inst✝⁴ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_1
γ : Type u_3
inst✝³ : LinearOrderedAddCommMonoid γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTopology γ
inst✝ : ContinuousAdd γ
f : ι → α → γ
a : Finset ι
ha✝ : ∀ (i : ι), i ∈ a → LowerSemicontinuousWithinAt (f i) s x
ha : ∀ (i : ι), i ∈ ∅ → LowerSemicontinuousWithinAt (f i) s x
⊢ LowerSemicontinuousWithinAt (fun z => ∑ i in ∅, f i z) s x

tactic: simp only [ia, Finset.sum_insert, not_false_iff]
state_before: case insert
α : Type u_2
inst✝⁵ : TopologicalSpace α
β : Type ?u.104654
inst✝⁴ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_1
γ : Type u_3
inst✝³ : LinearOrderedAddCommMonoid γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTopology γ
inst✝ : ContinuousAdd γ
f : ι → α → γ
a✝ : Finset ι
ha✝ : ∀ (i : ι), i ∈ a✝ → LowerSemicontinuousWithinAt (f i) s x
i : ι
a : Finset ι
ia : ¬i ∈ a
IH :
  (∀ (i : ι), i ∈ a → LowerSemicontinuousWithinAt (f i) s x) →
    LowerSemicontinuousWithinAt (fun z => ∑ i in a, f i z) s x
ha : ∀ (i_1 : ι), i_1 ∈ insert i a → LowerSemicontinuousWithinAt (f i_1) s x
⊢ LowerSemicontinuousWithinAt (fun z => ∑ i in insert i a, f i z) s x

tactic: exact
  LowerSemicontinuousWithinAt.add (ha _ (Finset.mem_insert_self i a))
    (IH fun j ja => ha j (Finset.mem_insert_of_mem ja))
state_before: case insert
α : Type u_2
inst✝⁵ : TopologicalSpace α
β : Type ?u.104654
inst✝⁴ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Type u_1
γ : Type u_3
inst✝³ : LinearOrderedAddCommMonoid γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTopology γ
inst✝ : ContinuousAdd γ
f : ι → α → γ
a✝ : Finset ι
ha✝ : ∀ (i : ι), i ∈ a✝ → LowerSemicontinuousWithinAt (f i) s x
i : ι
a : Finset ι
ia : ¬i ∈ a
IH :
  (∀ (i : ι), i ∈ a → LowerSemicontinuousWithinAt (f i) s x) →
    LowerSemicontinuousWithinAt (fun z => ∑ i in a, f i z) s x
ha : ∀ (i_1 : ι), i_1 ∈ insert i a → LowerSemicontinuousWithinAt (f i_1) s x
⊢ LowerSemicontinuousWithinAt (fun z => f i z + ∑ i in a, f i z) s x
Theorem: sdiff_idem
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sdiff_sdiff_left, sup_idem]
state_before: ι : Type ?u.135732
α : Type u_1
β : Type ?u.135738
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ (a \ b) \ b = a \ b
Theorem: Stream'.WSeq.destruct_dropn
File: Mathlib/Data/Seq/WSeq.lean

tactic: rw [← dropn_tail, destruct_dropn _ n, destruct_tail, LawfulMonad.bind_assoc]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ destruct (drop s (n + 1)) = destruct s >>= drop.aux (n + 1)

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ (destruct s >>= fun x => tail.aux x >>= drop.aux n) = destruct s >>= drop.aux (n + 1)
Theorem: Hyperreal.st_inv
File: Mathlib/Data/Real/Hyperreal.lean

tactic: by_cases h0 : x = 0
state_before: x : ℝ*
⊢ st x⁻¹ = (st x)⁻¹

tactic: rw [h0, inv_zero, ← coe_zero, st_id_real, inv_zero]
state_before: case pos
x : ℝ*
h0 : x = 0
⊢ st x⁻¹ = (st x)⁻¹

case neg
x : ℝ*
h0 : ¬x = 0
⊢ st x⁻¹ = (st x)⁻¹

tactic: by_cases h1 : Infinitesimal x
state_before: case neg
x : ℝ*
h0 : ¬x = 0
⊢ st x⁻¹ = (st x)⁻¹

tactic: rw [((infinitesimal_iff_infinite_inv h0).mp h1).st_eq, h1.st_eq, inv_zero]
state_before: case pos
x : ℝ*
h0 : ¬x = 0
h1 : Infinitesimal x
⊢ st x⁻¹ = (st x)⁻¹

case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬Infinitesimal x
⊢ st x⁻¹ = (st x)⁻¹

tactic: by_cases h2 : Infinite x
state_before: case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬Infinitesimal x
⊢ st x⁻¹ = (st x)⁻¹

tactic: rw [(infinitesimal_inv_of_infinite h2).st_eq, h2.st_eq, inv_zero]
state_before: case pos
x : ℝ*
h0 : ¬x = 0
h1 : ¬Infinitesimal x
h2 : Infinite x
⊢ st x⁻¹ = (st x)⁻¹

case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬Infinitesimal x
h2 : ¬Infinite x
⊢ st x⁻¹ = (st x)⁻¹

tactic: exact ((isSt_st' h2).inv h1).st_eq
state_before: case neg
x : ℝ*
h0 : ¬x = 0
h1 : ¬Infinitesimal x
h2 : ¬Infinite x
⊢ st x⁻¹ = (st x)⁻¹
Theorem: SimpleGraph.edgeSet_subgraphOfAdj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext e
state_before: ι : Sort ?u.217461
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
v w : V
hvw : Adj G v w
⊢ Subgraph.edgeSet (subgraphOfAdj G hvw) = {Quotient.mk (Sym2.Rel.setoid V) (v, w)}

tactic: refine' e.ind _
state_before: case h
ι : Sort ?u.217461
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
v w : V
hvw : Adj G v w
e : Sym2 V
⊢ e ∈ Subgraph.edgeSet (subgraphOfAdj G hvw) ↔ e ∈ {Quotient.mk (Sym2.Rel.setoid V) (v, w)}

tactic: simp only [eq_comm, Set.mem_singleton_iff, Subgraph.mem_edgeSet, subgraphOfAdj_Adj, iff_self_iff,
  forall₂_true_iff]
state_before: case h
ι : Sort ?u.217461
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
v w : V
hvw : Adj G v w
e : Sym2 V
⊢ ∀ (x y : V),
    Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ Subgraph.edgeSet (subgraphOfAdj G hvw) ↔
      Quotient.mk (Sym2.Rel.setoid V) (x, y) ∈ {Quotient.mk (Sym2.Rel.setoid V) (v, w)}
Theorem: Isometry.norm_map_of_map_one
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [← dist_one_right, ← h₁, hi.dist_eq, dist_one_right]
state_before: 𝓕 : Type ?u.51314
𝕜 : Type ?u.51317
α : Type ?u.51320
ι : Type ?u.51323
κ : Type ?u.51326
E : Type u_1
F : Type u_2
G : Type ?u.51335
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
f : E → F
hi : Isometry f
h₁ : f 1 = 1
x : E
⊢ ‖f x‖ = ‖x‖
Theorem: MvFunctor.LiftR_def
File: Mathlib/Control/Functor/Multivariate.lean

tactic: simp only [map_map, comp_assoc, subtypeVal_toSubtype']
state_before: n : ℕ
α β γ : TypeVec n
F : TypeVec n → Type v
inst✝¹ : MvFunctor F
P : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
x y : F α
⊢ ∀ (u : F fun i => { p // (fun i x y => ofRepeat (R i (prod.mk i x y))) i p.fst p.snd }),
    (fun i t => (↑t).fst) <$$> u = x ∧ (fun i t => (↑t).snd) <$$> u = y ↔
      (prod.fst ⊚ subtypeVal R) <$$> toSubtype' R <$$> u = x ∧ (prod.snd ⊚ subtypeVal R) <$$> toSubtype' R <$$> u = y

tactic: simp [comp]
state_before: n : ℕ
α β γ : TypeVec n
F : TypeVec n → Type v
inst✝¹ : MvFunctor F
P : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
x y : F α
⊢ ∀ (u : F fun i => { p // (fun i x y => ofRepeat (R i (prod.mk i x y))) i p.fst p.snd }),
    (fun i t => (↑t).fst) <$$> u = x ∧ (fun i t => (↑t).snd) <$$> u = y ↔
      (prod.fst ⊚ fun i x => prod.mk i (↑x).fst (↑x).snd) <$$> u = x ∧
        (prod.snd ⊚ fun i x => prod.mk i (↑x).fst (↑x).snd) <$$> u = y
Theorem: WithTop.sum_eq_top_iff
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: induction s using Finset.cons_induction <;> simp [*]
state_before: ι : Type u_2
α : Type ?u.187623
β : Type ?u.187626
M : Type u_1
N : Type ?u.187632
G : Type ?u.187635
k : Type ?u.187638
R : Type ?u.187641
inst✝ : AddCommMonoid M
s : Finset ι
f : ι → WithTop M
⊢ ∑ i in s, f i = ⊤ ↔ ∃ i, i ∈ s ∧ f i = ⊤