ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Filter.image_mem_of_mem_comap
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
c : β → α
h : range c ∈ f
W : Set β
W_in : W ∈ comap c f
⊢ c '' W ∈ f
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
c : β → α
h : range c ∈ f
W : Set β
W_in : W ∈ comap c f
⊢ c '' W ∈ map c (comap c f)
tactic: rw [← map_comap_of_mem h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter α
c : β → α
h : range c ∈ f
W : Set β
W_in : W ∈ comap c f
⊢ c '' W ∈ map c (comap c f)
state_after: no goals
tactic: exact image_mem_map W_in
Theorem: norm_sup_sub_sup_le_add_norm
File: Mathlib/Analysis/Normed/Order/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b c d : α
⊢ ‖a ⊔ b - c ⊔ d‖ ≤ ‖a - c‖ + ‖b - d‖
state_after: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b c d : α
⊢ ‖a ⊔ b - c ⊔ d‖ ≤ ‖|a - c|‖ + ‖|b - d|‖
tactic: rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b c d : α
⊢ ‖a ⊔ b - c ⊔ d‖ ≤ ‖|a - c|‖ + ‖|b - d|‖
state_after: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b c d : α
⊢ |a ⊔ b - c ⊔ d| ≤ ||a - c| + |b - d||
tactic: refine le_trans (solid ?_) (norm_add_le |a - c| |b - d|)
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b c d : α
⊢ |a ⊔ b - c ⊔ d| ≤ ||a - c| + |b - d||
state_after: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b c d : α
⊢ |a ⊔ b - c ⊔ d| ≤ |a - c| + |b - d|
tactic: rw [abs_of_nonneg (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
Theorem: List.sum_range_succ
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
f : ℕ → M
n : ℕ
⊢ (map f (range n.succ)).prod = (map f (range n)).prod * f n
state_after: no goals
tactic: rw [range_succ, map_append, map_singleton, prod_append, prod_cons, prod_nil, mul_one]
Theorem: AddSubgroup.leftTransversals.vadd_diff_vadd
File: Mathlib/GroupTheory/Transfer.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
A : Type u_2
inst✝¹ : CommGroup A
ϕ : ↥H →* A
R S T : ↑(leftTransversals ↑H)
inst✝ : H.FiniteIndex
g : G
x✝¹ : Fintype (G ⧸ H) := H.fintypeQuotientOfFiniteIndex
x✝ : G ⧸ H
⊢ ϕ ⟨(↑((MemLeftTransversals.toEquiv ⋯) x✝))⁻¹ * ↑((MemLeftTransversals.toEquiv ⋯) x✝), ⋯⟩ =
    ϕ
      ⟨(↑((MemLeftTransversals.toEquiv ⋯) ((Equiv.symm (toPerm g)) x✝)))⁻¹ *
          ↑((MemLeftTransversals.toEquiv ⋯) ((Equiv.symm (toPerm g)) x✝)),
        ⋯⟩
state_after: no goals
tactic: simp only [smul_apply_eq_smul_apply_inv_smul, smul_eq_mul, mul_inv_rev, mul_assoc,
      inv_mul_cancel_left, toPerm_symm_apply]
Theorem: RelSeries.smash_natAdd
File: Mathlib/Order/RelSeries.lean

Proof steps:
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
⊢ (p.smash q h).toFun (Fin.natAdd p.length i).castSucc = q.toFun i.castSucc
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
⊢ q.toFun ⟨↑(Fin.natAdd p.length i).castSucc - p.length, ⋯⟩ = q.toFun i.castSucc
tactic: rw [smash_toFun, dif_neg (by simp)]
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
⊢ q.toFun ⟨↑(Fin.natAdd p.length i).castSucc - p.length, ⋯⟩ = q.toFun i.castSucc
state_after: case e_a.e_val
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
⊢ ↑(Fin.natAdd p.length i).castSucc - p.length = ↑i
tactic: congr
state_before: case e_a.e_val
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
⊢ ↑(Fin.natAdd p.length i).castSucc - p.length = ↑i
state_after: no goals
tactic: exact Nat.add_sub_self_left _ _
Theorem: Tree.treesOfNumNodesEq_succ
File: Mathlib/Combinatorics/Enumerative/Catalan.lean

Proof steps:
state_before: n : ℕ
⊢ treesOfNumNodesEq (n + 1) =
    (antidiagonal n).biUnion fun ij => pairwiseNode (treesOfNumNodesEq ij.1) (treesOfNumNodesEq ij.2)
state_after: n : ℕ
⊢ ((antidiagonal n).attach.biUnion fun ijh => pairwiseNode (treesOfNumNodesEq (↑ijh).1) (treesOfNumNodesEq (↑ijh).2)) =
    (antidiagonal n).biUnion fun ij => pairwiseNode (treesOfNumNodesEq ij.1) (treesOfNumNodesEq ij.2)
tactic: rw [treesOfNumNodesEq]
state_before: n : ℕ
⊢ ((antidiagonal n).attach.biUnion fun ijh => pairwiseNode (treesOfNumNodesEq (↑ijh).1) (treesOfNumNodesEq (↑ijh).2)) =
    (antidiagonal n).biUnion fun ij => pairwiseNode (treesOfNumNodesEq ij.1) (treesOfNumNodesEq ij.2)
state_after: case a
n : ℕ
a✝ : Tree Unit
⊢ (a✝ ∈
      (antidiagonal n).attach.biUnion fun ijh =>
        pairwiseNode (treesOfNumNodesEq (↑ijh).1) (treesOfNumNodesEq (↑ijh).2)) ↔
    a✝ ∈ (antidiagonal n).biUnion fun ij => pairwiseNode (treesOfNumNodesEq ij.1) (treesOfNumNodesEq ij.2)
tactic: ext
state_before: case a
n : ℕ
a✝ : Tree Unit
⊢ (a✝ ∈
      (antidiagonal n).attach.biUnion fun ijh =>
        pairwiseNode (treesOfNumNodesEq (↑ijh).1) (treesOfNumNodesEq (↑ijh).2)) ↔
    a✝ ∈ (antidiagonal n).biUnion fun ij => pairwiseNode (treesOfNumNodesEq ij.1) (treesOfNumNodesEq ij.2)
state_after: no goals
tactic: simp
Theorem: Multiset.toDFinsupp_replicate
File: Mathlib/Data/DFinsupp/Multiset.lean

Proof steps:
state_before: α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
n : ℕ
⊢ toDFinsupp (replicate n a) = DFinsupp.single a n
state_after: case h
α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
n : ℕ
i : α
⊢ (toDFinsupp (replicate n a)) i = (DFinsupp.single a n) i
tactic: ext i
state_before: case h
α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
n : ℕ
i : α
⊢ (toDFinsupp (replicate n a)) i = (DFinsupp.single a n) i
state_after: case h
α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
n : ℕ
i : α
⊢ count i (replicate n a) = (DFinsupp.single a n) i
tactic: dsimp [toDFinsupp]
state_before: case h
α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s t : Multiset α
a : α
n : ℕ
i : α
⊢ count i (replicate n a) = (DFinsupp.single a n) i
state_after: no goals
tactic: simp [count_replicate, eq_comm]
Theorem: MulAction.orbitZPowersEquiv_symm_apply'
File: Mathlib/Data/ZMod/Quotient.lean

Proof steps:
state_before: n : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : Group α
a : α
inst✝ : MulAction α β
b : β
k : ℤ
⊢ (orbitZPowersEquiv a b).symm ↑k = ⟨a, ⋯⟩ ^ k • ⟨b, ⋯⟩
state_after: n : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : Group α
a : α
inst✝ : MulAction α β
b : β
k : ℤ
⊢ ⟨a, ⋯⟩ ^ (k % ↑(minimalPeriod (fun x => a • x) b)) • ⟨b, ⋯⟩ = ⟨a, ⋯⟩ ^ k • ⟨b, ⋯⟩
tactic: rw [orbitZPowersEquiv_symm_apply, ZMod.coe_intCast]
state_before: n : ℕ
A : Type u_1
R : Type u_2
inst✝³ : AddGroup A
inst✝² : Ring R
α : Type u_3
β : Type u_4
inst✝¹ : Group α
a : α
inst✝ : MulAction α β
b : β
k : ℤ
⊢ ⟨a, ⋯⟩ ^ (k % ↑(minimalPeriod (fun x => a • x) b)) • ⟨b, ⋯⟩ = ⟨a, ⋯⟩ ^ k • ⟨b, ⋯⟩
state_after: no goals
tactic: exact Subtype.ext (zpow_smul_mod_minimalPeriod _ _ k)
Theorem: IsOpen.connectedComponentIn
File: Mathlib/Topology/Connected/LocallyConnected.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
⊢ IsOpen (connectedComponentIn F x)
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
⊢ ∀ x_1 ∈ connectedComponentIn F x, connectedComponentIn F x ∈ 𝓝 x_1
tactic: rw [isOpen_iff_mem_nhds]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
⊢ ∀ x_1 ∈ connectedComponentIn F x, connectedComponentIn F x ∈ 𝓝 x_1
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
y : α
hy : y ∈ connectedComponentIn F x
⊢ connectedComponentIn F x ∈ 𝓝 y
tactic: intro y hy
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
y : α
hy : y ∈ connectedComponentIn F x
⊢ connectedComponentIn F x ∈ 𝓝 y
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
y : α
hy : y ∈ connectedComponentIn F x
⊢ connectedComponentIn F y ∈ 𝓝 y
tactic: rw [connectedComponentIn_eq hy]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : LocallyConnectedSpace α
F : Set α
x : α
hF : IsOpen F
y : α
hy : y ∈ connectedComponentIn F x
⊢ connectedComponentIn F y ∈ 𝓝 y
state_after: no goals
tactic: exact connectedComponentIn_mem_nhds (hF.mem_nhds <| connectedComponentIn_subset F x hy)
Theorem: gradient_const
File: Mathlib/Analysis/Calculus/Gradient/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
c : 𝕜
⊢ ∇ (fun x => c) x = 0
state_after: no goals
tactic: rw [gradient, fderiv_const, Pi.zero_apply, map_zero]
Theorem: Polynomial.trailingDegree_C_mul_X_pow
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
ha : a ≠ 0
⊢ (C a * X ^ n).trailingDegree = ↑n
state_after: no goals
tactic: rw [C_mul_X_pow_eq_monomial, trailingDegree_monomial ha]
Theorem: Cubic.leadingCoeff_of_b_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b ≠ 0
⊢ P.toPoly.leadingCoeff = P.b
state_after: no goals
tactic: rw [of_a_eq_zero ha, leadingCoeff_quadratic hb]
Theorem: adjoinRootXPowSubCEquiv_symm_eq_root
File: Mathlib/FieldTheory/KummerExtension.lean

Proof steps:
state_before: K : Type u
inst✝³ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
L : Type u_1
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsSplittingField K L (X ^ n - C a)
α : L
hα : α ^ n = (algebraMap K L) a
⊢ (adjoinRootXPowSubCEquiv hζ H hα).symm α = root (X ^ n - C a)
state_after: case a
K : Type u
inst✝³ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
L : Type u_1
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsSplittingField K L (X ^ n - C a)
α : L
hα : α ^ n = (algebraMap K L) a
⊢ (adjoinRootXPowSubCEquiv hζ H hα) ((adjoinRootXPowSubCEquiv hζ H hα).symm α) =
    (adjoinRootXPowSubCEquiv hζ H hα) (root (X ^ n - C a))
tactic: apply (adjoinRootXPowSubCEquiv hζ H hα).injective
state_before: case a
K : Type u
inst✝³ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
L : Type u_1
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsSplittingField K L (X ^ n - C a)
α : L
hα : α ^ n = (algebraMap K L) a
⊢ (adjoinRootXPowSubCEquiv hζ H hα) ((adjoinRootXPowSubCEquiv hζ H hα).symm α) =
    (adjoinRootXPowSubCEquiv hζ H hα) (root (X ^ n - C a))
state_after: no goals
tactic: rw [(adjoinRootXPowSubCEquiv hζ H hα).apply_symm_apply, adjoinRootXPowSubCEquiv_root]
Theorem: EuclideanDomain.mul_div_assoc
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : EuclideanDomain R
x y z : R
h : z ∣ y
⊢ x * y / z = x * (y / z)
state_after: case pos
R : Type u
inst✝ : EuclideanDomain R
x y z : R
h : z ∣ y
hz : z = 0
⊢ x * y / z = x * (y / z)

case neg
R : Type u
inst✝ : EuclideanDomain R
x y z : R
h : z ∣ y
hz : ¬z = 0
⊢ x * y / z = x * (y / z)
tactic: by_cases hz : z = 0
state_before: case neg
R : Type u
inst✝ : EuclideanDomain R
x y z : R
h : z ∣ y
hz : ¬z = 0
⊢ x * y / z = x * (y / z)
state_after: case neg.intro
R : Type u
inst✝ : EuclideanDomain R
x z : R
hz : ¬z = 0
p : R
⊢ x * (z * p) / z = x * (z * p / z)
tactic: rcases h with ⟨p, rfl⟩
state_before: case neg.intro
R : Type u
inst✝ : EuclideanDomain R
x z : R
hz : ¬z = 0
p : R
⊢ x * (z * p) / z = x * (z * p / z)
state_after: no goals
tactic: rw [mul_div_cancel_left₀ _ hz, mul_left_comm, mul_div_cancel_left₀ _ hz]
Theorem: Set.preimage_mul_const_Icc
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ (fun x => x * c) ⁻¹' Icc a b = Icc (a / c) (b / c)
state_after: no goals
tactic: simp [← Ici_inter_Iic, h]
Theorem: Set.offDiag_inter
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
s t : Set α
x✝ : α × α
a : α
x : α × α
⊢ x ∈ (s ∩ t).offDiag ↔ x ∈ s.offDiag ∩ t.offDiag
state_after: α : Type u_1
s t : Set α
x✝ : α × α
a : α
x : α × α
⊢ (x.1 ∈ s ∧ x.1 ∈ t) ∧ (x.2 ∈ s ∧ x.2 ∈ t) ∧ x.1 ≠ x.2 ↔
    (x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2) ∧ x.1 ∈ t ∧ x.2 ∈ t ∧ x.1 ≠ x.2
tactic: simp only [mem_offDiag, mem_inter_iff]
state_before: α : Type u_1
s t : Set α
x✝ : α × α
a : α
x : α × α
⊢ (x.1 ∈ s ∧ x.1 ∈ t) ∧ (x.2 ∈ s ∧ x.2 ∈ t) ∧ x.1 ≠ x.2 ↔
    (x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2) ∧ x.1 ∈ t ∧ x.2 ∈ t ∧ x.1 ≠ x.2
state_after: no goals
tactic: tauto
Theorem: MeasureTheory.Measure.haar.addPrehaar_mono
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ K₂.carrier
⊢ prehaar (↑K₀) U K₁ ≤ prehaar (↑K₀) U K₂
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ K₂.carrier
⊢ ↑(index (↑K₁) U) / ↑(index (↑K₀) U) ≤ ↑(index (↑K₂) U) / ↑(index (↑K₀) U)
tactic: simp only [prehaar]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ K₂.carrier
⊢ ↑(index (↑K₁) U) / ↑(index (↑K₀) U) ≤ ↑(index (↑K₂) U) / ↑(index (↑K₀) U)
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ K₂.carrier
⊢ ↑(index (↑K₁) U) ≤ ↑(index (↑K₂) U)

G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ K₂.carrier
⊢ 0 < ↑(index (↑K₀) U)
tactic: rw [div_le_div_right]
Theorem: Set.image_diff_preimage
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s : Set α
t : Set β
⊢ f '' (s \ f ⁻¹' t) = f '' s \ t
state_after: no goals
tactic: simp_rw [diff_eq, ← preimage_compl, image_inter_preimage]
Theorem: CategoryTheory.Functor.map_eq_zero_iff
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Zero.lean

Proof steps:
state_before: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁵ : Category.{v₃, u₃} E
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
inst✝² : HasZeroMorphisms E
F : C ⥤ D
inst✝¹ : F.PreservesZeroMorphisms
inst✝ : F.Faithful
X Y : C
f : X ⟶ Y
⊢ f = 0 → F.map f = 0
state_after: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁵ : Category.{v₃, u₃} E
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
inst✝² : HasZeroMorphisms E
F : C ⥤ D
inst✝¹ : F.PreservesZeroMorphisms
inst✝ : F.Faithful
X Y : C
⊢ F.map 0 = 0
tactic: rintro rfl
state_before: C : Type u₁
inst✝⁷ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁶ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁵ : Category.{v₃, u₃} E
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
inst✝² : HasZeroMorphisms E
F : C ⥤ D
inst✝¹ : F.PreservesZeroMorphisms
inst✝ : F.Faithful
X Y : C
⊢ F.map 0 = 0
state_after: no goals
tactic: exact F.map_zero _ _
Theorem: CategoryTheory.ShortComplex.SnakeInput.L₀_g_δ
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ S.L₀.g ≫ S.δ = 0
state_after: no goals
tactic: erw [← L₀X₂ToP_comp_pullback_snd, assoc, S.L₀'_exact.g_desc,
    L₀X₂ToP_comp_φ₁_assoc, zero_comp]
Theorem: mul_lt_of_one_lt_left
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a b c d : α
inst✝³ : ExistsAddOfLE α
inst✝² : MulPosStrictMono α
inst✝¹ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
hb : b < 0
h : 1 < a
⊢ a * b < b
state_after: no goals
tactic: simpa only [one_mul] using mul_lt_mul_of_neg_right h hb
Theorem: Submonoid.closure_eq_image_prod
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : Monoid M
a : M
s : Set M
⊢ ↑(closure s) = List.prod '' {l | ∀ x ∈ l, x ∈ s}
state_after: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : Monoid M
a : M
s : Set M
⊢ Set.range ⇑(FreeMonoid.lift Subtype.val) = Set.range (List.prod ∘ List.map Subtype.val)
tactic: rw [closure_eq_mrange, coe_mrange, ← Set.range_list_map_coe, ← Set.range_comp]
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : Monoid M
a : M
s : Set M
⊢ Set.range ⇑(FreeMonoid.lift Subtype.val) = Set.range (List.prod ∘ List.map Subtype.val)
state_after: no goals
tactic: exact congrArg _ (funext <| FreeMonoid.lift_apply _)
Theorem: Set.bounded_inter_not
File: Mathlib/Order/Bounded.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a : α
⊢ Bounded r (s ∩ {b | ¬r b a}) ↔ Bounded r s
state_after: α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a : α
⊢ Bounded r (s ∩ {b | ¬r b a}) → Bounded r s
tactic: refine ⟨?_, Bounded.mono inter_subset_left⟩
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a : α
⊢ Bounded r (s ∩ {b | ¬r b a}) → Bounded r s
state_after: case intro
α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a b : α
hb : ∀ b_1 ∈ s ∩ {b | ¬r b a}, r b_1 b
⊢ Bounded r s
tactic: rintro ⟨b, hb⟩
state_before: case intro
α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a b : α
hb : ∀ b_1 ∈ s ∩ {b | ¬r b a}, r b_1 b
⊢ Bounded r s
state_after: case intro.intro
α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a b : α
hb : ∀ b_1 ∈ s ∩ {b | ¬r b a}, r b_1 b
m : α
hm : ∀ (c : α), r c a ∨ r c b → r c m
⊢ Bounded r s
tactic: cases' H a b with m hm
state_before: case intro.intro
α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a b : α
hb : ∀ b_1 ∈ s ∩ {b | ¬r b a}, r b_1 b
m : α
hm : ∀ (c : α), r c a ∨ r c b → r c m
⊢ Bounded r s
state_after: no goals
tactic: exact ⟨m, fun c hc => hm c (or_iff_not_imp_left.2 fun hca => hb c ⟨hc, hca⟩)⟩
Theorem: Nat.succ_mul_centralBinom_succ
File: Mathlib/Data/Nat/Choose/Central.lean

Proof steps:
state_before: n : ℕ
⊢ (2 * n + 2).choose (n + 1) * (n + 1) = (2 * n + 1).choose n * (2 * n + 2)
state_after: no goals
tactic: rw [choose_succ_right_eq, choose_mul_succ_eq]
state_before: n : ℕ
⊢ (2 * n + 1).choose n * (2 * n + 2) = 2 * ((2 * n + 1).choose n * (n + 1))
state_after: no goals
tactic: ring
state_before: n : ℕ
⊢ 2 * ((2 * n + 1).choose n * (n + 1)) = 2 * ((2 * n + 1).choose n * (2 * n + 1 - n))
state_after: no goals
tactic: rw [two_mul n, add_assoc,
                                                               Nat.add_sub_cancel_left]
state_before: n : ℕ
⊢ 2 * ((2 * n + 1).choose n * (2 * n + 1 - n)) = 2 * ((2 * n).choose n * (2 * n + 1))
state_after: no goals
tactic: rw [choose_mul_succ_eq]
state_before: n : ℕ
⊢ 2 * ((2 * n).choose n * (2 * n + 1)) = 2 * (2 * n + 1) * (2 * n).choose n
state_after: no goals
tactic: rw [mul_assoc, mul_comm (2 * n + 1)]
Theorem: dist_eq_norm_sub'
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist a b = ‖b / a‖
state_after: no goals
tactic: rw [dist_comm, dist_eq_norm_div]
Theorem: UniversalEnvelopingAlgebra.ι_apply
File: Mathlib/Algebra/Lie/UniversalEnveloping.lean

Proof steps:
state_before: R : Type u₁
L : Type u₂
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x y : L
⊢ __src✝.toFun ⁅x, y⁆ = ⁅__src✝.toFun x, __src✝.toFun y⁆
state_after: R : Type u₁
L : Type u₂
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x y : L
⊢ (mkAlgHom R L) (ιₜ ⁅x, y⁆ + ιₜ y * ιₜ x) = (mkAlgHom R L) (ιₜ x * ιₜ y)
tactic: suffices mkAlgHom R L (ιₜ ⁅x, y⁆ + ιₜ y * ιₜ x) = mkAlgHom R L (ιₜ x * ιₜ y) by
        rw [map_mul] at this; simp [LieRing.of_associative_ring_bracket, ← this]
state_before: R : Type u₁
L : Type u₂
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x y : L
⊢ (mkAlgHom R L) (ιₜ ⁅x, y⁆ + ιₜ y * ιₜ x) = (mkAlgHom R L) (ιₜ x * ιₜ y)
state_after: no goals
tactic: exact RingQuot.mkAlgHom_rel _ (Rel.lie_compat x y)
Theorem: Finset.sdiff_erase_self
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
ha : a ∈ s
⊢ s \ s.erase a = {a}
state_after: no goals
tactic: rw [sdiff_erase ha, Finset.sdiff_self, insert_emptyc_eq]
Theorem: _private.Mathlib.RingTheory.MvPolynomial.NewtonIdentities.0.MvPolynomial.NewtonIdentities.sum_filter_pairs_eq_sum_filter_antidiagonal_powersetCard_sum
File: Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean

Proof steps:
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
f : Finset σ × σ → MvPolynomial σ R
⊢ ∑ t ∈ filter (fun t => t.1.card < k) (MvPolynomial.NewtonIdentities.pairs σ k), f t =
    ∑ a ∈ filter (fun a => a.1 < k) (antidiagonal k), ∑ A ∈ powersetCard a.1 univ, ∑ j : σ, f (A, j)
state_after: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
f : Finset σ × σ → MvPolynomial σ R
⊢ ∑ i ∈ range k, ∑ x ∈ powersetCard i univ, ∑ y : σ, f (x, y) =
    ∑ a ∈ filter (fun a => a.1 < k) (antidiagonal k), ∑ A ∈ powersetCard a.1 univ, ∑ j : σ, f (A, j)
tactic: rw [filter_pairs_lt, sum_product, sum_disjiUnion]
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
f : Finset σ × σ → MvPolynomial σ R
⊢ ∑ i ∈ range k, ∑ x ∈ powersetCard i univ, ∑ y : σ, f (x, y) =
    ∑ a ∈ filter (fun a => a.1 < k) (antidiagonal k), ∑ A ∈ powersetCard a.1 univ, ∑ j : σ, f (A, j)
state_after: no goals
tactic: refine sum_nbij' (fun n ↦ (n, k - n)) Prod.fst ?_ ?_ ?_ ?_ ?_ <;>
    simp (config := { contextual := true }) [@eq_comm _ _ k, Nat.add_sub_cancel', le_of_lt]