ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Relation.reflTransGen_iff_eq_or_transGen
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
⊢ ReflTransGen r a b ↔ b = a ∨ TransGen r a b
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : ReflTransGen r a b
⊢ b = a ∨ TransGen r a b

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : b = a ∨ TransGen r a b
⊢ ReflTransGen r a b
tactic: refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
Theorem: Ordinal.nmul_one
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ a ⨳ 1 = a
state_after: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ sInf {c | ∀ a' < a, ∀ b' < 1, a' ⨳ 1 ♯ a ⨳ b' < c ♯ a' ⨳ b'} = a
tactic: rw [nmul]
state_before: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ sInf {c | ∀ a' < a, ∀ b' < 1, a' ⨳ 1 ♯ a ⨳ b' < c ♯ a' ⨳ b'} = a
state_after: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ sInf {c | ∀ a' < a, a' ⨳ 1 < c} = a
tactic: simp only [lt_one_iff_zero, forall_eq, nmul_zero, nadd_zero]
state_before: a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ sInf {c | ∀ a' < a, a' ⨳ 1 < c} = a
state_after: case h.e'_2.h.e'_3
a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ {c | ∀ a' < a, a' ⨳ 1 < c} = Set.Ici a
tactic: convert csInf_Ici (α := Ordinal)
state_before: case h.e'_2.h.e'_3
a✝ b c d : Ordinal.{u}
a : Ordinal.{u_1}
⊢ {c | ∀ a' < a, a' ⨳ 1 < c} = Set.Ici a
state_after: case h.e'_2.h.e'_3.h
a✝ b✝ c d : Ordinal.{u}
a b : Ordinal.{u_1}
⊢ b ∈ {c | ∀ a' < a, a' ⨳ 1 < c} ↔ b ∈ Set.Ici a
tactic: ext b
state_before: case h.e'_2.h.e'_3.h
a✝ b✝ c d : Ordinal.{u}
a b : Ordinal.{u_1}
⊢ b ∈ {c | ∀ a' < a, a' ⨳ 1 < c} ↔ b ∈ Set.Ici a
state_after: case h.e'_2.h.e'_3.h
a✝ b✝ c d : Ordinal.{u}
a b : Ordinal.{u_1}
⊢ (∀ a' < a, a' ⨳ 1 < b) ↔ a ≤ b
tactic: simp only [Set.mem_setOf_eq, Set.mem_Ici]
state_before: case h.e'_2.h.e'_3.h
a✝ b✝ c d : Ordinal.{u}
a b : Ordinal.{u_1}
⊢ (∀ a' < a, a' ⨳ 1 < b) ↔ a ≤ b
state_after: case h.e'_2.h.e'_3.h.refine_1
a✝ b✝ c✝ d : Ordinal.{u}
a b : Ordinal.{u_1}
H : ∀ a' < a, a' ⨳ 1 < b
c : Ordinal.{u_1}
hc : c < a
⊢ c < b

case h.e'_2.h.e'_3.h.refine_2
a✝ b✝ c✝ d : Ordinal.{u}
a b : Ordinal.{u_1}
ha : a ≤ b
c : Ordinal.{u_1}
hc : c < a
⊢ c ⨳ 1 < b
tactic: refine ⟨fun H => le_of_forall_lt fun c hc => ?_, fun ha c hc => ?_⟩
Theorem: ProbabilityTheory.Kernel.compProdFun_tsum_left
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : Kernel α β
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel κ
a : α
s : Set (β × γ)
⊢ κ.compProdFun η a s = ∑' (n : ℕ), (κ.seq n).compProdFun η a s
state_after: no goals
tactic: simp_rw [compProdFun, (measure_sum_seq κ _).symm, lintegral_sum_measure]
Theorem: Rat.mul_add
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q a b c : ℚ
⊢ a * (b + c) = a * b + a * c
state_after: no goals
tactic: rw [Rat.mul_comm, Rat.add_mul, Rat.mul_comm, Rat.mul_comm c a]
Theorem: Filter.blimsup_eq_limsup
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u : β → α
p : β → Prop
⊢ blimsup u f p = limsup u (f ⊓ 𝓟 {x | p x})
state_after: no goals
tactic: simp only [blimsup_eq, limsup_eq, eventually_inf_principal, mem_setOf_eq]
Theorem: Real.tan_add
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: x y : ℝ
h :
  ((∀ (k : ℤ), x ≠ (2 * ↑k + 1) * π / 2) ∧ ∀ (l : ℤ), y ≠ (2 * ↑l + 1) * π / 2) ∨
    (∃ k, x = (2 * ↑k + 1) * π / 2) ∧ ∃ l, y = (2 * ↑l + 1) * π / 2
