ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: compositionAsSet_card
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n✝ n : ℕ
⊢ Fintype.card (CompositionAsSet n) = 2 ^ (n - 1)
state_after: n✝ n : ℕ
this : Fintype.card (Finset (Fin (n - 1))) = 2 ^ (n - 1)
⊢ Fintype.card (CompositionAsSet n) = 2 ^ (n - 1)
tactic: have : Fintype.card (Finset (Fin (n - 1))) = 2 ^ (n - 1) := by simp
state_before: n✝ n : ℕ
this : Fintype.card (Finset (Fin (n - 1))) = 2 ^ (n - 1)
⊢ Fintype.card (CompositionAsSet n) = 2 ^ (n - 1)
state_after: n✝ n : ℕ
this : Fintype.card (Finset (Fin (n - 1))) = 2 ^ (n - 1)
⊢ Fintype.card (CompositionAsSet n) = Fintype.card (Finset (Fin (n - 1)))
tactic: rw [← this]
state_before: n✝ n : ℕ
this : Fintype.card (Finset (Fin (n - 1))) = 2 ^ (n - 1)
⊢ Fintype.card (CompositionAsSet n) = Fintype.card (Finset (Fin (n - 1)))
state_after: no goals
tactic: exact Fintype.card_congr (compositionAsSetEquiv n)
Theorem: Zsqrtd.mul_nonneg
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d : ℕ
a b : ℤ√↑d
⊢ 0 ≤ a → 0 ≤ b → 0 ≤ a * b
state_after: d : ℕ
a b : ℤ√↑d
⊢ a.Nonneg → b.Nonneg → (a * b).Nonneg
tactic: simp_rw [← nonneg_iff_zero_le]
state_before: d : ℕ
a b : ℤ√↑d
⊢ a.Nonneg → b.Nonneg → (a * b).Nonneg
state_after: no goals
tactic: exact nonneg_mul
Theorem: AddLECancellable.tsub_tsub_assoc
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hbc : AddLECancellable (b - c)
h₁ : b ≤ a
h₂ : c ≤ b
⊢ a = a - b + c + (b - c)
state_after: no goals
tactic: rw [add_assoc, add_tsub_cancel_of_le h₂, tsub_add_cancel_of_le h₁]
Theorem: OrderEmbedding.birkhoffSet_apply
File: Mathlib/Order/Birkhoff.lean

Proof steps:
state_before: α : Type u_1
inst✝⁴ : DistribLattice α
inst✝³ : OrderBot α
inst✝² : Fintype α
inst✝¹ : DecidablePred SupIrred
inst✝ : DecidableEq α
a : α
⊢ birkhoffSet a = ↑(OrderIso.lowerSetSupIrred a)
state_after: α : Type u_1
inst✝⁴ : DistribLattice α
inst✝³ : OrderBot α
inst✝² : Fintype α
inst✝¹ : DecidablePred SupIrred
inst✝ : DecidableEq α
a : α
⊢ OrderIso.lowerSetSupIrred a = OrderIso.lowerSetSupIrred a
tactic: simp [birkhoffSet]
state_before: α : Type u_1
inst✝⁴ : DistribLattice α
inst✝³ : OrderBot α
inst✝² : Fintype α
inst✝¹ : DecidablePred SupIrred
inst✝ : DecidableEq α
a : α
⊢ OrderIso.lowerSetSupIrred a = OrderIso.lowerSetSupIrred a
state_after: α : Type u_1
inst✝⁴ : DistribLattice α
inst✝³ : OrderBot α
inst✝² : Fintype α
inst✝¹ : DecidablePred SupIrred
inst✝ : DecidableEq α
a : α
this : Subsingleton (OrderBot α)
⊢ OrderIso.lowerSetSupIrred a = OrderIso.lowerSetSupIrred a
tactic: have : Subsingleton (OrderBot α) := inferInstance
state_before: α : Type u_1
inst✝⁴ : DistribLattice α
inst✝³ : OrderBot α
inst✝² : Fintype α
inst✝¹ : DecidablePred SupIrred
inst✝ : DecidableEq α
a : α
this : Subsingleton (OrderBot α)
⊢ OrderIso.lowerSetSupIrred a = OrderIso.lowerSetSupIrred a
state_after: no goals
tactic: convert rfl
Theorem: AddSemiconjBy.neg_neg_symm_iff
File: Mathlib/Algebra/Group/Semiconj/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : DivisionMonoid G
a x y : G
⊢ SemiconjBy a⁻¹ x⁻¹ y⁻¹ ↔ SemiconjBy a y x
state_after: no goals
tactic: simp_rw [SemiconjBy, ← mul_inv_rev, inv_inj, eq_comm]
Theorem: AddCircle.measure_univ
File: Mathlib/MeasureTheory/Integral/Periodic.lean

