1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Rack.self_act_invAct_eq
File: Mathlib/Algebra/Quandle.lean

tactic: rw [← left_cancel (x ◃ x)]
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃ x) ◃⁻¹ y = x ◃⁻¹ y
state_after: R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃ x) ◃ (x ◃ x) ◃⁻¹ y = (x ◃ x) ◃ x ◃⁻¹ y

tactic: rw [right_inv]
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃ x) ◃ (x ◃ x) ◃⁻¹ y = (x ◃ x) ◃ x ◃⁻¹ y
state_after: R : Type u_1
inst✝ : Rack R
x y : R
⊢ y = (x ◃ x) ◃ x ◃⁻¹ y

tactic: rw [self_act_act_eq]
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ y = (x ◃ x) ◃ x ◃⁻¹ y
state_after: R : Type u_1
inst✝ : Rack R
x y : R
⊢ y = x ◃ x ◃⁻¹ y

tactic: rw [right_inv]
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ y = x ◃ x ◃⁻¹ y
state_after: no goals
Theorem: hnot_hnot_sdiff_distrib
File: Mathlib/Order/Heyting/Basic.lean

tactic: apply le_antisymm
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢(a \ b) = ￢￢a \ ￢￢b
state_after: case a
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢(a \ b) ≤ ￢￢a \ ￢￢b

case a
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢a \ ￢￢b ≤ ￢￢(a \ b)

