ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.OplaxNatTrans.whiskerRight_app
File: Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I : OplaxFunctor B C
η θ : F ⟶ G
Γ : η ⟶ θ
ι : G ⟶ H
a b : B
f : a ⟶ b
⊢ F.map f ◁ (fun a => Γ.app a ▷ ι.app a) b ≫ (θ ≫ ι).naturality f =
    (η ≫ ι).naturality f ≫ (fun a => Γ.app a ▷ ι.app a) a ▷ H.map f
state_after: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I : OplaxFunctor B C
η θ : F ⟶ G
Γ : η ⟶ θ
ι : G ⟶ H
a b : B
f : a ⟶ b
⊢ F.map f ◁ Γ.app b ▷ ι.app b ≫
      (α_ (F.map f) (θ.app b) (ι.app b)).inv ≫
        θ.naturality f ▷ ι.app b ≫
          (α_ (θ.app a) (G.map f) (ι.app b)).hom ≫ θ.app a ◁ ι.naturality f ≫ (α_ (θ.app a) (ι.app a) (H.map f)).inv =
    ((α_ (F.map f) (η.app b) (ι.app b)).inv ≫
        η.naturality f ▷ ι.app b ≫
          (α_ (η.app a) (G.map f) (ι.app b)).hom ≫ η.app a ◁ ι.naturality f ≫ (α_ (η.app a) (ι.app a) (H.map f)).inv) ≫
      Γ.app a ▷ ι.app a ▷ H.map f
tactic: dsimp
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I : OplaxFunctor B C
η θ : F ⟶ G
Γ : η ⟶ θ
ι : G ⟶ H
a b : B
f : a ⟶ b
⊢ F.map f ◁ Γ.app b ▷ ι.app b ≫
      (α_ (F.map f) (θ.app b) (ι.app b)).inv ≫
        θ.naturality f ▷ ι.app b ≫
          (α_ (θ.app a) (G.map f) (ι.app b)).hom ≫ θ.app a ◁ ι.naturality f ≫ (α_ (θ.app a) (ι.app a) (H.map f)).inv =
    ((α_ (F.map f) (η.app b) (ι.app b)).inv ≫
        η.naturality f ▷ ι.app b ≫
          (α_ (η.app a) (G.map f) (ι.app b)).hom ≫ η.app a ◁ ι.naturality f ≫ (α_ (η.app a) (ι.app a) (H.map f)).inv) ≫
      Γ.app a ▷ ι.app a ▷ H.map f
state_after: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I : OplaxFunctor B C
η θ : F ⟶ G
Γ : η ⟶ θ
ι : G ⟶ H
a b : B
f : a ⟶ b
⊢ F.map f ◁ Γ.app b ▷ ι.app b ≫
      (α_ (F.map f) (θ.app b) (ι.app b)).inv ≫
        θ.naturality f ▷ ι.app b ≫
          (α_ (θ.app a) (G.map f) (ι.app b)).hom ≫ θ.app a ◁ ι.naturality f ≫ (α_ (θ.app a) (ι.app a) (H.map f)).inv =
    (α_ (F.map f) (η.app b) (ι.app b)).inv ≫
      η.naturality f ▷ ι.app b ≫
        (α_ (η.app a) (G.map f) (ι.app b)).hom ≫
          Γ.app a ▷ (G.map f ≫ ι.app b) ≫ θ.app a ◁ ι.naturality f ≫ (α_ (θ.app a) (ι.app a) (H.map f)).inv
tactic: simp_rw [assoc, ← associator_inv_naturality_left, whisker_exchange_assoc]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I : OplaxFunctor B C
η θ : F ⟶ G
Γ : η ⟶ θ
ι : G ⟶ H
a b : B
f : a ⟶ b
⊢ F.map f ◁ Γ.app b ▷ ι.app b ≫
      (α_ (F.map f) (θ.app b) (ι.app b)).inv ≫
        θ.naturality f ▷ ι.app b ≫
          (α_ (θ.app a) (G.map f) (ι.app b)).hom ≫ θ.app a ◁ ι.naturality f ≫ (α_ (θ.app a) (ι.app a) (H.map f)).inv =
    (α_ (F.map f) (η.app b) (ι.app b)).inv ≫
      η.naturality f ▷ ι.app b ≫
        (α_ (η.app a) (G.map f) (ι.app b)).hom ≫
          Γ.app a ▷ (G.map f ≫ ι.app b) ≫ θ.app a ◁ ι.naturality f ≫ (α_ (θ.app a) (ι.app a) (H.map f)).inv
