1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ArithmeticFunction.not_LSeriesSummable_moebius_at_one
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

tactic: intro h
state_before: ⊢ ¬LSeriesSummable (fun n => ↑(μ n)) 1
state_after: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ False

tactic: refine not_summable_one_div_on_primes <| summable_ofReal.mp <| Summable.of_neg ?_
state_before: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ False
state_after: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ Summable fun b => -↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) b)

tactic: simp only [← Pi.neg_def, Set.indicator_comp_of_zero ofReal_zero, ofReal_inv, ofReal_natCast]
state_before: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ Summable fun b => -↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) b)
state_after: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ Summable (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i))

tactic: refine (h.indicator {n | n.Prime}).congr (fun n ↦ ?_)
state_before: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ Summable (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i))
state_after: h : LSeriesSummable (fun n => ↑(μ n)) 1
n : ℕ
⊢ {n | Nat.Prime n}.indicator (term (fun n => ↑(μ n)) 1) n =
    (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i)) n

tactic: by_cases hn : n ∈ {p | p.Prime}
state_before: h : LSeriesSummable (fun n => ↑(μ n)) 1
n : ℕ
⊢ {n | Nat.Prime n}.indicator (term (fun n => ↑(μ n)) 1) n =
    (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i)) n
state_after: case pos
h : LSeriesSummable (fun n => ↑(μ n)) 1
n : ℕ
hn : n ∈ {p | Nat.Prime p}
⊢ {n | Nat.Prime n}.indicator (term (fun n => ↑(μ n)) 1) n =
    (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i)) n

case neg
h : LSeriesSummable (fun n => ↑(μ n)) 1
n : ℕ
hn : n ∉ {p | Nat.Prime p}
⊢ {n | Nat.Prime n}.indicator (term (fun n => ↑(μ n)) 1) n =
    (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i)) n

tactic: simp only [Pi.neg_apply, Set.indicator_of_mem hn, term_of_ne_zero hn.ne_zero,
  moebius_apply_prime hn, cpow_one, push_cast, neg_div]
state_before: case pos
h : LSeriesSummable (fun n => ↑(μ n)) 1
n : ℕ
hn : n ∈ {p | Nat.Prime p}
⊢ {n | Nat.Prime n}.indicator (term (fun n => ↑(μ n)) 1) n =
    (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i)) n
state_after: no goals

tactic: simp only [one_div, Pi.neg_apply, Set.indicator_of_not_mem hn, ofReal_zero, neg_zero]
state_before: case neg
h : LSeriesSummable (fun n => ↑(μ n)) 1
n : ℕ
hn : n ∉ {p | Nat.Prime p}
⊢ {n | Nat.Prime n}.indicator (term (fun n => ↑(μ n)) 1) n =
    (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i)) n
state_after: no goals
Theorem: Matrix.lie_transpose
File: Mathlib/Algebra/Lie/SkewAdjoint.lean

tactic: simp
state_before: R : Type u
n : Type w
inst✝² : CommRing R
inst✝¹ : DecidableEq n
inst✝ : Fintype n
J A B : Matrix n n R
⊢ (A * B - B * A)ᵀ = Bᵀ * Aᵀ - Aᵀ * Bᵀ
state_after: no goals
Theorem: Real.rpow_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp [rpow_def]
state_before: x✝ y z x : ℝ
⊢ x ^ 1 = x
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.biInf_apply'
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

tactic: simp only [← iInf_subtype'', iInf_apply' _ hs]
state_before: α : Type u_1
ι : Type u_2
I : Set ι
m : ι → OuterMeasure α
s : Set α
hs : s.Nonempty
⊢ (⨅ i ∈ I, m i) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ i ∈ I, (m i) (t n)
state_after: no goals
Theorem: nonempty_frontier_iff
File: Mathlib/Topology/Connected/Basic.lean

tactic: simp only [nonempty_iff_ne_empty, Ne, frontier_eq_empty_iff, not_or]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : Set α
⊢ (frontier s).Nonempty ↔ s.Nonempty ∧ s ≠ univ
state_after: no goals
Theorem: Multiset.map_add_right_Ioc
File: Mathlib/Algebra/Order/Interval/Multiset.lean

tactic: simp_rw [add_comm _ c]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => x + c) (Ioc a b) = Ioc (a + c) (b + c)
state_after: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Ioc a b) = Ioc (c + a) (c + b)

tactic: exact map_add_left_Ioc _ _ _
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Ioc a b) = Ioc (c + a) (c + b)
state_after: no goals
Theorem: ENNReal.top_div
File: Mathlib/Data/ENNReal/Inv.lean

