ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matrix.vec2_eq
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
a₀ a₁ b₀ b₁ : α
h₀ : a₀ = b₀
h₁ : a₁ = b₁
⊢ ![a₀, a₁] = ![b₀, b₁]
state_after: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
b₀ b₁ : α
⊢ ![b₀, b₁] = ![b₀, b₁]
tactic: subst_vars
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
b₀ b₁ : α
⊢ ![b₀, b₁] = ![b₀, b₁]
state_after: no goals
tactic: rfl
Theorem: List.sum_neg_reverse
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✝ : Group G
⊢ [].prod⁻¹ = (map (fun x => x⁻¹) []).reverse.prod
state_after: no goals
tactic: simp
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✝ : Group G
x : G
xs : List G
⊢ (x :: xs).prod⁻¹ = (map (fun x => x⁻¹) (x :: xs)).reverse.prod
state_after: no goals
tactic: simp [prod_inv_reverse xs]
Theorem: Ring.smeval_ascPochhammer_nat_cast
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
n k : ℕ
⊢ (ascPochhammer ℕ k).smeval ↑n = ↑((ascPochhammer ℕ k).smeval n)
state_after: no goals
tactic: rw [smeval_at_natCast (ascPochhammer ℕ k) n]
Theorem: MvPFunctor.M.map_dest
File: Mathlib/Data/PFunctor/Multivariate/M.lean

Proof steps:
state_before: n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ g <$$> dest P x = dest P (dropFun g <$$> x)
state_after: n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ g <$$> dest P x = (dropFun g ::: fun x => dropFun g <$$> x) <$$> dest P x
tactic: rw [M.dest_map]
state_before: n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ g <$$> dest P x = (dropFun g ::: fun x => dropFun g <$$> x) <$$> dest P x
state_after: case e_a
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ g = (dropFun g ::: fun x => dropFun g <$$> x)
tactic: congr
state_before: case e_a
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ g = (dropFun g ::: fun x => dropFun g <$$> x)
state_after: case e_a.h₁
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ lastFun g = fun x => dropFun g <$$> x
tactic: apply eq_of_drop_last_eq <;> simp
state_before: case e_a.h₁
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
⊢ lastFun g = fun x => dropFun g <$$> x
state_after: case e_a.h₁.h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
x✝ : (α ::: P.M α).last
⊢ lastFun g x✝ = dropFun g <$$> x✝
tactic: ext1
state_before: case e_a.h₁.h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α β : TypeVec.{u} n
g : α ::: P.M α ⟹ β ::: P.M β
x : P.M α
h : ∀ (x : P.M α), lastFun g x = dropFun g <$$> x
x✝ : (α ::: P.M α).last
⊢ lastFun g x✝ = dropFun g <$$> x✝
state_after: no goals
tactic: apply h
Theorem: Set.Nonempty.pairwise_iff_exists_forall
File: Mathlib/Data/Set/Pairwise/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
hs : s.Nonempty
⊢ s.Pairwise (r on f) ↔ ∃ z, ∀ x ∈ s, r (f x) z
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
hs : s.Nonempty
⊢ s.Pairwise (r on f) → ∃ z, ∀ x ∈ s, r (f x) z

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
inst✝ : IsEquiv α r
s : Set ι
hs : s.Nonempty
⊢ (∃ z, ∀ x ∈ s, r (f x) z) → s.Pairwise (r on f)
tactic: constructor
Theorem: hasFDerivAtFilter_const
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝¹ : E
s t : Set E
L✝ L₁ L₂ : Filter E
c : F
x : E
L : Filter E
x✝ : E
⊢ 0 = c - c - 0 (x✝ - x)
state_after: no goals
tactic: simp only [zero_apply, sub_self]
Theorem: IsClosed.isNowhereDense_iff
File: Mathlib/Topology/GDelta.lean