Proof steps:
state_before: T : ℝ
hT : Fact (0 < T)
⊢ volume univ = ENNReal.ofReal T
state_after: T : ℝ
hT : Fact (0 < T)
⊢ ENNReal.ofReal T * (addHaarMeasure ⊤) univ = ENNReal.ofReal T
tactic: dsimp [volume]
state_before: T : ℝ
hT : Fact (0 < T)
⊢ ENNReal.ofReal T * (addHaarMeasure ⊤) univ = ENNReal.ofReal T
state_after: T : ℝ
hT : Fact (0 < T)
⊢ ENNReal.ofReal T * (addHaarMeasure ⊤) ↑⊤ = ENNReal.ofReal T
tactic: rw [← PositiveCompacts.coe_top]
state_before: T : ℝ
hT : Fact (0 < T)
⊢ ENNReal.ofReal T * (addHaarMeasure ⊤) ↑⊤ = ENNReal.ofReal T
state_after: no goals
tactic: simp [addHaarMeasure_self (G := AddCircle T), -PositiveCompacts.coe_top]
Theorem: Set.mem_fintype_sum
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝⁴ : FunLike F α β
inst✝³ : CommMonoid α
inst✝² : CommMonoid β
inst✝¹ : MonoidHomClass F α β
inst✝ : Fintype ι
f : ι → Set α
a : α
⊢ a ∈ ∏ i : ι, f i ↔ ∃ g, ∃ (_ : ∀ (i : ι), g i ∈ f i), ∏ i : ι, g i = a
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝⁴ : FunLike F α β
inst✝³ : CommMonoid α
inst✝² : CommMonoid β
inst✝¹ : MonoidHomClass F α β
inst✝ : Fintype ι
f : ι → Set α
a : α
⊢ (∃ g, ∃ (_ : ∀ {i : ι}, i ∈ Finset.univ → g i ∈ f i), ∏ i : ι, g i = a) ↔
    ∃ g, ∃ (_ : ∀ (i : ι), g i ∈ f i), ∏ i : ι, g i = a
tactic: rw [mem_finset_prod]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝⁴ : FunLike F α β
inst✝³ : CommMonoid α
inst✝² : CommMonoid β
inst✝¹ : MonoidHomClass F α β
inst✝ : Fintype ι
f : ι → Set α
a : α
⊢ (∃ g, ∃ (_ : ∀ {i : ι}, i ∈ Finset.univ → g i ∈ f i), ∏ i : ι, g i = a) ↔
    ∃ g, ∃ (_ : ∀ (i : ι), g i ∈ f i), ∏ i : ι, g i = a
state_after: no goals
tactic: simp
Theorem: UniqueAdd.iff_existsUnique
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
x✝ : UniqueMul A B a0 b0
⊢ ∀ (y : G × G), (fun ab => ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = a0 * b0) y → y = (a0, b0)
state_after: no goals
tactic: simpa
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = a0 * b0
⊢ ∀ (x : G × G),
    x ∈ A ×ˢ B ∧ x.1 * x.2 = a0 * b0 → (∀ (y : G × G), y ∈ A ×ˢ B ∧ y.1 * y.2 = a0 * b0 → y = x) → UniqueMul A B a0 b0
