ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: BddDistLat.Iso.mk_hom_toLatticeHom_toSupHom_toFun
File: Mathlib/Order/Category/BddDistLat.lean

Proof steps:
state_before: α β : BddDistLat
e : ↑α.toDistLat ≃o ↑β.toDistLat
⊢ ((let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
      let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) =
    𝟙 α
state_after: case w
α β : BddDistLat
e : ↑α.toDistLat ≃o ↑β.toDistLat
x✝ : (forget BddDistLat).obj α
⊢ ((let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 α) x✝
tactic: ext
state_before: case w
α β : BddDistLat
e : ↑α.toDistLat ≃o ↑β.toDistLat
x✝ : (forget BddDistLat).obj α
⊢ ((let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : BddDistLat
e : ↑α.toDistLat ≃o ↑β.toDistLat
⊢ ((let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
      let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) =
    𝟙 β
state_after: case w
α β : BddDistLat
e : ↑α.toDistLat ≃o ↑β.toDistLat
x✝ : (forget BddDistLat).obj β
⊢ ((let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 β) x✝
tactic: ext
state_before: case w
α β : BddDistLat
e : ↑α.toDistLat ≃o ↑β.toDistLat
x✝ : (forget BddDistLat).obj β
⊢ ((let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: minpoly.min
File: Mathlib/FieldTheory/Minpoly/Basic.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
p : A[X]
pmonic : p.Monic
hp : (Polynomial.aeval x) p = 0
⊢ (minpoly A x).degree ≤ p.degree
state_after: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
p : A[X]
pmonic : p.Monic
hp : (Polynomial.aeval x) p = 0
⊢ (if hx : IsIntegral A x then ⋯.min (fun x_1 => x_1.Monic ∧ eval₂ (algebraMap A B) x x_1 = 0) hx else 0).degree ≤
    p.degree
tactic: delta minpoly
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
p : A[X]
pmonic : p.Monic
hp : (Polynomial.aeval x) p = 0
⊢ (if hx : IsIntegral A x then ⋯.min (fun x_1 => x_1.Monic ∧ eval₂ (algebraMap A B) x x_1 = 0) hx else 0).degree ≤
    p.degree
state_after: case pos
A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
p : A[X]
pmonic : p.Monic
hp : (Polynomial.aeval x) p = 0
hx : IsIntegral A x
⊢ (⋯.min (fun x_1 => x_1.Monic ∧ eval₂ (algebraMap A B) x x_1 = 0) hx).degree ≤ p.degree

case neg
A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
p : A[X]
pmonic : p.Monic
hp : (Polynomial.aeval x) p = 0
hx : ¬IsIntegral A x
⊢ degree 0 ≤ p.degree
tactic: split_ifs with hx
Theorem: QuadraticMap.isOrtho_inl_inl_iff
File: Mathlib/LinearAlgebra/QuadraticForm/Prod.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
P : Type u_7
Mᵢ : ι → Type u_8
Nᵢ : ι → Type u_9
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M₁
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid N₁
inst✝⁶ : AddCommMonoid N₂
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R P
Q₁ : QuadraticMap R M₁ P
Q₂ : QuadraticMap R M₂ P
m₁ m₁' : M₁
⊢ (Q₁.prod Q₂).IsOrtho (m₁, 0) (m₁', 0) ↔ Q₁.IsOrtho m₁ m₁'
state_after: no goals
tactic: simp [isOrtho_def]
Theorem: intervalIntegral.integral_eq_integral_of_support_subset
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✝ c d : ℝ
f g : ℝ → E
μ : Measure ℝ
a b : ℝ
h : support f ⊆ Ioc a b
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = ∫ (x : ℝ), f x ∂μ
state_after: case inl
ι : 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✝ c d : ℝ
f g : ℝ → E
μ : Measure ℝ
a b : ℝ
h : support f ⊆ Ioc a b
hab : a ≤ b
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = ∫ (x : ℝ), f x ∂μ

case inr
ι : 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✝ c d : ℝ
f g : ℝ → E
μ : Measure ℝ
a b : ℝ
h : support f ⊆ Ioc a b
hab : b ≤ a
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = ∫ (x : ℝ), f x ∂μ
tactic: rcases le_total a b with hab | hab
Theorem: pow_eq_pow_iff_cases
File: Mathlib/Algebra/Order/Ring/Abs.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝ : LinearOrderedRing R
a b : R
n : ℕ
⊢ a ^ n = b ^ n ↔ n = 0 ∨ a = b ∨ a = -b ∧ Even n
state_after: no goals
tactic: rcases eq_or_ne n 0 with rfl | hn <;> simp [pow_eq_pow_iff_of_ne_zero, *]
Theorem: Cardinal.aleph_succ
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: o : Ordinal.{u_1}
⊢ aleph (succ o) = succ (aleph o)
state_after: no goals
tactic: rw [aleph, add_succ, aleph'_succ, aleph]
Theorem: Subgroup.IsComplement.equiv_fst_eq_self_of_mem_of_one_mem
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
hg : g ∈ S
⊢ (hST.equiv g).1 = ⟨g, hg⟩
state_after: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
hg : g ∈ S
this : hST.equiv.symm (⟨g, hg⟩, ⟨1, h1⟩) = g
⊢ (hST.equiv g).1 = ⟨g, hg⟩
tactic: have : hST.equiv.symm (⟨g, hg⟩, ⟨1, h1⟩) = g := by
    rw [equiv, Equiv.ofBijective]; simp
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
hg : g ∈ S
this : hST.equiv.symm (⟨g, hg⟩, ⟨1, h1⟩) = g
⊢ (hST.equiv g).1 = ⟨g, hg⟩
state_after: no goals
tactic: conv_lhs => rw [← this, Equiv.apply_symm_apply]
Theorem: Complex.isometryOfOrthonormal_apply
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
v : OrthonormalBasis (Fin 2) ℝ F
z : ℂ
⊢ (isometryOfOrthonormal v) z = z.re • v 0 + z.im • v 1
state_after: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
v : OrthonormalBasis (Fin 2) ℝ F
z : ℂ
⊢ v.repr.symm (orthonormalBasisOneI.repr z) = z.re • v 0 + z.im • v 1
tactic: rw [Complex.isometryOfOrthonormal, LinearIsometryEquiv.trans_apply]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
v : OrthonormalBasis (Fin 2) ℝ F
z : ℂ
⊢ v.repr.symm (orthonormalBasisOneI.repr z) = z.re • v 0 + z.im • v 1
state_after: no goals
tactic: simp [← v.sum_repr_symm]
Theorem: CliffordAlgebra.ι_range_map_lift
File: Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
Q : QuadraticForm R M
n : ℕ
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : M →ₗ[R] A
cond : ∀ (m : M), f m * f m = (algebraMap R A) (Q m)
⊢ Submodule.map ((lift Q) ⟨f, cond⟩).toLinearMap (LinearMap.range (ι Q)) = LinearMap.range f
state_after: no goals
tactic: rw [← LinearMap.range_comp, ι_comp_lift]
Theorem: AddOpposite.addSemiconjBy_op
File: Mathlib/Algebra/Group/Opposite.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Mul α
a x y : α
⊢ SemiconjBy (op a) (op y) (op x) ↔ SemiconjBy a x y
state_after: no goals
tactic: simp only [SemiconjBy, ← op_mul, op_inj, eq_comm]
Theorem: Nat.Prime.coprime_iff_not_dvd
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n✝ p n : ℕ
pp : Prime p
co : p.Coprime n
d : p ∣ n
⊢ p ∣ n * 1
state_after: no goals
tactic: simp [d]
Theorem: continuousAt_update_same
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DecidableEq α
f : α → β
x : α
y : β
⊢ ContinuousAt (update f x y) x ↔ Tendsto f (𝓝[≠] x) (𝓝 y)
state_after: no goals
tactic: rw [← continuousWithinAt_univ, continuousWithinAt_update_same, compl_eq_univ_diff]
Theorem: WithTop.coe_mul_eq_bind
File: Mathlib/Algebra/Order/Ring/WithTop.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b : WithTop α
a : α
ha : a ≠ 0
⊢ ↑a * ⊤ = Option.bind ⊤ fun b => Option.some (a * b)
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b : WithTop α
a : α
ha : a ≠ 0
⊢ ⊤ = Option.bind ⊤ fun b => Option.some (a * b)
tactic: simp [top_mul, ha]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b : WithTop α
a : α
ha : a ≠ 0
⊢ ⊤ = Option.bind ⊤ fun b => Option.some (a * b)
state_after: no goals
tactic: rfl
Theorem: HasFPowerSeriesOnBall.hasSum_sub
File: Mathlib/Analysis/Analytic/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y : E
hy : y ∈ EMetric.ball x r
⊢ HasSum (fun n => (p n) fun x_1 => y - x) (f y)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y : E
hy : y ∈ EMetric.ball x r
this : y - x ∈ EMetric.ball 0 r
⊢ HasSum (fun n => (p n) fun x_1 => y - x) (f y)
tactic: have : y - x ∈ EMetric.ball (0 : E) r := by simpa [edist_eq_coe_nnnorm_sub] using hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
y : E
hy : y ∈ EMetric.ball x r
this : y - x ∈ EMetric.ball 0 r
⊢ HasSum (fun n => (p n) fun x_1 => y - x) (f y)
state_after: no goals
tactic: simpa only [add_sub_cancel] using hf.hasSum this
Theorem: Nat.coprime_self
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

Proof steps:
state_before: n : Nat
⊢ n.Coprime n ↔ n = 1
state_after: no goals
tactic: simp [Coprime]
Theorem: Stream'.Seq.eq_of_bisim
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Seq α → Seq α → Prop
bisim : IsBisimulation R
s₁ s₂ : Seq α
r : R s₁ s₂
⊢ s₁ = s₂
state_after: case a
α : Type u
β : Type v
γ : Type w
R : Seq α → Seq α → Prop
bisim : IsBisimulation R
s₁ s₂ : Seq α
r : R s₁ s₂
⊢ ↑s₁ = ↑s₂
tactic: apply Subtype.eq
state_before: case a
α : Type u
β : Type v
γ : Type w
R : Seq α → Seq α → Prop
bisim : IsBisimulation R
s₁ s₂ : Seq α
r : R s₁ s₂
⊢ ↑s₁ = ↑s₂
state_after: case a.bisim
α : Type u
β : Type v
γ : Type w
R : Seq α → Seq α → Prop
bisim : IsBisimulation R
s₁ s₂ : Seq α
r : R s₁ s₂
⊢ Stream'.IsBisimulation fun x y => ∃ s s', ↑s = x ∧ ↑s' = y ∧ R s s'

case a.a
α : Type u
β : Type v
γ : Type w
R : Seq α → Seq α → Prop
bisim : IsBisimulation R
s₁ s₂ : Seq α
r : R s₁ s₂
⊢ ∃ s s', ↑s = ↑s₁ ∧ ↑s' = ↑s₂ ∧ R s s'
tactic: apply Stream'.eq_of_bisim fun x y => ∃ s s' : Seq α, s.1 = x ∧ s'.1 = y ∧ R s s'
Theorem: List.formPerm_apply_lt_getElem
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
xs : List α
h : xs.Nodup
n : ℕ
hn : n + 1 < xs.length
⊢ xs.formPerm xs[n] = xs[n + 1]
state_after: case zero
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
xs : List α
h : xs.Nodup
hn : 0 + 1 < xs.length
⊢ xs.formPerm xs[0] = xs[0 + 1]

case succ
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
n : ℕ
IH : ∀ (xs : List α), xs.Nodup → ∀ (hn : n + 1 < xs.length), xs.formPerm xs[n] = xs[n + 1]
xs : List α
h : xs.Nodup
hn : n + 1 + 1 < xs.length
⊢ xs.formPerm xs[n + 1] = xs[n + 1 + 1]
tactic: induction' n with n IH generalizing xs
Theorem: PMF.toMeasure_mono
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : MeasurableSpace α
p : PMF α
s✝ t✝ s t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
h : s ∩ p.support ⊆ t
⊢ p.toMeasure s ≤ p.toMeasure t
state_after: no goals
tactic: simpa only [p.toMeasure_apply_eq_toOuterMeasure_apply, hs, ht] using toOuterMeasure_mono p h
Theorem: AddCommGroup.ModEq.of_zsmul
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
x✝ : a ≡ b [PMOD z • p]
m : ℤ
hm : b - a = m • z • p
⊢ b - a = (m * z) • p
state_after: no goals
tactic: rwa [mul_smul]
Theorem: CategoryTheory.Arrow.iso_w
File: Mathlib/CategoryTheory/Comma/Arrow.lean

Proof steps:
state_before: T : Type u
inst✝ : Category.{v, u} T
f g : Arrow T
e : f ≅ g
⊢ g.hom = e.inv.left ≫ f.hom ≫ e.hom.right
state_after: T : Type u
inst✝ : Category.{v, u} T
f g : Arrow T
e : f ≅ g
eq : (e.inv ≫ e.hom).right = (𝟙 g).right
⊢ g.hom = e.inv.left ≫ f.hom ≫ e.hom.right
tactic: have eq := Arrow.hom.congr_right e.inv_hom_id
state_before: T : Type u
inst✝ : Category.{v, u} T
f g : Arrow T
e : f ≅ g
eq : (e.inv ≫ e.hom).right = (𝟙 g).right
⊢ g.hom = e.inv.left ≫ f.hom ≫ e.hom.right
state_after: T : Type u
inst✝ : Category.{v, u} T
f g : Arrow T
e : f ≅ g
eq : e.inv.right ≫ e.hom.right = 𝟙 g.right
⊢ g.hom = e.inv.left ≫ f.hom ≫ e.hom.right
tactic: rw [Arrow.comp_right, Arrow.id_right] at eq
state_before: T : Type u
inst✝ : Category.{v, u} T
f g : Arrow T
e : f ≅ g
eq : e.inv.right ≫ e.hom.right = 𝟙 g.right
⊢ g.hom = e.inv.left ≫ f.hom ≫ e.hom.right
state_after: no goals
tactic: erw [Arrow.w_assoc, eq, Category.comp_id]
Theorem: Matroid.Basis.basis_iUnion
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B I J X✝ Y : Set α
e : α
ι : Type u_2
inst✝ : Nonempty ι
X : ι → Set α
hI : ∀ (i : ι), M.Basis I (X i)
⊢ M.Basis I (⋃ i, X i)
state_after: α : Type u_1
M : Matroid α
B I J X✝ Y : Set α
e : α
ι : Type u_2
inst✝ : Nonempty ι
X : ι → Set α
hI : ∀ (i : ι), M.Basis I (X i)
⊢ M.Indep I
tactic: convert Basis.iUnion_basis_iUnion X (fun _ ↦ I) (fun i ↦ hI i) _ <;> rw [iUnion_const]
state_before: α : Type u_1
M : Matroid α
B I J X✝ Y : Set α
e : α
ι : Type u_2
inst✝ : Nonempty ι
X : ι → Set α
hI : ∀ (i : ι), M.Basis I (X i)
⊢ M.Indep I
state_after: no goals
tactic: exact (hI (Classical.arbitrary ι)).indep
Theorem: IsFractionRing.isUnit_den_zero
File: Mathlib/RingTheory/Localization/NumDen.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ IsUnit ↑(den A 0)
state_after: no goals
tactic: simp [isUnit_den_iff, IsLocalization.isInteger_zero]
Theorem: Matrix.left_inv_eq_left_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 C : Matrix n n α
h : B * A = 1
g : C * A = 1
⊢ B = C
state_after: no goals
tactic: rw [← inv_eq_left_inv h, ← inv_eq_left_inv g]
Theorem: Filter.ZeroAtFilter.boundedAtFilter
File: Mathlib/Order/Filter/ZeroAndBoundedAtFilter.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NormedAddCommGroup β
l : Filter α
f : α → β
hf : l.ZeroAtFilter f
⊢ l.BoundedAtFilter f
state_after: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NormedAddCommGroup β
l : Filter α
f : α → β
hf : f =o[l] fun _x => 1
⊢ l.BoundedAtFilter f
tactic: rw [ZeroAtFilter, ← Asymptotics.isLittleO_const_iff (one_ne_zero' ℝ)] at hf
state_before: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NormedAddCommGroup β
l : Filter α
f : α → β
hf : f =o[l] fun _x => 1
⊢ l.BoundedAtFilter f
state_after: no goals
tactic: exact hf.isBigO
Theorem: segment_eq_image₂
File: Mathlib/Analysis/Convex/Segment.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
s : Set E
x✝ y✝ x y : E
⊢ [x-[𝕜]y] = (fun p => p.1 • x + p.2 • y) '' {p | 0 ≤ p.1 ∧ 0 ≤ p.2 ∧ p.1 + p.2 = 1}
state_after: no goals
tactic: simp only [segment, image, Prod.exists, mem_setOf_eq, exists_prop, and_assoc]
Theorem: List.permutationsAux2_comp_append
File: Mathlib/Data/List/Permutation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
t : α
ts ys : List α
r : List β
f : List α → β
⊢ (permutationsAux2 t [] r ys fun x => f (x ++ ts)).2 = (permutationsAux2 t ts r ys f).2
state_after: case nil
α : Type u_1
β : Type u_2
t : α
ts : List α
r : List β
f : List α → β
⊢ (permutationsAux2 t [] r [] fun x => f (x ++ ts)).2 = (permutationsAux2 t ts r [] f).2

case cons
α : Type u_1
β : Type u_2
t : α
ts : List α
r : List β
ys_hd : α
tail✝ : List α
ys_ih : ∀ (f : List α → β), (permutationsAux2 t [] r tail✝ fun x => f (x ++ ts)).2 = (permutationsAux2 t ts r tail✝ f).2
f : List α → β
⊢ (permutationsAux2 t [] r (ys_hd :: tail✝) fun x => f (x ++ ts)).2 = (permutationsAux2 t ts r (ys_hd :: tail✝) f).2
tactic: induction' ys with ys_hd _ ys_ih generalizing f
Theorem: _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_nsmul
File: Mathlib/RingTheory/WittVector/Basic.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
x✝ y : 𝕎 R
m : ℕ
x : 𝕎 R
⊢ WittVector.ghostFun (m • x) = m • WittVector.ghostFun x
state_after: no goals
tactic: ghost_fun_tac m • (X 0), ![x.coeff]
Theorem: AddCon.coe_sInf
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
⊢ ⇑(sInf S) = sInf (DFunLike.coe '' S)
state_after: case h.h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x✝¹ x✝ : M
⊢ (sInf S) x✝¹ x✝ ↔ sInf (DFunLike.coe '' S) x✝¹ x✝
tactic: ext
state_before: case h.h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x✝¹ x✝ : M
⊢ (sInf S) x✝¹ x✝ ↔ sInf (DFunLike.coe '' S) x✝¹ x✝
state_after: case h.h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x✝¹ x✝ : M
⊢ (sInf S) x✝¹ x✝ ↔ ∀ i ∈ S, i x✝¹ x✝
tactic: simp only [sInf_image, iInf_apply, iInf_Prop_eq]
state_before: case h.h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c : Con M
S : Set (Con M)
x✝¹ x✝ : M
⊢ (sInf S) x✝¹ x✝ ↔ ∀ i ∈ S, i x✝¹ x✝
state_after: no goals
tactic: rfl
Theorem: FreeAddSemigroup.hom_ext
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Mul β
f g : FreeSemigroup α →ₙ* β
h : ⇑f ∘ of = ⇑g ∘ of
x✝ : FreeSemigroup α
x : α
y : FreeSemigroup α
hx : f (of x) = g (of x)
hy : f y = g y
⊢ f (of x * y) = g (of x * y)
state_after: no goals
tactic: simp only [map_mul, *]
Theorem: covariant_le_of_covariant_lt
File: Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
⊢ (Covariant M N μ fun x x_1 => x < x_1) → Covariant M N μ fun x x_1 => x ≤ x_1
state_after: M : Type u_1
N : Type u_2
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
h : Covariant M N μ fun x x_1 => x < x_1
a : M
b c : N
bc : b ≤ c
⊢ μ a b ≤ μ a c
tactic: intro h a b c bc
state_before: M : Type u_1
N : Type u_2
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
h : Covariant M N μ fun x x_1 => x < x_1
a : M
b c : N
bc : b ≤ c
⊢ μ a b ≤ μ a c
state_after: case inl
M : Type u_1
N : Type u_2
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
h : Covariant M N μ fun x x_1 => x < x_1
a : M
b : N
bc : b ≤ b
⊢ μ a b ≤ μ a b

case inr
M : Type u_1
N : Type u_2
μ : M → N → N
r : N → N → Prop
inst✝ : PartialOrder N
h : Covariant M N μ fun x x_1 => x < x_1
a : M
b c : N
bc✝ : b ≤ c
bc : b < c
⊢ μ a b ≤ μ a c
tactic: rcases bc.eq_or_lt with (rfl | bc)