ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: linearIndependent_iUnion_of_directed
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
η : Type u_8
s : η → Set M
hs : Directed (fun x x_1 => x ⊆ x_1) s
h : ∀ (i : η), LinearIndependent R fun (x : ↑(s i)) => ↑x
⊢ LinearIndependent R fun (x : ↑(⋃ i, s i)) => ↑x
state_after: case pos
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
η : Type u_8
s : η → Set M
hs : Directed (fun x x_1 => x ⊆ x_1) s
h : ∀ (i : η), LinearIndependent R fun (x : ↑(s i)) => ↑x
hη : Nonempty η
⊢ LinearIndependent R fun (x : ↑(⋃ i, s i)) => ↑x

case neg
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
η : Type u_8
s : η → Set M
hs : Directed (fun x x_1 => x ⊆ x_1) s
h : ∀ (i : η), LinearIndependent R fun (x : ↑(s i)) => ↑x
hη : ¬Nonempty η
⊢ LinearIndependent R fun (x : ↑(⋃ i, s i)) => ↑x
tactic: by_cases hη : Nonempty η
Theorem: Subsemigroup.map_comap_eq_self
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
f : M →ₙ* N
S : Subsemigroup N
h : S ≤ f.srange
⊢ map f (comap f S) = S
state_after: no goals
tactic: simpa only [inf_of_le_left h] using map_comap_eq f S
Theorem: List.get?_zero_mul_tail_prod
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List M
⊢ (l.get? 0).getD 1 * l.tail.prod = l.prod
state_after: no goals
tactic: cases l <;> simp
Theorem: Nat.log_ne_padicValNat_succ
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p n : ℕ
hn : n ≠ 0
⊢ log 2 n ≠ padicValNat 2 (n + 1)
state_after: p n : ℕ
hn : n ≠ 0
⊢ ¬(2 ^ padicValNat 2 (n + 1) ≤ n ∧ n < 2 ^ (padicValNat 2 (n + 1) + 1))
tactic: rw [Ne, log_eq_iff (by simp [hn])]
state_before: p n : ℕ
hn : n ≠ 0
⊢ ¬(2 ^ padicValNat 2 (n + 1) ≤ n ∧ n < 2 ^ (padicValNat 2 (n + 1) + 1))
state_after: case intro
p n : ℕ
hn : n ≠ 0
h1 : 2 ^ padicValNat 2 (n + 1) ≤ n
h2 : n < 2 ^ (padicValNat 2 (n + 1) + 1)
⊢ False
tactic: rintro ⟨h1, h2⟩
state_before: case intro
p n : ℕ
hn : n ≠ 0
h1 : 2 ^ padicValNat 2 (n + 1) ≤ n
h2 : n < 2 ^ (padicValNat 2 (n + 1) + 1)
⊢ False
state_after: case intro
p n : ℕ
hn : n ≠ 0
h1 : 2 ^ padicValNat 2 (n + 1) * 1 < n + 1
h2 : n < 2 ^ (padicValNat 2 (n + 1) + 1)
⊢ False
tactic: rw [← Nat.lt_add_one_iff, ← mul_one (2 ^ _)] at h1
state_before: case intro
p n : ℕ
hn : n ≠ 0
h1 : 2 ^ padicValNat 2 (n + 1) * 1 < n + 1
h2 : n < 2 ^ (padicValNat 2 (n + 1) + 1)
⊢ False
state_after: case intro
p n : ℕ
hn : n ≠ 0
h1 : 2 ^ padicValNat 2 (n + 1) * 1 < n + 1
h2 : n + 1 ≤ 2 ^ padicValNat 2 (n + 1) * 2
⊢ False
tactic: rw [← add_one_le_iff, Nat.pow_succ] at h2
state_before: case intro
p n : ℕ
hn : n ≠ 0
h1 : 2 ^ padicValNat 2 (n + 1) * 1 < n + 1
h2 : n + 1 ≤ 2 ^ padicValNat 2 (n + 1) * 2
⊢ False
state_after: case intro
p n : ℕ
hn : n ≠ 0
h1 : 2 ^ padicValNat 2 (n + 1) * 1 < n + 1
h2 : n + 1 ≤ 2 ^ padicValNat 2 (n + 1) * 2
⊢ 2 ^ padicValNat 2 (n + 1) * (1 + 1) ≠ n + 1
tactic: refine not_dvd_of_between_consec_multiples h1 (lt_of_le_of_ne' h2 ?_) pow_padicValNat_dvd
state_before: case intro
p n : ℕ
hn : n ≠ 0
h1 : 2 ^ padicValNat 2 (n + 1) * 1 < n + 1
h2 : n + 1 ≤ 2 ^ padicValNat 2 (n + 1) * 2
⊢ 2 ^ padicValNat 2 (n + 1) * (1 + 1) ≠ n + 1
state_after: no goals
tactic: exact pow_succ_padicValNat_not_dvd (p := 2) n.succ_ne_zero ∘ dvd_of_eq
Theorem: FirstOrder.Language.Theory.SemanticallyEquivalent.all
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α (n + 1)
h : T.SemanticallyEquivalent φ ψ
⊢ T.SemanticallyEquivalent (∀'φ) (∀'ψ)
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α (n + 1)
h : T.SemanticallyEquivalent φ ψ
⊢ ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M),
    (∀ (a : ↑M), φ.Realize v (Fin.snoc xs a)) ↔ ∀ (a : ↑M), ψ.Realize v (Fin.snoc xs a)
