tasksource/leandojo huggingface dataset:
Theorem: ProbabilityTheory.condCount_self
File: Mathlib/Probability/CondCount.lean

tactic: rw [condCount, cond_apply _ hs.measurableSet, Set.inter_self, ENNReal.inv_mul_cancel]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : Set.Finite s
hs' : Set.Nonempty s
⊢ ↑↑(condCount s) s = 1

tactic: exact fun h => hs'.ne_empty <| Measure.empty_of_count_eq_zero h
state_before: case h0
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : Set.Finite s
hs' : Set.Nonempty s
⊢ ↑↑Measure.count s ≠ 0

tactic: exact (Measure.count_apply_lt_top.2 hs).ne
state_before: case ht
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : Set.Finite s
hs' : Set.Nonempty s
⊢ ↑↑Measure.count s ≠ ⊤
Theorem: Complex.ofReal_sinh_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← sinh_conj, conj_ofReal]
state_before: x✝ y : ℂ
x : ℝ
⊢ ↑(starRingEnd ℂ) (sinh ↑x) = sinh ↑x
Theorem: sign_sum
File: Mathlib/Data/Sign.lean

tactic: cases t
state_before: α : Type u_2
inst✝ : LinearOrderedAddCommGroup α
ι : Type u_1
s : Finset ι
f : ι → α
hs : Finset.Nonempty s
t : SignType
h : ∀ (i : ι), i ∈ s → ↑sign (f i) = t
⊢ ↑sign (∑ i in s, f i) = t

tactic: simp_rw [zero_eq_zero, sign_eq_zero_iff] at h⊢
state_before: case zero
α : Type u_2
inst✝ : LinearOrderedAddCommGroup α
ι : Type u_1
s : Finset ι
f : ι → α
hs : Finset.Nonempty s
h : ∀ (i : ι), i ∈ s → ↑sign (f i) = zero
⊢ ↑sign (∑ i in s, f i) = zero

tactic: exact Finset.sum_eq_zero h
state_before: case zero
α : Type u_2
inst✝ : LinearOrderedAddCommGroup α
ι : Type u_1
s : Finset ι
f : ι → α
hs : Finset.Nonempty s
h : ∀ (i : ι), i ∈ s → f i = 0
⊢ ∑ i in s, f i = 0

tactic: simp_rw [neg_eq_neg_one, sign_eq_neg_one_iff] at h⊢
state_before: case neg
α : Type u_2
inst✝ : LinearOrderedAddCommGroup α
ι : Type u_1
s : Finset ι
f : ι → α
hs : Finset.Nonempty s
h : ∀ (i : ι), i ∈ s → ↑sign (f i) = neg
⊢ ↑sign (∑ i in s, f i) = neg

tactic: exact Finset.sum_neg h hs
state_before: case neg
α : Type u_2
inst✝ : LinearOrderedAddCommGroup α
ι : Type u_1
s : Finset ι
f : ι → α
hs : Finset.Nonempty s
h : ∀ (i : ι), i ∈ s → f i < 0
⊢ ∑ i in s, f i < 0

tactic: simp_rw [pos_eq_one, sign_eq_one_iff] at h⊢
state_before: case pos
α : Type u_2
inst✝ : LinearOrderedAddCommGroup α
ι : Type u_1
s : Finset ι
f : ι → α
hs : Finset.Nonempty s
h : ∀ (i : ι), i ∈ s → ↑sign (f i) = pos
⊢ ↑sign (∑ i in s, f i) = pos