tactic: refine hnot_le_comm.1 ((hnot_anti sdiff_le_inf_hnot).trans' ?_)
state_before: case a
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢(a \ b) ≤ ￢￢a \ ￢￢b
state_after: case a
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢(￢￢a \ ￢￢b) ≤ ￢(a ⊓ ￢b)

tactic: rw [hnot_inf_distrib, hnot_le_iff_codisjoint_right, codisjoint_left_comm, ←
  hnot_le_iff_codisjoint_right]
state_before: case a
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢(￢￢a \ ￢￢b) ≤ ￢(a ⊓ ￢b)
state_after: case a
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢a ≤ ￢￢a \ ￢￢b ⊔ ￢￢b

tactic: exact le_sdiff_sup
state_before: case a
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢a ≤ ￢￢a \ ￢￢b ⊔ ￢￢b
state_after: no goals

tactic: rw [sdiff_le_iff, ← hnot_hnot_sup_distrib]
state_before: case a
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢a \ ￢￢b ≤ ￢￢(a \ b)
state_after: case a
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢a ≤ ￢￢(b ⊔ a \ b)

tactic: exact hnot_anti (hnot_anti le_sup_sdiff)
state_before: case a
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢￢a ≤ ￢￢(b ⊔ a \ b)
state_after: no goals
Theorem: AddSubmonoid.pow_eq_closure_pow_set
File: Mathlib/Algebra/Group/Submonoid/Pointwise.lean

tactic: rw [← closure_pow, closure_eq]
state_before: α : Type u_1
G : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : AddMonoid A
inst✝ : Semiring R
s : AddSubmonoid R
n : ℕ
⊢ s ^ n = closure (↑s ^ n)
state_after: no goals
Theorem: CategoryTheory.ShortComplex.RightHomologyData.map_g'
File: Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean

tactic: rw [← cancel_epi (h.map F).p, p_g', map_g, map_p, ← F.map_comp, p_g']
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_4, u_1} C
inst✝⁴ : Category.{u_3, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : S.RightHomologyData
F : C ⥤ D
inst✝¹ : F.PreservesZeroMorphisms
inst✝ : h.IsPreservedBy F
⊢ (h.map F).g' = F.map h.g'
state_after: no goals
Theorem: CoxeterSystem.IsReflection.isRightInversion_mul_left_iff
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

tactic: unfold IsRightInversion
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
t : W
ht : cs.IsReflection t
w : W
⊢ cs.IsRightInversion (w * t) t ↔ ¬cs.IsRightInversion w t
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
t : W
ht : cs.IsReflection t
w : W
⊢ cs.IsReflection t ∧ cs.length (w * t * t) < cs.length (w * t) ↔ ¬(cs.IsReflection t ∧ cs.length (w * t) < cs.length w)

tactic: simp only [mul_assoc, ht.inv, ht.mul_self, mul_one, ht, true_and, not_lt]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
t : W
ht : cs.IsReflection t
w : W
⊢ cs.IsReflection t ∧ cs.length (w * t * t) < cs.length (w * t) ↔ ¬(cs.IsReflection t ∧ cs.length (w * t) < cs.length w)
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
t : W
ht : cs.IsReflection t
w : W
⊢ cs.length w < cs.length (w * t) ↔ cs.length w ≤ cs.length (w * t)

tactic: constructor
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
t : W
ht : cs.IsReflection t
w : W
⊢ cs.length w < cs.length (w * t) ↔ cs.length w ≤ cs.length (w * t)
state_after: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
t : W
ht : cs.IsReflection t
w : W
⊢ cs.length w < cs.length (w * t) → cs.length w ≤ cs.length (w * t)

case mpr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
t : W
ht : cs.IsReflection t
w : W
⊢ cs.length w ≤ cs.length (w * t) → cs.length w < cs.length (w * t)

tactic: exact le_of_lt
state_before: case mp
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
t : W
ht : cs.IsReflection t
w : W
⊢ cs.length w < cs.length (w * t) → cs.length w ≤ cs.length (w * t)
state_after: no goals
Theorem: differentiableWithinAt_add_const_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa using h.add_const (-c)
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
h : DifferentiableWithinAt 𝕜 (fun y => f y + c) s x
⊢ DifferentiableWithinAt 𝕜 f s x
state_after: no goals
Theorem: List.toList_toAssocList
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

tactic: induction l <;> simp [*]
state_before: α : Type u_1
β : Type u_2
l : List (α × β)
⊢ l.toAssocList.toList = l
state_after: no goals
Theorem: Polynomial.hasseDeriv_apply
File: Mathlib/Algebra/Polynomial/HasseDeriv.lean

tactic: dsimp [hasseDeriv]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (hasseDeriv k) f = f.sum fun i r => (monomial (i - k)) (↑(i.choose k) * r)
state_after: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (f.sum fun x x_1 => (monomial (x - k)) (x.choose k • x_1)) = f.sum fun i r => (monomial (i - k)) (↑(i.choose k) * r)

tactic: congr
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (f.sum fun x x_1 => (monomial (x - k)) (x.choose k • x_1)) = f.sum fun i r => (monomial (i - k)) (↑(i.choose k) * r)
state_after: case e_f
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (fun x x_1 => (monomial (x - k)) (x.choose k • x_1)) = fun i r => (monomial (i - k)) (↑(i.choose k) * r)

tactic: ext
state_before: case e_f
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (fun x x_1 => (monomial (x - k)) (x.choose k • x_1)) = fun i r => (monomial (i - k)) (↑(i.choose k) * r)
state_after: case e_f.h.h.a
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
x✝¹ : ℕ
x✝ : R
n✝ : ℕ
⊢ ((monomial (x✝¹ - k)) (x✝¹.choose k • x✝)).coeff n✝ = ((monomial (x✝¹ - k)) (↑(x✝¹.choose k) * x✝)).coeff n✝

tactic: congr
state_before: case e_f.h.h.a
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
x✝¹ : ℕ
x✝ : R
n✝ : ℕ
⊢ ((monomial (x✝¹ - k)) (x✝¹.choose k • x✝)).coeff n✝ = ((monomial (x✝¹ - k)) (↑(x✝¹.choose k) * x✝)).coeff n✝
state_after: case e_f.h.h.a.e_a.h.e_6.h
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
x✝¹ : ℕ
x✝ : R
n✝ : ℕ
⊢ x✝¹.choose k • x✝ = ↑(x✝¹.choose k) * x✝

tactic: apply nsmul_eq_mul
state_before: case e_f.h.h.a.e_a.h.e_6.h
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
x✝¹ : ℕ
x✝ : R
n✝ : ℕ
⊢ x✝¹.choose k • x✝ = ↑(x✝¹.choose k) * x✝
state_after: no goals
Theorem: HurwitzZeta.hasSum_nat_cosZeta
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

tactic: have := (hasSum_int_cosZeta a hs).nat_add_neg
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => ↑(Real.cos (2 * π * a * ↑n)) / ↑n ^ s) (cosZeta (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
this :
  HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑↑n) / ↑|↑n| ^ s / 2 + cexp (2 * ↑π * I * ↑a * ↑(-↑n)) / ↑|(-↑n)| ^ s / 2)
    (cosZeta (↑a) s + cexp (2 * ↑π * I * ↑a * ↑0) / ↑|0| ^ s / 2)
