ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: NormedRing.tsum_geometric_of_norm_lt_one
File: Mathlib/Analysis/SpecificLimits/Normed.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
⊢ ‖∑' (n : ℕ), x ^ n‖ ≤ ‖1‖ - 1 + (1 - ‖x‖)⁻¹
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
⊢ ‖x ^ 0 + ∑' (b : ℕ), x ^ (b + 1)‖ ≤ ‖1‖ - 1 + (1 - ‖x‖)⁻¹
tactic: rw [tsum_eq_zero_add (summable_geometric_of_norm_lt_one x h)]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
⊢ ‖x ^ 0 + ∑' (b : ℕ), x ^ (b + 1)‖ ≤ ‖1‖ - 1 + (1 - ‖x‖)⁻¹
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
⊢ ‖1 + ∑' (b : ℕ), x ^ (b + 1)‖ ≤ ‖1‖ - 1 + (1 - ‖x‖)⁻¹
tactic: simp only [_root_.pow_zero]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
⊢ ‖1 + ∑' (b : ℕ), x ^ (b + 1)‖ ≤ ‖1‖ - 1 + (1 - ‖x‖)⁻¹
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
⊢ ‖1‖ + ‖∑' (b : ℕ), x ^ (b + 1)‖ ≤ ‖1‖ - 1 + (1 - ‖x‖)⁻¹
tactic: refine le_trans (norm_add_le _ _) ?_
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
⊢ ‖1‖ + ‖∑' (b : ℕ), x ^ (b + 1)‖ ≤ ‖1‖ - 1 + (1 - ‖x‖)⁻¹
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
this : ‖∑' (b : ℕ), (fun n => x ^ (n + 1)) b‖ ≤ (1 - ‖x‖)⁻¹ - 1
⊢ ‖1‖ + ‖∑' (b : ℕ), x ^ (b + 1)‖ ≤ ‖1‖ - 1 + (1 - ‖x‖)⁻¹
tactic: have : ‖∑' b : ℕ, (fun n ↦ x ^ (n + 1)) b‖ ≤ (1 - ‖x‖)⁻¹ - 1 := by
    refine tsum_of_norm_bounded ?_ fun b ↦ norm_pow_le' _ (Nat.succ_pos b)
    convert (hasSum_nat_add_iff' 1).mpr (hasSum_geometric_of_lt_one (norm_nonneg x) h)
    simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
R : Type u_4
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : R
h : ‖x‖ < 1
this : ‖∑' (b : ℕ), (fun n => x ^ (n + 1)) b‖ ≤ (1 - ‖x‖)⁻¹ - 1
⊢ ‖1‖ + ‖∑' (b : ℕ), x ^ (b + 1)‖ ≤ ‖1‖ - 1 + (1 - ‖x‖)⁻¹
state_after: no goals
tactic: linarith
Theorem: ExteriorAlgebra.liftAlternating_apply_ιMulti
File: Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n : ℕ
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
v : Fin n → M
⊢ (liftAlternating f) ((ιMulti R n) v) = (f n) v
state_after: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n : ℕ
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
v : Fin n → M
⊢ (liftAlternating f) (List.ofFn fun i => (ι R) (v i)).prod = (f n) v
tactic: rw [ιMulti_apply]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n : ℕ
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
v : Fin n → M
⊢ (liftAlternating f) (List.ofFn fun i => (ι R) (v i)).prod = (f n) v
state_after: case zero
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
v : Fin 0 → M
⊢ (liftAlternating f) (List.ofFn fun i => (ι R) (v i)).prod = (f 0) v

case succ
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
n : ℕ
ih :
  ∀ (f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N) (v : Fin n → M),
    (liftAlternating f) (List.ofFn fun i => (ι R) (v i)).prod = (f n) v
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
v : Fin (n + 1) → M
⊢ (liftAlternating f) (List.ofFn fun i => (ι R) (v i)).prod = (f (n + 1)) v
tactic: induction' n with n ih generalizing f
Theorem: Int.pred_iterate
File: Mathlib/Data/Int/SuccPred.lean

Proof steps:
state_before: a : ℤ
n : ℕ
⊢ pred^[n + 1] a = a - ↑(n + 1)
state_after: a : ℤ
n : ℕ
⊢ (pred ∘ pred^[n]) a = a - ↑n - 1
tactic: rw [Function.iterate_succ', Int.ofNat_succ, ← sub_sub]
state_before: a : ℤ
n : ℕ
⊢ (pred ∘ pred^[n]) a = a - ↑n - 1
state_after: no goals
tactic: exact congr_arg _ (pred_iterate a n)
Theorem: finprod_mem_one
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s✝ t s : Set α
⊢ ∏ᶠ (i : α) (_ : i ∈ s), 1 = 1
state_after: no goals
tactic: simp
Theorem: pow_mem_range_pow_of_coprime
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommGroupWithZero α
a✝ b : α
m n : ℕ
hmn : m.Coprime n
a : α
⊢ (a ^ m ∈ Set.range fun x => x ^ n) ↔ a ∈ Set.range fun x => x ^ n
state_after: α : Type u_1
inst✝ : CommGroupWithZero α
a✝ b : α
m n : ℕ
hmn : m.Coprime n
a : α
⊢ (∃ y c, y = c ^ m ∧ a = c ^ n) ↔ ∃ y, y ^ n = a
tactic: simp [pow_eq_pow_iff_of_coprime hmn.symm]
state_before: α : Type u_1
inst✝ : CommGroupWithZero α
a✝ b : α
m n : ℕ
hmn : m.Coprime n
a : α
⊢ (∃ y c, y = c ^ m ∧ a = c ^ n) ↔ ∃ y, y ^ n = a
state_after: no goals
tactic: aesop
Theorem: gaussSum_sq
File: Mathlib/NumberTheory/GaussSum.lean

Proof steps:
state_before: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ ^ 2 = χ (-1) * ↑(Fintype.card R)
state_after: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ * gaussSum χ ψ = gaussSum χ ψ * (gaussSum χ ψ⁻¹ * χ (-1))
tactic: rw [pow_two, ← gaussSum_mul_gaussSum_eq_card hχ₁ hψ, hχ₂.inv, mul_rotate']
state_before: R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ * gaussSum χ ψ = gaussSum χ ψ * (gaussSum χ ψ⁻¹ * χ (-1))
state_after: case e_a
R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ = gaussSum χ ψ⁻¹ * χ (-1)
tactic: congr
state_before: case e_a
R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ gaussSum χ ψ = gaussSum χ ψ⁻¹ * χ (-1)
state_after: case e_a
R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ χ ↑(-1) * gaussSum χ (ψ.mulShift ↑(-1)) = χ (-1) * gaussSum χ (ψ.mulShift (-1))
tactic: rw [mul_comm, ← gaussSum_mulShift _ _ (-1 : Rˣ), inv_mulShift]
state_before: case e_a
R : Type u
inst✝³ : Field R
inst✝² : Fintype R
R' : Type v
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
χ : MulChar R R'
hχ₁ : χ ≠ 1
hχ₂ : χ.IsQuadratic
ψ : AddChar R R'
hψ : ψ.IsPrimitive
⊢ χ ↑(-1) * gaussSum χ (ψ.mulShift ↑(-1)) = χ (-1) * gaussSum χ (ψ.mulShift (-1))
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.prodOpEquiv_counitIso
File: Mathlib/CategoryTheory/Products/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
x✝ : (C × D)ᵒᵖ
X : C
Y : D
⊢ { obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op), map_id := ⋯,
            map_comp := ⋯ }.map
        ((Iso.refl (𝟭 (C × D)ᵒᵖ)).hom.app (op (X, Y))) ≫
      (Iso.refl
              ({
                  obj := fun x =>
                    match x with
                    | (X, Y) => op (unop X, unop Y),
                  map := fun {X Y} x =>
                    match x with
                    | (f, g) => op (f.unop, g.unop),
                  map_id := ⋯, map_comp := ⋯ } ⋙
                { obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op),
                  map_id := ⋯, map_comp := ⋯ })).hom.app
        ({ obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op),
              map_id := ⋯, map_comp := ⋯ }.obj
          (op (X, Y))) =
    𝟙
      ({ obj := fun X => (op (unop X).1, op (unop X).2), map := fun {X Y} f => (f.unop.1.op, f.unop.2.op), map_id := ⋯,
            map_comp := ⋯ }.obj
        (op (X, Y)))