state_after: no goals
tactic: simp
Theorem: Int.fract_mul_nat
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✝ a : α
b : ℕ
⊢ ∃ z, fract a * ↑b - fract (a * ↑b) = ↑z
state_after: case zero
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ ∃ z, fract a * ↑0 - fract (a * ↑0) = ↑z

case succ
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
c : ℕ
hc : ∃ z, fract a * ↑c - fract (a * ↑c) = ↑z
⊢ ∃ z, fract a * ↑(c + 1) - fract (a * ↑(c + 1)) = ↑z
tactic: induction' b with c hc
Theorem: Ordinal.pred_eq_iff_not_succ'
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
⊢ o.pred = o ↔ ∀ (a : Ordinal.{u_4}), o ≠ succ a
state_after: no goals
tactic: simpa using pred_eq_iff_not_succ
Theorem: Polynomial.derivative_C_mul_X
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝ : Semiring R
a : R
⊢ derivative (C a * X) = C a
state_after: no goals
tactic: simp [C_mul_X_eq_monomial, derivative_monomial, Nat.cast_one, mul_one]
Theorem: CategoryTheory.Limits.biprod.mapBiprod_hom_desc
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

Proof steps:
state_before: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
inst✝² : F.PreservesZeroMorphisms
X Y : C
inst✝¹ : HasBinaryBiproduct X Y
inst✝ : PreservesBinaryBiproduct X Y F
W : C
f : X ⟶ W
g : Y ⟶ W
⊢ (F.mapBiprod X Y).hom ≫ desc (F.map f) (F.map g) = F.map (desc f g)
state_after: no goals
tactic: rw [← biprod.mapBiprod_inv_map_desc, Iso.hom_inv_id_assoc]
Theorem: Monoid.PushoutI.NormalWord.empty_head
File: Mathlib/GroupTheory/PushoutI.lean

Proof steps:
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝² : Monoid K
inst✝¹ : (i : ι) → Group (G i)
inst✝ : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
i : ι
g : G i
⊢ ⟨i, g⟩ ∈ Word.empty.toList → g ∈ d.set i
state_after: no goals
tactic: simp [CoprodI.Word.empty]
Theorem: Stirling.log_stirlingSeq_diff_hasSum
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

