ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ProbabilityTheory.Kernel.sum_map_seq
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
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf : Measurable f
⊢ (Kernel.sum fun n => (κ.seq n).map f hf) = κ.map f hf
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf : Measurable f
a : α
s : Set γ
hs : MeasurableSet s
⊢ ((Kernel.sum fun n => (κ.seq n).map f hf) a) s = ((κ.map f hf) a) s
tactic: ext a s hs
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf : Measurable f
a : α
s : Set γ
hs : MeasurableSet s
⊢ ((Kernel.sum fun n => (κ.seq n).map f hf) a) s = ((κ.map f hf) a) s
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf : Measurable f
a : α
s : Set γ
hs : MeasurableSet s
⊢ ∑' (i : ℕ), (((κ.seq i).map f hf) a) s = ∑' (i : ℕ), ((κ.seq i) a) (f ⁻¹' s)
tactic: rw [Kernel.sum_apply, map_apply' κ hf a hs, Measure.sum_apply _ hs, ← measure_sum_seq κ,
    Measure.sum_apply _ (hf hs)]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f : β → γ
g : γ → α
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf : Measurable f
a : α
s : Set γ
hs : MeasurableSet s
⊢ ∑' (i : ℕ), (((κ.seq i).map f hf) a) s = ∑' (i : ℕ), ((κ.seq i) a) (f ⁻¹' s)
state_after: no goals
tactic: simp_rw [map_apply' _ hf _ hs]
Theorem: ContractingWith.edist_efixedPoint_le
File: Mathlib/Topology/MetricSpace/Contracting.lean

Proof steps:
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x : α
hx : edist x (f x) ≠ ⊤
⊢ edist x (efixedPoint f hf x hx) ≤ edist x (f x) / (1 - ↑K)
state_after: case h.e'_4.h.e'_5
α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x : α
hx : edist x (f x) ≠ ⊤
⊢ edist x (f x) = edist x (f x) * ↑K ^ 0
tactic: convert hf.apriori_edist_iterate_efixedPoint_le hx 0
state_before: case h.e'_4.h.e'_5
α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x : α
hx : edist x (f x) ≠ ⊤
⊢ edist x (f x) = edist x (f x) * ↑K ^ 0
state_after: no goals
tactic: simp only [pow_zero, mul_one]
Theorem: mul_rotate'
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommSemigroup G
a b c : G
⊢ a * (b * c) = b * (c * a)
state_after: no goals
tactic: simp only [mul_left_comm, mul_comm]
Theorem: Fin.sum_univ_four
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 4 → β
⊢ ∏ i : Fin 4, f i = f 0 * f 1 * f 2 * f 3
state_after: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 4 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (last 3) = f 0 * f 1 * f 2 * f 3
tactic: rw [prod_univ_castSucc, prod_univ_three]
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 4 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (last 3) = f 0 * f 1 * f 2 * f 3
state_after: no goals
tactic: rfl
Theorem: Mathlib.Meta.Multiset.range_zero'
File: Mathlib/Tactic/NormNum/BigOperators.lean

Proof steps:
state_before: u v : Level
n : ℕ
pn : NormNum.IsNat n 0
⊢ Multiset.range n = 0
state_after: no goals
tactic: rw [pn.out, Nat.cast_zero, Multiset.range_zero]
Theorem: idRel_subset
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
s : Set (α × α)
⊢ idRel ⊆ s ↔ ∀ (a : α), (a, a) ∈ s
state_after: no goals
tactic: simp [subset_def]
Theorem: ContinuousLinearEquiv.integral_comp_comm
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝⁷ : MeasurableSpace X
μ : Measure X
𝕜 : Type u_5
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ F
inst✝ : NormedSpace ℝ E
L : E ≃L[𝕜] F
φ : X → E
⊢ ∫ (x : X), L (φ x) ∂μ = L (∫ (x : X), φ x ∂μ)
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝⁷ : MeasurableSpace X
μ : Measure X
𝕜 : Type u_5
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ F
inst✝ : NormedSpace ℝ E
L : E ≃L[𝕜] F
φ : X → E
this : CompleteSpace E ↔ CompleteSpace F
⊢ ∫ (x : X), L (φ x) ∂μ = L (∫ (x : X), φ x ∂μ)
tactic: have : CompleteSpace E ↔ CompleteSpace F :=
    completeSpace_congr (e := L.toEquiv) L.uniformEmbedding
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝⁷ : MeasurableSpace X
μ : Measure X
𝕜 : Type u_5
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ F
inst✝ : NormedSpace ℝ E
L : E ≃L[𝕜] F
φ : X → E
this : CompleteSpace E ↔ CompleteSpace F
⊢ ∫ (x : X), L (φ x) ∂μ = L (∫ (x : X), φ x ∂μ)
state_after: case inl.intro
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝⁷ : MeasurableSpace X
μ : Measure X
𝕜 : Type u_5
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ F
inst✝ : NormedSpace ℝ E
L : E ≃L[𝕜] F
φ : X → E
this : CompleteSpace E ↔ CompleteSpace F
left✝ : CompleteSpace E
right✝ : CompleteSpace F
⊢ ∫ (x : X), L (φ x) ∂μ = L (∫ (x : X), φ x ∂μ)

case inr.intro
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝⁷ : MeasurableSpace X
μ : Measure X
𝕜 : Type u_5
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ F
inst✝ : NormedSpace ℝ E
L : E ≃L[𝕜] F
φ : X → E
this : CompleteSpace E ↔ CompleteSpace F
left✝ : ¬CompleteSpace E
right✝ : ¬CompleteSpace F
⊢ ∫ (x : X), L (φ x) ∂μ = L (∫ (x : X), φ x ∂μ)
tactic: obtain ⟨_, _⟩|⟨_, _⟩ := iff_iff_and_or_not_and_not.mp this
Theorem: Real.cos_arccos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ cos (arccos x) = x
state_after: no goals
tactic: rw [arccos, cos_pi_div_two_sub, sin_arcsin hx₁ hx₂]
Theorem: List.isRotated_singleton_iff'
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l l' : List α
x : α
⊢ [x] ~r l ↔ [x] = l
state_after: no goals
tactic: rw [isRotated_comm, isRotated_singleton_iff, eq_comm]
Theorem: SimpleGraph.connected_induce_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
s : Set V
⊢ (induce s G).Connected ↔ (⊤.induce s).Connected
state_after: no goals
tactic: rw [induce_eq_coe_induce_top, ← Subgraph.connected_iff']
Theorem: AddSemiconjBy.map
File: Mathlib/Algebra/Group/Commute/Hom.lean

Proof steps:
state_before: F : Type u_1
M : Type u_2
N : Type u_3
inst✝³ : Mul M
inst✝² : Mul N
a x y : M
inst✝¹ : FunLike F M N
inst✝ : MulHomClass F M N
h : SemiconjBy a x y
f : F
⊢ SemiconjBy (f a) (f x) (f y)
state_after: no goals
tactic: simpa only [SemiconjBy, map_mul] using congr_arg f h
Theorem: OreLocalization.one_div_mul
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.101505
inst✝ : MulAction R X
r : R
s t : ↥S
⊢ 1 /ₒ t * (r /ₒ s) = r /ₒ (s * t)
state_after: no goals
tactic: simp [oreDiv_mul_char 1 r t s 1 s (by simp)]
Theorem: ModelWithCorners.image_eq
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝³ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
H : Type u_3
inst✝ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
s : Set H
⊢ ↑I '' s = ↑I.symm ⁻¹' s ∩ range ↑I
state_after: case refine_1
𝕜 : Type u_1
inst✝³ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
H : Type u_3
inst✝ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
s : Set H
⊢ s ⊆ I.source

case refine_2
𝕜 : Type u_1
inst✝³ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
H : Type u_3
inst✝ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
s : Set H
⊢ I.target ∩ ↑I.symm ⁻¹' s = ↑I.symm ⁻¹' s ∩ range ↑I
tactic: refine (I.toPartialEquiv.image_eq_target_inter_inv_preimage ?_).trans ?_
Theorem: Matrix.inv_add_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : IsUnit A ↔ IsUnit B
⊢ A⁻¹ + B⁻¹ = A⁻¹ * (A + B) * B⁻¹
state_after: no goals
tactic: simpa only [nonsing_inv_eq_ring_inverse] using Ring.inverse_add_inverse h
Theorem: ltByCases_eq_iff
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
P : Sort u_5
x y : α
h₁ : x < y → P
h₂ : x = y → P
h₃ : y < x → P
p : P
⊢ ltByCases x y h₁ h₂ h₃ = p ↔ (∃ h, h₁ h = p) ∨ (∃ h, h₂ h = p) ∨ ∃ h, h₃ h = p
state_after: case refine_1
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
P : Sort u_5
x y : α
h₁ : x < y → P
h₂ : x = y → P
h₃ : y < x → P
p : P
h : x < y
⊢ ltByCases x y h₁ h₂ h₃ = p ↔ (∃ h, h₁ h = p) ∨ (∃ h, h₂ h = p) ∨ ∃ h, h₃ h = p

case refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
P : Sort u_5
x y : α
h₁ : x < y → P
h₂ : x = y → P
h₃ : y < x → P
p : P
h : x = y
⊢ ltByCases x y h₁ h₂ h₃ = p ↔ (∃ h, h₁ h = p) ∨ (∃ h, h₂ h = p) ∨ ∃ h, h₃ h = p

case refine_3
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
P : Sort u_5
x y : α
h₁ : x < y → P
h₂ : x = y → P
h₃ : y < x → P
p : P
h : y < x
⊢ ltByCases x y h₁ h₂ h₃ = p ↔ (∃ h, h₁ h = p) ∨ (∃ h, h₂ h = p) ∨ ∃ h, h₃ h = p
tactic: refine ltByCases x y (fun h => ?_) (fun h => ?_) (fun h => ?_)
Theorem: Stream'.WSeq.head_terminates_of_head_tail_terminates
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
⊢ s.destruct.Terminates
state_after: case mk.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ s.tail.destruct
⊢ s.destruct.Terminates
tactic: rcases (head_terminates_iff _).1 T with ⟨⟨a, h⟩⟩
state_before: case mk.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ s.tail.destruct
⊢ s.destruct.Terminates
state_after: case mk.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
⊢ s.destruct.Terminates
tactic: simp? [tail] at h says simp only [tail, destruct_flatten] at h
state_before: case mk.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
⊢ s.destruct.Terminates
state_after: case mk.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
s' : WSeq α
h1 : s' ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct
right✝ : a ∈ s'.destruct
⊢ s.destruct.Terminates
tactic: rcases exists_of_mem_bind h with ⟨s', h1, _⟩
state_before: case mk.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
s' : WSeq α
h1 : s' ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct
right✝ : a ∈ s'.destruct
⊢ s.destruct.Terminates
state_after: case mk.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
s' : WSeq α
h1 : s' ∈ Applicative.toFunctor.1 (fun o => Option.rec nil Prod.snd o) s.destruct
right✝ : a ∈ s'.destruct
⊢ s.destruct.Terminates
tactic: unfold Functor.map at h1
state_before: case mk.intro.intro.intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
T : s.tail.head.Terminates
a : Option (α × WSeq α)
h : a ∈ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct
s' : WSeq α
h1 : s' ∈ Applicative.toFunctor.1 (fun o => Option.rec nil Prod.snd o) s.destruct
right✝ : a ∈ s'.destruct
⊢ s.destruct.Terminates
state_after: no goals
tactic: exact
      let ⟨t, h3, _⟩ := Computation.exists_of_mem_map h1
      Computation.terminates_of_mem h3
Theorem: add_eq_of_eq_neg_add
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : b = a⁻¹ * c
⊢ a * b = c
state_after: no goals
tactic: rw [h, mul_inv_cancel_left]
Theorem: intervalIntegral.norm_integral_le_abs_integral_norm
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
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 ℝ
⊢ ‖∫ (x : ℝ) in a..b, f x ∂μ‖ ≤ |∫ (x : ℝ) in a..b, ‖f x‖ ∂μ|
state_after: ι : 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 ℝ
⊢ ‖∫ (x : ℝ) in Ι a b, f x ∂μ‖ ≤ ‖∫ (x : ℝ) in Ι a b, ‖f x‖ ∂μ‖
tactic: simp only [← Real.norm_eq_abs, norm_integral_eq_norm_integral_Ioc]
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 ℝ
⊢ ‖∫ (x : ℝ) in Ι a b, f x ∂μ‖ ≤ ‖∫ (x : ℝ) in Ι a b, ‖f x‖ ∂μ‖
state_after: no goals
tactic: exact le_trans (norm_integral_le_integral_norm _) (le_abs_self _)
Theorem: Finset.eq_of_mem_uIcc_of_mem_uIcc
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ [[b, c]] → b ∈ [[a, c]] → a = b
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ⊓ c ≤ a ∧ a ≤ b ⊔ c → a ⊓ c ≤ b ∧ b ≤ a ⊔ c → a = b
tactic: simp_rw [mem_uIcc]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ⊓ c ≤ a ∧ a ≤ b ⊔ c → a ⊓ c ≤ b ∧ b ≤ a ⊔ c → a = b
state_after: no goals
tactic: exact Set.eq_of_mem_uIcc_of_mem_uIcc
Theorem: Num.castNum_shiftRight
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m : Num
n : ℕ
⊢ ↑(m >>> n) = ↑m >>> n
state_after: case zero
α : Type u_1
n : ℕ
⊢ ↑0 = ↑zero >>> n

case pos
α : Type u_1
n : ℕ
m : PosNum
⊢ ↑(m >>> n) = ↑(pos m) >>> n
tactic: cases' m with m <;> dsimp only [← shiftr_eq_shiftRight, shiftr]
state_before: case pos
α : Type u_1
n : ℕ
m : PosNum
⊢ ↑(m >>> n) = ↑(pos m) >>> n
state_after: case pos.zero
α : Type u_1
m : PosNum
⊢ ↑(m >>> 0) = ↑(pos m) >>> 0

case pos.succ
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), ↑(m >>> n) = ↑(pos m) >>> n
m : PosNum
⊢ ↑(m >>> (n + 1)) = ↑(pos m) >>> (n + 1)
tactic: induction' n with n IH generalizing m
state_before: case pos.succ
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), ↑(m >>> n) = ↑(pos m) >>> n
m : PosNum
⊢ ↑(m >>> (n + 1)) = ↑(pos m) >>> (n + 1)
state_after: case pos.succ
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), ↑(m >>> n) = ↑(pos m) >>> n
m : PosNum
hdiv2 : ∀ (m : ℕ), (m + m).div2 = m
⊢ ↑(m >>> (n + 1)) = ↑(pos m) >>> (n + 1)
tactic: have hdiv2 : ∀ m, Nat.div2 (m + m) = m := by intro; rw [Nat.div2_val]; omega
state_before: case pos.succ
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), ↑(m >>> n) = ↑(pos m) >>> n
m : PosNum
hdiv2 : ∀ (m : ℕ), (m + m).div2 = m
⊢ ↑(m >>> (n + 1)) = ↑(pos m) >>> (n + 1)
state_after: case pos.succ.one
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), ↑(m >>> n) = ↑(pos m) >>> n
hdiv2 : ∀ (m : ℕ), (m + m).div2 = m
⊢ ↑0 = ↑(pos one) >>> (n + 1)