tactic: simp_rw [SemanticallyEquivalent, ModelsBoundedFormula, BoundedFormula.realize_iff,
    BoundedFormula.realize_all]
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ ψ : L.BoundedFormula α (n + 1)
h : T.SemanticallyEquivalent φ ψ
⊢ ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M),
    (∀ (a : ↑M), φ.Realize v (Fin.snoc xs a)) ↔ ∀ (a : ↑M), ψ.Realize v (Fin.snoc xs a)
state_after: no goals
tactic: exact fun M v xs => forall_congr' fun a => h.realize_bd_iff
Theorem: List.Sorted.orderedInsert
File: Mathlib/Data/List/Sort.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l : List α
h : Sorted r (b :: l)
⊢ Sorted r (List.orderedInsert r a (b :: l))
state_after: case pos
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l : List α
h : Sorted r (b :: l)
h' : r a b
⊢ Sorted r (List.orderedInsert r a (b :: l))

case neg
α : Type u
r : α → α → Prop
inst✝² : DecidableRel r
inst✝¹ : IsTotal α r
inst✝ : IsTrans α r
a b : α
l : List α
h : Sorted r (b :: l)
h' : ¬r a b
⊢ Sorted r (List.orderedInsert r a (b :: l))
tactic: by_cases h' : a ≼ b
Theorem: Complex.ofReal_log
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: x : ℝ
hx : 0 ≤ x
⊢ (↑(Real.log x)).re = (log ↑x).re
state_after: no goals
tactic: rw [log_re, ofReal_re, abs_of_nonneg hx]
state_before: x : ℝ
hx : 0 ≤ x
⊢ (↑(Real.log x)).im = (log ↑x).im
state_after: no goals
tactic: rw [ofReal_im, log_im, arg_ofReal_of_nonneg hx]
Theorem: Abelianization.equivOfComm_symm_apply
File: Mathlib/GroupTheory/Abelianization.lean