tactic: exact Finset.sum_pos h hs
state_before: case pos
α : Type u_2
inst✝ : LinearOrderedAddCommGroup α
ι : Type u_1
s : Finset ι
f : ι → α
hs : Finset.Nonempty s
h : ∀ (i : ι), i ∈ s → 0 < f i
⊢ 0 < ∑ i in s, f i
Theorem: MonoidAlgebra.lift_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp only [lift_apply', Algebra.smul_def]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.1218573
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type ?u.1218610
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : G →* A
f : MonoidAlgebra k G
⊢ ↑(↑(lift k G A) F) f = sum f fun a b => b • ↑F a
Theorem: MeasureTheory.FiniteMeasure.normalize_eq_inv_mass_smul_of_nonzero
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: nth_rw 3 [μ.self_eq_mass_smul_normalize]
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
nonzero : μ ≠ 0
⊢ ProbabilityMeasure.toFiniteMeasure (normalize μ) = (mass μ)⁻¹ • μ

tactic: rw [← smul_assoc]
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
nonzero : μ ≠ 0
⊢ ProbabilityMeasure.toFiniteMeasure (normalize μ) =
    (mass μ)⁻¹ • mass μ • ProbabilityMeasure.toFiniteMeasure (normalize μ)

tactic: simp only [μ.mass_nonzero_iff.mpr nonzero, Algebra.id.smul_eq_mul, inv_mul_cancel, Ne.def,
  not_false_iff, one_smul]
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
nonzero : μ ≠ 0
⊢ ProbabilityMeasure.toFiniteMeasure (normalize μ) =
    ((mass μ)⁻¹ • mass μ) • ProbabilityMeasure.toFiniteMeasure (normalize μ)
Theorem: Set.inter_singleton_eq_empty
File: Mathlib/Data/Set/Basic.lean

tactic: rw [inter_comm, singleton_inter_eq_empty]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ s ∩ {a} = ∅ ↔ ¬a ∈ s
Theorem: Dfinsupp.support_single_ne_zero
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext j
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
b : β i
hb : b ≠ 0
⊢ support (single i b) = {i}

tactic: by_cases h : i = j
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
b : β i
hb : b ≠ 0
j : ι
⊢ j ∈ support (single i b) ↔ j ∈ {i}

tactic: simp [Ne.symm h, h]
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
b : β i
hb : b ≠ 0
j : ι
h : ¬i = j
⊢ j ∈ support (single i b) ↔ j ∈ {i}

tactic: subst h
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
b : β i
hb : b ≠ 0
j : ι
h : i = j
⊢ j ∈ support (single i b) ↔ j ∈ {i}

tactic: simp [hb]
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
b : β i
hb : b ≠ 0
⊢ i ∈ support (single i b) ↔ i ∈ {i}
Theorem: Function.Injective.wbtw_map_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: refine' ⟨fun h => _, fun h => h.map _⟩
state_before: R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
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
f : P →ᵃ[R] P'
hf : Injective ↑f
⊢ Wbtw R (↑f x) (↑f y) (↑f z) ↔ Wbtw R x y z

tactic: rwa [Wbtw, ← affineSegment_image, hf.mem_set_image] at h
state_before: R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
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
f : P →ᵃ[R] P'
hf : Injective ↑f
h : Wbtw R (↑f x) (↑f y) (↑f z)
⊢ Wbtw R x y z
Theorem: IsPrimitiveRoot.pow_sub_one_eq
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: rw [eq_neg_iff_add_eq_zero, add_comm, ← sum_range_succ, ← Nat.succ_eq_add_one,
  Nat.succ_pred_eq_of_pos (pos_of_gt hk), hζ.geom_sum_eq_zero hk]
state_before: M : Type ?u.2780127
N : Type ?u.2780130
G : Type ?u.2780133
R : Type u_1
S : Type ?u.2780139
F : Type ?u.2780142
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
hζ : IsPrimitiveRoot ζ k
hk : 1 < k
⊢ ζ ^ Nat.pred k = -∑ i in range (Nat.pred k), ζ ^ i
Theorem: DiscreteQuotient.map_comp
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: ext ⟨⟩
state_before: α : Type ?u.31962
X : Type u_3
Y : Type u_1
Z : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
h1 : LEComap g B C
h2 : LEComap f A B
⊢ map (ContinuousMap.comp g f) (_ : LEComap (ContinuousMap.comp g f) A C) = map g h1 ∘ map f h2

tactic: rfl
state_before: case h.mk
α : Type ?u.31962
X : Type u_3
Y : Type u_1
Z : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
f : C(X, Y)
A A' : DiscreteQuotient X
B B' : DiscreteQuotient Y
g : C(Y, Z)
C : DiscreteQuotient Z
h1 : LEComap g B C
h2 : LEComap f A B
x✝ : Quotient A.toSetoid
a✝ : X
⊢ map (ContinuousMap.comp g f) (_ : LEComap (ContinuousMap.comp g f) A C) (Quot.mk Setoid.r a✝) =
    (map g h1 ∘ map f h2) (Quot.mk Setoid.r a✝)
Theorem: List.keys_kreplace
File: Mathlib/Data/List/Sigma.lean

tactic: rintro ⟨a₁, b₂⟩ ⟨a₂, b₂⟩
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
⊢ ∀ (a_1 b_1 : Sigma β), (b_1 ∈ if a = a_1.fst then some { fst := a, snd := b } else none) → a_1.fst = b_1.fst

tactic: dsimp
state_before: case mk.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a₁ : α
b₂✝ : β a₁
a₂ : α
b₂ : β a₂
⊢ ({ fst := a₂, snd := b₂ } ∈ if a = { fst := a₁, snd := b₂✝ }.fst then some { fst := a, snd := b } else none) →
    { fst := a₁, snd := b₂✝ }.fst = { fst := a₂, snd := b₂ }.fst

tactic: split_ifs with h <;> simp (config := { contextual := true }) [h]
state_before: case mk.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a₁ : α
b₂✝ : β a₁
a₂ : α
b₂ : β a₂
⊢ ({ fst := a₂, snd := b₂ } ∈ if a = a₁ then some { fst := a, snd := b } else none) → a₁ = a₂
Theorem: Complex.cos_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← ofReal_cos, Real.cos_pi]
state_before: ⊢ cos ↑π = -1