case pos.succ.bit1
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), ↑(m >>> n) = ↑(pos m) >>> n
hdiv2 : ∀ (m : ℕ), (m + m).div2 = m
m : PosNum
⊢ ↑(m.shiftr n) = ↑(pos m.bit1) >>> (n + 1)

case pos.succ.bit0
α : Type u_1
n : ℕ
IH : ∀ (m : PosNum), ↑(m >>> n) = ↑(pos m) >>> n
hdiv2 : ∀ (m : ℕ), (m + m).div2 = m
m : PosNum
⊢ ↑(m.shiftr n) = ↑(pos m.bit0) >>> (n + 1)
tactic: cases' m with m m <;> dsimp only [PosNum.shiftr, ← PosNum.shiftr_eq_shiftRight]
Theorem: Monoid.exponent_pi
File: Mathlib/GroupTheory/Exponent.lean

Proof steps:
state_before: G : Type u
ι : Type u_1
inst✝¹ : Fintype ι
M : ι → Type u_2
inst✝ : (i : ι) → Monoid (M i)
⊢ exponent ((i : ι) → M i) = univ.lcm fun x => exponent (M x)
state_after: case refine_1
G : Type u
ι : Type u_1
inst✝¹ : Fintype ι
M : ι → Type u_2
inst✝ : (i : ι) → Monoid (M i)
⊢ exponent ((i : ι) → M i) ∣ univ.lcm fun x => exponent (M x)