Proof steps:
state_before: G : Type u
inst✝¹ : Group G
H : Type u_1
inst✝ : CommGroup H
⊢ Function.RightInverse ⇑(lift (MonoidHom.id H)) ⇑of
state_after: case mk
G : Type u
inst✝¹ : Group G
H : Type u_1
inst✝ : CommGroup H
x✝ : Abelianization H
a : H
⊢ of ((lift (MonoidHom.id H)) (Quot.mk Setoid.r a)) = Quot.mk Setoid.r a
tactic: rintro ⟨a⟩
state_before: case mk
G : Type u
inst✝¹ : Group G
H : Type u_1
inst✝ : CommGroup H
x✝ : Abelianization H
a : H
⊢ of ((lift (MonoidHom.id H)) (Quot.mk Setoid.r a)) = Quot.mk Setoid.r a
state_after: no goals
tactic: rfl
Theorem: AddMonoidAlgebra.supDegree_zero
File: Mathlib/Algebra/MonoidAlgebra/Degree.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
A : Type u_3
T : Type u_4
B : Type u_5
ι : Type u_6
inst✝⁵ : Semiring R
inst✝⁴ : Ring R'
inst✝³ : AddZeroClass A
inst✝² : SemilatticeSup B
inst✝¹ : Add B
inst✝ : OrderBot B
D : A → B
p q : R[A]
⊢ supDegree D 0 = ⊥
state_after: no goals
tactic: simp [supDegree]
Theorem: Partrec.bind_decode₂_iff
File: Mathlib/Computability/Partrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α →. σ
h : Nat.Partrec fun n => (↑(decode₂ α n)).bind fun a => Part.map encode (f a)
⊢ Partrec fun a => Part.map encode (f a)
state_after: no goals
tactic: simpa [encodek₂] using (nat_iff.2 h).comp (@Computable.encode α _)
Theorem: orderOf_dvd_card
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✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
⊢ orderOf x ∣ card G
state_after: no goals
tactic: classical
    have ft_prod : Fintype ((G ⧸ zpowers x) × zpowers x) :=
      Fintype.ofEquiv G groupEquivQuotientProdSubgroup
    have ft_s : Fintype (zpowers x) := @Fintype.prodRight _ _ _ ft_prod _
    have ft_cosets : Fintype (G ⧸ zpowers x) :=
      @Fintype.prodLeft _ _ _ ft_prod ⟨⟨1, (zpowers x).one_mem⟩⟩
    have eq₁ : Fintype.card G = @Fintype.card _ ft_cosets * @Fintype.card _ ft_s :=
      calc
        Fintype.card G = @Fintype.card _ ft_prod :=
          @Fintype.card_congr _ _ _ ft_prod groupEquivQuotientProdSubgroup
        _ = @Fintype.card _ (@instFintypeProd _ _ ft_cosets ft_s) :=
          congr_arg (@Fintype.card _) <| Subsingleton.elim _ _
        _ = @Fintype.card _ ft_cosets * @Fintype.card _ ft_s :=
          @Fintype.card_prod _ _ ft_cosets ft_s

    have eq₂ : orderOf x = @Fintype.card _ ft_s :=
      calc
        orderOf x = _ := Fintype.card_zpowers.symm
        _ = _ := congr_arg (@Fintype.card _) <| Subsingleton.elim _ _

    exact Dvd.intro (@Fintype.card (G ⧸ Subgroup.zpowers x) ft_cosets) (by rw [eq₁, eq₂, mul_comm])