state_after: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
x✝ : (C × D)ᵒᵖ
X : C
Y : D
⊢ (𝟙 (op X) ≫ 𝟙 (op X), 𝟙 (op Y) ≫ 𝟙 (op Y)) = (𝟙 (op X), 𝟙 (op Y))
tactic: dsimp
state_before: A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
x✝ : (C × D)ᵒᵖ
X : C
Y : D
⊢ (𝟙 (op X) ≫ 𝟙 (op X), 𝟙 (op Y) ≫ 𝟙 (op Y)) = (𝟙 (op X), 𝟙 (op Y))
state_after: no goals
tactic: ext <;> apply Category.id_comp
Theorem: MeasureTheory.StronglyMeasurable.measurableSet_lt
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
f✝ g✝ : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : LinearOrder β
inst✝¹ : OrderClosedTopology β
inst✝ : PseudoMetrizableSpace β
f g : α → β
hf : StronglyMeasurable f
hg : StronglyMeasurable g
⊢ MeasurableSet {a | f a < g a}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
f✝ g✝ : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : LinearOrder β
inst✝¹ : OrderClosedTopology β
inst✝ : PseudoMetrizableSpace β
f g : α → β
hf : StronglyMeasurable f
hg : StronglyMeasurable g
this✝¹ : MeasurableSpace (β × β) := borel (β × β)
this✝ : BorelSpace (β × β)
⊢ MeasurableSet {a | f a < g a}
tactic: borelize (β × β)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
f✝ g✝ : α → β
m : MeasurableSpace α
inst✝³ : TopologicalSpace β
inst✝² : LinearOrder β
inst✝¹ : OrderClosedTopology β
inst✝ : PseudoMetrizableSpace β
f g : α → β
hf : StronglyMeasurable f
hg : StronglyMeasurable g
this✝¹ : MeasurableSpace (β × β) := borel (β × β)
this✝ : BorelSpace (β × β)
⊢ MeasurableSet {a | f a < g a}
state_after: no goals
tactic: exact (hf.prod_mk hg).measurable isOpen_lt_prod.measurableSet
Theorem: EReal.mul_div
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: a b c : EReal
⊢ a * (b / c) = a * b / c
state_after: a b c : EReal
⊢ a * (b * c⁻¹) = a * b * c⁻¹
tactic: change a * (b * c⁻¹) = (a * b) * c⁻¹
state_before: a b c : EReal
⊢ a * (b * c⁻¹) = a * b * c⁻¹
state_after: no goals
tactic: rw [mul_assoc]
Theorem: AddSemiconjBy.neg_right_iff
File: Mathlib/Algebra/Group/Semiconj/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
a x y : G
⊢ SemiconjBy a x⁻¹ y⁻¹ ↔ SemiconjBy a x y
state_after: no goals
tactic: rw [← inv_symm_left_iff, inv_inv_symm_iff]
Theorem: Submonoid.LocalizationMap.inv_unique
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : ↥S), IsUnit (f ↑y)
y : ↥S
z : N
H : f ↑y * z = 1
⊢ ↑((IsUnit.liftRight (f.restrict S) h) y)⁻¹ = z
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : ↥S), IsUnit (f ↑y)
y : ↥S
z : N
H : f ↑y * z = 1
⊢ ↑1 = f ↑y * z
tactic: rw [← one_mul _⁻¹, Units.val_mul, mul_inv_left]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : ↥S), IsUnit (f ↑y)
y : ↥S
z : N
H : f ↑y * z = 1
⊢ ↑1 = f ↑y * z
state_after: no goals
tactic: exact H.symm
Theorem: TopologicalSpace.IsTopologicalBasis.inf_induced
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
γ : Type u_2
s : TopologicalSpace β
B₁ : Set (Set α)
B₂ : Set (Set β)
h₁ : IsTopologicalBasis B₁
h₂ : IsTopologicalBasis B₂
f₁ : γ → α
f₂ : γ → β
⊢ IsTopologicalBasis (image2 (fun x x_1 => f₁ ⁻¹' x ∩ f₂ ⁻¹' x_1) B₁ B₂)
state_after: no goals
tactic: simpa only [image2_image_left, image2_image_right] using (h₁.induced f₁).inf (h₂.induced f₂)
Theorem: TensorProduct.forall_vanishesTrivially_iff_forall_rTensor_injective
File: Mathlib/LinearAlgebra/TensorProduct/Vanishing.lean