case refine_2
G : Type u
ι : Type u_1
inst✝¹ : Fintype ι
M : ι → Type u_2
inst✝ : (i : ι) → Monoid (M i)
⊢ (univ.lcm fun x => exponent (M x)) ∣ exponent ((i : ι) → M i)
tactic: refine dvd_antisymm ?_ ?_
Theorem: sup_lt_of_lt_sdiff_left
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y < z \ x
hxz : x ≤ z
⊢ x ⊔ y < z
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y < z \ x
hxz : x ≤ z
⊢ x ⊔ y < x ⊔ z \ x
tactic: rw [← sup_sdiff_cancel_right hxz]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y < z \ x
hxz : x ≤ z
⊢ x ⊔ y < x ⊔ z \ x
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y < z \ x
hxz : x ≤ z
h' : x ⊔ z \ x ≤ x ⊔ y
⊢ z \ x ≤ y
tactic: refine (sup_le_sup_left h.le _).lt_of_not_le fun h' => h.not_le ?_
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y < z \ x
hxz : x ≤ z
h' : x ⊔ z \ x ≤ x ⊔ y
⊢ z \ x ≤ y
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y < z \ x
hxz : x ≤ z
h' : x ⊔ z \ x ≤ x ⊔ y
⊢ (z \ x) \ x ≤ y
tactic: rw [← sdiff_idem]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : y < z \ x
hxz : x ≤ z
h' : x ⊔ z \ x ≤ x ⊔ y
⊢ (z \ x) \ x ≤ y
state_after: no goals
tactic: exact (sdiff_le_sdiff_of_sup_le_sup_left h').trans sdiff_le
Theorem: LieEquiv.nilpotent_iff_equiv_nilpotent
File: Mathlib/Algebra/Lie/Nilpotent.lean

Proof steps:
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
e : L ≃ₗ⁅R⁆ L'
⊢ LieAlgebra.IsNilpotent R L ↔ LieAlgebra.IsNilpotent R L'
state_after: case mp
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
e : L ≃ₗ⁅R⁆ L'
h : LieAlgebra.IsNilpotent R L
⊢ LieAlgebra.IsNilpotent R L'

case mpr
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
e : L ≃ₗ⁅R⁆ L'
h : LieAlgebra.IsNilpotent R L'
⊢ LieAlgebra.IsNilpotent R L
tactic: constructor <;> intro h
Theorem: div_lt_iff_lt_mul'
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a / b < c ↔ a < b * c
state_after: no goals
tactic: rw [div_lt_iff_lt_mul, mul_comm]
Theorem: Rat.divInt_div_divInt_cancel_right
File: Mathlib/Algebra/Ring/Rat.lean

Proof steps:
state_before: x : ℤ
hx : x ≠ 0
n d : ℤ
⊢ x /. n / (x /. d) = d /. n
state_after: no goals
tactic: rw [div_eq_mul_inv, inv_divInt', mul_comm, divInt_mul_divInt_cancel hx]
Theorem: Behrend.two_div_one_sub_two_div_e_le_eight
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 2 / (1 - 2 / rexp 1) ≤ 8
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 8 * 2 ≤ (8 - 2) * rexp 1

α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 0 < 1 - 2 / rexp 1
tactic: rw [div_le_iff, mul_sub, mul_one, mul_div_assoc', le_sub_comm, div_le_iff (exp_pos _)]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ 0 < 1 - 2 / rexp 1
state_after: no goals
tactic: rw [sub_pos, div_lt_one] <;> exact exp_one_gt_d9.trans' (by norm_num)
Theorem: Set.image_neg_Ici
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ Neg.neg '' Ici a = Iic (-a)
state_after: no goals
tactic: simp
Theorem: MeasureTheory.vadd_ae_eq_self_of_mem_zmultiples
File: Mathlib/MeasureTheory/Group/AEStabilizer.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
x y : G
s : Set α
hs : x • s =ᶠ[ae μ] s
hy : y ∈ Subgroup.zpowers x
⊢ y • s =ᶠ[ae μ] s
state_after: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
x y : G
s : Set α
hs : Subgroup.zpowers x ≤ MulAction.aestabilizer G μ s
hy : y ∈ Subgroup.zpowers x
⊢ y • s =ᶠ[ae μ] s
tactic: rw [← MulAction.mem_aestabilizer, ← Subgroup.zpowers_le] at hs
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
x y : G
s : Set α
hs : Subgroup.zpowers x ≤ MulAction.aestabilizer G μ s
hy : y ∈ Subgroup.zpowers x
⊢ y • s =ᶠ[ae μ] s
state_after: no goals
tactic: exact hs hy
Theorem: EuclideanGeometry.cospherical_iff_exists_mem_of_complete
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
⊢ Cospherical ps ↔ ∃ center ∈ s, ∃ radius, ∀ p ∈ ps, dist p center = radius
state_after: case mp
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
⊢ Cospherical ps → ∃ center ∈ s, ∃ radius, ∀ p ∈ ps, dist p center = radius

case mpr
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
⊢ (∃ center ∈ s, ∃ radius, ∀ p ∈ ps, dist p center = radius) → Cospherical ps
tactic: constructor
Theorem: continuous_iff_isClosed
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : X → Y
s : Set X
x : X
y : Y
⊢ (∀ (x : Set Y), IsOpen xᶜ → IsOpen (f ⁻¹' xᶜ)) ↔ ∀ (s : Set Y), IsClosed s → IsClosed (f ⁻¹' s)
state_after: no goals
tactic: simp only [isOpen_compl_iff, preimage_compl]