Theorem: ContinuousLinearMap.comp_neg
File: Mathlib/Topology/Algebra/Module/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁶ : Ring R
R₂ : Type u_2
inst✝¹⁵ : Ring R₂
R₃ : Type u_3
inst✝¹⁴ : Ring R₃
M : Type u_4
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommGroup M
M₂ : Type u_5
inst✝¹¹ : TopologicalSpace M₂
inst✝¹⁰ : AddCommGroup M₂
M₃ : Type u_6
inst✝⁹ : TopologicalSpace M₃
inst✝⁸ : AddCommGroup M₃
M₄ : Type u_7
inst✝⁷ : TopologicalSpace M₄
inst✝⁶ : AddCommGroup M₄
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : TopologicalAddGroup M₂
inst✝ : TopologicalAddGroup M₃
g : M₂ →SL[σ₂₃] M₃
f : M →SL[σ₁₂] M₂
⊢ g.comp (-f) = -g.comp f
state_after: case h
R : Type u_1
inst✝¹⁶ : Ring R
R₂ : Type u_2
inst✝¹⁵ : Ring R₂
R₃ : Type u_3
inst✝¹⁴ : Ring R₃
M : Type u_4
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommGroup M
M₂ : Type u_5
inst✝¹¹ : TopologicalSpace M₂
inst✝¹⁰ : AddCommGroup M₂
M₃ : Type u_6
inst✝⁹ : TopologicalSpace M₃
inst✝⁸ : AddCommGroup M₃
M₄ : Type u_7
inst✝⁷ : TopologicalSpace M₄
inst✝⁶ : AddCommGroup M₄
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : TopologicalAddGroup M₂
inst✝ : TopologicalAddGroup M₃
g : M₂ →SL[σ₂₃] M₃
f : M →SL[σ₁₂] M₂
x : M
⊢ (g.comp (-f)) x = (-g.comp f) x
tactic: ext x
state_before: case h
R : Type u_1
inst✝¹⁶ : Ring R
R₂ : Type u_2
inst✝¹⁵ : Ring R₂
R₃ : Type u_3
inst✝¹⁴ : Ring R₃
M : Type u_4
inst✝¹³ : TopologicalSpace M
inst✝¹² : AddCommGroup M
M₂ : Type u_5
inst✝¹¹ : TopologicalSpace M₂
inst✝¹⁰ : AddCommGroup M₂
M₃ : Type u_6
inst✝⁹ : TopologicalSpace M₃
inst✝⁸ : AddCommGroup M₃
M₄ : Type u_7
inst✝⁷ : TopologicalSpace M₄
inst✝⁶ : AddCommGroup M₄
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : TopologicalAddGroup M₂
inst✝ : TopologicalAddGroup M₃
g : M₂ →SL[σ₂₃] M₃
f : M →SL[σ₁₂] M₂
x : M
⊢ (g.comp (-f)) x = (-g.comp f) x
state_after: no goals
tactic: simp
Theorem: IsMetricSeparated.finite_iUnion_left_iff
File: Mathlib/Topology/MetricSpace/MetricSeparated.lean

Proof steps:
state_before: X : Type u_1
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_2
I : Set ι
hI : I.Finite
s : ι → Set X
t : Set X
⊢ IsMetricSeparated (⋃ i ∈ I, s i) t ↔ ∀ i ∈ I, IsMetricSeparated (s i) t
state_after: X : Type u_1
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_2
I✝ : Set ι
hI✝ : I✝.Finite
s : ι → Set X
t : Set X
i : ι
I : Set ι
x✝¹ : i ∉ I
x✝ : I.Finite
hI : IsMetricSeparated (⋃ i ∈ I, s i) t ↔ ∀ i ∈ I, IsMetricSeparated (s i) t
⊢ IsMetricSeparated (⋃ i_1 ∈ insert i I, s i_1) t ↔ ∀ i_1 ∈ insert i I, IsMetricSeparated (s i_1) t
tactic: refine Finite.induction_on hI (by simp) @fun i I _ _ hI => ?_
state_before: X : Type u_1
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_2
I✝ : Set ι
hI✝ : I✝.Finite
s : ι → Set X
t : Set X
i : ι
I : Set ι
x✝¹ : i ∉ I
x✝ : I.Finite
hI : IsMetricSeparated (⋃ i ∈ I, s i) t ↔ ∀ i ∈ I, IsMetricSeparated (s i) t
⊢ IsMetricSeparated (⋃ i_1 ∈ insert i I, s i_1) t ↔ ∀ i_1 ∈ insert i I, IsMetricSeparated (s i_1) t
state_after: no goals
tactic: rw [biUnion_insert, forall_mem_insert, union_left_iff, hI]
Theorem: toIcoMod_le_toIocMod
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp a b ≤ toIocMod hp a b
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a b • p ≤ toIcoDiv hp a b • p
tactic: rw [toIcoMod, toIocMod, sub_le_sub_iff_left]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a b • p ≤ toIcoDiv hp a b • p
state_after: no goals
tactic: exact zsmul_mono_left hp.le (toIocDiv_wcovBy_toIcoDiv _ _ _).le
Theorem: PartialHomeomorph.contDiffOn_univBall_symm
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

