1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.BinaryBiconeMorphism.ext
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: cases f
state_before: J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q : C
c c' : BinaryBicone P Q
f g : c ⟶ c'
w : f.hom = g.hom
⊢ f = g
state_after: case mk
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q : C
c c' : BinaryBicone P Q
g : c ⟶ c'
hom✝ : c.pt ⟶ c'.pt
wfst✝ : hom✝ ≫ c'.fst = c.fst
wsnd✝ : hom✝ ≫ c'.snd = c.snd
winl✝ : c.inl ≫ hom✝ = c'.inl
winr✝ : c.inr ≫ hom✝ = c'.inr
w : { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }.hom = g.hom
⊢ { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ } = g

tactic: cases g
state_before: case mk
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q : C
c c' : BinaryBicone P Q
g : c ⟶ c'
hom✝ : c.pt ⟶ c'.pt
wfst✝ : hom✝ ≫ c'.fst = c.fst
wsnd✝ : hom✝ ≫ c'.snd = c.snd
winl✝ : c.inl ≫ hom✝ = c'.inl
winr✝ : c.inr ≫ hom✝ = c'.inr
w : { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }.hom = g.hom
⊢ { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ } = g
state_after: case mk.mk
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q : C
c c' : BinaryBicone P Q
hom✝¹ : c.pt ⟶ c'.pt
wfst✝¹ : hom✝¹ ≫ c'.fst = c.fst
wsnd✝¹ : hom✝¹ ≫ c'.snd = c.snd
winl✝¹ : c.inl ≫ hom✝¹ = c'.inl
winr✝¹ : c.inr ≫ hom✝¹ = c'.inr
hom✝ : c.pt ⟶ c'.pt
wfst✝ : hom✝ ≫ c'.fst = c.fst
wsnd✝ : hom✝ ≫ c'.snd = c.snd
winl✝ : c.inl ≫ hom✝ = c'.inl
winr✝ : c.inr ≫ hom✝ = c'.inr
w :
  { hom := hom✝¹, wfst := wfst✝¹, wsnd := wsnd✝¹, winl := winl✝¹, winr := winr✝¹ }.hom =
    { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }.hom
⊢ { hom := hom✝¹, wfst := wfst✝¹, wsnd := wsnd✝¹, winl := winl✝¹, winr := winr✝¹ } =
    { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }

tactic: congr
state_before: case mk.mk
J : Type w
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
P Q : C
c c' : BinaryBicone P Q
hom✝¹ : c.pt ⟶ c'.pt
wfst✝¹ : hom✝¹ ≫ c'.fst = c.fst
wsnd✝¹ : hom✝¹ ≫ c'.snd = c.snd
winl✝¹ : c.inl ≫ hom✝¹ = c'.inl
winr✝¹ : c.inr ≫ hom✝¹ = c'.inr
hom✝ : c.pt ⟶ c'.pt
wfst✝ : hom✝ ≫ c'.fst = c.fst
wsnd✝ : hom✝ ≫ c'.snd = c.snd
winl✝ : c.inl ≫ hom✝ = c'.inl
winr✝ : c.inr ≫ hom✝ = c'.inr
w :
  { hom := hom✝¹, wfst := wfst✝¹, wsnd := wsnd✝¹, winl := winl✝¹, winr := winr✝¹ }.hom =
    { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }.hom
⊢ { hom := hom✝¹, wfst := wfst✝¹, wsnd := wsnd✝¹, winl := winl✝¹, winr := winr✝¹ } =
    { hom := hom✝, wfst := wfst✝, wsnd := wsnd✝, winl := winl✝, winr := winr✝ }
state_after: no goals
Theorem: Computability.decode_encodeNat
File: Mathlib/Computability/Encoding.lean

tactic: intro n
state_before: ⊢ ∀ (n : ℕ), decodeNat (encodeNat n) = n
state_after: n : ℕ
⊢ decodeNat (encodeNat n) = n

tactic: conv_rhs => rw [← Num.to_of_nat n]
state_before: n : ℕ
⊢ decodeNat (encodeNat n) = n
state_after: n : ℕ
⊢ decodeNat (encodeNat n) = ↑↑n