tactic: simp
state_before: ⊢ ↑(-1) = -1
Theorem: GeneralizedContinuedFraction.denominators_stable_of_terminated
File: Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean

tactic: simp only [denom_eq_conts_b, continuants_stable_of_terminated n_le_m terminated_at_n]
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n m : ℕ
inst✝ : DivisionRing K
n_le_m : n ≤ m
terminated_at_n : TerminatedAt g n
⊢ denominators g m = denominators g n
Theorem: SimpleGraph.Subgraph.neighborSet_sSup
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext
state_before: ι : Sort ?u.90110
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
s : Set (Subgraph G)
v : V
⊢ neighborSet (sSup s) v = ⋃ (G' : Subgraph G) (_ : G' ∈ s), neighborSet G' v

tactic: simp
state_before: case h
ι : Sort ?u.90110
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : Subgraph G
a b : V
s : Set (Subgraph G)
v x✝ : V
⊢ x✝ ∈ neighborSet (sSup s) v ↔ x✝ ∈ ⋃ (G' : Subgraph G) (_ : G' ∈ s), neighborSet G' v
Theorem: List.Subperm.cons_left
File: Mathlib/Data/List/Perm.lean

tactic: rw [subperm_ext_iff] at h⊢
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h : l₁ <+~ l₂
x : α
hx : count x l₁ < count x l₂
⊢ x :: l₁ <+~ l₂

tactic: intro y hy
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h✝ : l₁ <+~ l₂
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
x : α
hx : count x l₁ < count x l₂
⊢ ∀ (x_1 : α), x_1 ∈ x :: l₁ → count x_1 (x :: l₁) ≤ count x_1 l₂

tactic: by_cases hy' : y = x
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h✝ : l₁ <+~ l₂
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
x : α
hx : count x l₁ < count x l₂
y : α
hy : y ∈ x :: l₁
⊢ count y (x :: l₁) ≤ count y l₂

tactic: subst x
state_before: case pos
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h✝ : l₁ <+~ l₂
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
x : α
hx : count x l₁ < count x l₂
y : α
hy : y ∈ x :: l₁
hy' : y = x
⊢ count y (x :: l₁) ≤ count y l₂

tactic: simpa using Nat.succ_le_of_lt hx
state_before: case pos
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h✝ : l₁ <+~ l₂
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
y : α
hx : count y l₁ < count y l₂
hy : y ∈ y :: l₁
⊢ count y (y :: l₁) ≤ count y l₂