Proof steps:
state_before: n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
c : E
r : ℝ
⊢ ContDiffOn ℝ n (↑(univBall c r).symm) (ball c r)
state_after: n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
c : E
r : ℝ
⊢ ContDiffOn ℝ n
    (↑(if h : 0 < r then univUnitBall.trans' (unitBallBall c r h) ⋯
        else (IsometryEquiv.vaddConst c).toHomeomorph.toPartialHomeomorph).symm)
    (ball c r)
tactic: unfold univBall
state_before: n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
c : E
r : ℝ
⊢ ContDiffOn ℝ n
    (↑(if h : 0 < r then univUnitBall.trans' (unitBallBall c r h) ⋯
        else (IsometryEquiv.vaddConst c).toHomeomorph.toPartialHomeomorph).symm)
    (ball c r)
state_after: case pos
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
c : E
r : ℝ
h : 0 < r
⊢ ContDiffOn ℝ n (↑(univUnitBall.trans' (unitBallBall c r h) ⋯).symm) (ball c r)

case neg
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
c : E
r : ℝ
h : ¬0 < r
⊢ ContDiffOn ℝ n (↑(IsometryEquiv.vaddConst c).toHomeomorph.toPartialHomeomorph.symm) (ball c r)
tactic: split_ifs with h
Theorem: ENat.iInf_toNat
File: Mathlib/Data/ENat/Lattice.lean

Proof steps:
state_before: ι : Sort u_1
f : ι → ℕ
s : Set ℕ
⊢ (⨅ i, ↑(f i)).toNat = ⨅ i, f i
state_after: case inl
ι : Sort u_1
f : ι → ℕ
s : Set ℕ
h✝ : IsEmpty ι
⊢ (⨅ i, ↑(f i)).toNat = ⨅ i, f i

case inr
ι : Sort u_1
f : ι → ℕ
s : Set ℕ
h✝ : Nonempty ι
⊢ (⨅ i, ↑(f i)).toNat = ⨅ i, f i
tactic: cases isEmpty_or_nonempty ι
Theorem: CategoryTheory.ShortComplex.RightHomologyData.map_g'
File: Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_4, u_1} C
inst✝⁴ : Category.{u_3, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : S.RightHomologyData
F : C ⥤ D
inst✝¹ : F.PreservesZeroMorphisms
inst✝ : h.IsPreservedBy F
⊢ (h.map F).g' = F.map h.g'
state_after: no goals
tactic: rw [← cancel_epi (h.map F).p, p_g', map_g, map_p, ← F.map_comp, p_g']
Theorem: Monoid.CoprodI.lift_injective_of_ping_pong
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝⁴ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝³ : Monoid N
hnontriv : Nontrivial ι
G : Type u_4
inst✝² : Group G
H : ι → Type u_5
inst✝¹ : (i : ι) → Group (H i)
f : (i : ι) → H i →* G
hcard : 3 ≤ #ι ∨ ∃ i, 3 ≤ #(H i)
α : Type u_6
inst✝ : MulAction G α
X : ι → Set α
hXnonempty : ∀ (i : ι), (X i).Nonempty
hXdisj : Pairwise fun i j => Disjoint (X i) (X j)
hpp : Pairwise fun i j => ∀ (h : H i), h ≠ 1 → (f i) h • X j ⊆ X i
⊢ Function.Injective ⇑(lift f)
state_after: no goals
tactic: classical
    apply (injective_iff_map_eq_one (lift f)).mpr
    rw [(CoprodI.Word.equiv).forall_congr_left]
    intro w Heq
    dsimp [Word.equiv] at *
    rw [empty_of_word_prod_eq_one f hcard X hXnonempty hXdisj hpp Heq, Word.prod_empty]
Theorem: tendstoUniformly_iff_tendstoUniformlyOnFilter
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ TendstoUniformly F f p ↔ TendstoUniformlyOnFilter F f p ⊤
state_after: no goals
tactic: rw [← tendstoUniformlyOn_univ, tendstoUniformlyOn_iff_tendstoUniformlyOnFilter, principal_univ]
Theorem: Equiv.sumEmpty_symm_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Type ?u.16691
β : Type ?u.16690
inst✝ : IsEmpty β
s : α ⊕ β
⊢ inl (Sum.elim id (fun a => isEmptyElim a) s) = s
state_after: case inl
α : Type ?u.16691
β : Type ?u.16690
inst✝ : IsEmpty β
val✝ : α
⊢ inl (Sum.elim id (fun a => isEmptyElim a) (inl val✝)) = inl val✝

case inr
α : Type ?u.16691
β : Type ?u.16690
inst✝ : IsEmpty β
x : β
⊢ inl (Sum.elim id (fun a => isEmptyElim a) (inr x)) = inr x
tactic: rcases s with (_ | x)
Theorem: CochainComplex.HomComplex.Cochain.rightShift_leftShift
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
⊢ (γ.leftShift a n' hn').rightShift a n hn' = (a * n' + a * (a - 1) / 2).negOnePow • γ.shift a
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n = q
⊢ ((γ.leftShift a n' hn').rightShift a n hn').v p q hpq = ((a * n' + a * (a - 1) / 2).negOnePow • γ.shift a).v p q hpq
tactic: ext p q hpq
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n = q
⊢ ((γ.leftShift a n' hn').rightShift a n hn').v p q hpq = ((a * n' + a * (a - 1) / 2).negOnePow • γ.shift a).v p q hpq
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n = q
⊢ ((a * n' + a * (a - 1) / 2).negOnePow • (K.shiftFunctorObjXIso a p (p + a) ⋯).hom ≫ γ.v (p + a) (q + a) ⋯) ≫
      (L.shiftFunctorObjXIso a q (q + a) ⋯).inv =
    (a * n' + a * (a - 1) / 2).negOnePow • γ.v (p + a) (q + a) ⋯
tactic: simp only [rightShift_v _ a n hn' p q hpq (q + a) (by omega),
    leftShift_v _ a n' hn' p (q + a) (by omega) (p + a) (by omega), units_smul_v, shift_v']
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n = q
⊢ ((a * n' + a * (a - 1) / 2).negOnePow • (K.shiftFunctorObjXIso a p (p + a) ⋯).hom ≫ γ.v (p + a) (q + a) ⋯) ≫
      (L.shiftFunctorObjXIso a q (q + a) ⋯).inv =
    (a * n' + a * (a - 1) / 2).negOnePow • γ.v (p + a) (q + a) ⋯
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n = q
⊢ ((a * n' + a * (a - 1) / 2).negOnePow • 𝟙 (K.X (p + a)) ≫ γ.v (p + a) (q + a) ⋯) ≫ 𝟙 (L.X (q + a)) =
    (a * n' + a * (a - 1) / 2).negOnePow • γ.v (p + a) (q + a) ⋯
tactic: dsimp
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n = q
⊢ ((a * n' + a * (a - 1) / 2).negOnePow • 𝟙 (K.X (p + a)) ≫ γ.v (p + a) (q + a) ⋯) ≫ 𝟙 (L.X (q + a)) =
    (a * n' + a * (a - 1) / 2).negOnePow • γ.v (p + a) (q + a) ⋯
state_after: no goals
tactic: rw [id_comp, comp_id]
Theorem: WithTop.top_pow
File: Mathlib/Algebra/Order/Ring/WithTop.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : MonoidWithZero α
inst✝¹ : NoZeroDivisors α
inst✝ : Nontrivial α
n : ℕ
n_pos : 0 < n
m : ℕ
x✝ : Nat.succ 0 ≤ m
hm : ⊤ ^ m = ⊤
⊢ ⊤ ^ (m + 1) = ⊤
state_after: no goals
tactic: rw [pow_succ, hm, top_mul_top]
Theorem: CategoryTheory.Functor.uncurry_obj_curry_obj_flip_flip'
File: Mathlib/CategoryTheory/Functor/Currying.lean

Proof steps:
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F₁ : B ⥤ C
F₂ : D ⥤ E
G : C × E ⥤ H
⊢ ∀ (X : B × D), (uncurry.obj (F₁ ⋙ (F₂ ⋙ (curry.obj G).flip).flip)).obj X = (F₁.prod F₂ ⋙ G).obj X
state_after: no goals
tactic: simp
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F₁ : B ⥤ C
F₂ : D ⥤ E
G : C × E ⥤ H
x✝² x✝¹ : B × D
x₁ : B
x₂ : D
y₁ : B
y₂ : D
x✝ : (x₁, x₂) ⟶ (y₁, y₂)
f₁ : (x₁, x₂).1 ⟶ (y₁, y₂).1
f₂ : (x₁, x₂).2 ⟶ (y₁, y₂).2
⊢ (uncurry.obj (F₁ ⋙ (F₂ ⋙ (curry.obj G).flip).flip)).map (f₁, f₂) =
    eqToHom ⋯ ≫ (F₁.prod F₂ ⋙ G).map (f₁, f₂) ≫ eqToHom ⋯
state_after: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F₁ : B ⥤ C
F₂ : D ⥤ E
G : C × E ⥤ H
x✝² x✝¹ : B × D
x₁ : B
x₂ : D
y₁ : B
y₂ : D
x✝ : (x₁, x₂) ⟶ (y₁, y₂)
f₁ : (x₁, x₂).1 ⟶ (y₁, y₂).1
f₂ : (x₁, x₂).2 ⟶ (y₁, y₂).2
⊢ G.map (F₁.map f₁, 𝟙 (F₂.obj x₂)) ≫ G.map (𝟙 (F₁.obj y₁), F₂.map f₂) =
    𝟙 (G.obj (F₁.obj x₁, F₂.obj x₂)) ≫ G.map (F₁.map f₁, F₂.map f₂) ≫ 𝟙 (G.obj (F₁.obj y₁, F₂.obj y₂))
tactic: dsimp
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F₁ : B ⥤ C
F₂ : D ⥤ E
G : C × E ⥤ H
x✝² x✝¹ : B × D
x₁ : B
x₂ : D
y₁ : B
y₂ : D
x✝ : (x₁, x₂) ⟶ (y₁, y₂)
f₁ : (x₁, x₂).1 ⟶ (y₁, y₂).1
f₂ : (x₁, x₂).2 ⟶ (y₁, y₂).2
⊢ G.map (F₁.map f₁, 𝟙 (F₂.obj x₂)) ≫ G.map (𝟙 (F₁.obj y₁), F₂.map f₂) =
    𝟙 (G.obj (F₁.obj x₁, F₂.obj x₂)) ≫ G.map (F₁.map f₁, F₂.map f₂) ≫ 𝟙 (G.obj (F₁.obj y₁, F₂.obj y₂))
state_after: no goals
tactic: simp only [Category.id_comp, Category.comp_id, ← G.map_comp, prod_comp]
Theorem: IsUnit.exists_left_inv
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a✝ b a : M
h : IsUnit a
⊢ ∃ b, b * a = 1
state_after: case intro.mk
α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a✝ b✝ a b : M
val_inv✝ : a * b = 1
hba : b * a = 1
⊢ ∃ b_1, b_1 * ↑{ val := a, inv := b, val_inv := val_inv✝, inv_val := hba } = 1
tactic: rcases h with ⟨⟨a, b, _, hba⟩, rfl⟩
state_before: case intro.mk
α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a✝ b✝ a b : M
val_inv✝ : a * b = 1
hba : b * a = 1
⊢ ∃ b_1, b_1 * ↑{ val := a, inv := b, val_inv := val_inv✝, inv_val := hba } = 1
state_after: no goals
tactic: exact ⟨b, hba⟩
Theorem: ssubset_of_ssubset_of_eq
File: Mathlib/Order/RelClasses.lean

Proof steps:
state_before: α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝ : HasSSubset α
a b c : α
hab : a ⊂ b
hbc : b = c
⊢ a ⊂ c
state_after: no goals
tactic: rwa [← hbc]