⊢ tan (x + y) = (tan x + tan y) / (1 - tan x * tan y)
state_after: no goals
tactic: simpa only [← Complex.ofReal_inj, Complex.ofReal_sub, Complex.ofReal_add, Complex.ofReal_div,
    Complex.ofReal_mul, Complex.ofReal_tan] using
    @Complex.tan_add (x : ℂ) (y : ℂ) (by convert h <;> norm_cast)
Theorem: MeasureTheory.AEEqFun.coeFn_pair
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : α →ₘ[μ] γ
⊢ ↑(f.pair g) =ᶠ[ae μ] fun x => (↑f x, ↑g x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : α →ₘ[μ] γ
⊢ ↑(mk (fun x => (↑f x, ↑g x)) ⋯) =ᶠ[ae μ] fun x => (↑f x, ↑g x)
tactic: rw [pair_eq_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : α →ₘ[μ] γ
⊢ ↑(mk (fun x => (↑f x, ↑g x)) ⋯) =ᶠ[ae μ] fun x => (↑f x, ↑g x)
state_after: no goals
tactic: apply coeFn_mk
Theorem: dist_lineMap_lineMap
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

Proof steps:
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c₁ c₂ : 𝕜
⊢ dist ((lineMap p₁ p₂) c₁) ((lineMap p₁ p₂) c₂) = dist c₁ c₂ * dist p₁ p₂
state_after: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c₁ c₂ : 𝕜
⊢ dist ((lineMap p₁ p₂) c₁) ((lineMap p₁ p₂) c₂) = dist c₁ c₂ * dist p₂ p₁
tactic: rw [dist_comm p₁ p₂]
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c₁ c₂ : 𝕜
⊢ dist ((lineMap p₁ p₂) c₁) ((lineMap p₁ p₂) c₂) = dist c₁ c₂ * dist p₂ p₁
state_after: no goals
tactic: simp only [lineMap_apply, dist_eq_norm_vsub, vadd_vsub_vadd_cancel_right,
    ← sub_smul, norm_smul, vsub_eq_sub]
Theorem: CategoryTheory.Limits.biproduct.whiskerEquiv_hom_eq_lift
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
⊢ g (e (e.symm k)) = g k
state_after: no goals
tactic: simp
state_before: J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
⊢ (whiskerEquiv e w).hom = lift fun k => π f (e.symm k) ≫ (w (e.symm k)).inv ≫ eqToHom ⋯
state_after: J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
⊢ (desc fun j => (w j).inv ≫ ι g (e j)) = lift fun k => π f (e.symm k) ≫ (w (e.symm k)).inv ≫ eqToHom ⋯
tactic: simp only [whiskerEquiv_hom]
state_before: J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
⊢ (desc fun j => (w j).inv ≫ ι g (e j)) = lift fun k => π f (e.symm k) ≫ (w (e.symm k)).inv ≫ eqToHom ⋯
state_after: case w.w
J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
⊢ ι f j ≫ (desc fun j => (w j).inv ≫ ι g (e j)) ≫ π g k =
    ι f j ≫ (lift fun k => π f (e.symm k) ≫ (w (e.symm k)).inv ≫ eqToHom ⋯) ≫ π g k
tactic: ext k j
state_before: case w.w
J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
⊢ ι f j ≫ (desc fun j => (w j).inv ≫ ι g (e j)) ≫ π g k =
    ι f j ≫ (lift fun k => π f (e.symm k) ≫ (w (e.symm k)).inv ≫ eqToHom ⋯) ≫ π g k
state_after: case pos
J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
h : k = e j
⊢ ι f j ≫ (desc fun j => (w j).inv ≫ ι g (e j)) ≫ π g k =
    ι f j ≫ (lift fun k => π f (e.symm k) ≫ (w (e.symm k)).inv ≫ eqToHom ⋯) ≫ π g k

case neg
J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
j : J
h : ¬k = e j
⊢ ι f j ≫ (desc fun j => (w j).inv ≫ ι g (e j)) ≫ π g k =
    ι f j ≫ (lift fun k => π f (e.symm k) ≫ (w (e.symm k)).inv ≫ eqToHom ⋯) ≫ π g k
tactic: by_cases h : k = e j
Theorem: IsGLB.mul_right
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
s : Set α
ha : 0 ≤ a
hs : IsGLB s b
⊢ IsGLB ((fun b => b * a) '' s) (b * a)
state_after: no goals
tactic: simpa [mul_comm] using hs.mul_left ha
Theorem: MeasureTheory.Measure.addHaar_closedBall_mul
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

Proof steps:
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
hs : 0 ≤ s
⊢ μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (closedBall 0 s)
state_after: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
hs : 0 ≤ s
this : closedBall 0 (r * s) = r • closedBall 0 s
⊢ μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (closedBall 0 s)
tactic: have : closedBall (0 : E) (r * s) = r • closedBall (0 : E) s := by
    simp [smul_closedBall r (0 : E) hs, abs_of_nonneg hr]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
hs : 0 ≤ s
this : closedBall 0 (r * s) = r • closedBall 0 s
⊢ μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (closedBall 0 s)
state_after: no goals
tactic: simp only [this, addHaar_smul, abs_of_nonneg hr, addHaar_closedBall_center, abs_pow]
Theorem: AddAction.set_mem_fixedBy_iff
File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
⊢ s ∈ fixedBy (Set α) g ↔ ∀ (x : α), g • x ∈ s ↔ x ∈ s
state_after: no goals
tactic: simp_rw [mem_fixedBy, ← eq_inv_smul_iff, Set.ext_iff, Set.mem_inv_smul_set_iff, Iff.comm]
Theorem: Batteries.RBNode.DelProp.redred
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: c : RBColor
α✝ : Type u_1
t : RBNode α✝
n : Nat
h : DelProp c t n
⊢ ∃ n', RedRed (c = black) t n'
state_after: c : RBColor
α✝ : Type u_1
t : RBNode α✝
n : Nat
h :
  match c with
  | black => ∃ n', n = n' + 1 ∧ RedRed True t n'
  | red => ∃ c, t.Balanced c n
⊢ ∃ n', RedRed (c = black) t n'
tactic: unfold DelProp at h
state_before: c : RBColor
α✝ : Type u_1
t : RBNode α✝
n : Nat
h :
  match c with
  | black => ∃ n', n = n' + 1 ∧ RedRed True t n'
  | red => ∃ c, t.Balanced c n
⊢ ∃ n', RedRed (c = black) t n'
state_after: no goals
tactic: exact match c, h with
  | red, ⟨_, h⟩ => ⟨_, .balanced h⟩
  | black, ⟨_, _, h⟩ => ⟨_, h.imp fun _ => rfl⟩
Theorem: Nat.coprime_add_self_left
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n : ℕ
⊢ (m + n).Coprime n ↔ m.Coprime n
state_after: no goals
tactic: rw [Coprime, Coprime, gcd_add_self_left]
Theorem: Bornology.isBounded_sUnion
File: Mathlib/Topology/Bornology/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
s : Set α
inst✝ : Bornology α
S : Set (Set α)
hs : S.Finite
⊢ IsBounded (⋃₀ S) ↔ ∀ s ∈ S, IsBounded s
state_after: no goals
tactic: rw [sUnion_eq_biUnion, isBounded_biUnion hs]
Theorem: Polynomial.content_X_pow
File: Mathlib/RingTheory/Polynomial/Content.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
k : ℕ
⊢ (X ^ k).content = 1
state_after: case zero
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
⊢ (X ^ 0).content = 1

case succ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
k : ℕ
hi : (X ^ k).content = 1
⊢ (X ^ (k + 1)).content = 1
tactic: induction' k with k hi
state_before: case succ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
k : ℕ
hi : (X ^ k).content = 1
⊢ (X ^ (k + 1)).content = 1
state_after: no goals
tactic: rw [pow_succ', content_X_mul, hi]
Theorem: ProbabilityTheory.Kernel.iIndep.meas_iInter
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
β : ι → Type u_4
mβ : (i : ι) → MeasurableSpace (β i)
_mα : MeasurableSpace α
m : ι → MeasurableSpace Ω
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
π : ι → Set (Set Ω)
s : ι → Set Ω
S : Finset ι
f : (x : ι) → Ω → β x
inst✝ : Fintype ι
h : iIndep m κ μ
hs : ∀ (i : ι), MeasurableSet (s i)
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i, s i) = ∏ i : ι, (κ a) (s i)
state_after: case h
α : Type u_1
Ω : Type u_2
ι : Type u_3
β : ι → Type u_4
mβ : (i : ι) → MeasurableSpace (β i)
_mα : MeasurableSpace α
m : ι → MeasurableSpace Ω
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
π : ι → Set (Set Ω)
s : ι → Set Ω
S : Finset ι
f : (x : ι) → Ω → β x
inst✝ : Fintype ι
h : iIndep m κ μ
hs : ∀ (i : ι), MeasurableSet (s i)
a : α
ha : (κ a) (⋂ i ∈ Finset.univ, s i) = ∏ i : ι, (κ a) (s i)
⊢ (κ a) (⋂ i, s i) = ∏ i : ι, (κ a) (s i)
tactic: filter_upwards [h.meas_biInter (fun i (_ : i ∈ Finset.univ) ↦ hs _)] with a ha
state_before: case h
α : Type u_1
Ω : Type u_2
ι : Type u_3
β : ι → Type u_4
mβ : (i : ι) → MeasurableSpace (β i)
_mα : MeasurableSpace α
m : ι → MeasurableSpace Ω
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
π : ι → Set (Set Ω)
s : ι → Set Ω
S : Finset ι
f : (x : ι) → Ω → β x
inst✝ : Fintype ι
h : iIndep m κ μ
hs : ∀ (i : ι), MeasurableSet (s i)
a : α
ha : (κ a) (⋂ i ∈ Finset.univ, s i) = ∏ i : ι, (κ a) (s i)
⊢ (κ a) (⋂ i, s i) = ∏ i : ι, (κ a) (s i)
state_after: no goals
tactic: simp [← ha]
Theorem: Int.add_one_le_ceil_iff
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ z + 1 ≤ ⌈a⌉ ↔ ↑z < a
state_after: no goals
tactic: rw [← lt_ceil, add_one_le_iff]
Theorem: Batteries.BinomialHeap.Imp.Heap.WF.tail?
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

Proof steps:
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
tl : Heap α
hwf : WF le n s
⊢ Heap.tail? le s = some tl → WF le 0 tl
state_after: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
tl : Heap α
hwf : WF le n s
⊢ Option.map (fun x => x.snd) (Heap.deleteMin le s) = some tl → WF le 0 tl
tactic: simp only [Heap.tail?]
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
tl : Heap α
hwf : WF le n s
⊢ Option.map (fun x => x.snd) (Heap.deleteMin le s) = some tl → WF le 0 tl
state_after: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
tl : Heap α
hwf : WF le n s
eq : Option.map (fun x => x.snd) (Heap.deleteMin le s) = some tl
⊢ WF le 0 tl
tactic: intro eq
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
tl : Heap α
hwf : WF le n s
eq : Option.map (fun x => x.snd) (Heap.deleteMin le s) = some tl
⊢ WF le 0 tl
state_after: no goals
tactic: match eq₂ : s.deleteMin le, eq with
  | some (a, tl), rfl => exact hwf.deleteMin eq₂
Theorem: Nat.Primrec'.prec'
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: n : ℕ
f g : Vector ℕ n → ℕ
h : Vector ℕ (n + 2) → ℕ
hf : Primrec' f
hg : Primrec' g
hh : Primrec' h
⊢ Primrec' fun v => Nat.rec (g v) (fun y IH => h (y ::ᵥ IH ::ᵥ v)) (f v)
state_after: no goals
tactic: simpa using comp' (prec hg hh) (hf.cons idv)
Theorem: sdiff_inf_sdiff
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ ⊥ = x ⊓ y ⊓ x \ y
state_after: no goals
tactic: rw [inf_inf_sdiff]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ y ⊓ x \ y = x ⊓ (y ⊓ x ⊔ y \ x) ⊓ x \ y
state_after: no goals
tactic: rw [sup_inf_sdiff]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ (y ⊓ x ⊔ y \ x) ⊓ x \ y = (x ⊓ (y ⊓ x) ⊔ x ⊓ y \ x) ⊓ x \ y
state_after: no goals
tactic: rw [inf_sup_left]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (x ⊓ (y ⊓ x) ⊔ x ⊓ y \ x) ⊓ x \ y = (y ⊓ (x ⊓ x) ⊔ x ⊓ y \ x) ⊓ x \ y
state_after: no goals
tactic: ac_rfl
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (y ⊓ (x ⊓ x) ⊔ x ⊓ y \ x) ⊓ x \ y = (y ⊓ x ⊔ x ⊓ y \ x) ⊓ x \ y
state_after: no goals
tactic: rw [inf_idem]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (y ⊓ x ⊔ x ⊓ y \ x) ⊓ x \ y = x ⊓ y ⊓ x \ y ⊔ x ⊓ y \ x ⊓ x \ y
state_after: no goals
tactic: rw [inf_sup_right, inf_comm x y]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ y ⊓ x \ y ⊔ x ⊓ y \ x ⊓ x \ y = x ⊓ y \ x ⊓ x \ y
state_after: no goals
tactic: rw [inf_inf_sdiff, bot_sup_eq]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ y \ x ⊓ x \ y = x ⊓ x \ y ⊓ y \ x
state_after: no goals
tactic: ac_rfl
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ x \ y ⊓ y \ x = x \ y ⊓ y \ x
state_after: no goals
tactic: rw [inf_of_le_right sdiff_le']
Theorem: Prod.Lex.toLex_mono
File: Mathlib/Data/Prod/Lex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
⊢ Monotone ⇑toLex
state_after: case mk.mk.intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
ha : (a₁, b₁).1 ≤ (a₂, b₂).1
hb : (a₁, b₁).2 ≤ (a₂, b₂).2
⊢ toLex (a₁, b₁) ≤ toLex (a₂, b₂)
tactic: rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ ⟨ha, hb⟩
state_before: case mk.mk.intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
ha : (a₁, b₁).1 ≤ (a₂, b₂).1
hb : (a₁, b₁).2 ≤ (a₂, b₂).2
⊢ toLex (a₁, b₁) ≤ toLex (a₂, b₂)
state_after: case mk.mk.intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ b₂ : β
ha : (a₁, b₁).1 ≤ (a₁, b₂).1
hb : (a₁, b₁).2 ≤ (a₁, b₂).2
⊢ toLex (a₁, b₁) ≤ toLex (a₁, b₂)

case mk.mk.intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
ha✝ : (a₁, b₁).1 ≤ (a₂, b₂).1
hb : (a₁, b₁).2 ≤ (a₂, b₂).2
ha : (a₁, b₁).1 < (a₂, b₂).1
⊢ toLex (a₁, b₁) ≤ toLex (a₂, b₂)
tactic: obtain rfl | ha : a₁ = a₂ ∨ _ := ha.eq_or_lt
Theorem: inner_zero_left
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : E
⊢ ⟪0, x⟫_𝕜 = 0
state_after: no goals
tactic: rw [← zero_smul 𝕜 (0 : E), inner_smul_left, RingHom.map_zero, zero_mul]
Theorem: List.headI_mul_tail_prod_of_ne_nil
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : Inhabited M
l : List M
h : l ≠ []
⊢ l.headI * l.tail.prod = l.prod
state_after: no goals
tactic: cases l <;> [contradiction; simp]
Theorem: not_dvd_index_sylow
File: Mathlib/GroupTheory/Sylow.lean

Proof steps:
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : (↑P).relindex (↑P).normalizer ≠ 0
⊢ ¬p ∣ (↑P).index
state_after: p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : (↑P).relindex (↑P).normalizer ≠ 0
⊢ ¬p ∣ (↑P).relindex (↑P).normalizer * Nat.card (Sylow p G)
tactic: rw [← relindex_mul_index le_normalizer, ← card_sylow_eq_index_normalizer]
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : (↑P).relindex (↑P).normalizer ≠ 0
⊢ ¬p ∣ (↑P).relindex (↑P).normalizer * Nat.card (Sylow p G)
state_after: p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : (↑P).relindex (↑P).normalizer ≠ 0
this : (↑(P.subtype ⋯)).Normal
⊢ ¬p ∣ (↑P).relindex (↑P).normalizer * Nat.card (Sylow p G)
tactic: haveI : (P.subtype le_normalizer : Subgroup (P : Subgroup G).normalizer).Normal :=
    Subgroup.normal_in_normalizer
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : (↑P).relindex (↑P).normalizer ≠ 0
this : (↑(P.subtype ⋯)).Normal
⊢ ¬p ∣ (↑P).relindex (↑P).normalizer * Nat.card (Sylow p G)
state_after: p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : (↑P).relindex (↑P).normalizer ≠ 0
this✝ : (↑(P.subtype ⋯)).Normal
this : (↑(P.subtype ⋯)).FiniteIndex
⊢ ¬p ∣ (↑P).relindex (↑P).normalizer * Nat.card (Sylow p G)
tactic: haveI : FiniteIndex ↑(P.subtype le_normalizer : Subgroup (P : Subgroup G).normalizer) := ⟨hP⟩
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : (↑P).relindex (↑P).normalizer ≠ 0
this✝ : (↑(P.subtype ⋯)).Normal
this : (↑(P.subtype ⋯)).FiniteIndex
⊢ ¬p ∣ (↑P).relindex (↑P).normalizer * Nat.card (Sylow p G)
state_after: p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this✝ : (↑(P.subtype ⋯)).Normal
this : (↑(P.subtype ⋯)).FiniteIndex
hP : ¬p ∣ (↑(P.subtype ⋯)).index
⊢ ¬p ∣ (↑P).relindex (↑P).normalizer * Nat.card (Sylow p G)
tactic: replace hP := not_dvd_index_sylow' (P.subtype le_normalizer)
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
this✝ : (↑(P.subtype ⋯)).Normal
this : (↑(P.subtype ⋯)).FiniteIndex
hP : ¬p ∣ (↑(P.subtype ⋯)).index
⊢ ¬p ∣ (↑P).relindex (↑P).normalizer * Nat.card (Sylow p G)
state_after: no goals
tactic: exact hp.1.not_dvd_mul hP (not_dvd_card_sylow p G)