tactic: rw [count_cons_of_ne hy']
state_before: case neg
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h✝ : l₁ <+~ l₂
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
x : α
hx : count x l₁ < count x l₂
y : α
hy : y ∈ x :: l₁
hy' : ¬y = x
⊢ count y (x :: l₁) ≤ count y l₂

tactic: refine' h y _
state_before: case neg
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h✝ : l₁ <+~ l₂
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
x : α
hx : count x l₁ < count x l₂
y : α
hy : y ∈ x :: l₁
hy' : ¬y = x
⊢ count y l₁ ≤ count y l₂

tactic: simpa [hy'] using hy
state_before: case neg
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ : List α
h✝ : l₁ <+~ l₂
h : ∀ (x : α), x ∈ l₁ → count x l₁ ≤ count x l₂
x : α
hx : count x l₁ < count x l₂
y : α
hy : y ∈ x :: l₁
hy' : ¬y = x
⊢ y ∈ l₁
Theorem: Multiset.Ico_sub_Ico_left
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [Ico, Ico, Ico, ← Finset.sdiff_val, Finset.Ico_diff_Ico_left]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c✝ d a b c : α
⊢ Ico a b - Ico a c = Ico (max a c) b
Theorem: Seminorm.closedBall_finset_sup
File: Mathlib/Analysis/Seminorm.lean

tactic: rw [Finset.inf_eq_iInf]
state_before: R : Type ?u.1100644
R' : Type ?u.1100647
𝕜 : Type u_1
𝕜₂ : Type ?u.1100653
𝕜₃ : Type ?u.1100656
𝕝 : Type ?u.1100659
E : Type u_2
E₂ : Type ?u.1100665
E₃ : Type ?u.1100668
F : Type ?u.1100671
G : Type ?u.1100674
ι : Type u_3
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p✝ : Seminorm 𝕜 E
p : ι → Seminorm 𝕜 E
s : Finset ι
x : E
r : ℝ
hr : 0 ≤ r
⊢ closedBall (Finset.sup s p) x r = Finset.inf s fun i => closedBall (p i) x r

tactic: exact closedBall_finset_sup_eq_iInter _ _ _ hr
state_before: R : Type ?u.1100644
R' : Type ?u.1100647
𝕜 : Type u_1
𝕜₂ : Type ?u.1100653
𝕜₃ : Type ?u.1100656
𝕝 : Type ?u.1100659
E : Type u_2
E₂ : Type ?u.1100665
E₃ : Type ?u.1100668
F : Type ?u.1100671
G : Type ?u.1100674
ι : Type u_3
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p✝ : Seminorm 𝕜 E
p : ι → Seminorm 𝕜 E
s : Finset ι
x : E
r : ℝ
hr : 0 ≤ r
⊢ closedBall (Finset.sup s p) x r = ⨅ (a : ι) (_ : a ∈ s), closedBall (p a) x r
Theorem: ZFSet.mem_powerset
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp [mem_powerset, subset_iff]
state_before: x y : ZFSet
x✝¹ x✝ : PSet
α : Type u
A : α → PSet
β : Type u
B : β → PSet
⊢ PSet.mk β B ∈ PSet.powerset (PSet.mk α A) ↔ Quotient.mk setoid (PSet.mk β B) ⊆ Quotient.mk setoid (PSet.mk α A)
Theorem: Vector.mOfFn_pure
File: Mathlib/Data/Vector/Basic.lean

tactic: rw [mOfFn, @mOfFn_pure m _ _ _ n _, ofFn]
state_before: n✝ : ℕ
α✝ : Type ?u.39247
m : Type u_1 → Type u_2
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α : Type u_1
n : ℕ
f : Fin (n + 1) → α
⊢ (mOfFn fun i => pure (f i)) = pure (ofFn f)

tactic: simp
state_before: n✝ : ℕ
α✝ : Type ?u.39247
m : Type u_1 → Type u_2
inst✝¹ : Monad m
inst✝ : LawfulMonad m
α : Type u_1
n : ℕ
f : Fin (n + 1) → α
⊢ (do
      let a ← pure (f 0)
      let v ← pure (ofFn fun i => f (Fin.succ i))
      pure (a ::ᵥ v)) =
    pure (f 0 ::ᵥ ofFn fun i => f (Fin.succ i))
Theorem: Finset.sum_smul_sum_eq_sum_perm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp_rw [sum_smul_sum, product_self_eq_disjUnion_perm hσ, sum_disjiUnion, sum_map]
state_before: ι : Type u_1
α : Type u_3
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : Semiring α
inst✝¹ : AddCommMonoid β
inst✝ : Module α β
s : Finset ι
σ : Perm ι
hσ : IsCycleOn σ ↑s
f : ι → α
g : ι → β
⊢ (∑ i in s, f i) • ∑ i in s, g i = ∑ k in range (card s), ∑ i in s, f i • g (↑(σ ^ k) i)

tactic: rfl
state_before: ι : Type u_1
α : Type u_3
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : Semiring α
inst✝¹ : AddCommMonoid β
inst✝ : Module α β
s : Finset ι
σ : Perm ι
hσ : IsCycleOn σ ↑s
f : ι → α
g : ι → β
⊢ ∑ x in range (card s),
      ∑ x_1 in s,
        f
            (↑{ toFun := fun i => (i, ↑(σ ^ x) i),
                    inj' :=
                      (_ :
                        ∀ (i j : ι),
                          (fun i => (i, ↑(σ ^ x) i)) i = (fun i => (i, ↑(σ ^ x) i)) j →
                            ((fun i => (i, ↑(σ ^ x) i)) i).fst = ((fun i => (i, ↑(σ ^ x) i)) j).fst) }
                x_1).fst •
          g
            (↑{ toFun := fun i => (i, ↑(σ ^ x) i),
                    inj' :=
                      (_ :
                        ∀ (i j : ι),
                          (fun i => (i, ↑(σ ^ x) i)) i = (fun i => (i, ↑(σ ^ x) i)) j →
                            ((fun i => (i, ↑(σ ^ x) i)) i).fst = ((fun i => (i, ↑(σ ^ x) i)) j).fst) }
                x_1).snd =
    ∑ x in range (card s), ∑ x_1 in s, f x_1 • g (↑(σ ^ x) x_1)
Theorem: Equiv.Perm.fixed_point_card_lt_of_ne_one
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [lt_tsub_iff_left, ← lt_tsub_iff_right, ← Finset.card_compl, Finset.compl_filter]
state_before: ι : Type ?u.3061128
α : Type u_1
β : Type ?u.3061134
inst✝² : DecidableEq α
inst✝¹ : Fintype α
σ✝ τ : Perm α
inst✝ : Fintype α
σ : Perm α
h : σ ≠ 1
⊢ card (filter (fun x => ↑σ x = x) univ) < Fintype.card α - 1

tactic: exact one_lt_card_support_of_ne_one h
state_before: ι : Type ?u.3061128
α : Type u_1
β : Type ?u.3061134
inst✝² : DecidableEq α
inst✝¹ : Fintype α
σ✝ τ : Perm α
inst✝ : Fintype α
σ : Perm α
h : σ ≠ 1
⊢ 1 < card (filter (fun x => ¬↑σ x = x) univ)
Theorem: FiniteDimensional.finset_card_le_finrank_of_linearIndependent
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← Fintype.card_coe]
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
b : Finset V
h : LinearIndependent K fun x => ↑x
⊢ Finset.card b ≤ finrank K V

tactic: exact fintype_card_le_finrank_of_linearIndependent h
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
b : Finset V
h : LinearIndependent K fun x => ↑x
⊢ Fintype.card { x // x ∈ b } ≤ finrank K V
Theorem: Std.PairingHeapImp.Heap.WF.deleteMin
File: Std/Data/PairingHeap.lean

tactic: cases h with cases eq | node h => exact Heap.WF.combine h
state_before: α : Type u_1
le : α → α → Bool
a : α
s' s : Heap α
h : WF le s
eq : Heap.deleteMin le s = some (a, s')
⊢ WF le s'

tactic: exact Heap.WF.combine h
state_before: case node.refl
α : Type u_1
le : α → α → Bool
a : α
c✝ : Heap α
h : NodeWF le a c✝
⊢ WF le (Heap.combine le c✝)
Theorem: CategoryTheory.IsFiltered.of_right_adjoint
File: Mathlib/CategoryTheory/Filtered.lean

tactic: rw [← h.homEquiv_naturality_left, ← h.homEquiv_naturality_left, coeq_condition]
state_before: C : Type u
inst✝⁴ : Category C
inst✝³ : IsFiltered C
O : Finset C
H : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y))
J : Type v
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
D : Type u₁
inst✝ : Category D
L : D ⥤ C
R : C ⥤ D
h : L ⊣ R
X Y : D
f g : X ⟶ Y
⊢ f ≫
      ↑(Adjunction.homEquiv h Y (coeq (?m.33962 h X Y f g) (?m.33963 h X Y f g)))
        (coeqHom (?m.33962 h X Y f g) (?m.33963 h X Y f g)) =
    g ≫
      ↑(Adjunction.homEquiv h Y (coeq (?m.33962 h X Y f g) (?m.33963 h X Y f g)))
        (coeqHom (?m.33962 h X Y f g) (?m.33963 h X Y f g))
Theorem: Real.tanh_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [tanh]
state_before: x y : ℝ
⊢ tanh 0 = 0
Theorem: Submodule.mem_span_mul_finite_of_mem_mul
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rwa [← Submodule.span_eq P, ← Submodule.span_eq Q, Submodule.span_mul_span] at hx
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P✝ Q✝ : Submodule R A
m n : A
P Q : Submodule R A
x : A
hx : x ∈ P * Q
⊢ x ∈ span R (↑P * ↑Q)
Theorem: Real.sinh_sub
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sub_eq_add_neg, sinh_add, sinh_neg, cosh_neg]
state_before: x y : ℝ
⊢ sinh (x - y) = sinh x * cosh y - cosh x * sinh y
Theorem: Encodable.decode_prod_val
File: Mathlib/Logic/Encodable/Basic.lean