state_after: case mk
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = a0 * b0
x1 x2 : G
a✝ : (x1, x2) ∈ A ×ˢ B ∧ (x1, x2).1 * (x1, x2).2 = a0 * b0
J : ∀ (y : G × G), y ∈ A ×ˢ B ∧ y.1 * y.2 = a0 * b0 → y = (x1, x2)
x y : G
hx : x ∈ A
hy : y ∈ B
l : x * y = a0 * b0
⊢ x = a0 ∧ y = b0
tactic: rintro ⟨x1, x2⟩ _ J x y hx hy l
state_before: case mk
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = a0 * b0
x1 x2 : G
a✝ : (x1, x2) ∈ A ×ˢ B ∧ (x1, x2).1 * (x1, x2).2 = a0 * b0
J : ∀ (y : G × G), y ∈ A ×ˢ B ∧ y.1 * y.2 = a0 * b0 → y = (x1, x2)
x y : G
hx : x ∈ A
hy : y ∈ B
l : x * y = a0 * b0
⊢ x = a0 ∧ y = b0
state_after: case mk.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = a0 * b0
x y : G
hx : x ∈ A
hy : y ∈ B
l : x * y = a0 * b0
a✝ : (a0, b0) ∈ A ×ˢ B ∧ (a0, b0).1 * (a0, b0).2 = a0 * b0
J : ∀ (y : G × G), y ∈ A ×ˢ B ∧ y.1 * y.2 = a0 * b0 → y = (a0, b0)
⊢ x = a0 ∧ y = b0
tactic: rcases Prod.mk.inj_iff.mp (J (a0, b0) ⟨Finset.mk_mem_product aA bB, rfl⟩) with ⟨rfl, rfl⟩
state_before: case mk.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = a0 * b0
x y : G
hx : x ∈ A
hy : y ∈ B
l : x * y = a0 * b0
a✝ : (a0, b0) ∈ A ×ˢ B ∧ (a0, b0).1 * (a0, b0).2 = a0 * b0
J : ∀ (y : G × G), y ∈ A ×ˢ B ∧ y.1 * y.2 = a0 * b0 → y = (a0, b0)
⊢ x = a0 ∧ y = b0
state_after: no goals
tactic: exact Prod.mk.inj_iff.mp (J (x, y) ⟨Finset.mk_mem_product hx hy, l⟩)
Theorem: continuousAt_iff_continuous_left_right
File: Mathlib/Topology/Order/LeftRight.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
f : α → β
⊢ ContinuousAt f a ↔ ContinuousWithinAt f (Iic a) a ∧ ContinuousWithinAt f (Ici a) a
state_after: no goals
tactic: simp only [ContinuousWithinAt, ContinuousAt, ← tendsto_sup, nhds_left_sup_nhds_right]
Theorem: TopCat.Presheaf.germ_stalkPullbackInv
File: Mathlib/Topology/Sheaves/Stalks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
V : Opens ↑X
hV : x ∈ V
⊢ ((pullback C f).obj F).germ ⟨x, hV⟩ ≫ stalkPullbackInv C f F x = germToPullbackStalk C f F V ⟨x, hV⟩
state_after: no goals
tactic: apply colimit.ι_desc
Theorem: norm_div_sub_norm_div_le_norm_div
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₂ : ℝ
u v w : E
⊢ ‖u / w‖ - ‖v / w‖ ≤ ‖u / v‖
state_after: no goals
tactic: simpa only [div_div_div_cancel_right'] using norm_sub_norm_le' (u / w) (v / w)
Theorem: real_inner_smul_self_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
r : ℝ
⊢ ⟪x, r • x⟫_ℝ = r * (‖x‖ * ‖x‖)
state_after: no goals
tactic: rw [inner_smul_right, ← real_inner_self_eq_norm_mul_norm]
Theorem: Prod.Lex.toLex_strictMono
File: Mathlib/Data/Prod/Lex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
⊢ StrictMono ⇑toLex
state_after: case mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
h : (a₁, b₁) < (a₂, b₂)
⊢ toLex (a₁, b₁) < toLex (a₂, b₂)
tactic: rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ h
state_before: case mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
h : (a₁, b₁) < (a₂, b₂)
⊢ toLex (a₁, b₁) < toLex (a₂, b₂)
state_after: case mk.mk.inl
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ b₂ : β
h : (a₁, b₁) < (a₁, b₂)
⊢ toLex (a₁, b₁) < toLex (a₁, b₂)

case mk.mk.inr
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
a₁ : α
b₁ : β
a₂ : α
b₂ : β
h : (a₁, b₁) < (a₂, b₂)
ha : (a₁, b₁).1 < (a₂, b₂).1
⊢ toLex (a₁, b₁) < toLex (a₂, b₂)
tactic: obtain rfl | ha : a₁ = a₂ ∨ _ := h.le.1.eq_or_lt
Theorem: inv_mul_le_iff_le_mul
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ b⁻¹ * a ≤ c ↔ a ≤ b * c
state_after: no goals
tactic: rw [← mul_le_mul_iff_left b, mul_inv_cancel_left]
Theorem: Monotone.alternating_series_le_tendsto
File: Mathlib/Analysis/SpecificLimits/Normed.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
inst✝² : OrderedRing E
inst✝¹ : TopologicalSpace E
inst✝ : OrderClosedTopology E
l : E
f : ℕ → E
hfl : Tendsto (fun n => ∑ i ∈ Finset.range n, (-1) ^ i * f i) atTop (𝓝 l)
hfm : Monotone f
k : ℕ
⊢ ∑ i ∈ Finset.range (2 * k + 1), (-1) ^ i * f i ≤ l
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
inst✝² : OrderedRing E
inst✝¹ : TopologicalSpace E
inst✝ : OrderClosedTopology E
l : E
f : ℕ → E
hfl : Tendsto (fun n => ∑ i ∈ Finset.range n, (-1) ^ i * f i) atTop (𝓝 l)
hfm : Monotone f
k : ℕ
hm : Monotone fun n => ∑ i ∈ Finset.range (2 * n + 1), (-1) ^ i * f i
⊢ ∑ i ∈ Finset.range (2 * k + 1), (-1) ^ i * f i ≤ l
tactic: have hm : Monotone (fun n ↦ ∑ i ∈ range (2 * n + 1), (-1) ^ i * f i) := by
    refine monotone_nat_of_le_succ (fun n ↦ ?_)
    rw [show 2 * (n + 1) = 2 * n + 1 + 1 by ring,
      sum_range_succ _ (2 * n + 1 + 1), sum_range_succ _ (2 * n + 1)]
    simp_rw [_root_.pow_succ', show (-1 : E) ^ (2 * n) = 1 by simp, neg_one_mul, neg_neg, one_mul,
      ← sub_eq_add_neg, sub_add_eq_add_sub, le_sub_iff_add_le]
    gcongr
    exact hfm (by omega)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
inst✝² : OrderedRing E
inst✝¹ : TopologicalSpace E
inst✝ : OrderClosedTopology E
l : E
f : ℕ → E
hfl : Tendsto (fun n => ∑ i ∈ Finset.range n, (-1) ^ i * f i) atTop (𝓝 l)
hfm : Monotone f
k : ℕ
hm : Monotone fun n => ∑ i ∈ Finset.range (2 * n + 1), (-1) ^ i * f i
⊢ ∑ i ∈ Finset.range (2 * k + 1), (-1) ^ i * f i ≤ l
state_after: no goals
tactic: exact hm.ge_of_tendsto (hfl.comp (tendsto_atTop_mono (fun n ↦ by dsimp; omega) tendsto_id)) _
Theorem: Matrix.vecAlt1_vecAppend
File: Mathlib/Data/Fin/VecNotation.lean

Proof steps:
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (n + 1) → α
⊢ vecAlt1 ⋯ (vecAppend ⋯ v v) = v ∘ fun n_1 => n_1 + n_1 + 1
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (n + 1) → α
i : Fin (n + 1)
⊢ vecAlt1 ⋯ (vecAppend ⋯ v v) i = (v ∘ fun n_1 => n_1 + n_1 + 1) i
tactic: ext i
state_before: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (n + 1) → α
i : Fin (n + 1)
⊢ vecAlt1 ⋯ (vecAppend ⋯ v v) i = (v ∘ fun n_1 => n_1 + n_1 + 1) i
state_after: case h
α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
v : Fin (n + 1) → α
i : Fin (n + 1)
⊢ (if h : ↑i + ↑i + 1 < n + 1 then v ⟨↑i + ↑i + 1, ⋯⟩ else v ⟨↑i + ↑i + 1 - (n + 1), ⋯⟩) = v (i + i + 1)
tactic: simp_rw [Function.comp, vecAlt1, vecAppend_eq_ite]
Theorem: norm_sub_mul_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ - 2 * re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖x - y‖ ^ 2 = ‖x‖ ^ 2 - 2 * re ⟪x, y⟫_𝕜 + ‖y‖ ^ 2
tactic: repeat' rw [← sq (M := ℝ)]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ‖x - y‖ ^ 2 = ‖x‖ ^ 2 - 2 * re ⟪x, y⟫_𝕜 + ‖y‖ ^ 2
state_after: no goals
tactic: exact norm_sub_sq _ _
Theorem: Padic.norm_lt_pow_iff_norm_le_pow_sub_one
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
⊢ ‖x‖ < ↑p ^ n ↔ ‖x‖ ≤ ↑p ^ (n - 1)
state_after: no goals
tactic: rw [norm_le_pow_iff_norm_lt_pow_add_one, sub_add_cancel]
Theorem: Matrix.IsAdjMatrix.apply_diag_ne
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

Proof steps:
state_before: V : Type u_1
α : Type u_2
β : Type u_3
A : Matrix V V α
inst✝¹ : MulZeroOneClass α
inst✝ : Nontrivial α
h : A.IsAdjMatrix
i : V
⊢ ¬A i i = 1
state_after: no goals
tactic: simp [h.apply_diag i]
Theorem: Equicontinuous.uniformInducing_uniformFun_iff_pi
File: Mathlib/Topology/UniformSpace/Ascoli.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
β : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
F : ι → X → α
G : ι → β → α
inst✝¹ : UniformSpace ι
inst✝ : CompactSpace X
F_eqcont : Equicontinuous F
⊢ UniformInducing (⇑UniformFun.ofFun ∘ F) ↔ UniformInducing F
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
β : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
F : ι → X → α
G : ι → β → α
inst✝¹ : UniformSpace ι
inst✝ : CompactSpace X
F_eqcont : Equicontinuous F
⊢ UniformSpace.comap (⇑UniformFun.ofFun ∘ F) (UniformFun.uniformSpace X α) = inst✝¹ ↔
    UniformSpace.comap F (UniformFun.uniformSpace X α) = inst✝¹
tactic: rw [uniformInducing_iff_uniformSpace, uniformInducing_iff_uniformSpace,
      ← F_eqcont.comap_uniformFun_eq]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
β : Type u_5
inst✝⁴ : TopologicalSpace X
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
F : ι → X → α
G : ι → β → α
inst✝¹ : UniformSpace ι
inst✝ : CompactSpace X
F_eqcont : Equicontinuous F
⊢ UniformSpace.comap (⇑UniformFun.ofFun ∘ F) (UniformFun.uniformSpace X α) = inst✝¹ ↔
    UniformSpace.comap F (UniformFun.uniformSpace X α) = inst✝¹
state_after: no goals
tactic: rfl
Theorem: Mathlib.Meta.NormNum.isNat_rpow_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: a b : ℝ
nb ne : ℕ
pb : IsNat b nb
pe' : IsNat (a ^ nb) ne
⊢ IsNat (a ^ b) ne
state_after: no goals
tactic: rwa [pb.out, rpow_natCast]
Theorem: topCatToCondensedSet_map_val_app
File: Mathlib/Condensed/TopComparison.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
G : C ⥤ TopCat
X : Type w'
inst✝ : TopologicalSpace X
X✝ Y✝ : TopCat
f : X✝ ⟶ Y✝
⊢ ∀ ⦃X Y : CompHausᵒᵖ⦄ (f_1 : X ⟶ Y),
    ((fun X => X.toCondensedSet) X✝).val.map f_1 ≫ (fun x g => comp f g) Y =
      (fun x g => comp f g) X ≫ ((fun X => X.toCondensedSet) Y✝).val.map f_1
state_after: no goals
tactic: aesop
Theorem: SimpleGraph.isBridge_iff_adj_and_forall_walk_mem_edges
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ G.IsBridge s(v, w) ↔ G.Adj v w ∧ ∀ (p : G.Walk v w), s(v, w) ∈ p.edges
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ ¬(G \ fromEdgeSet {s(v, w)}).Reachable v w ↔ ∀ (p : G.Walk v w), s(v, w) ∈ p.edges
tactic: rw [isBridge_iff, and_congr_right']
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ ¬(G \ fromEdgeSet {s(v, w)}).Reachable v w ↔ ∀ (p : G.Walk v w), s(v, w) ∈ p.edges
state_after: no goals
tactic: rw [reachable_delete_edges_iff_exists_walk, not_exists_not]
Theorem: Stream'.WSeq.destruct_dropn
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ (s.drop (n + 1)).destruct = s.destruct >>= drop.aux (n + 1)
state_after: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ (s.destruct >>= fun x => tail.aux x >>= drop.aux n) = s.destruct >>= drop.aux (n + 1)
tactic: rw [← dropn_tail, destruct_dropn _ n, destruct_tail, LawfulMonad.bind_assoc]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
n : ℕ
⊢ (s.destruct >>= fun x => tail.aux x >>= drop.aux n) = s.destruct >>= drop.aux (n + 1)
state_after: no goals
tactic: rfl
Theorem: Polynomial.comp_C
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p.comp (C a) = C (eval a p)
state_after: no goals
tactic: simp [comp, map_sum (C : R →+* _)]
Theorem: CategoryTheory.IsIso.of_isIso_comp_left
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : IsIso f
inst✝ : IsIso (f ≫ g)
⊢ IsIso g
state_after: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : IsIso f
inst✝ : IsIso (f ≫ g)
⊢ IsIso (inv f ≫ f ≫ g)
tactic: rw [← id_comp g, ← inv_hom_id f, assoc]
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : IsIso f
inst✝ : IsIso (f ≫ g)
⊢ IsIso (inv f ≫ f ≫ g)
state_after: no goals
tactic: infer_instance
Theorem: WeierstrassCurve.leadingCoeff_Ψ₂Sq
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
h : 4 ≠ 0
⊢ W.Ψ₂Sq.leadingCoeff = 4
state_after: no goals
tactic: rw [leadingCoeff, W.natDegree_Ψ₂Sq h, coeff_Ψ₂Sq]
Theorem: CategoryTheory.Mat_.embedding_obj_ι
File: Mathlib/CategoryTheory/Preadditive/Mat.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
x✝ : C
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (𝟙 x✝) =
    𝟙 ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj x✝)
state_after: case H.unit
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
x✝ : C
j✝ : ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj x✝).ι
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (𝟙 x✝) PUnit.unit j✝ =
    𝟙 ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj x✝) PUnit.unit j✝
