1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.shiftFunctorAdd'_zero_add
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: ext X
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
⊢ shiftFunctorAdd' C 0 a a ⋯ =
    (shiftFunctor C a).leftUnitor.symm ≪≫ isoWhiskerRight (shiftFunctorZero C A).symm (shiftFunctor C a)
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (shiftFunctorAdd' C 0 a a ⋯).hom.app X =
    ((shiftFunctor C a).leftUnitor.symm ≪≫ isoWhiskerRight (shiftFunctorZero C A).symm (shiftFunctor C a)).hom.app X

tactic: dsimp [shiftFunctorAdd', shiftFunctorZero, shiftFunctor]
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (shiftFunctorAdd' C 0 a a ⋯).hom.app X =
    ((shiftFunctor C a).leftUnitor.symm ≪≫ isoWhiskerRight (shiftFunctorZero C A).symm (shiftFunctor C a)).hom.app X
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (eqToHom ⋯).app X ≫ (shiftFunctorAdd C 0 a).hom.app X =
    𝟙 (((shiftMonoidalFunctor C A).obj { as := a }).obj X) ≫
      ((shiftMonoidalFunctor C A).obj { as := a }).map ((shiftMonoidalFunctor C A).ε.app X)

tactic: simp only [eqToHom_app, obj_ε_app, Discrete.addMonoidal_leftUnitor, eqToIso.inv,
  eqToHom_map, Category.id_comp]
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (eqToHom ⋯).app X ≫ (shiftFunctorAdd C 0 a).hom.app X =
    𝟙 (((shiftMonoidalFunctor C A).obj { as := a }).obj X) ≫
      ((shiftMonoidalFunctor C A).obj { as := a }).map ((shiftMonoidalFunctor C A).ε.app X)
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ eqToHom ⋯ ≫ (shiftFunctorAdd C 0 a).hom.app X =
    eqToHom ⋯ ≫ ((shiftMonoidalFunctor C A).μIso (𝟙_ (Discrete A)) { as := a }).inv.app X

tactic: rfl
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ eqToHom ⋯ ≫ (shiftFunctorAdd C 0 a).hom.app X =
    eqToHom ⋯ ≫ ((shiftMonoidalFunctor C A).μIso (𝟙_ (Discrete A)) { as := a }).inv.app X
state_after: no goals
Theorem: le_of_span_le_span
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: have :=
  eq_of_linearIndependent_of_span_subtype (hl.mono (Set.union_subset hsu htu))
    Set.subset_union_right (Set.union_subset (Set.Subset.trans subset_span hst) subset_span)
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✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
a b : R
x y : M
inst✝ : Nontrivial R
s t u : Set M
hl : LinearIndependent (ι := { x // x ∈ u }) R Subtype.val
hsu : s ⊆ u
htu : t ⊆ u
hst : span R s ≤ span R t
⊢ s ⊆ t
state_after: ι : 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✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
a b : R
x y : M
inst✝ : Nontrivial R
s t u : Set M
hl : LinearIndependent (ι := { x // x ∈ u }) R Subtype.val
hsu : s ⊆ u
htu : t ⊆ u
hst : span R s ≤ span R t
this : s ∪ t = t
⊢ s ⊆ t

tactic: rw [← this]
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✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
a b : R
x y : M
inst✝ : Nontrivial R
s t u : Set M
hl : LinearIndependent (ι := { x // x ∈ u }) R Subtype.val
hsu : s ⊆ u
htu : t ⊆ u
hst : span R s ≤ span R t
this : s ∪ t = t
⊢ s ⊆ t
state_after: ι : 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✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
a b : R
x y : M
inst✝ : Nontrivial R
s t u : Set M
hl : LinearIndependent (ι := { x // x ∈ u }) R Subtype.val
hsu : s ⊆ u
htu : t ⊆ u
hst : span R s ≤ span R t
this : s ∪ t = t
⊢ s ⊆ s ∪ t

tactic: apply Set.subset_union_left
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✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
a b : R
x y : M
inst✝ : Nontrivial R
s t u : Set M
hl : LinearIndependent (ι := { x // x ∈ u }) R Subtype.val
hsu : s ⊆ u
htu : t ⊆ u
hst : span R s ≤ span R t
this : s ∪ t = t
⊢ s ⊆ s ∪ t
state_after: no goals
Theorem: finprod_mem_mulSupport
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← mem_mulSupport, finprod_eq_mulIndicator_apply, mulIndicator_mulSupport]
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 : α → M
a : α
⊢ ∏ᶠ (_ : f a ≠ 1), f a = f a
state_after: no goals
Theorem: UpperSet.Ici_inf_erase
File: Mathlib/Order/UpperLower/Basic.lean

tactic: rw [inf_comm, erase_inf_Ici ha has]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : Preorder α
s : UpperSet α
t : Set α
a : α
ha : a ∈ s
has : ∀ b ∈ s, b ≤ a → b = a
⊢ Ici a ⊓ s.erase a = s
state_after: no goals
Theorem: Submodule.map₂_span_singleton_eq_map_flip
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

tactic: rw [← map₂_span_singleton_eq_map, map₂_flip]
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
s : Submodule R M
n : N
⊢ map₂ f s (span R {n}) = map (f.flip n) s
state_after: no goals
Theorem: Real.rpow_inv_le_iff_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← rpow_le_rpow_iff_of_neg hy _ hz, rpow_inv_rpow _ hz.ne] <;> positivity
state_before: x y z : ℝ
n : ℕ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ x ^ z⁻¹ ≤ y ↔ y ^ z ≤ x
state_after: no goals
Theorem: Stream'.get_inits
File: Mathlib/Data/Stream/Init.lean

tactic: intro n
state_before: α : Type u
β : Type v
δ : Type w
⊢ ∀ (n : ℕ) (s : Stream' α), s.inits.get n = take n.succ s
state_after: α : Type u
β : Type v
δ : Type w
n : ℕ
⊢ ∀ (s : Stream' α), s.inits.get n = take n.succ s

tactic: induction' n with n' ih
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
⊢ ∀ (s : Stream' α), s.inits.get n = take n.succ s
state_after: case zero
α : Type u
β : Type v
δ : Type w
⊢ ∀ (s : Stream' α), s.inits.get 0 = take (succ 0) s

case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), s.inits.get n' = take n'.succ s
⊢ ∀ (s : Stream' α), s.inits.get (n' + 1) = take (n' + 1).succ s

tactic: intros
state_before: case zero
α : Type u
β : Type v
δ : Type w
⊢ ∀ (s : Stream' α), s.inits.get 0 = take (succ 0) s
state_after: case zero
α : Type u
β : Type v
δ : Type w
s✝ : Stream' α
⊢ s✝.inits.get 0 = take (succ 0) s✝

tactic: rfl
state_before: case zero
α : Type u
β : Type v
δ : Type w
s✝ : Stream' α
⊢ s✝.inits.get 0 = take (succ 0) s✝
state_after: no goals

tactic: intros
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), s.inits.get n' = take n'.succ s
⊢ ∀ (s : Stream' α), s.inits.get (n' + 1) = take (n' + 1).succ s
state_after: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), s.inits.get n' = take n'.succ s
s✝ : Stream' α
⊢ s✝.inits.get (n' + 1) = take (n' + 1).succ s✝

tactic: rw [get_succ, take_succ, ← ih, tail_inits, inits_tail, cons_get_inits_core]
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), s.inits.get n' = take n'.succ s
s✝ : Stream' α
⊢ s✝.inits.get (n' + 1) = take (n' + 1).succ s✝
state_after: no goals
Theorem: Ordinal.sSup_ord
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [csSup_le_iff'
    (bddAbove_iff_small.2 (@small_image _ _ _ s (Cardinal.bddAbove_iff_small.1 hs))),
  ord_le, csSup_le_iff' hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β → β → Prop
t : γ → γ → Prop
s : Set Cardinal.{u}
hs : BddAbove s
a : Ordinal.{u}
⊢ (sSup s).ord ≤ a ↔ sSup (ord '' s) ≤ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β → β → Prop
t : γ → γ → Prop
s : Set Cardinal.{u}
hs : BddAbove s
a : Ordinal.{u}
⊢ (∀ x ∈ s, x ≤ a.card) ↔ ∀ x ∈ ord '' s, x ≤ a

tactic: simp [ord_le]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s✝ : β → β → Prop
t : γ → γ → Prop
s : Set Cardinal.{u}
hs : BddAbove s
a : Ordinal.{u}
⊢ (∀ x ∈ s, x ≤ a.card) ↔ ∀ x ∈ ord '' s, x ≤ a
state_after: no goals
Theorem: Filter.eventuallyEq_iff_sub
File: Mathlib/Order/Filter/Basic.lean

tactic: simpa using h.add (EventuallyEq.refl l g)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
inst✝ : AddGroup β
f g : α → β
l : Filter α
h : f - g =ᶠ[l] 0
⊢ f =ᶠ[l] g
state_after: no goals
Theorem: AddCircle.intervalIntegral_preimage
File: Mathlib/MeasureTheory/Integral/Periodic.lean

tactic: rw [integral_of_le, AddCircle.integral_preimage T t f]
state_before: T : ℝ
hT : Fact (0 < T)
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
t : ℝ
f : AddCircle T → E
⊢ ∫ (a : ℝ) in t..t + T, f ↑a = ∫ (b : AddCircle T), f b
state_after: T : ℝ
hT : Fact (0 < T)
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
t : ℝ
f : AddCircle T → E
⊢ t ≤ t + T

tactic: linarith [hT.out]
state_before: T : ℝ
hT : Fact (0 < T)
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
t : ℝ
f : AddCircle T → E
⊢ t ≤ t + T
state_after: no goals
Theorem: PEquiv.mem_single_iff
File: Mathlib/Data/PEquiv.lean

tactic: dsimp [single]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
a₁ a₂ : α
b₁ b₂ : β
⊢ b₁ ∈ (single a₂ b₂) a₁ ↔ a₁ = a₂ ∧ b₁ = b₂
state_after: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
a₁ a₂ : α
b₁ b₂ : β
⊢ (b₁ ∈ if a₁ = a₂ then some b₂ else none) ↔ a₁ = a₂ ∧ b₁ = b₂

tactic: split_ifs <;> simp [*, eq_comm]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
a₁ a₂ : α
b₁ b₂ : β
⊢ (b₁ ∈ if a₁ = a₂ then some b₂ else none) ↔ a₁ = a₂ ∧ b₁ = b₂
state_after: no goals
Theorem: ModuleCat.free_shortExact_finrank_add
File: Mathlib/Algebra/Category/ModuleCat/Free.lean

tactic: apply FiniteDimensional.finrank_eq_of_rank_eq
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
inst✝⁵ : Ring R
S : ShortComplex (ModuleCat R)
hS : S.Exact
hS' : S.ShortExact
v : ι → ↑S.X₁
n p : ℕ
inst✝⁴ : Module.Free R ↑S.X₁
inst✝³ : Module.Free R ↑S.X₃
inst✝² : Module.Finite R ↑S.X₁
inst✝¹ : Module.Finite R ↑S.X₃
hN : FiniteDimensional.finrank R ↑S.X₁ = n
hP : FiniteDimensional.finrank R ↑S.X₃ = p
inst✝ : StrongRankCondition R
⊢ FiniteDimensional.finrank R ↑S.X₂ = n + p
state_after: case h
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst✝⁵ : Ring R
S : ShortComplex (ModuleCat R)
hS : S.Exact
hS' : S.ShortExact
v : ι → ↑S.X₁
n p : ℕ
inst✝⁴ : Module.Free R ↑S.X₁
inst✝³ : Module.Free R ↑S.X₃
inst✝² : Module.Finite R ↑S.X₁
inst✝¹ : Module.Finite R ↑S.X₃
hN : FiniteDimensional.finrank R ↑S.X₁ = n
hP : FiniteDimensional.finrank R ↑S.X₃ = p
inst✝ : StrongRankCondition R
⊢ Module.rank R ↑S.X₂ = ↑(n + p)

tactic: rw [free_shortExact_rank_add hS', ← hN, ← hP]
state_before: case h
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst✝⁵ : Ring R
S : ShortComplex (ModuleCat R)
hS : S.Exact
hS' : S.ShortExact
v : ι → ↑S.X₁
n p : ℕ
inst✝⁴ : Module.Free R ↑S.X₁
inst✝³ : Module.Free R ↑S.X₃
inst✝² : Module.Finite R ↑S.X₁
inst✝¹ : Module.Finite R ↑S.X₃
hN : FiniteDimensional.finrank R ↑S.X₁ = n
hP : FiniteDimensional.finrank R ↑S.X₃ = p
inst✝ : StrongRankCondition R
⊢ Module.rank R ↑S.X₂ = ↑(n + p)
state_after: case h
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst✝⁵ : Ring R
S : ShortComplex (ModuleCat R)
hS : S.Exact
hS' : S.ShortExact
v : ι → ↑S.X₁
n p : ℕ
inst✝⁴ : Module.Free R ↑S.X₁
inst✝³ : Module.Free R ↑S.X₃
inst✝² : Module.Finite R ↑S.X₁
inst✝¹ : Module.Finite R ↑S.X₃
hN : FiniteDimensional.finrank R ↑S.X₁ = n
hP : FiniteDimensional.finrank R ↑S.X₃ = p
inst✝ : StrongRankCondition R
⊢ Module.rank R ↑S.X₁ + Module.rank R ↑S.X₃ = ↑(FiniteDimensional.finrank R ↑S.X₁ + FiniteDimensional.finrank R ↑S.X₃)

tactic: simp only [Nat.cast_add, finrank_eq_rank]
state_before: case h
ι : Type u_1
ι' : Type u_2
R : Type u_3
inst✝⁵ : Ring R
S : ShortComplex (ModuleCat R)
hS : S.Exact
hS' : S.ShortExact
v : ι → ↑S.X₁
n p : ℕ
inst✝⁴ : Module.Free R ↑S.X₁
inst✝³ : Module.Free R ↑S.X₃
inst✝² : Module.Finite R ↑S.X₁
inst✝¹ : Module.Finite R ↑S.X₃
hN : FiniteDimensional.finrank R ↑S.X₁ = n
hP : FiniteDimensional.finrank R ↑S.X₃ = p
inst✝ : StrongRankCondition R
⊢ Module.rank R ↑S.X₁ + Module.rank R ↑S.X₃ = ↑(FiniteDimensional.finrank R ↑S.X₁ + FiniteDimensional.finrank R ↑S.X₃)
state_after: no goals
Theorem: Nat.factorization_le_of_le_pow
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: if hn : n = 0 then simp [hn] else
if pp : p.Prime then
  exact (pow_le_pow_iff_right pp.one_lt).1 ((ord_proj_le p hn).trans hb)
else
  simp [factorization_eq_zero_of_non_prime n pp]
state_before: a b✝ m n✝ p✝ n p b : ℕ
hb : n ≤ p ^ b
⊢ n.factorization p ≤ b
state_after: no goals

tactic: simp [hn]
state_before: a b✝ m n✝ p✝ n p b : ℕ
hb : n ≤ p ^ b
hn : n = 0
⊢ n.factorization p ≤ b
state_after: no goals

tactic: if pp : p.Prime then
  exact (pow_le_pow_iff_right pp.one_lt).1 ((ord_proj_le p hn).trans hb)
else
  simp [factorization_eq_zero_of_non_prime n pp]
state_before: a b✝ m n✝ p✝ n p b : ℕ
hb : n ≤ p ^ b
hn : ¬n = 0
⊢ n.factorization p ≤ b
state_after: no goals

tactic: exact (pow_le_pow_iff_right pp.one_lt).1 ((ord_proj_le p hn).trans hb)
state_before: a b✝ m n✝ p✝ n p b : ℕ
hb : n ≤ p ^ b
hn : ¬n = 0
pp : Prime p
⊢ n.factorization p ≤ b
state_after: no goals

tactic: simp [factorization_eq_zero_of_non_prime n pp]
state_before: a b✝ m n✝ p✝ n p b : ℕ
hb : n ≤ p ^ b
hn : ¬n = 0
pp : ¬Prime p
⊢ n.factorization p ≤ b
state_after: no goals
Theorem: Finset.sym_eq_empty
File: Mathlib/Data/Finset/Sym.lean

tactic: cases n
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n : ℕ
⊢ s.sym n = ∅ ↔ n ≠ 0 ∧ s = ∅
state_after: case zero
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
⊢ s.sym 0 = ∅ ↔ 0 ≠ 0 ∧ s = ∅

case succ
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n✝ : ℕ
⊢ s.sym (n✝ + 1) = ∅ ↔ n✝ + 1 ≠ 0 ∧ s = ∅

tactic: exact iff_of_false (singleton_ne_empty _) fun h ↦ (h.1 rfl).elim
state_before: case zero
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
⊢ s.sym 0 = ∅ ↔ 0 ≠ 0 ∧ s = ∅
state_after: no goals

tactic: refine ⟨fun h ↦ ⟨Nat.succ_ne_zero _, eq_empty_of_sym_eq_empty h⟩, ?_⟩
state_before: case succ
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n✝ : ℕ
⊢ s.sym (n✝ + 1) = ∅ ↔ n✝ + 1 ≠ 0 ∧ s = ∅
state_after: case succ
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n✝ : ℕ
⊢ n✝ + 1 ≠ 0 ∧ s = ∅ → s.sym (n✝ + 1) = ∅

tactic: rintro ⟨_, rfl⟩
state_before: case succ
α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
a b : α
n✝ : ℕ
⊢ n✝ + 1 ≠ 0 ∧ s = ∅ → s.sym (n✝ + 1) = ∅
state_after: case succ.intro
α : Type u_1
inst✝ : DecidableEq α
t : Finset α
a b : α
n✝ : ℕ
left✝ : n✝ + 1 ≠ 0
⊢ ∅.sym (n✝ + 1) = ∅

tactic: exact sym_empty _
state_before: case succ.intro
α : Type u_1
inst✝ : DecidableEq α
t : Finset α
a b : α
n✝ : ℕ
left✝ : n✝ + 1 ≠ 0
⊢ ∅.sym (n✝ + 1) = ∅
state_after: no goals
Theorem: CategoryTheory.preserves_mono_of_preservesLimit
File: Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean

tactic: have := isLimitPullbackConeMapOfIsLimit F _ (PullbackCone.isLimitMkIdId f)
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesLimit (cospan f f) F
inst✝ : Mono f
⊢ Mono (F.map f)
state_after: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesLimit (cospan f f) F
inst✝ : Mono f
this :
  let_fun this := ⋯;
  IsLimit (PullbackCone.mk (F.map (𝟙 X)) (F.map (𝟙 X)) this)
⊢ Mono (F.map f)

tactic: simp_rw [F.map_id] at this
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesLimit (cospan f f) F
inst✝ : Mono f
this :
  let_fun this := ⋯;
  IsLimit (PullbackCone.mk (F.map (𝟙 X)) (F.map (𝟙 X)) this)
⊢ Mono (F.map f)
state_after: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesLimit (cospan f f) F
inst✝ : Mono f
this : IsLimit (PullbackCone.mk (𝟙 (F.obj X)) (𝟙 (F.obj X)) ⋯)
⊢ Mono (F.map f)

tactic: apply PullbackCone.mono_of_isLimitMkIdId _ this
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesLimit (cospan f f) F
inst✝ : Mono f
this : IsLimit (PullbackCone.mk (𝟙 (F.obj X)) (𝟙 (F.obj X)) ⋯)
⊢ Mono (F.map f)
state_after: no goals
Theorem: Set.comp_rangeSplitting
File: Mathlib/Data/Set/Defs.lean

tactic: ext
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
⊢ f ∘ rangeSplitting f = Subtype.val
state_after: case h
α : Type u
β : Type v
γ : Type w
f : α → β
x✝ : ↑(range f)
⊢ (f ∘ rangeSplitting f) x✝ = ↑x✝

tactic: simp only [Function.comp_apply]
state_before: case h
α : Type u
β : Type v
γ : Type w
f : α → β
x✝ : ↑(range f)
⊢ (f ∘ rangeSplitting f) x✝ = ↑x✝
state_after: case h
α : Type u
β : Type v
γ : Type w
f : α → β
x✝ : ↑(range f)
⊢ f (rangeSplitting f x✝) = ↑x✝

tactic: apply apply_rangeSplitting
state_before: case h
α : Type u
β : Type v
γ : Type w
f : α → β
x✝ : ↑(range f)
⊢ f (rangeSplitting f x✝) = ↑x✝
state_after: no goals
Theorem: UnitalShelf.act_idem
File: Mathlib/Algebra/Quandle.lean

tactic: rw [← act_one x, ← Shelf.self_distrib, act_one]
state_before: S : Type u_1
inst✝ : UnitalShelf S
x : S
⊢ x ◃ x = x
state_after: no goals
Theorem: Multiset.filter_cons
File: Mathlib/Data/Multiset/Basic.lean

tactic: split_ifs with h
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
⊢ filter p (a ::ₘ s) = (if p a then {a} else 0) + filter p s
state_after: case pos
α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : p a
⊢ filter p (a ::ₘ s) = {a} + filter p s

case neg
α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : ¬p a
⊢ filter p (a ::ₘ s) = 0 + filter p s

tactic: rw [filter_cons_of_pos _ h, singleton_add]
state_before: case pos
α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : p a
⊢ filter p (a ::ₘ s) = {a} + filter p s
state_after: no goals

tactic: rw [filter_cons_of_neg _ h, zero_add]
state_before: case neg
α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : ¬p a
⊢ filter p (a ::ₘ s) = 0 + filter p s
state_after: no goals
Theorem: LinearMap.sub_mem_ker_iff
File: Mathlib/Algebra/Module/Submodule/Ker.lean

tactic: rw [mem_ker, map_sub, sub_eq_zero]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
K : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₃ : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝¹¹ : Ring R
inst✝¹⁰ : Ring R₂
inst✝⁹ : Ring R₃
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_12
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f : F
x y : M
⊢ x - y ∈ ker f ↔ f x = f y
state_after: no goals
Theorem: Real.isBigO_exp_comp_one
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp only [isBigO_one_iff, norm_eq_abs, abs_exp, isBoundedUnder_le_exp_comp]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ ((fun x => rexp (f x)) =O[l] fun x => 1) ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l f
state_after: no goals
Theorem: inv_pow_sub
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [pow_sub a⁻¹ h, inv_pow, inv_pow, inv_inv]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
m n : ℕ
h : n ≤ m
⊢ a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n
state_after: no goals
Theorem: toIcoMod_add_left'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [add_comm, toIcoMod_add_right', add_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp (p + a) b = p + toIcoMod hp a b
state_after: no goals
Theorem: WittVector.ghostFun_nsmul
File: Mathlib/RingTheory/WittVector/Basic.lean

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

tactic: rw [iff_characterModule_injective,
  injective_characterModule_iff_rTensor_preserves_injective_linearMap]
state_before: R : Type u
M : Type v
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : Type w
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Small.{v, u} R
⊢ Flat R M ↔
    ∀ ⦃N N' : Type v⦄ [inst : AddCommGroup N] [inst_1 : AddCommGroup N'] [inst_2 : Module R N] [inst_3 : Module R N']
      (L : N →ₗ[R] N'), Function.Injective ⇑L → Function.Injective ⇑(rTensor M L)
state_after: no goals
Theorem: CategoryTheory.PreservesImage.hom_comp_map_image_ι
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Images.lean

tactic: rw [iso_hom, image.lift_fac]
state_before: A : Type u₁
B : Type u₂
inst✝⁷ : Category.{v₁, u₁} A
inst✝⁶ : Category.{v₂, u₂} B
inst✝⁵ : HasEqualizers A
inst✝⁴ : HasImages A
inst✝³ : StrongEpiCategory B
inst✝² : HasImages B
L : A ⥤ B
inst✝¹ : {X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PreservesLimit (cospan f g) L
inst✝ : {X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → PreservesColimit (span f g) L
X Y : A
f : X ⟶ Y
⊢ (iso L f).hom ≫ L.map (image.ι f) = image.ι (L.map f)
state_after: no goals
Theorem: Lagrange.interpolate_eq_add_interpolate_erase
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [interpolate_eq_sum_interpolate_insert_sdiff _ hvs ⟨i, mem_insert_self i {j}⟩ _,
  sum_insert (not_mem_singleton.mpr hij), sum_singleton, basis_pair_left hij,
  basis_pair_right hij, sdiff_insert_insert_of_mem_of_not_mem hi (not_mem_singleton.mpr hij),
  sdiff_singleton_eq_erase, pair_comm,
  sdiff_insert_insert_of_mem_of_not_mem hj (not_mem_singleton.mpr hij.symm),
  sdiff_singleton_eq_erase]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
hj : j ∈ s
hij : i ≠ j
⊢ (interpolate s v) r =
    (interpolate (s.erase j) v) r * basisDivisor (v i) (v j) + (interpolate (s.erase i) v) r * basisDivisor (v j) (v i)
state_after: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
hj : j ∈ s
hij : i ≠ j
⊢ {i, j} ⊆ s

tactic: exact insert_subset_iff.mpr ⟨hi, singleton_subset_iff.mpr hj⟩
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
hj : j ∈ s
hij : i ≠ j
⊢ {i, j} ⊆ s
state_after: no goals