tactic: simp only [decode_ofEquiv, Equiv.symm_symm, decode_sigma_val]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Encodable β
i : Encodable α
n : ℕ
⊢ decode n = Option.bind (decode (unpair n).fst) fun a => Option.map (Prod.mk a) (decode (unpair n).snd)

tactic: cases (decode n.unpair.1 : Option α) <;> cases (decode n.unpair.2 : Option β)
<;> rfl
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Encodable β
i : Encodable α
n : ℕ
⊢ Option.map (↑(Equiv.sigmaEquivProd α β))
      (Option.bind (decode (unpair n).fst) fun a => Option.map (Sigma.mk a) (decode (unpair n).snd)) =
    Option.bind (decode (unpair n).fst) fun a => Option.map (Prod.mk a) (decode (unpair n).snd)
Theorem: Subgroup.le_normalizer_of_normal
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simpa [mem_subgroupOf, mul_assoc] using
  hK.conj_mem ⟨x * y * x⁻¹, HK yH⟩ yH ⟨x⁻¹, K.inv_mem hx⟩
state_before: G : Type u_1
G' : Type ?u.385870
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.385879
inst✝ : AddGroup A
H K : Subgroup G
hK : Normal (subgroupOf H K)
HK : H ≤ K
x : G
hx : x ∈ K
y : G
yH : x * y * x⁻¹ ∈ H
⊢ y ∈ H
Theorem: MeasureTheory.AEEqFun.comp_eq_mk
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [← comp_mk g hg f f.aestronglyMeasurable, mk_coeFn]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.349637
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
hg : Continuous g
f : α →ₘ[μ] β
⊢ comp g hg f = mk (g ∘ ↑f) (_ : AEStronglyMeasurable (fun x => g (↑f x)) μ)
Theorem: Padic.AddValuation.map_one
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [addValuationDef, if_neg one_ne_zero, valuation_one, WithTop.coe_zero]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ addValuationDef 1 = 0
Theorem: AddCommGroup.ModEq.of_nsmul
File: Mathlib/Algebra/ModEq.lean

