1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.product_singleton
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b✝ b : β
⊢ s ×ˢ {b} = map { toFun := fun i => (i, b), inj' := ⋯ } s
state_after: case a.mk
α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b✝ b : β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ {b} ↔ (x, y) ∈ map { toFun := fun i => (i, b), inj' := ⋯ } s

tactic: simp [and_left_comm, eq_comm]
state_before: case a.mk
α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b✝ b : β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ {b} ↔ (x, y) ∈ map { toFun := fun i => (i, b), inj' := ⋯ } s
state_after: no goals
Theorem: DiscreteQuotient.isClopen_setOf_rel
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: rw [← fiber_eq]
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
x : X
⊢ IsClopen (setOf (S.Rel x))
state_after: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
x : X
⊢ IsClopen (S.proj ⁻¹' {S.proj x})

tactic: apply isClopen_preimage
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S : DiscreteQuotient X
x : X
⊢ IsClopen (S.proj ⁻¹' {S.proj x})
state_after: no goals
Theorem: hasProd_ite_div_hasProd
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

tactic: convert hf.update b 1 using 1
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : DecidableEq β
hf : HasProd f a
b : β
⊢ HasProd (fun n => if n = b then 1 else f n) (a / f b)
state_after: case h.e'_5
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : DecidableEq β
hf : HasProd f a
b : β
⊢ (fun n => if n = b then 1 else f n) = update f b 1

case h.e'_6
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : DecidableEq β
hf : HasProd f a
b : β
⊢ a / f b = 1 / f b * a

tactic: ext n
state_before: case h.e'_5
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : DecidableEq β
hf : HasProd f a
b : β
⊢ (fun n => if n = b then 1 else f n) = update f b 1
state_after: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : DecidableEq β
hf : HasProd f a
b n : β
⊢ (if n = b then 1 else f n) = update f b 1 n

tactic: rw [Function.update_apply]
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : DecidableEq β
hf : HasProd f a
b n : β
⊢ (if n = b then 1 else f n) = update f b 1 n
state_after: no goals

tactic: rw [div_mul_eq_mul_div, one_mul]
state_before: case h.e'_6
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : DecidableEq β
hf : HasProd f a
b : β
⊢ a / f b = 1 / f b * a
state_after: no goals
Theorem: Int.toNat_eq_zero
File: Mathlib/Data/Int/Defs.lean

tactic: simp
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ (↑n).toNat = 0 ↔ ↑n ≤ 0
state_after: no goals

tactic: simpa [toNat] using Int.le_of_lt (negSucc_lt_zero n)
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ -[n+1].toNat = 0 ↔ -[n+1] ≤ 0
state_after: no goals
Theorem: CategoryTheory.Iso.conjAut_apply
File: Mathlib/CategoryTheory/Conj.lean

tactic: aesop_cat
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
α : X ≅ Y
f : Aut X
⊢ α.conjAut f = α.symm ≪≫ f ≪≫ α
state_after: no goals
Theorem: PMF.mem_support_uniformOfFintype
File: Mathlib/Probability/Distributions/Uniform.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
inst✝ : Nonempty α
a : α
⊢ a ∈ (uniformOfFintype α).support
state_after: no goals
Theorem: MeasureTheory.squareCylinders_eq_iUnion_image
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

tactic: ext1 f
state_before: ι : Type u_2
α : ι → Type u_1
C : (i : ι) → Set (Set (α i))
⊢ squareCylinders C = ⋃ s, (fun t => (↑s).pi t) '' univ.pi C
state_after: case h
ι : Type u_2
α : ι → Type u_1
C : (i : ι) → Set (Set (α i))
f : Set ((i : ι) → α i)
⊢ f ∈ squareCylinders C ↔ f ∈ ⋃ s, (fun t => (↑s).pi t) '' univ.pi C

tactic: simp only [squareCylinders, mem_iUnion, mem_image, mem_univ_pi, exists_prop, mem_setOf_eq,
  eq_comm (a := f)]
state_before: case h
ι : Type u_2
α : ι → Type u_1
C : (i : ι) → Set (Set (α i))
f : Set ((i : ι) → α i)
⊢ f ∈ squareCylinders C ↔ f ∈ ⋃ s, (fun t => (↑s).pi t) '' univ.pi C
state_after: no goals
Theorem: intervalIntegral.integral_smul_measure
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [intervalIntegral, Measure.restrict_smul, integral_smul_measure, smul_sub]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
c : ℝ≥0∞
⊢ ∫ (x : ℝ) in a..b, f x ∂c • μ = c.toReal • ∫ (x : ℝ) in a..b, f x ∂μ
state_after: no goals
Theorem: List.Perm.join
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: induction h with
| nil => rfl
| cons _ _ ih => simp only [join_cons, perm_append_left_iff, ih]
| swap => simp only [join_cons, ← append_assoc, perm_append_right_iff]; exact perm_append_comm ..
| trans _ _ ih₁ ih₂ => exact trans ih₁ ih₂
state_before: α : Type u_1
l₁ l₂ : List (List α)
h : l₁ ~ l₂
⊢ l₁.join ~ l₂.join
state_after: no goals

tactic: rfl
state_before: case nil
α : Type u_1
l₁ l₂ : List (List α)
⊢ [].join ~ [].join
state_after: no goals

tactic: simp only [join_cons, perm_append_left_iff, ih]
state_before: case cons
α : Type u_1
l₁ l₂ : List (List α)
x✝ : List α
l₁✝ l₂✝ : List (List α)
a✝ : l₁✝ ~ l₂✝
ih : l₁✝.join ~ l₂✝.join
⊢ (x✝ :: l₁✝).join ~ (x✝ :: l₂✝).join
state_after: no goals

tactic: simp only [join_cons, ← append_assoc, perm_append_right_iff]
state_before: case swap
α : Type u_1
l₁ l₂ : List (List α)
x✝ y✝ : List α
l✝ : List (List α)
⊢ (y✝ :: x✝ :: l✝).join ~ (x✝ :: y✝ :: l✝).join
state_after: case swap
α : Type u_1
l₁ l₂ : List (List α)
x✝ y✝ : List α
l✝ : List (List α)
⊢ y✝ ++ x✝ ~ x✝ ++ y✝

tactic: exact perm_append_comm ..
state_before: case swap
α : Type u_1
l₁ l₂ : List (List α)
x✝ y✝ : List α
l✝ : List (List α)
⊢ y✝ ++ x✝ ~ x✝ ++ y✝
state_after: no goals

tactic: exact trans ih₁ ih₂
state_before: case trans
α : Type u_1
l₁ l₂ l₁✝ l₂✝ l₃✝ : List (List α)
a✝¹ : l₁✝ ~ l₂✝
a✝ : l₂✝ ~ l₃✝
ih₁ : l₁✝.join ~ l₂✝.join
ih₂ : l₂✝.join ~ l₃✝.join
⊢ l₁✝.join ~ l₃✝.join
state_after: no goals
Theorem: Quaternion.normSq_def'
File: Mathlib/Algebra/Quaternion.lean

tactic: simp only [normSq_def, sq, mul_neg, sub_neg_eq_add, mul_re, star_re, star_imI, star_imJ,
  star_imK]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ normSq a = a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 + a.imK ^ 2
state_after: no goals
Theorem: PowerSeries.C_injective
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: intro a b H
state_before: R : Type u_1
inst✝ : Semiring R
⊢ Function.Injective ⇑(C R)
state_after: R : Type u_1
inst✝ : Semiring R
a b : R
H : (C R) a = (C R) b
⊢ a = b

tactic: have := (ext_iff (φ := C R a) (ψ := C R b)).mp H 0
state_before: R : Type u_1
inst✝ : Semiring R
a b : R
H : (C R) a = (C R) b
⊢ a = b
state_after: R : Type u_1
inst✝ : Semiring R
a b : R
H : (C R) a = (C R) b
this : (coeff R 0) ((C R) a) = (coeff R 0) ((C R) b)
⊢ a = b

tactic: rwa [coeff_zero_C, coeff_zero_C] at this
state_before: R : Type u_1
inst✝ : Semiring R
a b : R
H : (C R) a = (C R) b
this : (coeff R 0) ((C R) a) = (coeff R 0) ((C R) b)
⊢ a = b
state_after: no goals
Theorem: IsNoetherian.subsingleton_of_prod_injective
File: Mathlib/RingTheory/Noetherian.lean

tactic: have h := IsNoetherian.injective_of_surjective_of_injective f _ i LinearMap.fst_surjective
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : M × N →ₗ[R] M
i : Injective ⇑f
x y : N
⊢ x = y
state_after: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : M × N →ₗ[R] M
i : Injective ⇑f
x y : N
h : Injective ⇑(LinearMap.fst R M N)
⊢ x = y

tactic: simpa using h (show LinearMap.fst R M N (0, x) = LinearMap.fst R M N (0, y) from rfl)
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
f : M × N →ₗ[R] M
i : Injective ⇑f
x y : N
h : Injective ⇑(LinearMap.fst R M N)
⊢ x = y
state_after: no goals
Theorem: aestronglyMeasurable_const_smul_iff
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simpa only [inv_smul_smul] using h.const_smul' c⁻¹
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝¹¹ : Countable ι
m : MeasurableSpace α
μ ν : Measure α
inst✝¹⁰ : TopologicalSpace β
inst✝⁹ : TopologicalSpace γ
f g : α → β
M : Type u_5
G : Type u_6
G₀ : Type u_7
inst✝⁸ : Monoid M
inst✝⁷ : MulAction M β
inst✝⁶ : ContinuousConstSMul M β
inst✝⁵ : Group G
inst✝⁴ : MulAction G β
inst✝³ : ContinuousConstSMul G β
inst✝² : GroupWithZero G₀
inst✝¹ : MulAction G₀ β
inst✝ : ContinuousConstSMul G₀ β
c : G
h : AEStronglyMeasurable (fun x => c • f x) μ
⊢ AEStronglyMeasurable f μ
state_after: no goals
Theorem: PMF.map_comp
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: simp [map, Function.comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
p : PMF α
b : β
g : β → γ
⊢ map g (map f p) = map (g ∘ f) p
state_after: no goals
Theorem: Filter.Tendsto.countable_compl_preimage_ker
File: Mathlib/Order/Filter/Cofinite.lean

tactic: rw [← ker_comap]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
l✝ : Filter α
f : α → β
l : Filter β
inst✝ : l.IsCountablyGenerated
h : Tendsto f cofinite l
⊢ (f ⁻¹' l.ker)ᶜ.Countable
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
l✝ : Filter α
f : α → β
l : Filter β
inst✝ : l.IsCountablyGenerated
h : Tendsto f cofinite l
⊢ (comap f l).kerᶜ.Countable

tactic: exact countable_compl_ker h.le_comap
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
l✝ : Filter α
f : α → β
l : Filter β
inst✝ : l.IsCountablyGenerated
h : Tendsto f cofinite l
⊢ (comap f l).kerᶜ.Countable
state_after: no goals
Theorem: RingHom.injective_iff_ker_eq_bot
File: Mathlib/RingTheory/Ideal/Maps.lean

tactic: rw [SetLike.ext'_iff, ker_eq, Set.ext_iff]
state_before: R : Type u
S : Type v
T : Type w
F : Type u_1
inst✝² : Ring R
inst✝¹ : Semiring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
⊢ Function.Injective ⇑f ↔ ker f = ⊥
state_after: R : Type u
S : Type v
T : Type w
F : Type u_1
inst✝² : Ring R
inst✝¹ : Semiring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
⊢ Function.Injective ⇑f ↔ ∀ (x : R), x ∈ ⇑f ⁻¹' {0} ↔ x ∈ ↑⊥

tactic: exact injective_iff_map_eq_zero' f
state_before: R : Type u
S : Type v
T : Type w
F : Type u_1
inst✝² : Ring R
inst✝¹ : Semiring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
⊢ Function.Injective ⇑f ↔ ∀ (x : R), x ∈ ⇑f ⁻¹' {0} ↔ x ∈ ↑⊥
state_after: no goals
Theorem: CategoryTheory.Limits.biproduct.matrix_desc
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: ext
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
J K : Type
inst✝² : Finite J
f✝ : J → C
inst✝¹ : HasFiniteBiproducts C
inst✝ : Fintype K
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
P : C
x : (k : K) → g k ⟶ P
⊢ matrix m ≫ desc x = desc fun j => ∑ k : K, m j k ≫ x k
state_after: case w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
J K : Type
inst✝² : Finite J
f✝ : J → C
inst✝¹ : HasFiniteBiproducts C
inst✝ : Fintype K
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
P : C
x : (k : K) → g k ⟶ P
j✝ : J
⊢ ι f j✝ ≫ matrix m ≫ desc x = ι f j✝ ≫ desc fun j => ∑ k : K, m j k ≫ x k

tactic: simp [lift_desc]
state_before: case w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
J K : Type
inst✝² : Finite J
f✝ : J → C
inst✝¹ : HasFiniteBiproducts C
inst✝ : Fintype K
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
P : C
x : (k : K) → g k ⟶ P
j✝ : J
⊢ ι f j✝ ≫ matrix m ≫ desc x = ι f j✝ ≫ desc fun j => ∑ k : K, m j k ≫ x k
state_after: no goals
Theorem: Cardinal.prod_le_prod
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: have := H i
state_before: α β : Type u
ι : Type u_1
f g : ι → Cardinal.{u_2}
H : ∀ (i : ι), f i ≤ g i
i : ι
⊢ Nonempty (Quotient.out (f i) ↪ Quotient.out (g i))
state_after: α β : Type u
ι : Type u_1
f g : ι → Cardinal.{u_2}
H : ∀ (i : ι), f i ≤ g i
i : ι
this : f i ≤ g i
⊢ Nonempty (Quotient.out (f i) ↪ Quotient.out (g i))

tactic: rwa [← mk_out (f i), ← mk_out (g i)] at this
state_before: α β : Type u
ι : Type u_1
f g : ι → Cardinal.{u_2}
H : ∀ (i : ι), f i ≤ g i
i : ι
this : f i ≤ g i
⊢ Nonempty (Quotient.out (f i) ↪ Quotient.out (g i))
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.RespectsIso.isoClosure_eq
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

tactic: rwa [isoClosure_eq_iff]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{?u.15622, u_1} D
P : MorphismProperty C
hP : P.RespectsIso
⊢ P.isoClosure = P
state_after: no goals
Theorem: List.dlookup_eq_none
File: Mathlib/Data/List/Sigma.lean

tactic: simp [← dlookup_isSome, Option.isNone_iff_eq_none]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
⊢ dlookup a l = none ↔ a ∉ l.keys
state_after: no goals
Theorem: ArithmeticFunction.coe_zeta_mul_coe_moebius
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [← coe_coe, ← intCoe_mul, coe_zeta_mul_moebius, intCoe_one]
state_before: R : Type u_1
inst✝ : Ring R
⊢ ↑ζ * ↑μ = 1
state_after: no goals
Theorem: CategoryTheory.GradedObject.mapBifunctorLeftUnitor_naturality
File: Mathlib/CategoryTheory/GradedObject/Unitor.lean

tactic: rw [← cancel_mono (mapBifunctorLeftUnitor F X e p hp Y').inv, assoc, assoc, Iso.hom_inv_id,
  comp_id, mapBifunctorLeftUnitor_inv_naturality, Iso.hom_inv_id_assoc]
state_before: C : Type u_1
D : Type u_2
I : Type u_3
J : Type u_4
inst✝⁷ : Category.{u_6, u_1} C
inst✝⁶ : Category.{u_5, u_2} D
inst✝⁵ : Zero I
inst✝⁴ : DecidableEq I
inst✝³ : HasInitial C
F : C ⥤ D ⥤ D
X : C
e : F.obj X ≅ 𝟭 D
inst✝² : (Y : D) → PreservesColimit (Functor.empty C) (F.flip.obj Y)
p : I × J → J
hp : ∀ (j : J), p (0, j) = j
Y Y' : GradedObject J D
φ : Y ⟶ Y'
inst✝¹ : (((mapBifunctor F I J).obj ((single₀ I).obj X)).obj Y).HasMap p
inst✝ : (((mapBifunctor F I J).obj ((single₀ I).obj X)).obj Y').HasMap p
⊢ mapBifunctorMapMap F p (𝟙 ((single₀ I).obj X)) φ ≫ (mapBifunctorLeftUnitor F X e p hp Y').hom =
    (mapBifunctorLeftUnitor F X e p hp Y).hom ≫ φ
state_after: no goals
Theorem: Real.sin_half_eq_neg_sqrt
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← abs_sin_half, abs_of_nonpos, neg_neg]
state_before: x : ℝ
hl : -(2 * π) ≤ x
hr : x ≤ 0
⊢ sin (x / 2) = -√((1 - cos x) / 2)
state_after: x : ℝ
hl : -(2 * π) ≤ x
hr : x ≤ 0
⊢ sin (x / 2) ≤ 0

tactic: apply sin_nonpos_of_nonnpos_of_neg_pi_le <;> linarith
state_before: x : ℝ
hl : -(2 * π) ≤ x
hr : x ≤ 0
⊢ sin (x / 2) ≤ 0
state_after: no goals
Theorem: Set.Icc_top
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: simp [← Ici_inter_Iic]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : OrderTop α
a : α
⊢ Icc a ⊤ = Ici a
state_after: no goals
Theorem: MeasureTheory.Measure.lintegral_condKernel_mem
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

tactic: conv_rhs => rw [← compProd_fst_condKernel ρ]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), (ρ.condKernel x) {y | (x, y) ∈ s} ∂ρ.fst = ρ s
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), (ρ.condKernel x) {y | (x, y) ∈ s} ∂ρ.fst = (ρ.fst ⊗ₘ ρ.condKernel) s

tactic: simp_rw [compProd_apply hs]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), (ρ.condKernel x) {y | (x, y) ∈ s} ∂ρ.fst = (ρ.fst ⊗ₘ ρ.condKernel) s
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), (ρ.condKernel x) {y | (x, y) ∈ s} ∂ρ.fst = ∫⁻ (a : β), (ρ.condKernel a) (Prod.mk a ⁻¹' s) ∂ρ.fst

tactic: rfl
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
s : Set (β × Ω)
hs : MeasurableSet s
⊢ ∫⁻ (x : β), (ρ.condKernel x) {y | (x, y) ∈ s} ∂ρ.fst = ∫⁻ (a : β), (ρ.condKernel a) (Prod.mk a ⁻¹' s) ∂ρ.fst
state_after: no goals
Theorem: RatFunc.laurent_at_zero
File: Mathlib/FieldTheory/Laurent.lean

tactic: induction f using RatFunc.induction_on
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
⊢ (laurent 0) f = f
state_after: case f
R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
p✝ q✝ : R[X]
hq✝ : q✝ ≠ 0
⊢ (laurent 0) ((algebraMap R[X] (RatFunc R)) p✝ / (algebraMap R[X] (RatFunc R)) q✝) =
    (algebraMap R[X] (RatFunc R)) p✝ / (algebraMap R[X] (RatFunc R)) q✝

tactic: simp
state_before: case f
R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
p✝ q✝ : R[X]
hq✝ : q✝ ≠ 0
⊢ (laurent 0) ((algebraMap R[X] (RatFunc R)) p✝ / (algebraMap R[X] (RatFunc R)) q✝) =
    (algebraMap R[X] (RatFunc R)) p✝ / (algebraMap R[X] (RatFunc R)) q✝
state_after: no goals
Theorem: MeasureTheory.Measure.compProd_zero_left
File: Mathlib/Probability/Kernel/MeasureCompProd.lean

tactic: simp [compProd]
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
κ✝ η κ : ↥(kernel α β)
⊢ 0 ⊗ₘ κ = 0
state_after: no goals
Theorem: Traversable.foldlm.ofFreeMonoid_comp_of
File: Mathlib/Control/Fold.lean

tactic: ext1 x
state_before: α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
⊢ ⇑(foldlM.ofFreeMonoid f) ∘ FreeMonoid.of = foldlM.mk ∘ flip f
state_after: case h
α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
x : β
⊢ (⇑(foldlM.ofFreeMonoid f) ∘ FreeMonoid.of) x = (foldlM.mk ∘ flip f) x

tactic: simp only [foldlM.ofFreeMonoid, Function.flip_def, MonoidHom.coe_mk, OneHom.coe_mk,
  Function.comp_apply, FreeMonoid.toList_of, List.foldlM_cons, List.foldlM_nil, bind_pure,
  foldlM.mk, op_inj]
state_before: case h
α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
x : β
⊢ (⇑(foldlM.ofFreeMonoid f) ∘ FreeMonoid.of) x = (foldlM.mk ∘ flip f) x
state_after: case h
α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
x : β
⊢ (fun a => f a x) = fun a => f a x

tactic: rfl
state_before: case h
α β γ : Type u
t : Type u → Type u
inst✝³ : Traversable t
inst✝² : LawfulTraversable t
m : Type u → Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m α
x : β
⊢ (fun a => f a x) = fun a => f a x
state_after: no goals
Theorem: Num.cmp_swap
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases m <;> cases n <;> try { rfl }
state_before: α : Type u_1
m n : Num
⊢ (m.cmp n).swap = n.cmp m
state_after: case pos.pos
α : Type u_1
a✝¹ a✝ : PosNum
⊢ ((pos a✝¹).cmp (pos a✝)).swap = (pos a✝).cmp (pos a✝¹)

tactic: apply PosNum.cmp_swap
state_before: case pos.pos
α : Type u_1
a✝¹ a✝ : PosNum
⊢ ((pos a✝¹).cmp (pos a✝)).swap = (pos a✝).cmp (pos a✝¹)
state_after: no goals

tactic: rfl
state_before: case pos.zero
α : Type u_1
a✝ : PosNum
⊢ ((pos a✝).cmp zero).swap = zero.cmp (pos a✝)
state_after: no goals
Theorem: NormedSpace.exp_unop
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: simp_rw [exp, expSeries_sum_eq, ← MulOpposite.unop_pow, ← MulOpposite.unop_smul, tsum_unop]
state_before: 𝕂 : Type u_1
𝔸 : Type u_2
inst✝⁵ : Field 𝕂
inst✝⁴ : Ring 𝔸
inst✝³ : Algebra 𝕂 𝔸
inst✝² : TopologicalSpace 𝔸
inst✝¹ : TopologicalRing 𝔸
inst✝ : T2Space 𝔸
x : 𝔸ᵐᵒᵖ
⊢ exp 𝕂 (MulOpposite.unop x) = MulOpposite.unop (exp 𝕂 x)
state_after: no goals
Theorem: LieSubmodule.map_comap_incl
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: rw [← coe_toSubmodule_eq_iff]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
f : M →ₗ⁅R,L⁆ M₂
⊢ map N.incl (comap N.incl N') = N ⊓ N'
state_after: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
f : M →ₗ⁅R,L⁆ M₂
⊢ ↑(map N.incl (comap N.incl N')) = ↑(N ⊓ N')

tactic: exact (N : Submodule R M).map_comap_subtype N'
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
f : M →ₗ⁅R,L⁆ M₂
⊢ ↑(map N.incl (comap N.incl N')) = ↑(N ⊓ N')
state_after: no goals