tactic: simp [div_eq_mul_inv, top_mul']
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ⊤ / a = if a = ⊤ then 0 else ⊤
state_after: no goals
Theorem: HurwitzZeta.isBigO_atTop_oddKernel
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

tactic: induction' a using QuotientAddGroup.induction_on with b
state_before: a : UnitAddCircle
⊢ ∃ p, 0 < p ∧ oddKernel a =O[atTop] fun x => rexp (-p * x)
state_after: case H
b : ℝ
⊢ ∃ p, 0 < p ∧ oddKernel ↑b =O[atTop] fun x => rexp (-p * x)

tactic: obtain ⟨p, hp, hp'⟩ := HurwitzKernelBounds.isBigO_atTop_F_int_one b
state_before: case H
b : ℝ
⊢ ∃ p, 0 < p ∧ oddKernel ↑b =O[atTop] fun x => rexp (-p * x)
state_after: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
⊢ ∃ p, 0 < p ∧ oddKernel ↑b =O[atTop] fun x => rexp (-p * x)

tactic: refine ⟨p, hp, (Eventually.isBigO ?_).trans hp'⟩
state_before: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
⊢ ∃ p, 0 < p ∧ oddKernel ↑b =O[atTop] fun x => rexp (-p * x)
state_after: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
⊢ ∀ᶠ (x : ℝ) in atTop, ‖oddKernel (↑b) x‖ ≤ HurwitzKernelBounds.F_int 1 (↑b) x

tactic: filter_upwards [eventually_gt_atTop 0] with t ht
state_before: case H.intro.intro
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
⊢ ∀ᶠ (x : ℝ) in atTop, ‖oddKernel (↑b) x‖ ≤ HurwitzKernelBounds.F_int 1 (↑b) x
state_after: case h
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ ‖oddKernel (↑b) t‖ ≤ HurwitzKernelBounds.F_int 1 (↑b) t

tactic: simpa only [← (hasSum_int_oddKernel b ht).tsum_eq, Real.norm_eq_abs, HurwitzKernelBounds.F_int,
  HurwitzKernelBounds.f_int, pow_one, norm_mul, abs_of_nonneg (exp_pos _).le] using
  norm_tsum_le_tsum_norm (hasSum_int_oddKernel b ht).summable.norm
state_before: case h
b p : ℝ
hp : 0 < p
hp' : HurwitzKernelBounds.F_int 1 ↑b =O[atTop] fun t => rexp (-p * t)
t : ℝ
ht : 0 < t
⊢ ‖oddKernel (↑b) t‖ ≤ HurwitzKernelBounds.F_int 1 (↑b) t
state_after: no goals
Theorem: Subgroup.index_ne_zero_of_finite
File: Mathlib/GroupTheory/Index.lean

tactic: cases nonempty_fintype (G ⧸ H)
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
hH : Finite (G ⧸ H)
⊢ H.index ≠ 0
state_after: case intro
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
hH : Finite (G ⧸ H)
val✝ : Fintype (G ⧸ H)
⊢ H.index ≠ 0

tactic: rw [index_eq_card]
state_before: case intro
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
hH : Finite (G ⧸ H)
val✝ : Fintype (G ⧸ H)
⊢ H.index ≠ 0
state_after: case intro
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
hH : Finite (G ⧸ H)
val✝ : Fintype (G ⧸ H)
⊢ Fintype.card (G ⧸ H) ≠ 0

tactic: exact Fintype.card_ne_zero
state_before: case intro
G : Type u_1
inst✝ : Group G
H K L : Subgroup G
hH : Finite (G ⧸ H)
val✝ : Fintype (G ⧸ H)
⊢ Fintype.card (G ⧸ H) ≠ 0
state_after: no goals
Theorem: strictAntiOn_of_hasDerivWithinAt_neg
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: rw [deriv_eqOn isOpen_interior hf' hx]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f f' : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, HasDerivWithinAt f (f' x) (interior D) x
hf'₀ : ∀ x ∈ interior D, f' x < 0
x : ℝ
hx : x ∈ interior D
⊢ deriv f x < 0
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f f' : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, HasDerivWithinAt f (f' x) (interior D) x
hf'₀ : ∀ x ∈ interior D, f' x < 0
x : ℝ
hx : x ∈ interior D
⊢ f' x < 0

tactic: exact hf'₀ _ hx
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f f' : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, HasDerivWithinAt f (f' x) (interior D) x
hf'₀ : ∀ x ∈ interior D, f' x < 0
x : ℝ
hx : x ∈ interior D
⊢ f' x < 0
state_after: no goals
Theorem: Matroid.Indep.exists_bijOn_of_map
File: Mathlib/Data/Matroid/Map.lean

tactic: obtain ⟨I₀, hI₀, rfl⟩ := hI
state_before: α : Type u_1
β : Type u_2
f : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
I : Set β
hf : InjOn f M.E
hI : (M.map f hf).Indep I
⊢ ∃ I₀, M.Indep I₀ ∧ BijOn f I₀ I
state_after: case intro.intro
α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
I₀ : Set α
hI₀ : M.Indep I₀
⊢ ∃ I₀_1, M.Indep I₀_1 ∧ BijOn f I₀_1 (f '' I₀)

tactic: exact ⟨I₀, hI₀, (hf.mono hI₀.subset_ground).bijOn_image⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
I₀ : Set α
hI₀ : M.Indep I₀
⊢ ∃ I₀_1, M.Indep I₀_1 ∧ BijOn f I₀_1 (f '' I₀)
state_after: no goals
Theorem: List.lookmap_cons_some
File: Mathlib/Data/List/Basic.lean

tactic: simp only [lookmap, lookmap.go, Array.toListAppend_eq, Array.data_toArray, nil_append]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
a b : α
l : List α
h : f a = some b
⊢ lookmap f (a :: l) = b :: l
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
a b : α
l : List α
h : f a = some b
⊢ (match f a with
    | some b => b :: l
    | none => lookmap.go f l (#[].push a)) =
    b :: l

tactic: rw [h]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → Option α
a b : α
l : List α
h : f a = some b
⊢ (match f a with
    | some b => b :: l
    | none => lookmap.go f l (#[].push a)) =
    b :: l
state_after: no goals
Theorem: Rel.core_univ
File: Mathlib/Data/Rel.lean

tactic: simp [mem_core]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : Rel α β
⊢ ∀ (x : α), x ∈ r.core Set.univ ↔ x ∈ Set.univ
state_after: no goals
Theorem: InnerProductGeometry.inner_eq_neg_mul_norm_iff_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: refine ⟨fun h => ?_, inner_eq_neg_mul_norm_of_angle_eq_pi⟩
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
⊢ ⟪x, y⟫_ℝ = -(‖x‖ * ‖y‖) ↔ angle x y = π
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ⟪x, y⟫_ℝ = -(‖x‖ * ‖y‖)
⊢ angle x y = π

tactic: have h₁ : ‖x‖ * ‖y‖ ≠ 0 := (mul_pos (norm_pos_iff.mpr hx) (norm_pos_iff.mpr hy)).ne'
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ⟪x, y⟫_ℝ = -(‖x‖ * ‖y‖)
⊢ angle x y = π
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ⟪x, y⟫_ℝ = -(‖x‖ * ‖y‖)
h₁ : ‖x‖ * ‖y‖ ≠ 0
⊢ angle x y = π

tactic: rw [angle, h, neg_div, div_self h₁, Real.arccos_neg_one]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ⟪x, y⟫_ℝ = -(‖x‖ * ‖y‖)
h₁ : ‖x‖ * ‖y‖ ≠ 0
⊢ angle x y = π
state_after: no goals
Theorem: Finset.sup_id_eq_sSup
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp [sSup_eq_iSup, sup_eq_iSup]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : CompleteLattice α
s : Finset α
⊢ s.sup id = sSup ↑s
state_after: no goals
Theorem: PartialHomeomorph.restr_source_inter
File: Mathlib/Topology/PartialHomeomorph.lean

tactic: refine PartialHomeomorph.ext _ _ (fun x => rfl) (fun x => rfl) ?_
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
s : Set X
⊢ e.restr (e.source ∩ s) = e.restr s
state_after: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
s : Set X
⊢ (e.restr (e.source ∩ s)).source = (e.restr s).source

tactic: simp [e.open_source.interior_eq, ← inter_assoc]
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
s : Set X
⊢ (e.restr (e.source ∩ s)).source = (e.restr s).source
state_after: no goals
Theorem: Equiv.removeNone_aux_none
File: Mathlib/Logic/Equiv/Option.lean

tactic: simp [removeNone_aux, Option.not_isSome_iff_eq_none.mpr h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
h : e (some x) = none
⊢ some (e.removeNone_aux x) = e none
state_after: no goals
Theorem: CategoryTheory.tensorLeftHomEquiv_symm_naturality
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: simp [tensorLeftHomEquiv]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : X ⟶ X'
g : X' ⟶ Y ⊗ Z
⊢ (tensorLeftHomEquiv X Y Y' Z).symm (f ≫ g) = Y' ◁ f ≫ (tensorLeftHomEquiv X' Y Y' Z).symm g
state_after: no goals
Theorem: IsometryEquiv.dimH_univ
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

tactic: rw [← e.dimH_preimage univ, preimage_univ]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s t : Set X
e : X ≃ᵢ Y
⊢ dimH univ = dimH univ
state_after: no goals
Theorem: RatFunc.ofFractionRing_div
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: simp only [Div.div, HDiv.hDiv, RatFunc.div]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p q : FractionRing K[X]
⊢ { toFractionRing := p / q } = { toFractionRing := p } / { toFractionRing := q }
state_after: no goals
Theorem: monovaryOn_iff_mul_rearrangement
File: Mathlib/Algebra/Order/Monovary.lean

tactic: simp only [smul_eq_mul, monovaryOn_iff_smul_rearrangement]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
f g : ι → α
s : Set ι
a b c d : α
⊢ MonovaryOn f g s ↔ ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → f i * g j + f j * g i ≤ f i * g i + f j * g j
state_after: no goals
Theorem: nhds_translation_mul_inv₀
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G₀ : Type u_3
inst✝² : TopologicalSpace G₀
inst✝¹ : GroupWithZero G₀
inst✝ : ContinuousMul G₀
a : G₀
ha : a ≠ 0
⊢ 𝓝 ((Homeomorph.mulRight₀ a ha).symm.symm 1) = 𝓝 a
state_after: no goals
Theorem: Stream'.map_cons
File: Mathlib/Data/Stream/Init.lean

tactic: rw [← Stream'.eta (map f (a::s)), map_eq]
state_before: α : Type u
β : Type v
δ : Type w
f : α → β
a : α
s : Stream' α
⊢ map f (a :: s) = f a :: map f s
state_after: α : Type u
β : Type v
δ : Type w
f : α → β
a : α
s : Stream' α
⊢ (f (a :: s).head :: map f (a :: s).tail).head :: (f (a :: s).head :: map f (a :: s).tail).tail = f a :: map f s

tactic: rfl
state_before: α : Type u
β : Type v
δ : Type w
f : α → β
a : α
s : Stream' α
⊢ (f (a :: s).head :: map f (a :: s).tail).head :: (f (a :: s).head :: map f (a :: s).tail).tail = f a :: map f s
state_after: no goals
Theorem: Complex.cos_add_sin_I
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← cosh_add_sinh, sinh_mul_I, cosh_mul_I]
state_before: x y : ℂ
⊢ cos x + sin x * I = cexp (x * I)
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.inverseImage_iff
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

tactic: rfl
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
P : MorphismProperty D
F : C ⥤ D
X Y : C
f : X ⟶ Y
⊢ P.inverseImage F f ↔ P (F.map f)
state_after: no goals
Theorem: AhlswedeZhang.supSum_union_add_supSum_infs
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

tactic: unfold supSum
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ supSum (𝒜 ∪ ℬ) + supSum (𝒜 ⊼ ℬ) = supSum 𝒜 + supSum ℬ
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∑ s : Finset α, ↑((𝒜 ∪ ℬ).truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) +
      ∑ s : Finset α, ↑((𝒜 ⊼ ℬ).truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) =
    ∑ s : Finset α, ↑(𝒜.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) +
      ∑ s : Finset α, ↑(ℬ.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card))

tactic: rw [← sum_add_distrib, ← sum_add_distrib, sum_congr rfl fun s _ ↦ _]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∑ s : Finset α, ↑((𝒜 ∪ ℬ).truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) +
      ∑ s : Finset α, ↑((𝒜 ⊼ ℬ).truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) =
    ∑ s : Finset α, ↑(𝒜.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) +
      ∑ s : Finset α, ↑(ℬ.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card))
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∀ s ∈ univ,
    ↑((𝒜 ∪ ℬ).truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) +
        ↑((𝒜 ⊼ ℬ).truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) =
      ↑(𝒜.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) +
        ↑(ℬ.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card))

tactic: simp_rw [div_add_div_same, ← Nat.cast_add, card_truncatedSup_union_add_card_truncatedSup_infs]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∀ s ∈ univ,
    ↑((𝒜 ∪ ℬ).truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) +
        ↑((𝒜 ⊼ ℬ).truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) =
      ↑(𝒜.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card)) +
        ↑(ℬ.truncatedSup s).card / ((↑(card α) - ↑s.card) * ↑((card α).choose s.card))
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∀ s ∈ univ, True

tactic: simp
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∀ s ∈ univ, True
state_after: no goals
Theorem: EuclideanGeometry.dist_eq_iff_dist_orthogonalProjection_eq
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

tactic: rw [← mul_self_inj_of_nonneg dist_nonneg dist_nonneg, ←
  mul_self_inj_of_nonneg dist_nonneg dist_nonneg,
  dist_sq_eq_dist_orthogonalProjection_sq_add_dist_orthogonalProjection_sq p3 hp1,
  dist_sq_eq_dist_orthogonalProjection_sq_add_dist_orthogonalProjection_sq p3 hp2]
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
p1 p2 p3 : P
hp1 : p1 ∈ s
hp2 : p2 ∈ s
⊢ dist p1 p3 = dist p2 p3 ↔ dist p1 ↑((orthogonalProjection s) p3) = dist p2 ↑((orthogonalProjection s) p3)
state_after: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
p1 p2 p3 : P
hp1 : p1 ∈ s
hp2 : p2 ∈ s
⊢ dist p1 ↑((orthogonalProjection s) p3) * dist p1 ↑((orthogonalProjection s) p3) +
        dist p3 ↑((orthogonalProjection s) p3) * dist p3 ↑((orthogonalProjection s) p3) =
      dist p2 ↑((orthogonalProjection s) p3) * dist p2 ↑((orthogonalProjection s) p3) +
        dist p3 ↑((orthogonalProjection s) p3) * dist p3 ↑((orthogonalProjection s) p3) ↔
    dist p1 ↑((orthogonalProjection s) p3) * dist p1 ↑((orthogonalProjection s) p3) =
      dist p2 ↑((orthogonalProjection s) p3) * dist p2 ↑((orthogonalProjection s) p3)

tactic: simp
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
p1 p2 p3 : P
hp1 : p1 ∈ s
hp2 : p2 ∈ s
⊢ dist p1 ↑((orthogonalProjection s) p3) * dist p1 ↑((orthogonalProjection s) p3) +
        dist p3 ↑((orthogonalProjection s) p3) * dist p3 ↑((orthogonalProjection s) p3) =
      dist p2 ↑((orthogonalProjection s) p3) * dist p2 ↑((orthogonalProjection s) p3) +
        dist p3 ↑((orthogonalProjection s) p3) * dist p3 ↑((orthogonalProjection s) p3) ↔
    dist p1 ↑((orthogonalProjection s) p3) * dist p1 ↑((orthogonalProjection s) p3) =
      dist p2 ↑((orthogonalProjection s) p3) * dist p2 ↑((orthogonalProjection s) p3)
state_after: no goals
Theorem: Cardinal.ofENat_eq_zero
File: Mathlib/SetTheory/Cardinal/ENat.lean

tactic: norm_cast
state_before: m : ℕ∞
⊢ ↑m = 0 ↔ m = 0
state_after: no goals
Theorem: PNat.find_le_iff
File: Mathlib/Data/PNat/Find.lean

tactic: simp only [exists_prop, ← lt_add_one_iff, find_lt_iff]
state_before: p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n✝ m n : ℕ+
⊢ PNat.find h ≤ n ↔ ∃ m ≤ n, p m
state_after: no goals
Theorem: HilbertBasis.hasSum_orthogonalProjection
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: simpa only [b.repr_apply_apply, inner_orthogonalProjection_eq_of_mem_left] using
  b.hasSum_repr (orthogonalProjection U x)
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁵ : RCLike 𝕜
E : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
U : Submodule 𝕜 E
inst✝ : CompleteSpace ↥U
b : HilbertBasis ι 𝕜 ↥U
x : E
⊢ HasSum (fun i => ⟪↑((fun i => b.repr.symm (lp.single 2 i 1)) i), x⟫_𝕜 • (fun i => b.repr.symm (lp.single 2 i 1)) i)
    ((orthogonalProjection U) x)
state_after: no goals
Theorem: Function.mulSupport_update_one
File: Mathlib/Algebra/Group/Support.lean

tactic: ext a
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
G : Type u_8
inst✝³ : One M
inst✝² : One N
inst✝¹ : One P
inst✝ : DecidableEq α
f : α → M
x : α
⊢ mulSupport (update f x 1) = mulSupport f \ {x}
state_after: case h
α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
G : Type u_8
inst✝³ : One M
inst✝² : One N
inst✝¹ : One P
inst✝ : DecidableEq α
f : α → M
x a : α
⊢ a ∈ mulSupport (update f x 1) ↔ a ∈ mulSupport f \ {x}

tactic: rcases eq_or_ne a x with rfl | hne <;> simp [*]
state_before: case h
α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
G : Type u_8
inst✝³ : One M
inst✝² : One N
inst✝¹ : One P
inst✝ : DecidableEq α
f : α → M
x a : α
⊢ a ∈ mulSupport (update f x 1) ↔ a ∈ mulSupport f \ {x}
state_after: no goals