tactic: ext ⟨⟩
state_before: case H.unit
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
x✝ : C
j✝ : ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj x✝).ι
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (𝟙 x✝) PUnit.unit j✝ =
    𝟙 ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj x✝) PUnit.unit j✝
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
X✝ Y✝ Z✝ : C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (x✝¹ ≫ x✝) =
    { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝¹ ≫
      { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝
state_after: case H.unit
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
X✝ Y✝ Z✝ : C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
j✝ : ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj Z✝).ι
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (x✝¹ ≫ x✝) PUnit.unit j✝ =
    ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝¹ ≫
        { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝)
      PUnit.unit j✝
tactic: ext ⟨⟩
state_before: case H.unit
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Preadditive C
X✝ Y✝ Z✝ : C
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
j✝ : ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.obj Z✝).ι
⊢ { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map (x✝¹ ≫ x✝) PUnit.unit j✝ =
    ({ obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝¹ ≫
        { obj := fun X => mk PUnit.{1} fun x => X, map := fun {X Y} f x x => f }.map x✝)
      PUnit.unit j✝
state_after: no goals
tactic: simp
Theorem: List.replicate_sublist_replicate
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m n : Nat
a : α
⊢ replicate m a <+ replicate n a ↔ m ≤ n
state_after: case refine_1
α : Type u_1
m n : Nat
a : α
h : replicate m a <+ replicate n a
⊢ m ≤ n

case refine_2
α : Type u_1
m n : Nat
a : α
h : m ≤ n
⊢ replicate m a <+ replicate n a
tactic: refine ⟨fun h => ?_, fun h => ?_⟩
Theorem: biSup_sigma
File: Mathlib/Data/Set/Sigma.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
β : Type u_5
inst✝ : CompleteLattice β
s : Set ι
t : (i : ι) → Set (α i)
f : Sigma α → β
x✝ : β
⊢ ⨆ ij ∈ s.sigma t, f ij ≤ x✝ → ⨆ i ∈ s, ⨆ j ∈ t i, f ⟨i, j⟩ ≤ x✝
state_after: no goals
tactic: simp_all
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
β : Type u_5
inst✝ : CompleteLattice β
s : Set ι
t : (i : ι) → Set (α i)
f : Sigma α → β
x✝ : β
⊢ ⨆ i ∈ s, ⨆ j ∈ t i, f ⟨i, j⟩ ≤ x✝ → ⨆ ij ∈ s.sigma t, f ij ≤ x✝
state_after: no goals
tactic: simp_all