Proof steps:
state_before: R : Type u
inst✝⁵ : CommRing R
M : Type u
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : Type u
inst✝² : AddCommGroup N
inst✝¹ : Module R N
ι : Type u
inst✝ : Fintype ι
m : ι → M
n : ι → N
⊢ (∀ {ι : Type u} [inst : Fintype ι] {m : ι → M} {n : ι → N}, ∑ i : ι, m i ⊗ₜ[R] n i = 0 → VanishesTrivially R m n) ↔
    ∀ (M' : Submodule R M), Injective ⇑(rTensor N M'.subtype)
state_after: case mp
R : Type u
inst✝⁵ : CommRing R
M : Type u
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : Type u
inst✝² : AddCommGroup N
inst✝¹ : Module R N
ι : Type u
inst✝ : Fintype ι
m : ι → M
n : ι → N
⊢ (∀ {ι : Type u} [inst : Fintype ι] {m : ι → M} {n : ι → N}, ∑ i : ι, m i ⊗ₜ[R] n i = 0 → VanishesTrivially R m n) →
    ∀ (M' : Submodule R M), Injective ⇑(rTensor N M'.subtype)

case mpr
R : Type u
inst✝⁵ : CommRing R
M : Type u
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : Type u
inst✝² : AddCommGroup N
inst✝¹ : Module R N
ι : Type u
inst✝ : Fintype ι
m : ι → M
n : ι → N
⊢ (∀ (M' : Submodule R M), Injective ⇑(rTensor N M'.subtype)) →
    ∀ {ι : Type u} [inst : Fintype ι] {m : ι → M} {n : ι → N}, ∑ i : ι, m i ⊗ₜ[R] n i = 0 → VanishesTrivially R m n