tactic: rwa [mul_smul, coe_nat_zsmul]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
x✝ : a ≡ b [PMOD n • p]
m : ℤ
hm : b - a = m • n • p
⊢ b - a = (m * ↑n) • p
Theorem: DistribMulActionHom.toLinearMap_injective
File: Mathlib/Algebra/Module/LinearMap.lean

tactic: ext m
state_before: R : Type u_1
R₁ : Type ?u.321615
R₂ : Type ?u.321618
R₃ : Type ?u.321621
k : Type ?u.321624
S : Type ?u.321627
S₃ : Type ?u.321630
T : Type ?u.321633
M : Type u_2
M₁ : Type ?u.321639
M₂ : Type u_3
M₃ : Type ?u.321645
N₁ : Type ?u.321648
N₂ : Type ?u.321651
N₃ : Type ?u.321654
ι : Type ?u.321657
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
f g : M →+[R] M₂
h : ↑f = ↑g
⊢ f = g

tactic: exact LinearMap.congr_fun h m
state_before: case a
R : Type u_1
R₁ : Type ?u.321615
R₂ : Type ?u.321618
R₃ : Type ?u.321621
k : Type ?u.321624
S : Type ?u.321627
S₃ : Type ?u.321630
T : Type ?u.321633
M : Type u_2
M₁ : Type ?u.321639
M₂ : Type u_3
M₃ : Type ?u.321645
N₁ : Type ?u.321648
N₂ : Type ?u.321651
N₃ : Type ?u.321654
ι : Type ?u.321657
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
f g : M →+[R] M₂
h : ↑f = ↑g
m : M
⊢ ↑f m = ↑g m
Theorem: OreLocalization.one_mul
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: induction' x using OreLocalization.ind with r s
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
x : OreLocalization R S
⊢ 1 * x = x

tactic: simp [OreLocalization.one_def, oreDiv_mul_char (1 : R) r (1 : S) s r 1 (by simp)]
state_before: case c
R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r : R
s : { x // x ∈ S }
⊢ 1 * (r /ₒ s) = r /ₒ s

tactic: simp
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
r : R
s : { x // x ∈ S }
⊢ r * ↑1 = ↑1 * r