Proof steps:
state_before: X✝ : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
X : Type u_5
inst✝ : TopologicalSpace X
s : Set X
hs : IsClosed s
⊢ IsNowhereDense s ↔ interior s = ∅
state_after: no goals
tactic: rw [IsNowhereDense, IsClosed.closure_eq hs]
Theorem: Real.arccos_eq_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ arccos x = π ↔ x ≤ -1
state_after: no goals
tactic: rw [arccos, sub_eq_iff_eq_add, ← sub_eq_iff_eq_add', div_two_sub_self, neg_pi_div_two_eq_arcsin]
Theorem: ChainComplex.mk_d_1_0
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₁ ⟶ X₀
d₁ : X₂ ⟶ X₁
s : d₁ ≫ d₀ = 0
succ : (S : ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ ⟶ S.X₁) ×' d₂ ≫ S.f = 0
⊢ (mk X₀ X₁ X₂ d₀ d₁ s succ).d 1 0 = d₀
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₁ ⟶ X₀
d₁ : X₂ ⟶ X₁
s : d₁ ≫ d₀ = 0
succ : (S : ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ ⟶ S.X₁) ×' d₂ ≫ S.f = 0
⊢ (if 1 = 0 + 1 then 𝟙 X₁ ≫ d₀ else 0) = d₀
tactic: change ite (1 = 0 + 1) (𝟙 X₁ ≫ d₀) 0 = d₀
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₁ ⟶ X₀
d₁ : X₂ ⟶ X₁
s : d₁ ≫ d₀ = 0
succ : (S : ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ ⟶ S.X₁) ×' d₂ ≫ S.f = 0
⊢ (if 1 = 0 + 1 then 𝟙 X₁ ≫ d₀ else 0) = d₀
state_after: no goals
tactic: rw [if_pos rfl, Category.id_comp]
Theorem: ContinuousMap.Homotopy.apply_zero_path
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/InducedMaps.lean

Proof steps:
state_before: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ (π.map f).map ⟦p'⟧ = hcast ⋯ ≫ (π.map H.uliftMap).map (prodToProdTopI (𝟙 (fromTop { down := 0 })) ⟦p'⟧) ≫ hcast ⋯
state_after: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H.uliftMap (((Path.refl { down := 0 }).prod p') t)
tactic: apply @eq_path_of_eq_image _ _ _ _ H.uliftMap _ _ _ _ _ ((Path.refl (ULift.up _)).prod p')
state_before: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H.uliftMap (((Path.refl { down := 0 }).prod p') t)
state_after: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H.uliftMap ((fun t => ((Path.refl { down := 0 }) t, p' t)) t)
tactic: erw [Path.prod_coe]
state_before: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H.uliftMap ((fun t => ((Path.refl { down := 0 }) t, p' t)) t)
state_after: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H (((Path.refl { down := 0 }) t).down, p' t)
tactic: simp_rw [ulift_apply]
state_before: X Y : TopCat
f g : C(↑X, ↑Y)
H : f.Homotopy g
x₀ x₁ : ↑X
p : fromTop x₀ ⟶ fromTop x₁
p' : Path (fromTop x₀).as (fromTop x₁).as
⊢ ∀ (t : ↑I), f (p' t) = H (((Path.refl { down := 0 }) t).down, p' t)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.ComposableArrows.exact_of_δlast
File: Mathlib/Algebra/Homology/ExactSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n✝ : ℕ
S✝ : ComposableArrows C n✝
n : ℕ
S : ComposableArrows C (n + 2)
h₁ : S.δlast.Exact
h₂ : (mk₂ (S.map' n (n + 1) ⋯ ⋯) (S.map' (n + 1) (n + 2) ⋯ ⋯)).Exact
⊢ S.Exact
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n✝ : ℕ
S✝ : ComposableArrows C n✝
n : ℕ
S : ComposableArrows C (n + 2)
h₁ : S.δlast.Exact
h₂ : (mk₂ (S.map' n (n + 1) ⋯ ⋯) (S.map' (n + 1) (n + 2) ⋯ ⋯)).Exact
⊢ S.δlast.Exact ∧ (mk₂ (S.map' n (n + 1) ⋯ ⋯) (S.map' (n + 1) (n + 2) ⋯ ⋯)).Exact
tactic: rw [exact_iff_δlast]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
n✝ : ℕ
S✝ : ComposableArrows C n✝
n : ℕ
S : ComposableArrows C (n + 2)
h₁ : S.δlast.Exact
h₂ : (mk₂ (S.map' n (n + 1) ⋯ ⋯) (S.map' (n + 1) (n + 2) ⋯ ⋯)).Exact
⊢ S.δlast.Exact ∧ (mk₂ (S.map' n (n + 1) ⋯ ⋯) (S.map' (n + 1) (n + 2) ⋯ ⋯)).Exact
state_after: no goals
tactic: constructor <;> assumption
Theorem: Set.exists_subsuperset_card_eq
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
n : ℕ
hst : s ⊆ t
hsn : s.ncard ≤ n
hnt : n ≤ t.ncard
⊢ ∃ u, s ⊆ u ∧ u ⊆ t ∧ u.ncard = n
state_after: case inl
α : Type u_1
β : Type u_2
s t : Set α
f : α → β
n : ℕ
hst : s ⊆ t
hsn : s.ncard ≤ n
hnt : n ≤ t.ncard
ht : t.Infinite
⊢ ∃ u, s ⊆ u ∧ u ⊆ t ∧ u.ncard = n

case inr
α : Type u_1
β : Type u_2
s t : Set α
f : α → β
n : ℕ
hst : s ⊆ t
hsn : s.ncard ≤ n
hnt : n ≤ t.ncard
ht : t.Finite
⊢ ∃ u, s ⊆ u ∧ u ⊆ t ∧ u.ncard = n
tactic: obtain ht | ht := t.infinite_or_finite
state_before: case inr
α : Type u_1
β : Type u_2
s t : Set α
f : α → β
n : ℕ
hst : s ⊆ t
hsn : s.ncard ≤ n
hnt : n ≤ t.ncard
ht : t.Finite
⊢ ∃ u, s ⊆ u ∧ u ⊆ t ∧ u.ncard = n
state_after: case inr.intro
α : Type u_1
β : Type u_2
t : Set α
f : α → β
n : ℕ
hnt : n ≤ t.ncard
ht : t.Finite
s : Finset α
hst : ↑s ⊆ t
hsn : (↑s).ncard ≤ n
⊢ ∃ u, ↑s ⊆ u ∧ u ⊆ t ∧ u.ncard = n
tactic: lift s to Finset α using ht.subset hst
state_before: case inr.intro
α : Type u_1
β : Type u_2
t : Set α
f : α → β
n : ℕ
hnt : n ≤ t.ncard
ht : t.Finite
s : Finset α
hst : ↑s ⊆ t
hsn : (↑s).ncard ≤ n
⊢ ∃ u, ↑s ⊆ u ∧ u ⊆ t ∧ u.ncard = n
state_after: case inr.intro.intro
α : Type u_1
β : Type u_2
f : α → β
n : ℕ
s : Finset α
hsn : (↑s).ncard ≤ n
t : Finset α
hnt : n ≤ (↑t).ncard
hst : ↑s ⊆ ↑t
⊢ ∃ u, ↑s ⊆ u ∧ u ⊆ ↑t ∧ u.ncard = n
tactic: lift t to Finset α using ht
state_before: case inr.intro.intro
α : Type u_1
β : Type u_2
f : α → β
n : ℕ
s : Finset α
hsn : (↑s).ncard ≤ n
t : Finset α
hnt : n ≤ (↑t).ncard
hst : ↑s ⊆ ↑t
⊢ ∃ u, ↑s ⊆ u ∧ u ⊆ ↑t ∧ u.ncard = n
state_after: case inr.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
f : α → β
n : ℕ
s : Finset α
hsn : (↑s).ncard ≤ n
t : Finset α
hnt : n ≤ (↑t).ncard
hst : ↑s ⊆ ↑t
u : Finset α
hsu : s ⊆ u
hut : u ⊆ t
hu : u.card = n
⊢ ∃ u, ↑s ⊆ u ∧ u ⊆ ↑t ∧ u.ncard = n
tactic: obtain ⟨u, hsu, hut, hu⟩ := Finset.exists_subsuperset_card_eq (mod_cast hst) (by simpa using hsn)
    (mod_cast hnt)
state_before: case inr.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
f : α → β
n : ℕ
s : Finset α
hsn : (↑s).ncard ≤ n
t : Finset α
hnt : n ≤ (↑t).ncard
hst : ↑s ⊆ ↑t
u : Finset α
hsu : s ⊆ u
hut : u ⊆ t
hu : u.card = n
⊢ ∃ u, ↑s ⊆ u ∧ u ⊆ ↑t ∧ u.ncard = n
state_after: no goals
tactic: exact ⟨u, mod_cast hsu, mod_cast hut, mod_cast hu⟩
Theorem: Orientation.map_refl
File: Mathlib/LinearAlgebra/Orientation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : StrictOrderedCommSemiring R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
ι : Type u_4
ι' : Type u_5
⊢ map ι (LinearEquiv.refl R M) = Equiv.refl (Orientation R M ι)
state_after: no goals
tactic: rw [Orientation.map, AlternatingMap.domLCongr_refl, Module.Ray.map_refl]
Theorem: CategoryTheory.ShortComplex.Homotopy.homologyMap'_congr
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
h : Homotopy φ₁ φ₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
⊢ homologyMap' φ₁ h₁ h₂ = homologyMap' φ₂ h₁ h₂
state_after: no goals
tactic: rw [h.eq_add_nullHomotopic, homologyMap'_add, homologyMap'_nullHomotopic, add_zero]
Theorem: le_max_left
File: Mathlib/Init/Order/LinearOrder.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ a ≤ max a b
state_after: no goals
tactic: if h : a ≤ b
  then simp [max_def, if_pos h]; exact h
  else simp [max_def, if_neg h, le_refl]
Theorem: List.prod_append
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₁ ++ l₂).prod = foldl (fun x x_1 => x * x_1) (foldl (fun x x_1 => x * x_1) 1 l₁ * 1) l₂
state_after: no goals
tactic: simp [List.prod]
Theorem: LowerSet.Iic_iInf₂
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : CompleteLattice α
f : (i : ι) → κ i → α
⊢ Iic (⨅ i, ⨅ j, f i j) = ⨅ i, ⨅ j, Iic (f i j)
state_after: no goals
tactic: simp_rw [Iic_iInf]
Theorem: FreeGroup.Red.sizeof_of_step
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ L1 L2 : List (α × Bool)
x : α
b : Bool
⊢ sizeOf (L1 ++ L2) < sizeOf (L1 ++ (x, b) :: (x, !b) :: L2)
state_after: no goals
tactic: induction L1 with
    | nil =>
      -- dsimp [sizeOf]
      dsimp
      simp only [Bool.sizeOf_eq_one]

      have H :
        1 + (1 + 1) + (1 + (1 + 1) + sizeOf L2) =
          sizeOf L2 + (1 + ((1 + 1) + (1 + 1) + 1)) := by
        ac_rfl
      rw [H]
      apply Nat.lt_add_of_pos_right
      apply Nat.lt_add_right
      apply Nat.zero_lt_one
    | cons hd tl ih =>
      dsimp
      exact Nat.add_lt_add_left ih _
Theorem: CategoryTheory.Limits.spanExt_app_right
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).app WalkingSpan.right = iZ
state_after: no goals
tactic: dsimp [spanExt]
Theorem: QuadraticMap.map_smul_of_tower
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
Q : QuadraticMap R M N
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : Module S M
inst✝² : IsScalarTower S R M
inst✝¹ : Module S N
inst✝ : IsScalarTower S R N
a : S
x : M
⊢ Q (a • x) = (a * a) • Q x
state_after: no goals
tactic: rw [← IsScalarTower.algebraMap_smul R a x, map_smul, ← RingHom.map_mul, algebraMap_smul]
Theorem: CategoryTheory.Abelian.imageStrongEpiMonoFactorisation_m
File: Mathlib/CategoryTheory/Abelian/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
⊢ Mono (image.ι f)
state_after: no goals
tactic: infer_instance
Theorem: Set.Iic_sInf
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
inst✝ : CompleteLattice α
s : Set α
⊢ Iic (sInf s) = ⋂ a ∈ s, Iic a
state_after: no goals
tactic: rw [sInf_eq_iInf, Iic_iInf₂]
Theorem: AddAction.stabilizer_vadd_eq_stabilizer_map_conj
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
inst✝¹ : AddGroup G
inst✝ : AddAction G α
g : G
a : α
⊢ stabilizer G (g +ᵥ a) = AddSubgroup.map (AddEquiv.toAddMonoidHom (AddAut.conj g)) (stabilizer G a)
state_after: case h
G : Type u_1
α : Type u_2
inst✝¹ : AddGroup G
inst✝ : AddAction G α
g : G
a : α
h : G
⊢ h ∈ stabilizer G (g +ᵥ a) ↔ h ∈ AddSubgroup.map (AddEquiv.toAddMonoidHom (AddAut.conj g)) (stabilizer G a)
tactic: ext h
state_before: case h
G : Type u_1
α : Type u_2
inst✝¹ : AddGroup G
inst✝ : AddAction G α
g : G
a : α
h : G
⊢ h ∈ stabilizer G (g +ᵥ a) ↔ h ∈ AddSubgroup.map (AddEquiv.toAddMonoidHom (AddAut.conj g)) (stabilizer G a)
state_after: no goals
tactic: rw [mem_stabilizer_iff, ← vadd_left_cancel_iff (-g), vadd_vadd, vadd_vadd, vadd_vadd,
    add_left_neg, zero_vadd, ← mem_stabilizer_iff, AddSubgroup.mem_map_equiv,
    AddAut.conj_symm_apply]
Theorem: MvPolynomial.rank_R
File: Mathlib/FieldTheory/Finite/Polynomial.lean

Proof steps:
state_before: σ K : Type u
inst✝² : Fintype K
inst✝¹ : Field K
inst✝ : Fintype σ
⊢ Module.rank K (↑{s | ∀ (n : σ), s n ≤ Fintype.card K - 1} →₀ K) = #↑{s | ∀ (n : σ), s n ≤ Fintype.card K - 1}
state_after: no goals
tactic: rw [rank_finsupp_self']
state_before: σ K : Type u
inst✝² : Fintype K
inst✝¹ : Field K
inst✝ : Fintype σ
⊢ #↑{s | ∀ (n : σ), s n ≤ Fintype.card K - 1} = #↑{s | ∀ (n : σ), s n < Fintype.card K}
state_after: σ K : Type u
inst✝² : Fintype K
inst✝¹ : Field K
inst✝ : Fintype σ
f : σ →₀ ℕ
⊢ f ∈ {s | ∀ (n : σ), s n ≤ Fintype.card K - 1} ↔ Finsupp.equivFunOnFinite f ∈ {s | ∀ (n : σ), s n < Fintype.card K}
tactic: refine Quotient.sound ⟨Equiv.subtypeEquiv Finsupp.equivFunOnFinite fun f => ?_⟩
state_before: σ K : Type u
inst✝² : Fintype K
inst✝¹ : Field K
inst✝ : Fintype σ
f : σ →₀ ℕ
⊢ f ∈ {s | ∀ (n : σ), s n ≤ Fintype.card K - 1} ↔ Finsupp.equivFunOnFinite f ∈ {s | ∀ (n : σ), s n < Fintype.card K}
state_after: σ K : Type u
inst✝² : Fintype K
inst✝¹ : Field K
inst✝ : Fintype σ
f : σ →₀ ℕ
n : σ
⊢ 1 ≤ Fintype.card K
tactic: refine forall_congr' fun n => le_tsub_iff_right ?_
state_before: σ K : Type u
inst✝² : Fintype K
inst✝¹ : Field K
inst✝ : Fintype σ
f : σ →₀ ℕ
n : σ
⊢ 1 ≤ Fintype.card K
state_after: no goals
tactic: exact Fintype.card_pos_iff.2 ⟨0⟩
Theorem: Disjoint.sdiff_eq_left
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
h : Disjoint a b
⊢ a \ b = a
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
h : Disjoint a b
⊢ a \ b = a \ ⊥
tactic: conv_rhs => rw [← @sdiff_bot _ _ a]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
h : Disjoint a b
⊢ a \ b = a \ ⊥
state_after: no goals
tactic: rw [← h.eq_bot, sdiff_inf_self_left]
Theorem: Set.indicator_preimage_of_not_mem
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t✝ : Set α
f✝ g : α → M
a : α
s : Set α
f : α → M
t : Set M
ht : 1 ∉ t
⊢ s.mulIndicator f ⁻¹' t = f ⁻¹' t ∩ s
state_after: no goals
tactic: simp [mulIndicator_preimage, Pi.one_def, Set.preimage_const_of_not_mem ht]
Theorem: CategoryTheory.MorphismProperty.StableUnderBaseChange.mk
File: Mathlib/CategoryTheory/MorphismProperty/Limits.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
P : MorphismProperty C
inst✝¹ : HasPullbacks C
inst✝ : P.RespectsIso
hP₂ : ∀ (X Y S : C) (f : X ⟶ S) (g : Y ⟶ S), P g → P (pullback.fst f g)
X Y Y' S : C
f : X ⟶ S
g : Y ⟶ S
f' : Y' ⟶ Y
g' : Y' ⟶ X
sq : IsPullback f' g' g f
hg : P g
⊢ P g'
state_after: C : Type u
inst✝² : Category.{v, u} C
P : MorphismProperty C
inst✝¹ : HasPullbacks C
inst✝ : P.RespectsIso
hP₂ : ∀ (X Y S : C) (f : X ⟶ S) (g : Y ⟶ S), P g → P (pullback.fst f g)
X Y Y' S : C
f : X ⟶ S
g : Y ⟶ S
f' : Y' ⟶ Y
g' : Y' ⟶ X
sq : IsPullback f' g' g f
hg : P g
e : Y' ≅ pullback f g := ⋯.isoPullback
⊢ P g'
tactic: let e := sq.flip.isoPullback
state_before: C : Type u
inst✝² : Category.{v, u} C
P : MorphismProperty C
inst✝¹ : HasPullbacks C
inst✝ : P.RespectsIso
hP₂ : ∀ (X Y S : C) (f : X ⟶ S) (g : Y ⟶ S), P g → P (pullback.fst f g)
X Y Y' S : C
f : X ⟶ S
g : Y ⟶ S
f' : Y' ⟶ Y
g' : Y' ⟶ X
sq : IsPullback f' g' g f
hg : P g
e : Y' ≅ pullback f g := ⋯.isoPullback
⊢ P g'
state_after: C : Type u
inst✝² : Category.{v, u} C
P : MorphismProperty C
inst✝¹ : HasPullbacks C
inst✝ : P.RespectsIso
hP₂ : ∀ (X Y S : C) (f : X ⟶ S) (g : Y ⟶ S), P g → P (pullback.fst f g)
X Y Y' S : C
f : X ⟶ S
g : Y ⟶ S
f' : Y' ⟶ Y
g' : Y' ⟶ X
sq : IsPullback f' g' g f
hg : P g
e : Y' ≅ pullback f g := ⋯.isoPullback
⊢ P (pullback.fst f g)
tactic: rw [← P.cancel_left_of_respectsIso e.inv, sq.flip.isoPullback_inv_fst]
state_before: C : Type u
inst✝² : Category.{v, u} C
P : MorphismProperty C
inst✝¹ : HasPullbacks C
inst✝ : P.RespectsIso
hP₂ : ∀ (X Y S : C) (f : X ⟶ S) (g : Y ⟶ S), P g → P (pullback.fst f g)
X Y Y' S : C
f : X ⟶ S
g : Y ⟶ S
f' : Y' ⟶ Y
g' : Y' ⟶ X
sq : IsPullback f' g' g f
hg : P g
e : Y' ≅ pullback f g := ⋯.isoPullback
⊢ P (pullback.fst f g)
state_after: no goals
tactic: exact hP₂ _ _ _ f g hg
Theorem: MvPolynomial.C_dvd_iff_map_hom_eq_zero
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q✝ : MvPolynomial σ R
f q : R →+* S₁
r : R
hr : ∀ (r' : R), q r' = 0 ↔ r ∣ r'
φ : MvPolynomial σ R
⊢ C r ∣ φ ↔ (map q) φ = 0
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q✝ : MvPolynomial σ R
f q : R →+* S₁
r : R
hr : ∀ (r' : R), q r' = 0 ↔ r ∣ r'
φ : MvPolynomial σ R
⊢ (∀ (i : σ →₀ ℕ), r ∣ coeff i φ) ↔ ∀ (m : σ →₀ ℕ), coeff m ((map q) φ) = coeff m 0
tactic: rw [C_dvd_iff_dvd_coeff, MvPolynomial.ext_iff]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q✝ : MvPolynomial σ R
f q : R →+* S₁
r : R
hr : ∀ (r' : R), q r' = 0 ↔ r ∣ r'
φ : MvPolynomial σ R
⊢ (∀ (i : σ →₀ ℕ), r ∣ coeff i φ) ↔ ∀ (m : σ →₀ ℕ), coeff m ((map q) φ) = coeff m 0
state_after: no goals
tactic: simp only [coeff_map, coeff_zero, hr]
Theorem: factorization_eq_count
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : NormalizationMonoid α
inst✝ : DecidableEq α
n p : α
⊢ (factorization n) p = Multiset.count p (normalizedFactors n)
state_after: no goals
tactic: simp [factorization]
Theorem: MulOpposite.op_div
File: Mathlib/Algebra/Group/Opposite.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DivInvMonoid α
x y : α
⊢ op (x / y) = (op y)⁻¹ * op x
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: isAddFreimanHom_id
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hA : A₁ ⊆ A₂
s t : Multiset α
x✝³ : ∀ ⦃x : α⦄, x ∈ s → x ∈ A₁
x✝² : ∀ ⦃x : α⦄, x ∈ t → x ∈ A₁
x✝¹ : card s = n
x✝ : card t = n
h : s.prod = t.prod
⊢ (map id s).prod = (map id t).prod
state_after: no goals
tactic: simpa using h