tactic: constructor
Theorem: CategoryTheory.Equivalence.unop_functor
File: Mathlib/CategoryTheory/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ e.functor.unop.map ((NatIso.unop e.unitIso).symm.hom.app X) ≫
      (NatIso.unop e.counitIso).symm.hom.app (e.functor.unop.obj X) =
    𝟙 (e.functor.unop.obj X)
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ (e.functor.unop.map ((NatIso.unop e.unitIso).symm.hom.app X) ≫
        (NatIso.unop e.counitIso).symm.hom.app (e.functor.unop.obj X)).op =
    (𝟙 (e.functor.unop.obj X)).op
tactic: apply Quiver.Hom.op_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ (e.functor.unop.map ((NatIso.unop e.unitIso).symm.hom.app X) ≫
        (NatIso.unop e.counitIso).symm.hom.app (e.functor.unop.obj X)).op =
    (𝟙 (e.functor.unop.obj X)).op
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ e.counitIso.inv.app (e.functor.obj (Opposite.op X)) ≫ e.functor.map (e.unitIso.inv.app (Opposite.op X)) =
    𝟙 (e.functor.obj (Opposite.op X))
tactic: dsimp
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ e.counitIso.inv.app (e.functor.obj (Opposite.op X)) ≫ e.functor.map (e.unitIso.inv.app (Opposite.op X)) =
    𝟙 (e.functor.obj (Opposite.op X))