Proof steps:
state_before: m : ℕ
⊢ HasSum (fun k => 1 / (2 * ↑(k + 1) + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ (k + 1))
    (Real.log (stirlingSeq (m + 1)) - Real.log (stirlingSeq (m + 2)))
state_after: m : ℕ
f : ℕ → ℝ := fun k => 1 / (2 * ↑k + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ k
⊢ HasSum (fun k => 1 / (2 * ↑(k + 1) + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ (k + 1))
    (Real.log (stirlingSeq (m + 1)) - Real.log (stirlingSeq (m + 2)))
tactic: let f (k : ℕ) := (1 : ℝ) / (2 * k + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ k
state_before: m : ℕ
f : ℕ → ℝ := fun k => 1 / (2 * ↑k + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ k
⊢ HasSum (fun k => 1 / (2 * ↑(k + 1) + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ (k + 1))
    (Real.log (stirlingSeq (m + 1)) - Real.log (stirlingSeq (m + 2)))
state_after: m : ℕ
f : ℕ → ℝ := fun k => 1 / (2 * ↑k + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ k
⊢ HasSum (fun k => f (k + 1)) (Real.log (stirlingSeq (m + 1)) - Real.log (stirlingSeq (m + 2)))
tactic: change HasSum (fun k => f (k + 1)) _
state_before: m : ℕ
f : ℕ → ℝ := fun k => 1 / (2 * ↑k + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ k
⊢ HasSum (fun k => f (k + 1)) (Real.log (stirlingSeq (m + 1)) - Real.log (stirlingSeq (m + 2)))
state_after: m : ℕ
f : ℕ → ℝ := fun k => 1 / (2 * ↑k + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ k
⊢ HasSum f (Real.log (stirlingSeq (m + 1)) - Real.log (stirlingSeq (m + 2)) + ∑ i ∈ range 1, f i)
tactic: rw [hasSum_nat_add_iff]
state_before: m : ℕ
f : ℕ → ℝ := fun k => 1 / (2 * ↑k + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ k
⊢ HasSum f (Real.log (stirlingSeq (m + 1)) - Real.log (stirlingSeq (m + 2)) + ∑ i ∈ range 1, f i)
state_after: case h.e'_5
m : ℕ
f : ℕ → ℝ := fun k => 1 / (2 * ↑k + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ k
⊢ f = fun i => (↑(m + 1) + 1 / 2) * (2 * (1 / (2 * ↑i + 1)) * (1 / (2 * (↑m + 1) + 1)) ^ (2 * i + 1))

case h.e'_6
m : ℕ
f : ℕ → ℝ := fun k => 1 / (2 * ↑k + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ k
⊢ Real.log (stirlingSeq (m + 1)) - Real.log (stirlingSeq (m + 2)) + ∑ i ∈ range 1, f i =
    (↑(m + 1) + 1 / 2) * Real.log (1 + (↑m + 1)⁻¹)
tactic: convert (hasSum_log_one_add_inv m.cast_add_one_pos).mul_left ((↑(m + 1) : ℝ) + 1 / 2) using 1
Theorem: AnalyticAt.comp_of_eq
File: Mathlib/Analysis/Analytic/Composition.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
g : F → G
f : E → F
y : F
x : E
hg : AnalyticAt 𝕜 g y
hf : AnalyticAt 𝕜 f x
hy : f x = y
⊢ AnalyticAt 𝕜 (g ∘ f) x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
g : F → G
f : E → F
y : F
x : E
hg : AnalyticAt 𝕜 g (f x)
hf : AnalyticAt 𝕜 f x
hy : f x = y
⊢ AnalyticAt 𝕜 (g ∘ f) x
tactic: rw [← hy] at hg
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
g : F → G
f : E → F
y : F
x : E
hg : AnalyticAt 𝕜 g (f x)
hf : AnalyticAt 𝕜 f x
hy : f x = y
⊢ AnalyticAt 𝕜 (g ∘ f) x
state_after: no goals
tactic: exact hg.comp hf
Theorem: UnitalShelf.act_act_self_eq
File: Mathlib/Algebra/Quandle.lean

Proof steps:
state_before: S : Type u_1
inst✝ : UnitalShelf S
x y : S
⊢ (x ◃ y) ◃ x = x ◃ y
state_after: S : Type u_1
inst✝ : UnitalShelf S
x y : S
h : (x ◃ y) ◃ x = (x ◃ y) ◃ x ◃ 1
⊢ (x ◃ y) ◃ x = x ◃ y
tactic: have h : (x ◃ y) ◃ x = (x ◃ y) ◃ (x ◃ 1) := by rw [act_one]
state_before: S : Type u_1
inst✝ : UnitalShelf S
x y : S
h : (x ◃ y) ◃ x = (x ◃ y) ◃ x ◃ 1
⊢ (x ◃ y) ◃ x = x ◃ y
state_after: no goals
tactic: rw [h, ← Shelf.self_distrib, act_one]
Theorem: Finmap.mem_lookup_iff
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
a : α
b : β a
⊢ b ∈ lookup a s ↔ ⟨a, b⟩ ∈ s.entries
state_after: case mk.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
entries✝ : Multiset (Sigma β)
l : List (Sigma β)
hl : Multiset.NodupKeys (Quot.mk Setoid.r l)
⊢ b ∈ lookup a { entries := Quot.mk Setoid.r l, nodupKeys := hl } ↔
    ⟨a, b⟩ ∈ { entries := Quot.mk Setoid.r l, nodupKeys := hl }.entries
tactic: rcases s with ⟨⟨l⟩, hl⟩
state_before: case mk.mk
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
entries✝ : Multiset (Sigma β)
l : List (Sigma β)
hl : Multiset.NodupKeys (Quot.mk Setoid.r l)
⊢ b ∈ lookup a { entries := Quot.mk Setoid.r l, nodupKeys := hl } ↔
    ⟨a, b⟩ ∈ { entries := Quot.mk Setoid.r l, nodupKeys := hl }.entries
state_after: no goals
tactic: exact List.mem_dlookup_iff hl
Theorem: Ordinal.range_enumOrd
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: S : Set Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ range (enumOrd S) = S
state_after: S : Set Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ (∀ (a : Ordinal.{u}), enumOrd S a ∈ S) ∧ ∀ b ∈ S, ∃ a, enumOrd S a = b
tactic: rw [range_eq_iff]
state_before: S : Set Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ (∀ (a : Ordinal.{u}), enumOrd S a ∈ S) ∧ ∀ b ∈ S, ∃ a, enumOrd S a = b
state_after: no goals
tactic: exact ⟨enumOrd_mem hS, enumOrd_surjective hS⟩
Theorem: PartitionOfUnity.coe_finsupport
File: Mathlib/Topology/PartitionOfUnity.lean

Proof steps:
state_before: ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type u_1
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s✝ : Set X
f : PartitionOfUnity ι X s✝
s : Set X
ρ : PartitionOfUnity ι X s
x₀✝ x₀ : X
⊢ ↑(ρ.finsupport x₀) = support fun i => (ρ i) x₀
state_after: case h
ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type u_1
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s✝ : Set X
f : PartitionOfUnity ι X s✝
s : Set X
ρ : PartitionOfUnity ι X s
x₀✝ x₀ : X
x✝ : ι
⊢ x✝ ∈ ↑(ρ.finsupport x₀) ↔ x✝ ∈ support fun i => (ρ i) x₀
tactic: ext
state_before: case h
ι : Type u
X : Type v
inst✝⁴ : TopologicalSpace X
E : Type u_1
inst✝³ : AddCommMonoid E
inst✝² : SMulWithZero ℝ E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
s✝ : Set X
f : PartitionOfUnity ι X s✝
s : Set X
ρ : PartitionOfUnity ι X s
x₀✝ x₀ : X
x✝ : ι
⊢ x✝ ∈ ↑(ρ.finsupport x₀) ↔ x✝ ∈ support fun i => (ρ i) x₀
state_after: no goals
tactic: rw [Finset.mem_coe, mem_finsupport]
Theorem: LinearMap.toMatrix'_algebraMap
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommSemiring R
k : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
inst✝¹ : DecidableEq n
inst✝ : Fintype n
x : R
⊢ toMatrix' ((algebraMap R (Module.End R (n → R))) x) = (scalar n) x
state_after: no goals
tactic: simp [Module.algebraMap_end_eq_smul_id, smul_eq_diagonal_mul]
Theorem: LieIdeal.map_eq_bot_iff
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ map f I = ⊥ ↔ I ≤ f.ker
state_after: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ map f I ≤ ⊥ ↔ I ≤ f.ker
tactic: rw [← le_bot_iff]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ map f I ≤ ⊥ ↔ I ≤ f.ker
state_after: no goals
tactic: exact LieIdeal.map_le_iff_le_comap
Theorem: IsOfFinOrder.finite_powers
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
ha : IsOfFinOrder a
⊢ (↑(powers a)).Finite
state_after: no goals
tactic: classical rw [ha.powers_eq_image_range_orderOf]; exact Finset.finite_toSet _
Theorem: Nat.prime_two
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n : ℕ
⊢ Prime 2
state_after: no goals
tactic: decide
Theorem: posPart_inf_negPart_eq_zero
File: Mathlib/Algebra/Order/Group/PosPart.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Lattice α
inst✝² : Group α
a✝ : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ a⁺ᵐ ⊓ a⁻ᵐ = 1
state_after: no goals
tactic: rw [← mul_left_inj a⁻ᵐ⁻¹, inf_mul, one_mul, mul_right_inv, ← div_eq_mul_inv,
    oneLePart_div_leOnePart, leOnePart_eq_inv_inf_one, inv_inv]
Theorem: CategoryTheory.Limits.colimit.pre_id
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

Proof steps:
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F✝ : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F✝ ⟶ G
F : J ⥤ C
⊢ pre F (𝟭 J) = colim.map F.leftUnitor.hom
state_after: no goals
tactic: aesop_cat
Theorem: CoxeterSystem.subgroup_closure_range_simple
File: Mathlib/GroupTheory/Coxeter/Basic.lean

Proof steps:
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ Subgroup.closure (Set.range cs.simple) = ⊤
state_after: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
this : cs.simple = ⇑cs.mulEquiv.symm ∘ PresentedGroup.of
⊢ Subgroup.closure (Set.range cs.simple) = ⊤
tactic: have : cs.simple = cs.mulEquiv.symm ∘ PresentedGroup.of := rfl
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
this : cs.simple = ⇑cs.mulEquiv.symm ∘ PresentedGroup.of
⊢ Subgroup.closure (Set.range cs.simple) = ⊤
state_after: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
this : cs.simple = ⇑cs.mulEquiv.symm ∘ PresentedGroup.of
⊢ cs.mulEquiv.symm.toMonoidHom.range = ⊤
tactic: rw [this, Set.range_comp, ← MulEquiv.coe_toMonoidHom, ← MonoidHom.map_closure,
    PresentedGroup.closure_range_of, ← MonoidHom.range_eq_map]
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
this : cs.simple = ⇑cs.mulEquiv.symm ∘ PresentedGroup.of
⊢ cs.mulEquiv.symm.toMonoidHom.range = ⊤
state_after: no goals
tactic: exact MonoidHom.range_top_of_surjective _ (MulEquiv.surjective _)
Theorem: MeasureTheory.generateFrom_measurableCylinders
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s t : Set ((i : ι) → α i)
⊢ MeasurableSpace.generateFrom (measurableCylinders α) = MeasurableSpace.pi
state_after: case a
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s t : Set ((i : ι) → α i)
⊢ MeasurableSpace.generateFrom (measurableCylinders α) ≤ MeasurableSpace.pi

case a
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → MeasurableSpace (α i)
s t : Set ((i : ι) → α i)
⊢ MeasurableSpace.pi ≤ MeasurableSpace.generateFrom (measurableCylinders α)
tactic: apply le_antisymm
Theorem: PartialEquiv.exists_mem_target
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
p : β → Prop
⊢ (∃ y ∈ e.target, p y) ↔ ∃ x ∈ e.source, p (↑e x)
state_after: no goals
tactic: rw [← image_source_eq_target, exists_mem_image]
Theorem: Module.finrank_le_one_iff_top_isPrincipal
File: Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝⁵ : Ring K
inst✝⁴ : StrongRankCondition K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : Free K V
inst✝ : Finite K V
⊢ finrank K V ≤ 1 ↔ ⊤.IsPrincipal
state_after: no goals
tactic: rw [← Module.rank_le_one_iff_top_isPrincipal, ← finrank_eq_rank, ← natCast_le, Nat.cast_one]
Theorem: MeasureTheory.convolution_zero
File: Mathlib/Analysis/Convolution.lean

Proof steps:
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup E'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : NormedSpace 𝕜 E''
inst✝³ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝² : MeasurableSpace G
μ ν : Measure G
inst✝¹ : NormedSpace ℝ F
inst✝ : AddGroup G
⊢ f ⋆[L, μ] 0 = 0
state_after: case h
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup E'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : NormedSpace 𝕜 E''
inst✝³ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝² : MeasurableSpace G
μ ν : Measure G
inst✝¹ : NormedSpace ℝ F
inst✝ : AddGroup G
x✝ : G
⊢ (f ⋆[L, μ] 0) x✝ = 0 x✝
tactic: ext
state_before: case h
𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup E'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F
f f' : G → E
g g' : G → E'
x x' : G
y y' : E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : NormedSpace 𝕜 E''
inst✝³ : NormedSpace 𝕜 F
L : E →L[𝕜] E' →L[𝕜] F
inst✝² : MeasurableSpace G
μ ν : Measure G
inst✝¹ : NormedSpace ℝ F
inst✝ : AddGroup G
x✝ : G
⊢ (f ⋆[L, μ] 0) x✝ = 0 x✝
state_after: no goals
tactic: simp_rw [convolution_def, Pi.zero_apply, (L _).map_zero, integral_zero]
Theorem: CategoryTheory.InjectiveResolution.desc_commutes_zero
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
Y Z : C
f : Z ⟶ Y
I : InjectiveResolution Y
J : InjectiveResolution Z
⊢ ((CochainComplex.single₀ C).map f ≫ I.ι).f 0 = f ≫ I.ι.f 0
state_after: no goals
tactic: simp
Theorem: Functor.Comp.id_map
File: Mathlib/Control/Functor.lean

Proof steps:
state_before: F : Type u → Type w
G : Type v → Type u
inst✝³ : Functor F
inst✝² : Functor G
inst✝¹ : LawfulFunctor F
inst✝ : LawfulFunctor G
α β γ : Type v
x : F (G α)
⊢ Comp.map id (mk x) = mk x
state_after: F : Type u → Type w
G : Type v → Type u
inst✝³ : Functor F
inst✝² : Functor G
inst✝¹ : LawfulFunctor F
inst✝ : LawfulFunctor G
α β γ : Type v
x : F (G α)
⊢ mk (mk x) = mk x
tactic: simp only [Comp.map, id_map, id_map']
state_before: F : Type u → Type w
G : Type v → Type u
inst✝³ : Functor F
inst✝² : Functor G
inst✝¹ : LawfulFunctor F
inst✝ : LawfulFunctor G
α β γ : Type v
x : F (G α)
⊢ mk (mk x) = mk x
state_after: no goals
tactic: rfl
Theorem: NumberField.InfinitePlace.not_isReal_iff_isComplex
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
w : InfinitePlace K
⊢ ¬w.IsReal ↔ w.IsComplex
state_after: no goals
tactic: rw [isComplex_iff, isReal_iff]
Theorem: List.countP_filter
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ countP p (filter q l) = countP (fun a => decide (p a = true ∧ q a = true)) l
state_after: no goals
tactic: simp only [countP_eq_length_filter, filter_filter]