⊢ HasSum (fun n => ↑(Real.cos (2 * π * a * ↑n)) / ↑n ^ s) (cosZeta (↑a) s)

tactic: simp_rw [abs_neg, Int.cast_neg, Nat.abs_cast, Int.cast_natCast, mul_neg, abs_zero, Int.cast_zero,
  zero_cpow (ne_zero_of_one_lt_re hs), div_zero, zero_div, add_zero, ← add_div,
  div_right_comm _ _ (2 : ℂ)] at this
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
this :
  HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑↑n) / ↑|↑n| ^ s / 2 + cexp (2 * ↑π * I * ↑a * ↑(-↑n)) / ↑|(-↑n)| ^ s / 2)
    (cosZeta (↑a) s + cexp (2 * ↑π * I * ↑a * ↑0) / ↑|0| ^ s / 2)
⊢ HasSum (fun n => ↑(Real.cos (2 * π * a * ↑n)) / ↑n ^ s) (cosZeta (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
this : HasSum (fun n => (cexp (2 * ↑π * I * ↑a * ↑n) + cexp (-(2 * ↑π * I * ↑a * ↑n))) / 2 / ↑n ^ s) (cosZeta (↑a) s)
⊢ HasSum (fun n => ↑(Real.cos (2 * π * a * ↑n)) / ↑n ^ s) (cosZeta (↑a) s)

tactic: simp_rw [push_cast, Complex.cos, neg_mul]
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
this : HasSum (fun n => (cexp (2 * ↑π * I * ↑a * ↑n) + cexp (-(2 * ↑π * I * ↑a * ↑n))) / 2 / ↑n ^ s) (cosZeta (↑a) s)
⊢ HasSum (fun n => ↑(Real.cos (2 * π * a * ↑n)) / ↑n ^ s) (cosZeta (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
this : HasSum (fun n => (cexp (2 * ↑π * I * ↑a * ↑n) + cexp (-(2 * ↑π * I * ↑a * ↑n))) / 2 / ↑n ^ s) (cosZeta (↑a) s)
⊢ HasSum (fun n => (cexp (2 * ↑π * ↑a * ↑n * I) + cexp (-(2 * ↑π * ↑a * ↑n * I))) / 2 / ↑n ^ s) (cosZeta (↑a) s)

tactic: exact this.congr_fun fun n ↦ by rw [show 2 * π * a * n * I = 2 * π * I * a * n by ring]
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
this : HasSum (fun n => (cexp (2 * ↑π * I * ↑a * ↑n) + cexp (-(2 * ↑π * I * ↑a * ↑n))) / 2 / ↑n ^ s) (cosZeta (↑a) s)
⊢ HasSum (fun n => (cexp (2 * ↑π * ↑a * ↑n * I) + cexp (-(2 * ↑π * ↑a * ↑n * I))) / 2 / ↑n ^ s) (cosZeta (↑a) s)
state_after: no goals

tactic: rw [show 2 * π * a * n * I = 2 * π * I * a * n by ring]
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
this : HasSum (fun n => (cexp (2 * ↑π * I * ↑a * ↑n) + cexp (-(2 * ↑π * I * ↑a * ↑n))) / 2 / ↑n ^ s) (cosZeta (↑a) s)
n : ℕ
⊢ (cexp (2 * ↑π * ↑a * ↑n * I) + cexp (-(2 * ↑π * ↑a * ↑n * I))) / 2 / ↑n ^ s =
    (cexp (2 * ↑π * I * ↑a * ↑n) + cexp (-(2 * ↑π * I * ↑a * ↑n))) / 2 / ↑n ^ s
state_after: no goals

tactic: ring
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
this : HasSum (fun n => (cexp (2 * ↑π * I * ↑a * ↑n) + cexp (-(2 * ↑π * I * ↑a * ↑n))) / 2 / ↑n ^ s) (cosZeta (↑a) s)
n : ℕ
⊢ 2 * ↑π * ↑a * ↑n * I = 2 * ↑π * I * ↑a * ↑n
state_after: no goals
Theorem: Set.Ico_diff_Iio
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [diff_eq, compl_Iio, Ico_inter_Ici, sup_eq_max]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ico a b \ Iio c = Ico (max a c) b
state_after: no goals
Theorem: borel_eq_generateFrom_Ico
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean

tactic: simpa only [exists_prop, mem_univ, true_and_iff] using
  (@dense_univ α _).borel_eq_generateFrom_Ico_mem_aux (fun _ _ => mem_univ _) fun _ _ _ _ =>
    mem_univ _
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α✝
inst✝⁹ : TopologicalSpace α✝
inst✝⁸ : MeasurableSpace α✝
inst✝⁷ : OpensMeasurableSpace α✝
inst✝⁶ : MeasurableSpace δ
inst✝⁵ : LinearOrder α✝
inst✝⁴ : OrderClosedTopology α✝
a b x : α✝
α : Type u_5
inst✝³ : TopologicalSpace α
inst✝² : SecondCountableTopology α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
⊢ borel α = MeasurableSpace.generateFrom {S | ∃ l u, l < u ∧ Ico l u = S}
state_after: no goals
Theorem: Associates.mk_ne_zero'
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [Associates.mk_ne_zero, Ideal.zero_eq_bot, Ne, Ideal.span_singleton_eq_bot]
state_before: R : Type u_1
inst✝ : CommSemiring R
r : R
⊢ Associates.mk (Ideal.span {r}) ≠ 0 ↔ r ≠ 0
state_after: no goals
Theorem: differentiableWithinAt_const_add_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa using h.const_add (-c)
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
h : DifferentiableWithinAt 𝕜 (fun y => c + f y) s x
⊢ DifferentiableWithinAt 𝕜 f s x
state_after: no goals
Theorem: MeasureTheory.Measure.bind_dirac
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → Measure β
hf : Measurable f
a : α
⊢ (dirac a).bind f = f a
state_after: case h
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → Measure β
hf : Measurable f
a : α
s : Set β
hs : MeasurableSet s
⊢ ((dirac a).bind f) s = (f a) s

tactic: erw [bind_apply hs hf, lintegral_dirac' a ((measurable_coe hs).comp hf)]
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → Measure β
hf : Measurable f
a : α
s : Set β
hs : MeasurableSet s
⊢ ((dirac a).bind f) s = (f a) s
state_after: case h
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → Measure β
hf : Measurable f
a : α
s : Set β
hs : MeasurableSet s
⊢ ((fun μ => μ s) ∘ f) a = (f a) s

tactic: rfl
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → Measure β
hf : Measurable f
a : α
s : Set β
hs : MeasurableSet s
⊢ ((fun μ => μ s) ∘ f) a = (f a) s
state_after: no goals
Theorem: TensorAlgebra.mk_reindex_fin_cast
File: Mathlib/LinearAlgebra/TensorAlgebra/ToTensorPower.lean

tactic: rw [finCongr_eq_equivCast, mk_reindex_cast h]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
n m : ℕ
h : n = m
x : ⨂[R]^n M
⊢ GradedMonoid.mk m ((PiTensorProduct.reindex R (fun x => M) (finCongr h)) x) = GradedMonoid.mk n x
state_after: no goals
Theorem: Submodule.closedComplemented_top
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: simp
state_before: R : Type u_1
inst✝⁶ : Ring R
M : Type u_2
inst✝⁵ : TopologicalSpace M
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M₂ : Type u_3
inst✝² : TopologicalSpace M₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
x : ↥⊤
⊢ ↑(((ContinuousLinearMap.id R M).codRestrict ⊤ ⋯) ↑x) = ↑x
state_after: no goals
Theorem: QPF.supp_eq
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: ext
state_before: F : Type u → Type u
q : QPF F
α : Type u
x : F α
⊢ supp x = {u | ∀ (a : (P F).A) (f : (P F).B a → α), abs ⟨a, f⟩ = x → u ∈ f '' univ}
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
x : F α
x✝ : α
⊢ x✝ ∈ supp x ↔ x✝ ∈ {u | ∀ (a : (P F).A) (f : (P F).B a → α), abs ⟨a, f⟩ = x → u ∈ f '' univ}

tactic: apply mem_supp
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
x : F α
x✝ : α
⊢ x✝ ∈ supp x ↔ x✝ ∈ {u | ∀ (a : (P F).A) (f : (P F).B a → α), abs ⟨a, f⟩ = x → u ∈ f '' univ}
state_after: no goals
Theorem: FiberBundleCore.mem_localTrivAt_baseSet
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: rw [localTrivAt, ← baseSet_at]
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
b✝ : B
a : F
b : B
⊢ b ∈ (Z.localTrivAt b).baseSet
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
b✝ : B
a : F
b : B
⊢ b ∈ Z.baseSet (Z.indexAt b)

tactic: exact Z.mem_baseSet_at b
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
b✝ : B
a : F
b : B
⊢ b ∈ Z.baseSet (Z.indexAt b)
state_after: no goals
Theorem: MeasureTheory.AEStronglyMeasurable.ae_integrable_condDistrib_map_iff
File: Mathlib/Probability/Kernel/CondDistrib.lean

tactic: rw [condDistrib, ← hf.ae_integrable_condKernel_iff, Measure.fst_map_prod_mk₀ hY]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
hY : AEMeasurable Y μ
hf : AEStronglyMeasurable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ (∀ᵐ (a : β) ∂Measure.map X μ, Integrable (fun ω => f (a, ω)) ((condDistrib Y X μ) a)) ∧
      Integrable (fun a => ∫ (ω : Ω), ‖f (a, ω)‖ ∂(condDistrib Y X μ) a) (Measure.map X μ) ↔
    Integrable f (Measure.map (fun a => (X a, Y a)) μ)
state_after: no goals
Theorem: CategoryTheory.CartesianClosed.uncurry_id_eq_ev
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

tactic: rw [uncurry_eq, prod.map_id_id, id_comp]
state_before: C : Type u
inst✝³ : Category.{v, u} C
A✝ B X✝ X' Y Y' Z : C
inst✝² : HasFiniteProducts C
inst✝¹ : Exponentiable A✝
A X : C
inst✝ : Exponentiable A
⊢ uncurry (𝟙 (A ⟹ X)) = (exp.ev A).app X
state_after: no goals
Theorem: le_inv_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [← inv_le_inv_of_neg (inv_lt_zero.2 hb) ha, inv_inv]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : a < 0
hb : b < 0
⊢ a ≤ b⁻¹ ↔ b ≤ a⁻¹
state_after: no goals
Theorem: Filter.disjoint_comap_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [disjoint_iff, disjoint_iff, ← comap_inf, comap_surjective_eq_bot h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
h : Surjective m
⊢ Disjoint (comap m g₁) (comap m g₂) ↔ Disjoint g₁ g₂
state_after: no goals
Theorem: tendstoUniformlyOn_iff_tendstoUniformlyOnFilter
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp only [TendstoUniformlyOn, TendstoUniformlyOnFilter]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ TendstoUniformlyOn F f p s ↔ TendstoUniformlyOnFilter F f p (𝓟 s)
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ (∀ u ∈ 𝓤 β, ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u) ↔
    ∀ u ∈ 𝓤 β, ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, (f n.2, F n.1 n.2) ∈ u

tactic: apply forall₂_congr
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ (∀ u ∈ 𝓤 β, ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u) ↔
    ∀ u ∈ 𝓤 β, ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, (f n.2, F n.1 n.2) ∈ u
state_after: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ ∀ a ∈ 𝓤 β, (∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ a) ↔ ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, (f n.2, F n.1 n.2) ∈ a

tactic: simp_rw [eventually_prod_principal_iff]
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ ∀ a ∈ 𝓤 β, (∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ a) ↔ ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, (f n.2, F n.1 n.2) ∈ a
state_after: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ ∀ a ∈ 𝓤 β, True

tactic: simp
state_before: case h
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ ∀ a ∈ 𝓤 β, True
state_after: no goals
Theorem: MeasureTheory.Measure.smul_finite
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: lift c to ℝ≥0 using hc
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
μ : Measure α
inst✝ : IsFiniteMeasure μ
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ IsFiniteMeasure (c • μ)
state_after: case intro
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
μ : Measure α
inst✝ : IsFiniteMeasure μ
c : ℝ≥0
⊢ IsFiniteMeasure (↑c • μ)

tactic: exact MeasureTheory.isFiniteMeasureSMulNNReal
state_before: case intro
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
μ : Measure α
inst✝ : IsFiniteMeasure μ
c : ℝ≥0
⊢ IsFiniteMeasure (↑c • μ)
state_after: no goals
Theorem: Matrix.IsHermitian.star_eigenvectorUnitary_mulVec
File: Mathlib/LinearAlgebra/Matrix/Spectrum.lean

tactic: rw [← eigenvectorUnitary_mulVec, mulVec_mulVec, unitary.coe_star_mul_self, one_mulVec]
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
n : Type u_2
inst✝¹ : Fintype n
A : Matrix n n 𝕜
inst✝ : DecidableEq n
hA : A.IsHermitian
j : n
⊢ star ↑hA.eigenvectorUnitary *ᵥ (WithLp.equiv 2 ((i : n) → (fun x => 𝕜) i)) (hA.eigenvectorBasis j) = Pi.single j 1
state_after: no goals
Theorem: RatFunc.algebraMap_apply
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: rw [← mk_eq_div]
state_before: K : Type u
inst✝³ : CommRing K
inst✝² : IsDomain K
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R K[X]
x : R
⊢ (algebraMap R (RatFunc K)) x = (algebraMap K[X] (RatFunc K)) ((algebraMap R K[X]) x) / (algebraMap K[X] (RatFunc K)) 1
state_after: K : Type u
inst✝³ : CommRing K
inst✝² : IsDomain K
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R K[X]
x : R
⊢ (algebraMap R (RatFunc K)) x = RatFunc.mk ((algebraMap R K[X]) x) 1

tactic: rfl
state_before: K : Type u
inst✝³ : CommRing K
inst✝² : IsDomain K
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R K[X]
x : R
⊢ (algebraMap R (RatFunc K)) x = RatFunc.mk ((algebraMap R K[X]) x) 1
state_after: no goals
Theorem: Filter.HasBasis.uniformEmbedding_iff
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: simp only [h.uniformEmbedding_iff' h', h.uniformContinuous_iff h']
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
ι : Sort u_1
ι' : Sort u_2
p : ι → Prop
p' : ι' → Prop
s : ι → Set (α × α)
s' : ι' → Set (β × β)
h : (𝓤 α).HasBasis p s
h' : (𝓤 β).HasBasis p' s'
f : α → β
⊢ UniformEmbedding f ↔
    Injective f ∧ UniformContinuous f ∧ ∀ (j : ι), p j → ∃ i, p' i ∧ ∀ (x y : α), (f x, f y) ∈ s' i → (x, y) ∈ s j
state_after: no goals
Theorem: Nat.mul_mem_smoothNumbers
File: Mathlib/NumberTheory/SmoothNumbers.lean

tactic: rw [smoothNumbers_eq_factoredNumbers] at hm1 hm2 ⊢
state_before: m₁ m₂ n : ℕ
hm1 : m₁ ∈ n.smoothNumbers
hm2 : m₂ ∈ n.smoothNumbers
⊢ m₁ * m₂ ∈ n.smoothNumbers
state_after: m₁ m₂ n : ℕ
hm1 : m₁ ∈ factoredNumbers (Finset.range n)
hm2 : m₂ ∈ factoredNumbers (Finset.range n)
⊢ m₁ * m₂ ∈ factoredNumbers (Finset.range n)

tactic: exact mul_mem_factoredNumbers hm1 hm2
state_before: m₁ m₂ n : ℕ
hm1 : m₁ ∈ factoredNumbers (Finset.range n)
hm2 : m₂ ∈ factoredNumbers (Finset.range n)
⊢ m₁ * m₂ ∈ factoredNumbers (Finset.range n)
state_after: no goals