state_after: no goals
tactic: simp
Theorem: symmDiff_symmDiff_right'
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ∆ (b ∆ c) = a ⊓ (b ⊓ c ⊔ bᶜ ⊓ cᶜ) ⊔ (b ⊓ cᶜ ⊔ c ⊓ bᶜ) ⊓ aᶜ
state_after: no goals
tactic: rw [symmDiff_eq, compl_symmDiff, bihimp_eq', symmDiff_eq]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ⊓ (b ⊓ c ⊔ bᶜ ⊓ cᶜ) ⊔ (b ⊓ cᶜ ⊔ c ⊓ bᶜ) ⊓ aᶜ = a ⊓ b ⊓ c ⊔ a ⊓ bᶜ ⊓ cᶜ ⊔ b ⊓ cᶜ ⊓ aᶜ ⊔ c ⊓ bᶜ ⊓ aᶜ
state_after: no goals
tactic: rw [inf_sup_left, inf_sup_right, ← sup_assoc, ← inf_assoc, ← inf_assoc]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ⊓ b ⊓ c ⊔ a ⊓ bᶜ ⊓ cᶜ ⊔ b ⊓ cᶜ ⊓ aᶜ ⊔ c ⊓ bᶜ ⊓ aᶜ = a ⊓ b ⊓ c ⊔ a ⊓ bᶜ ⊓ cᶜ ⊔ aᶜ ⊓ b ⊓ cᶜ ⊔ aᶜ ⊓ bᶜ ⊓ c
state_after: case e_a
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ a ⊓ b ⊓ c ⊔ a ⊓ bᶜ ⊓ cᶜ ⊔ b ⊓ cᶜ ⊓ aᶜ = a ⊓ b ⊓ c ⊔ a ⊓ bᶜ ⊓ cᶜ ⊔ aᶜ ⊓ b ⊓ cᶜ

case e_a
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
⊢ c ⊓ bᶜ ⊓ aᶜ = aᶜ ⊓ bᶜ ⊓ c
tactic: congr 1
Theorem: Cardinal.nat_succ
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
n : ℕ
⊢ ↑n.succ = succ ↑n
state_after: α β : Type u
n : ℕ
⊢ ↑n + 1 = succ ↑n
tactic: rw [Nat.cast_succ]
state_before: α β : Type u
n : ℕ
⊢ ↑n + 1 = succ ↑n
state_after: α β : Type u
n : ℕ
⊢ ↑n < ↑n + 1
tactic: refine (add_one_le_succ _).antisymm (succ_le_of_lt ?_)
state_before: α β : Type u
n : ℕ
⊢ ↑n < ↑n + 1
state_after: α β : Type u
n : ℕ
⊢ ↑n < ↑n.succ
tactic: rw [← Nat.cast_succ]
state_before: α β : Type u
n : ℕ
⊢ ↑n < ↑n.succ
state_after: no goals
tactic: exact natCast_lt.2 (Nat.lt_succ_self _)
Theorem: MeasureTheory.tendstoInMeasure_of_tendsto_eLpNorm
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
f : ι → α → E
g : α → E
l : Filter ι
hp_ne_zero : p ≠ 0
hf : ∀ (n : ι), AEStronglyMeasurable (f n) μ
hg : AEStronglyMeasurable g μ
hfg : Tendsto (fun n => eLpNorm (f n - g) p μ) l (𝓝 0)
⊢ TendstoInMeasure μ f l g
state_after: case pos
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
f : ι → α → E
g : α → E
l : Filter ι
hp_ne_zero : p ≠ 0
hf : ∀ (n : ι), AEStronglyMeasurable (f n) μ
hg : AEStronglyMeasurable g μ
hfg : Tendsto (fun n => eLpNorm (f n - g) p μ) l (𝓝 0)
hp_ne_top : p = ⊤
⊢ TendstoInMeasure μ f l g

case neg
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup E
p : ℝ≥0∞
f : ι → α → E
g : α → E
l : Filter ι
hp_ne_zero : p ≠ 0
hf : ∀ (n : ι), AEStronglyMeasurable (f n) μ
hg : AEStronglyMeasurable g μ
hfg : Tendsto (fun n => eLpNorm (f n - g) p μ) l (𝓝 0)
hp_ne_top : ¬p = ⊤
⊢ TendstoInMeasure μ f l g
tactic: by_cases hp_ne_top : p = ∞
Theorem: Cardinal.one_le_ofENat
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: n : ℕ∞
⊢ 1 ≤ ↑n ↔ 1 ≤ n
state_after: no goals
tactic: norm_cast
Theorem: ContinuousMap.addUnitsLift_symm_apply_apply_neg'
File: Mathlib/Topology/ContinuousFunction/Units.lean

Proof steps:
state_before: X : Type u_1
M : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
f : C(X, M)ˣ
x : X
⊢ ↑((unitsLift.symm f) x)⁻¹ = ↑f⁻¹ x
state_after: no goals
tactic: rfl
Theorem: Commute.invOf_left
File: Mathlib/Algebra/Group/Invertible/Basic.lean

Proof steps:
state_before: α : Type u
inst✝¹ : Monoid α
a b : α
inst✝ : Invertible b
h : Commute b a
⊢ ⅟b * a = ⅟b * (a * b * ⅟b)
state_after: no goals
tactic: simp [mul_assoc]
state_before: α : Type u
inst✝¹ : Monoid α
a b : α
inst✝ : Invertible b
h : Commute b a
⊢ ⅟b * (a * b * ⅟b) = ⅟b * (b * a * ⅟b)
state_after: no goals
tactic: rw [h.eq]
state_before: α : Type u
inst✝¹ : Monoid α
a b : α
inst✝ : Invertible b
h : Commute b a
⊢ ⅟b * (b * a * ⅟b) = a * ⅟b
state_after: no goals
tactic: simp [mul_assoc]
Theorem: bernoulli_zero
File: Mathlib/NumberTheory/Bernoulli.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli 0 = 1
state_after: no goals
tactic: simp [bernoulli]
Theorem: Function.Commute.iterate_pos_le_iff_map_le'
File: Mathlib/Order/Iterate.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : StrictMono f
hg : Monotone g
x : α
n : ℕ
hn : 0 < n
⊢ f^[n] x ≤ g^[n] x ↔ f x ≤ g x
state_after: no goals
tactic: simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt hg hf hn)
Theorem: uniformEmbedding_set_inclusion
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s t : Set α
hst : s ⊆ t
⊢ comap (fun x => (inclusion hst x.1, inclusion hst x.2)) (𝓤 ↑t) = 𝓤 ↑s
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s t : Set α
hst : s ⊆ t
⊢ comap ((fun q => (↑q.1, ↑q.2)) ∘ fun x => (inclusion hst x.1, inclusion hst x.2)) (𝓤 α) =
    comap (fun q => (↑q.1, ↑q.2)) (𝓤 α)