tactic: exact congr_arg ((↑) : Num → ℕ) (decode_encodeNum n)
state_before: n : ℕ
⊢ decodeNat (encodeNat n) = ↑↑n
state_after: no goals
Theorem: IsAdjoinRoot.aequiv_symm
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: ext
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
⊢ (h.aequiv h').symm = h'.aequiv h
state_after: case h
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
a✝ : T
⊢ (h.aequiv h').symm a✝ = (h'.aequiv h) a✝

tactic: rfl
state_before: case h
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
h' : IsAdjoinRoot T f
a✝ : T
⊢ (h.aequiv h').symm a✝ = (h'.aequiv h) a✝
state_after: no goals
Theorem: Nat.digits_getLast
File: Mathlib/Data/Nat/Digits.lean

tactic: by_cases hm : m = 0
state_before: n b m : ℕ
h : 1 < b
p : b.digits m ≠ []
q : b.digits (m / b) ≠ []
⊢ (b.digits m).getLast p = (b.digits (m / b)).getLast q
state_after: case pos
n b m : ℕ
h : 1 < b
p : b.digits m ≠ []
q : b.digits (m / b) ≠ []
hm : m = 0
⊢ (b.digits m).getLast p = (b.digits (m / b)).getLast q

case neg
n b m : ℕ
h : 1 < b
p : b.digits m ≠ []
q : b.digits (m / b) ≠ []
hm : ¬m = 0
⊢ (b.digits m).getLast p = (b.digits (m / b)).getLast q

tactic: simp only [digits_eq_cons_digits_div h hm]
state_before: case neg
n b m : ℕ
h : 1 < b
p : b.digits m ≠ []
q : b.digits (m / b) ≠ []
hm : ¬m = 0
⊢ (b.digits m).getLast p = (b.digits (m / b)).getLast q
state_after: case neg
n b m : ℕ
h : 1 < b
p : b.digits m ≠ []
q : b.digits (m / b) ≠ []
hm : ¬m = 0
⊢ (m % b :: b.digits (m / b)).getLast ⋯ = (b.digits (m / b)).getLast q

tactic: rw [List.getLast_cons]
state_before: case neg
n b m : ℕ
h : 1 < b
p : b.digits m ≠ []
q : b.digits (m / b) ≠ []
hm : ¬m = 0
⊢ (m % b :: b.digits (m / b)).getLast ⋯ = (b.digits (m / b)).getLast q
state_after: no goals

tactic: simp [hm]
state_before: case pos
n b m : ℕ
h : 1 < b
p : b.digits m ≠ []
q : b.digits (m / b) ≠ []
hm : m = 0
⊢ (b.digits m).getLast p = (b.digits (m / b)).getLast q
state_after: no goals
Theorem: Associates.factors_mono
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [eq, factors_mul]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
s t : Associates α
d : Associates α
eq : t = s * d
⊢ s.factors ≤ t.factors
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
s t : Associates α
d : Associates α
eq : t = s * d
⊢ s.factors ≤ s.factors + d.factors

tactic: exact le_add_of_nonneg_right bot_le
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
s t : Associates α
d : Associates α
eq : t = s * d
⊢ s.factors ≤ s.factors + d.factors
state_after: no goals
Theorem: MeasureTheory.snorm_condexpL2_le
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean

tactic: rw [lpMeas_coe, ← ENNReal.toReal_le_toReal (Lp.snorm_ne_top _) (Lp.snorm_ne_top _), ←
  Lp.norm_def, ← Lp.norm_def, Submodule.norm_coe]
state_before: α : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹³ : RCLike 𝕜
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : InnerProductSpace 𝕜 E
inst✝¹⁰ : CompleteSpace E
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : InnerProductSpace 𝕜 E'
inst✝⁷ : CompleteSpace E'
inst✝⁶ : NormedSpace ℝ E'
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace ℝ G'
inst✝ : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hm : m ≤ m0
f : ↥(Lp E 2 μ)
⊢ snorm (↑↑↑((condexpL2 E 𝕜 hm) f)) 2 μ ≤ snorm (↑↑f) 2 μ
state_after: α : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹³ : RCLike 𝕜
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : InnerProductSpace 𝕜 E
inst✝¹⁰ : CompleteSpace E
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : InnerProductSpace 𝕜 E'
inst✝⁷ : CompleteSpace E'
inst✝⁶ : NormedSpace ℝ E'
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace ℝ G'
inst✝ : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hm : m ≤ m0
f : ↥(Lp E 2 μ)
⊢ ‖(condexpL2 E 𝕜 hm) f‖ ≤ ‖f‖

tactic: exact norm_condexpL2_le hm f
state_before: α : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹³ : RCLike 𝕜
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : InnerProductSpace 𝕜 E
inst✝¹⁰ : CompleteSpace E
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : InnerProductSpace 𝕜 E'
inst✝⁷ : CompleteSpace E'
inst✝⁶ : NormedSpace ℝ E'
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace ℝ G'
inst✝ : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
hm : m ≤ m0
f : ↥(Lp E 2 μ)
⊢ ‖(condexpL2 E 𝕜 hm) f‖ ≤ ‖f‖
state_after: no goals
Theorem: lineMap_strict_mono_right
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: simp only [lineMap_apply_module]
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
hb : b < b'
hr : 0 < r
⊢ (lineMap a b) r < (lineMap a b') r
state_after: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
hb : b < b'
hr : 0 < r
⊢ (1 - r) • a + r • b < (1 - r) • a + r • b'

tactic: exact add_lt_add_left (smul_lt_smul_of_pos_left hb hr) _
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
hb : b < b'
hr : 0 < r
⊢ (1 - r) • a + r • b < (1 - r) • a + r • b'
state_after: no goals
Theorem: Filter.limsup_compl
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [limsup_eq_iInf_iSup, compl_iInf, compl_iSup, liminf_eq_iSup_iInf, Function.comp_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
⊢ (limsup u f)ᶜ = liminf (compl ∘ u) f
state_after: no goals
Theorem: MeasureTheory.LocallyIntegrable.aestronglyMeasurable
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

tactic: simpa only [restrict_univ] using (locallyIntegrableOn_univ.mpr hf).aestronglyMeasurable
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁶ : MeasurableSpace X
inst✝⁵ : TopologicalSpace X
inst✝⁴ : MeasurableSpace Y
inst✝³ : TopologicalSpace Y
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
inst✝ : SecondCountableTopology X
hf : LocallyIntegrable f μ
⊢ AEStronglyMeasurable f μ
state_after: no goals
Theorem: CategoryTheory.Limits.biproduct.matrix_map
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✝ : Finite K
f : J → C
g h : K → C
m : (j : J) → (k : K) → f j ⟶ g k
n : (k : K) → g k ⟶ h k
⊢ matrix m ≫ map n = matrix fun j k => m j k ≫ n k
state_after: case w.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✝ : Finite K
f : J → C
g h : K → C
m : (j : J) → (k : K) → f j ⟶ g k
n : (k : K) → g k ⟶ h k
j✝¹ : K
j✝ : J
⊢ ι f j✝ ≫ (matrix m ≫ map n) ≫ π h j✝¹ = ι f j✝ ≫ (matrix fun j k => m j k ≫ n k) ≫ π h j✝¹

tactic: simp
state_before: case w.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✝ : Finite K
f : J → C
g h : K → C
m : (j : J) → (k : K) → f j ⟶ g k
n : (k : K) → g k ⟶ h k
j✝¹ : K
j✝ : J
⊢ ι f j✝ ≫ (matrix m ≫ map n) ≫ π h j✝¹ = ι f j✝ ≫ (matrix fun j k => m j k ≫ n k) ≫ π h j✝¹
state_after: no goals
Theorem: inner_orthogonalProjection_left_eq_right
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [← inner_orthogonalProjection_eq_of_mem_left, inner_orthogonalProjection_eq_of_mem_right]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
u v : E
⊢ ⟪↑((orthogonalProjection K) u), v⟫_𝕜 = ⟪u, ↑((orthogonalProjection K) v)⟫_𝕜
state_after: no goals
Theorem: Set.countable_insert
File: Mathlib/Data/Set/Countable.lean

tactic: simp only [insert_eq, countable_union, countable_singleton, true_and_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
a : α
⊢ (insert a s).Countable ↔ s.Countable
state_after: no goals
Theorem: WithTop.image_coe_Iic
File: Mathlib/Order/Interval/Set/WithBotTop.lean

tactic: rw [← preimage_coe_Iic, image_preimage_eq_inter_range, range_coe,
  inter_eq_self_of_subset_left (Iic_subset_Iio.2 <| coe_lt_top a)]
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some '' Iic a = Iic ↑a
state_after: no goals
Theorem: DomMulAct.smul_Lp_add
File: Mathlib/MeasureTheory/Function/LpSpace/DomAct/Basic.lean

tactic: rintro ⟨⟨⟩, _⟩ ⟨⟨⟩, _⟩
state_before: M : Type u_1
N : Type u_2
α : Type u_3
E : Type u_4
inst✝⁶ : MeasurableSpace M
inst✝⁵ : MeasurableSpace N
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : SMul M α
inst✝¹ : SMulInvariantMeasure M α μ
inst✝ : MeasurableSMul M α
c : Mᵈᵐᵃ
⊢ ∀ (f g : ↥(Lp E p μ)), c • (f + g) = c • f + c • g
state_after: case mk.mk.mk.mk
M : Type u_1
N : Type u_2
α : Type u_3
E : Type u_4
inst✝⁶ : MeasurableSpace M
inst✝⁵ : MeasurableSpace N
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : SMul M α
inst✝¹ : SMulInvariantMeasure M α μ
inst✝ : MeasurableSMul M α
c : Mᵈᵐᵃ
val✝¹ : α →ₘ[μ] E
a✝¹ : { f // AEStronglyMeasurable f μ }
property✝¹ : Quot.mk Setoid.r a✝¹ ∈ Lp E p μ
val✝ : α →ₘ[μ] E
a✝ : { f // AEStronglyMeasurable f μ }
property✝ : Quot.mk Setoid.r a✝ ∈ Lp E p μ
⊢ c • (⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + ⟨Quot.mk Setoid.r a✝, property✝⟩) =
    c • ⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + c • ⟨Quot.mk Setoid.r a✝, property✝⟩

tactic: rfl
state_before: case mk.mk.mk.mk
M : Type u_1
N : Type u_2
α : Type u_3
E : Type u_4
inst✝⁶ : MeasurableSpace M
inst✝⁵ : MeasurableSpace N
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : SMul M α
inst✝¹ : SMulInvariantMeasure M α μ
inst✝ : MeasurableSMul M α
c : Mᵈᵐᵃ
val✝¹ : α →ₘ[μ] E
a✝¹ : { f // AEStronglyMeasurable f μ }
property✝¹ : Quot.mk Setoid.r a✝¹ ∈ Lp E p μ
val✝ : α →ₘ[μ] E
a✝ : { f // AEStronglyMeasurable f μ }
property✝ : Quot.mk Setoid.r a✝ ∈ Lp E p μ
⊢ c • (⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + ⟨Quot.mk Setoid.r a✝, property✝⟩) =
    c • ⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + c • ⟨Quot.mk Setoid.r a✝, property✝⟩
state_after: no goals
Theorem: lowerSemicontinuous_iff_le_liminf
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp only [← lowerSemicontinuousAt_iff_le_liminf, LowerSemicontinuous]
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
β : Type u_2
inst✝² : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝¹ : CompleteLinearOrder γ
inst✝ : DenselyOrdered γ
f : α → γ
⊢ LowerSemicontinuous f ↔ ∀ (x : α), f x ≤ liminf f (𝓝 x)
state_after: no goals
Theorem: SymAlg.mul_comm
File: Mathlib/Algebra/Symmetrized.lean

tactic: rw [mul_def, mul_def, add_comm]
state_before: α : Type u_1
inst✝⁴ : Mul α
inst✝³ : AddCommSemigroup α
inst✝² : One α
inst✝¹ : OfNat α 2
inst✝ : Invertible 2
a b : αˢʸᵐ
⊢ a * b = b * a
state_after: no goals
Theorem: VitaliFamily.eventually_filterAt_measurableSet
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: filter_upwards [v.eventually_filterAt_mem_setsAt x] with _ ha using v.measurableSet _ _ ha
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
⊢ ∀ᶠ (a : Set α) in v.filterAt x, MeasurableSet a
state_after: no goals
Theorem: integral_gaussian_Ioi
File: Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean

tactic: rcases le_or_lt b 0 with (hb | hb)
state_before: b : ℝ
⊢ ∫ (x : ℝ) in Ioi 0, rexp (-b * x ^ 2) = √(π / b) / 2
state_after: case inl
b : ℝ
hb : b ≤ 0
⊢ ∫ (x : ℝ) in Ioi 0, rexp (-b * x ^ 2) = √(π / b) / 2

case inr
b : ℝ
hb : 0 < b
⊢ ∫ (x : ℝ) in Ioi 0, rexp (-b * x ^ 2) = √(π / b) / 2

tactic: rw [← RCLike.ofReal_inj (K := ℂ), ← integral_ofReal, ← RCLike.algebraMap_eq_ofReal,
  coe_algebraMap]
state_before: case inr
b : ℝ
hb : 0 < b
⊢ ∫ (x : ℝ) in Ioi 0, rexp (-b * x ^ 2) = √(π / b) / 2
state_after: case inr
b : ℝ
hb : 0 < b
⊢ ∫ (x : ℝ) in Ioi 0, ↑(rexp (-b * x ^ 2)) = ↑(√(π / b) / 2)

tactic: convert integral_gaussian_complex_Ioi (by rwa [ofReal_re] : 0 < (b : ℂ).re)
state_before: case inr
b : ℝ
hb : 0 < b
⊢ ∫ (x : ℝ) in Ioi 0, ↑(rexp (-b * x ^ 2)) = ↑(√(π / b) / 2)
state_after: case h.e'_2.h.e'_7.h
b : ℝ
hb : 0 < b
x✝ : ℝ
⊢ ↑(rexp (-b * x✝ ^ 2)) = cexp (-↑b * ↑x✝ ^ 2)

case h.e'_3
b : ℝ
hb : 0 < b
⊢ ↑(√(π / b) / 2) = (↑π / ↑b) ^ (1 / 2) / 2

tactic: rw [integral_undef, sqrt_eq_zero_of_nonpos, zero_div]
state_before: case inl
b : ℝ
hb : b ≤ 0
⊢ ∫ (x : ℝ) in Ioi 0, rexp (-b * x ^ 2) = √(π / b) / 2
state_after: case inl
b : ℝ
hb : b ≤ 0
⊢ π / b ≤ 0

case inl
b : ℝ
hb : b ≤ 0
⊢ ¬Integrable (fun x => rexp (-b * x ^ 2)) (volume.restrict (Ioi 0))

tactic: exact div_nonpos_of_nonneg_of_nonpos pi_pos.le hb
state_before: case inl
b : ℝ
hb : b ≤ 0
⊢ π / b ≤ 0
state_after: no goals

tactic: rwa [← IntegrableOn, integrableOn_Ioi_exp_neg_mul_sq_iff, not_lt]
state_before: case inl
b : ℝ
hb : b ≤ 0
⊢ ¬Integrable (fun x => rexp (-b * x ^ 2)) (volume.restrict (Ioi 0))
state_after: no goals

tactic: rwa [ofReal_re]
state_before: b : ℝ
hb : 0 < b
⊢ 0 < (↑b).re
state_after: no goals

tactic: simp
state_before: case h.e'_2.h.e'_7.h
b : ℝ
hb : 0 < b
x✝ : ℝ
⊢ ↑(rexp (-b * x✝ ^ 2)) = cexp (-↑b * ↑x✝ ^ 2)
state_after: no goals

tactic: rw [sqrt_eq_rpow, ← ofReal_div, ofReal_div, ofReal_cpow]
state_before: case h.e'_3
b : ℝ
hb : 0 < b
⊢ ↑(√(π / b) / 2) = (↑π / ↑b) ^ (1 / 2) / 2
state_after: case h.e'_3
b : ℝ
hb : 0 < b
⊢ ↑(π / b) ^ ↑(1 / 2) / ↑2 = ↑(π / b) ^ (1 / 2) / 2

case h.e'_3.hx
b : ℝ
hb : 0 < b
⊢ 0 ≤ π / b

tactic: norm_num
state_before: case h.e'_3
b : ℝ
hb : 0 < b
⊢ ↑(π / b) ^ ↑(1 / 2) / ↑2 = ↑(π / b) ^ (1 / 2) / 2
state_after: no goals

tactic: exact (div_pos pi_pos hb).le
state_before: case h.e'_3.hx
b : ℝ
hb : 0 < b
⊢ 0 ≤ π / b
state_after: no goals
Theorem: Nat.factorization_mul_apply_of_coprime
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp only [← factors_count_eq, perm_iff_count.mp (perm_factors_mul_of_coprime hab), count_append]
state_before: a✝ b✝ m n p✝ p a b : ℕ
hab : a.Coprime b
⊢ (a * b).factorization p = a.factorization p + b.factorization p
state_after: no goals
Theorem: CategoryTheory.ShortComplex.RightHomologyData.pOpcycles_comp_opcyclesIso_hom
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

tactic: simp only [← h.p_comp_opcyclesIso_inv, assoc, Iso.inv_hom_id, comp_id]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
inst✝ : S.HasRightHomology
⊢ S.pOpcycles ≫ h.opcyclesIso.hom = h.p
state_after: no goals
Theorem: generateFrom_eq_pi
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: simp only [← funext hC, generateFrom_pi_eq h2C]
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝¹ : Finite ι
inst✝ : Finite ι'
h : (i : ι) → MeasurableSpace (α i)
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), generateFrom (C i) = h i
h2C : ∀ (i : ι), IsCountablySpanning (C i)
⊢ generateFrom (univ.pi '' univ.pi C) = MeasurableSpace.pi
state_after: no goals
Theorem: bddBelow_upperClosure
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [BddBelow, lowerBounds_upperClosure]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x : α
⊢ BddBelow ↑(upperClosure s) ↔ BddBelow s
state_after: no goals
Theorem: MulChar.IsQuadratic.pow_even
File: Mathlib/NumberTheory/MulChar/Basic.lean

tactic: obtain ⟨n, rfl⟩ := even_iff_two_dvd.mp hn
state_before: R : Type u_1
inst✝² : CommMonoid R
R' : Type u_2
inst✝¹ : CommRing R'
R'' : Type u_3
inst✝ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
n : ℕ
hn : Even n
⊢ χ ^ n = 1
state_after: case intro
R : Type u_1
inst✝² : CommMonoid R
R' : Type u_2
inst✝¹ : CommRing R'
R'' : Type u_3
inst✝ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
n : ℕ
hn : Even (2 * n)
⊢ χ ^ (2 * n) = 1

tactic: rw [pow_mul, hχ.sq_eq_one, one_pow]
state_before: case intro
R : Type u_1
inst✝² : CommMonoid R
R' : Type u_2
inst✝¹ : CommRing R'
R'' : Type u_3
inst✝ : CommRing R''
χ : MulChar R R'
hχ : χ.IsQuadratic
n : ℕ
hn : Even (2 * n)
⊢ χ ^ (2 * n) = 1
state_after: no goals
Theorem: Multiset.Ico_filter_le
File: Mathlib/Order/Interval/Multiset.lean

tactic: rw [Ico, Ico, ← Finset.filter_val, Finset.Ico_filter_le]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c✝ d a b c : α
⊢ filter (fun x => c ≤ x) (Ico a b) = Ico (max a c) b
state_after: no goals
Theorem: Int.floor_sub_nat
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← Int.cast_natCast, floor_sub_int]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
n : ℕ
⊢ ⌊a - ↑n⌋ = ⌊a⌋ - ↑n
state_after: no goals
Theorem: Multiset.dvd_prod
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

tactic: simpa using List.dvd_prod h
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
l : List α
a : α
h : a ∈ ⟦l⟧
⊢ a ∣ prod ⟦l⟧
state_after: no goals
Theorem: pow_bit0_pos_iff
File: Mathlib/Algebra/Order/Ring/Basic.lean

tactic: simpa [bit0]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a✝ b : R
m n✝ : ℕ
inst✝ : ExistsAddOfLE R
a : R
n : ℕ
hn : n ≠ 0
⊢ bit0 n ≠ 0
state_after: no goals
Theorem: tendstoUniformlyOn_singleton_iff_tendsto
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp_rw [tendstoUniformlyOn_iff_tendsto, Uniform.tendsto_nhds_right, tendsto_def]
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 {x} ↔ Tendsto (fun n => F n x) p (𝓝 (f x))
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ (∀ s ∈ 𝓤 β, (fun q => (f q.2, F q.1 q.2)) ⁻¹' s ∈ p ×ˢ 𝓟 {x}) ↔ ∀ s ∈ 𝓤 β, (fun x_1 => (f x, F x_1 x)) ⁻¹' s ∈ p

tactic: exact forall₂_congr fun u _ => by simp [mem_prod_principal, preimage]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ (∀ s ∈ 𝓤 β, (fun q => (f q.2, F q.1 q.2)) ⁻¹' s ∈ p ×ˢ 𝓟 {x}) ↔ ∀ s ∈ 𝓤 β, (fun x_1 => (f x, F x_1 x)) ⁻¹' s ∈ p
state_after: no goals

tactic: simp [mem_prod_principal, preimage]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
u : Set (β × β)
x✝ : u ∈ 𝓤 β
⊢ (fun q => (f q.2, F q.1 q.2)) ⁻¹' u ∈ p ×ˢ 𝓟 {x} ↔ (fun x_1 => (f x, F x_1 x)) ⁻¹' u ∈ p
state_after: no goals
Theorem: Primrec.id
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
⊢ ∀ (n : ℕ), encode (decode n) = encode (Option.map id (decode n))
state_after: no goals