ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.ComposableArrows.isoMk₄_inv
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.337009, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 4
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ≅ g.obj' 4 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄.hom = app₃.hom ≫ g.map' 3 4 ⋯ ⋯
⊢ g.map' 0 1 ⋯ ⋯ ≫ app₁.inv = app₀.inv ≫ f.map' 0 1 ⋯ ⋯
state_after: no goals
tactic: rw [map'_inv_eq_inv_map' (by valid) app₀ app₁ w₀]
state_before: C : Type u_1
inst✝ : Category.{?u.337009, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 4
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ≅ g.obj' 4 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄.hom = app₃.hom ≫ g.map' 3 4 ⋯ ⋯
⊢ g.map' 1 2 ⋯ ⋯ ≫ app₂.inv = app₁.inv ≫ f.map' 1 2 ⋯ ⋯
state_after: no goals
tactic: rw [map'_inv_eq_inv_map' (by valid) app₁ app₂ w₁]
state_before: C : Type u_1
inst✝ : Category.{?u.337009, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 4
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ≅ g.obj' 4 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄.hom = app₃.hom ≫ g.map' 3 4 ⋯ ⋯
⊢ g.map' 2 3 ⋯ ⋯ ≫ app₃.inv = app₂.inv ≫ f.map' 2 3 ⋯ ⋯
state_after: no goals
tactic: rw [map'_inv_eq_inv_map' (by valid) app₂ app₃ w₂]
state_before: C : Type u_1
inst✝ : Category.{?u.337009, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 4
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ≅ g.obj' 4 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄.hom = app₃.hom ≫ g.map' 3 4 ⋯ ⋯
⊢ g.map' 3 4 ⋯ ⋯ ≫ app₄.inv = app₃.inv ≫ f.map' 3 4 ⋯ ⋯
state_after: no goals
tactic: rw [map'_inv_eq_inv_map' (by valid) app₃ app₄ w₃]
Theorem: Multiset.toFinset_prod_dvd_prod
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ S.toFinset.prod id ∣ S.prod
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ (map id S.toFinset.val).prod ∣ S.prod
tactic: rw [Finset.prod_eq_multiset_prod]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ (map id S.toFinset.val).prod ∣ S.prod
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ map id S.toFinset.val ≤ S
tactic: refine Multiset.prod_dvd_prod_of_le ?_
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
S : Multiset α
⊢ map id S.toFinset.val ≤ S
state_after: no goals
tactic: simp [Multiset.dedup_le S]
Theorem: Right.min_le_max_of_mul_le_mul
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Mul α
inst✝² : LinearOrder α
a b c d : α
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
h : a * b ≤ c * d
⊢ min a b ≤ max c d
state_after: α : Type u_1
β : Type u_2
inst✝³ : Mul α
inst✝² : LinearOrder α
a b c d : α
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
h : a * b ≤ c * d
⊢ (a ≤ c ∨ a ≤ d) ∨ b ≤ c ∨ b ≤ d
tactic: simp_rw [min_le_iff, le_max_iff]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Mul α
inst✝² : LinearOrder α
a b c d : α
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
h : a * b ≤ c * d
⊢ (a ≤ c ∨ a ≤ d) ∨ b ≤ c ∨ b ≤ d
state_after: α : Type u_1
β : Type u_2
inst✝³ : Mul α
inst✝² : LinearOrder α
a b c d : α
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
h : (c < a ∧ d < a) ∧ c < b ∧ d < b
⊢ c * d < a * b
tactic: contrapose! h
state_before: α : Type u_1
β : Type u_2
inst✝³ : Mul α
inst✝² : LinearOrder α
a b c d : α
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
h : (c < a ∧ d < a) ∧ c < b ∧ d < b
⊢ c * d < a * b
state_after: no goals
tactic: exact mul_lt_mul_of_lt_of_le h.1.1 h.2.2.le
Theorem: unitInterval.symm_symm
File: Mathlib/Topology/UnitInterval.lean

Proof steps:
state_before: x : ↑I
⊢ ↑(σ (σ x)) = ↑x
state_after: no goals
tactic: simp [symm]
Theorem: CategoryTheory.ShortComplex.Exact.epi_f_iff
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.69935, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ Epi S.f ↔ S.g = 0
state_after: case mp
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.69935, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ Epi S.f → S.g = 0

case mpr
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.69935, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ S.g = 0 → Epi S.f
tactic: constructor
Theorem: sub_pow_expChar_pow
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
q : ℕ
hR : ExpChar R q
n : ℕ
x y : R
⊢ (x - y) ^ q ^ n = x ^ q ^ n - y ^ q ^ n
state_after: case zero
R : Type u
inst✝¹ : CommRing R
n : ℕ
x y : R
inst✝ : CharZero R
⊢ (x - y) ^ 1 ^ n = x ^ 1 ^ n - y ^ 1 ^ n

case prime
R : Type u
inst✝ : CommRing R
q n : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x - y) ^ q ^ n = x ^ q ^ n - y ^ q ^ n
tactic: cases' hR with _ _ hprime _
state_before: case prime
R : Type u
inst✝ : CommRing R
q n : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
⊢ (x - y) ^ q ^ n = x ^ q ^ n - y ^ q ^ n
state_after: case prime
R : Type u
inst✝ : CommRing R
q n : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x - y) ^ q ^ n = x ^ q ^ n - y ^ q ^ n
tactic: haveI := Fact.mk hprime
state_before: case prime
R : Type u
inst✝ : CommRing R
q n : ℕ
x y : R
hprime : Nat.Prime q
hchar✝ : CharP R q
this : Fact (Nat.Prime q)
⊢ (x - y) ^ q ^ n = x ^ q ^ n - y ^ q ^ n
state_after: no goals
tactic: exact sub_pow_char_pow R x y
Theorem: AddCon.orderIsoOp_apply
File: Mathlib/GroupTheory/Congruence/Opposite.lean

Proof steps:
state_before: M : Type u_1
inst✝ : Mul M
c d : Con M
⊢ { toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } c ≤
      { toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } d ↔
    c ≤ d
state_after: M : Type u_1
inst✝ : Mul M
c d : Con M
⊢ (∀ {x y : Mᵐᵒᵖ},
      ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } c) x y →
        ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } d) x y) ↔
    ∀ {x y : M}, c x y → d x y