tactic: rw [uniformity_subtype, uniformity_subtype, comap_comap]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s t : Set α
hst : s ⊆ t
⊢ comap ((fun q => (↑q.1, ↑q.2)) ∘ fun x => (inclusion hst x.1, inclusion hst x.2)) (𝓤 α) =
    comap (fun q => (↑q.1, ↑q.2)) (𝓤 α)
state_after: no goals
tactic: rfl
Theorem: Set.Sized.compls
File: Mathlib/Data/Finset/Sups.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : BooleanAlgebra α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a b c : α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
n : ℕ
h𝒜 : Set.Sized n ↑𝒜
s : Finset α
hs : s ∈ 𝒜
⊢ sᶜ.card = Fintype.card α - n
state_after: no goals
tactic: rw [Finset.card_compl, h𝒜 hs]
Theorem: Multiset.bind_singleton
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
f : α → β
⊢ (bind 0 fun x => {f x}) = map f 0
state_after: no goals
tactic: rw [zero_bind, map_zero]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g : α → Multiset β
f : α → β
⊢ ∀ (a : α) (s : Multiset α), (s.bind fun x => {f x}) = map f s → ((a ::ₘ s).bind fun x => {f x}) = map f (a ::ₘ s)
state_after: no goals
tactic: simp [singleton_add]
Theorem: eq_of_hammingDist_eq_zero
File: Mathlib/InformationTheory/Hamming.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝ : (i : ι) → DecidableEq (γ i)
x y : (i : ι) → β i
⊢ hammingDist x y = 0 → x = y
state_after: no goals
tactic: simp_rw [hammingDist, card_eq_zero, filter_eq_empty_iff, Classical.not_not, funext_iff, mem_univ,
    forall_true_left, imp_self]
Theorem: Ordinal.principal_mul_omega
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
m n : ℕ
ha : ↑m < ω
hb : ↑n < ω
⊢ (fun x x_1 => x * x_1) ↑m ↑n < ω
state_after: a b : Ordinal.{u_1}
m n : ℕ
ha : ↑m < ω
hb : ↑n < ω
⊢ ↑m * ↑n < ω
tactic: dsimp only
state_before: a b : Ordinal.{u_1}
m n : ℕ
ha : ↑m < ω
hb : ↑n < ω
⊢ ↑m * ↑n < ω
state_after: a b : Ordinal.{u_1}
m n : ℕ
ha : ↑m < ω
hb : ↑n < ω
⊢ ↑(m * n) < ω
tactic: rw [← natCast_mul]
state_before: a b : Ordinal.{u_1}
m n : ℕ
ha : ↑m < ω
hb : ↑n < ω
⊢ ↑(m * n) < ω
state_after: no goals
tactic: apply nat_lt_omega
Theorem: preNormEDS'_two
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
⊢ preNormEDS' b c d 2 = 1
state_after: no goals
tactic: rw [preNormEDS']