tactic: rw [le_def, le_def]
state_before: M : Type u_1
inst✝ : Mul M
c d : Con M
⊢ (∀ {x y : Mᵐᵒᵖ},
      ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } c) x y →
        ({ toFun := op, invFun := unop, left_inv := ⋯, right_inv := ⋯ } d) x y) ↔
    ∀ {x y : M}, c x y → d x y
state_after: no goals
tactic: constructor <;> intro h _ _ h' <;> exact h h'
Theorem: ProbabilityTheory.hasFiniteIntegral_compProd_iff'
File: Mathlib/Probability/Kernel/IntegralCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → E
h1f : AEStronglyMeasurable f ((κ ⊗ₖ η) a)
⊢ HasFiniteIntegral f ((κ ⊗ₖ η) a) ↔
    (∀ᵐ (x : β) ∂κ a, HasFiniteIntegral (fun y => f (x, y)) (η (a, x))) ∧
      HasFiniteIntegral (fun x => ∫ (y : γ), ‖f (x, y)‖ ∂η (a, x)) (κ a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → E
h1f : AEStronglyMeasurable f ((κ ⊗ₖ η) a)
⊢ (∀ᵐ (x : β) ∂κ a, HasFiniteIntegral (fun y => AEStronglyMeasurable.mk f h1f (x, y)) (η (a, x))) ∧
      HasFiniteIntegral (fun x => ∫ (y : γ), ‖AEStronglyMeasurable.mk f h1f (x, y)‖ ∂η (a, x)) (κ a) ↔
    (∀ᵐ (x : β) ∂κ a, HasFiniteIntegral (fun y => f (x, y)) (η (a, x))) ∧
      HasFiniteIntegral (fun x => ∫ (y : γ), ‖f (x, y)‖ ∂η (a, x)) (κ a)
tactic: rw [hasFiniteIntegral_congr h1f.ae_eq_mk,
    hasFiniteIntegral_compProd_iff h1f.stronglyMeasurable_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → E
h1f : AEStronglyMeasurable f ((κ ⊗ₖ η) a)
⊢ (∀ᵐ (x : β) ∂κ a, HasFiniteIntegral (fun y => AEStronglyMeasurable.mk f h1f (x, y)) (η (a, x))) ∧
      HasFiniteIntegral (fun x => ∫ (y : γ), ‖AEStronglyMeasurable.mk f h1f (x, y)‖ ∂η (a, x)) (κ a) ↔
    (∀ᵐ (x : β) ∂κ a, HasFiniteIntegral (fun y => f (x, y)) (η (a, x))) ∧
      HasFiniteIntegral (fun x => ∫ (y : γ), ‖f (x, y)‖ ∂η (a, x)) (κ a)
state_after: case h₁
α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → E
h1f : AEStronglyMeasurable f ((κ ⊗ₖ η) a)
⊢ (∀ᵐ (x : β) ∂κ a, HasFiniteIntegral (fun y => AEStronglyMeasurable.mk f h1f (x, y)) (η (a, x))) ↔
    ∀ᵐ (x : β) ∂κ a, HasFiniteIntegral (fun y => f (x, y)) (η (a, x))

case h₂
α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → E
h1f : AEStronglyMeasurable f ((κ ⊗ₖ η) a)
⊢ HasFiniteIntegral (fun x => ∫ (y : γ), ‖AEStronglyMeasurable.mk f h1f (x, y)‖ ∂η (a, x)) (κ a) ↔
    HasFiniteIntegral (fun x => ∫ (y : γ), ‖f (x, y)‖ ∂η (a, x)) (κ a)
tactic: apply and_congr
Theorem: hasSum_subtype_iff_of_support_subset
File: Mathlib/Topology/Algebra/InfiniteSum/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s✝ : Finset β
s : Set β
hf : mulSupport f ⊆ s
⊢ ∀ x ∉ Set.range fun a => ↑a, f x = 1
state_after: no goals
tactic: simpa using mulSupport_subset_iff'.1 hf
Theorem: MeasureTheory.OuterMeasure.restrict_sInf_eq_sInf_restrict
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

Proof steps:
state_before: α : Type u_1
m : Set (OuterMeasure α)
s : Set α
hm : m.Nonempty
⊢ (restrict s) (sInf m) = sInf (⇑(restrict s) '' m)
state_after: no goals
tactic: simp only [sInf_eq_iInf, restrict_biInf, hm, iInf_image]
Theorem: TrivSqZeroExt.inv_inv
File: Mathlib/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
x : tsze R M
hx : x.fst ≠ 0
⊢ x⁻¹⁻¹ = 1 * x⁻¹⁻¹
state_after: no goals
tactic: rw [one_mul]
state_before: R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
x : tsze R M
hx : x.fst ≠ 0
⊢ 1 * x⁻¹⁻¹ = x * x⁻¹ * x⁻¹⁻¹
state_after: no goals
tactic: rw [TrivSqZeroExt.mul_inv_cancel hx]
state_before: R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
x : tsze R M
hx : x.fst ≠ 0
⊢ x * x⁻¹ * x⁻¹⁻¹ = x
state_after: R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
x : tsze R M
hx : x.fst ≠ 0
⊢ x⁻¹.fst ≠ 0
tactic: rw [mul_assoc, TrivSqZeroExt.mul_inv_cancel, mul_one]
state_before: R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
x : tsze R M
hx : x.fst ≠ 0
⊢ x⁻¹.fst ≠ 0
state_after: R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
x : tsze R M
hx : x.fst ≠ 0
⊢ x.fst⁻¹ ≠ 0
tactic: rw [fst_inv]
state_before: R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
x : tsze R M
hx : x.fst ≠ 0
⊢ x.fst⁻¹ ≠ 0
state_after: no goals
tactic: apply inv_ne_zero hx
Theorem: Monoid.MulEquiv.coprodCongr_apply
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
M' : Type u_3
N' : Type u_4
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass M'
inst✝ : MulOneClass N'
e : M ≃* N
e' : M' ≃* N'
⊢ (Coprod.map ↑e.symm ↑e'.symm).comp (Coprod.map ↑e ↑e') = MonoidHom.id (M ∗ M')
state_after: no goals
tactic: ext <;> simp
state_before: M : Type u_1
N : Type u_2
M' : Type u_3
N' : Type u_4
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass M'
inst✝ : MulOneClass N'
e : M ≃* N
e' : M' ≃* N'
⊢ (Coprod.map ↑e ↑e').comp (Coprod.map ↑e.symm ↑e'.symm) = MonoidHom.id (N ∗ N')
state_after: no goals
tactic: ext <;> simp
Theorem: AnalyticAt.eventually_eq_or_eventually_ne
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
hg : AnalyticAt 𝕜 g z₀
⊢ (∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = g z) ∨ ∀ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z ≠ g z
state_after: no goals
tactic: simpa [sub_eq_zero] using (hf.sub hg).eventually_eq_zero_or_eventually_ne_zero
Theorem: quasispectrum.mem_of_not_quasiregular
File: Mathlib/Algebra/Algebra/Quasispectrum.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : NonUnitalRing A
inst✝² : Module R A
inst✝¹ : IsScalarTower R A A
inst✝ : SMulCommClass R A A
a : A
r : Rˣ
hr : ¬IsQuasiregular (-(r⁻¹ • a))
x✝ : IsUnit ↑r
⊢ ¬IsQuasiregular (-(x✝.unit⁻¹ • a))
state_after: no goals
tactic: simpa using hr
Theorem: Metric.continuousOn_iff'
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : TopologicalSpace β
f : β → α
s : Set β
⊢ ContinuousOn f s ↔ ∀ b ∈ s, ∀ ε > 0, ∀ᶠ (x : β) in 𝓝[s] b, dist (f x) (f b) < ε
state_after: no goals
tactic: simp [ContinuousOn, continuousWithinAt_iff']
Theorem: Cardinal.univ_inaccessible
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
⊢ ℵ₀ < univ.{u, v}
state_after: no goals
tactic: simpa using lift_lt_univ' ℵ₀
state_before: α : Type u_1
r : α → α → Prop
⊢ univ.{u, v} ≤ univ.{u, v}.ord.cof
state_after: no goals
tactic: simp
state_before: α : Type u_1
r : α → α → Prop
c : Cardinal.{max (u + 1) v}
h : c < univ.{u, v}
⊢ 2 ^ c < univ.{u, v}
state_after: case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ 2 ^ lift.{max (u + 1) v, u} c < univ.{u, v}
tactic: rcases lt_univ'.1 h with ⟨c, rfl⟩
state_before: case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ 2 ^ lift.{max (u + 1) v, u} c < univ.{u, v}
state_after: case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ lift.{max (u + 1) v, u} (2 ^ c) < univ.{u, v}
tactic: rw [← lift_two_power]
state_before: case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ lift.{max (u + 1) v, u} (2 ^ c) < univ.{u, v}
state_after: no goals
tactic: apply lift_lt_univ'
Theorem: CategoryTheory.InjectiveResolution.iso_hom_naturality
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasInjectiveResolutions C
X Y : C
f : X ⟶ Y
I : InjectiveResolution X
J : InjectiveResolution Y
φ : I.cocomplex ⟶ J.cocomplex
comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0
⊢ (injectiveResolutions C).map f ≫ J.iso.hom = I.iso.hom ≫ (HomotopyCategory.quotient C (ComplexShape.up ℕ)).map φ
state_after: case h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasInjectiveResolutions C
X Y : C
f : X ⟶ Y
I : InjectiveResolution X
J : InjectiveResolution Y
φ : I.cocomplex ⟶ J.cocomplex
comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0
⊢ Homotopy (desc f (injectiveResolution Y) (injectiveResolution X) ≫ ((injectiveResolution Y).homotopyEquiv J).hom)
    (((injectiveResolution X).homotopyEquiv I).hom ≫ φ)
tactic: apply HomotopyCategory.eq_of_homotopy
state_before: case h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasInjectiveResolutions C
X Y : C
f : X ⟶ Y
I : InjectiveResolution X
J : InjectiveResolution Y
φ : I.cocomplex ⟶ J.cocomplex
comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0
⊢ Homotopy (desc f (injectiveResolution Y) (injectiveResolution X) ≫ ((injectiveResolution Y).homotopyEquiv J).hom)
    (((injectiveResolution X).homotopyEquiv I).hom ≫ φ)
state_after: case h.g_comm
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasInjectiveResolutions C
X Y : C
f : X ⟶ Y
I : InjectiveResolution X
J : InjectiveResolution Y
φ : I.cocomplex ⟶ J.cocomplex
comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0
⊢ (injectiveResolution X).ι ≫
      desc f (injectiveResolution Y) (injectiveResolution X) ≫ ((injectiveResolution Y).homotopyEquiv J).hom =
    (CochainComplex.single₀ C).map f ≫ J.ι

case h.h_comm
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasInjectiveResolutions C
X Y : C
f : X ⟶ Y
I : InjectiveResolution X
J : InjectiveResolution Y
φ : I.cocomplex ⟶ J.cocomplex
comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0
⊢ (injectiveResolution X).ι ≫ ((injectiveResolution X).homotopyEquiv I).hom ≫ φ = (CochainComplex.single₀ C).map f ≫ J.ι
tactic: apply descHomotopy f
state_before: case h.g_comm
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasInjectiveResolutions C
X Y : C
f : X ⟶ Y
I : InjectiveResolution X
J : InjectiveResolution Y
φ : I.cocomplex ⟶ J.cocomplex
comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0
⊢ (injectiveResolution X).ι ≫
      desc f (injectiveResolution Y) (injectiveResolution X) ≫ ((injectiveResolution Y).homotopyEquiv J).hom =
    (CochainComplex.single₀ C).map f ≫ J.ι

case h.h_comm
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasInjectiveResolutions C
X Y : C
f : X ⟶ Y
I : InjectiveResolution X
J : InjectiveResolution Y
φ : I.cocomplex ⟶ J.cocomplex
comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0
⊢ (injectiveResolution X).ι ≫ ((injectiveResolution X).homotopyEquiv I).hom ≫ φ = (CochainComplex.single₀ C).map f ≫ J.ι
state_after: no goals
tactic: all_goals aesop_cat
Theorem: rank_prod
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹¹ : Ring R
inst✝¹⁰ : CommRing S
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup M'
inst✝⁷ : AddCommGroup M₁
inst✝⁶ : Module R M
inst✝⁵ : Module R M'
inst✝⁴ : Module R M₁
inst✝³ : StrongRankCondition R
inst✝² : Module.Free R M
inst✝¹ : Module.Free R M'
inst✝ : Module.Free R M₁
⊢ Module.rank R (M × M') = lift.{v', v} (Module.rank R M) + lift.{v, v'} (Module.rank R M')
state_after: no goals
tactic: simpa [rank_eq_card_chooseBasisIndex R M, rank_eq_card_chooseBasisIndex R M', lift_umax,
    lift_umax'] using ((chooseBasis R M).prod (chooseBasis R M')).mk_eq_rank.symm
Theorem: AddSubsemigroup.prod_eq_top_iff
File: Mathlib/Algebra/Group/Subsemigroup/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
σ : Type u_4
inst✝⁴ : Mul M
inst✝³ : Mul N
inst✝² : Mul P
S : Subsemigroup M
inst✝¹ : Nonempty M
inst✝ : Nonempty N
s : Subsemigroup M
t : Subsemigroup N
⊢ s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤
state_after: no goals
tactic: simp only [eq_top_iff, le_prod_iff, ← (gc_map_comap _).le_iff_le, ← srange_eq_map, srange_fst,
    srange_snd]
Theorem: CategoryTheory.Limits.IsTerminal.mono_from
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsTerminal X
f : X ⟶ Y
⊢ Mono f
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsTerminal X
f : X ⟶ Y
this : IsSplitMono f
⊢ Mono f
tactic: haveI := t.isSplitMono_from f
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsTerminal X
f : X ⟶ Y
this : IsSplitMono f
⊢ Mono f
state_after: no goals
tactic: infer_instance
Theorem: FirstOrder.Language.Equiv.injective_toEmbedding
File: Mathlib/ModelTheory/Basic.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
⊢ Function.Injective toEmbedding
state_after: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
a₁✝ a₂✝ : M ≃[L] N
h : a₁✝.toEmbedding = a₂✝.toEmbedding
⊢ a₁✝ = a₂✝
tactic: intro _ _ h
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
a₁✝ a₂✝ : M ≃[L] N
h : a₁✝.toEmbedding = a₂✝.toEmbedding
⊢ a₁✝ = a₂✝
state_after: case a
L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
a₁✝ a₂✝ : M ≃[L] N
h : a₁✝.toEmbedding = a₂✝.toEmbedding
⊢ (fun f => ⇑f) a₁✝ = (fun f => ⇑f) a₂✝
tactic: apply DFunLike.coe_injective
state_before: case a
L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
a₁✝ a₂✝ : M ≃[L] N
h : a₁✝.toEmbedding = a₂✝.toEmbedding
⊢ (fun f => ⇑f) a₁✝ = (fun f => ⇑f) a₂✝
state_after: no goals
tactic: exact congr_arg (DFunLike.coe ∘ Embedding.toHom) h