ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.sheafifyMap_sheafifyLift
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ sheafifyMap J η ≫ sheafifyLift J γ hR = sheafifyLift J (η ≫ γ) hR
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ toSheafify J P ≫ sheafifyMap J η ≫ sheafifyLift J γ hR = η ≫ γ
tactic: apply sheafifyLift_unique
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ toSheafify J P ≫ sheafifyMap J η ≫ sheafifyLift J γ hR = η ≫ γ
state_after: no goals
tactic: rw [← Category.assoc, ← toSheafify_naturality, Category.assoc, toSheafify_sheafifyLift]
Theorem: AddGroupSeminorm.smul_sup
File: Mathlib/Analysis/Normed/Group/Seminorm.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
R' : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
inst✝⁴ : FunLike F E ℝ
inst✝³ : AddGroup E
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
p✝ : AddGroupSeminorm E
r : R
p q : AddGroupSeminorm E
x y : ℝ
⊢ r • max x y = max (r • x) (r • y)
state_after: no goals
tactic: simpa only [← smul_eq_mul, ← NNReal.smul_def, smul_one_smul ℝ≥0 r (_ : ℝ)] using
      mul_max_of_nonneg x y (r • (1 : ℝ≥0) : ℝ≥0).coe_nonneg
Theorem: Nat.primeFactors_gcd
File: Mathlib/Data/Nat/PrimeFin.lean

Proof steps:
state_before: a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (a.gcd b).primeFactors = a.primeFactors ∩ b.primeFactors
state_after: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ a✝ ∈ (a.gcd b).primeFactors ↔ a✝ ∈ a.primeFactors ∩ b.primeFactors
tactic: ext
state_before: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ a✝ ∈ (a.gcd b).primeFactors ↔ a✝ ∈ a.primeFactors ∩ b.primeFactors
state_after: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ Prime a✝ ∧ a✝ ∣ a ∧ a✝ ∣ b ↔ (Prime a✝ ∧ a✝ ∣ a) ∧ Prime a✝ ∧ a✝ ∣ b
tactic: simp [dvd_gcd_iff, ha, hb, gcd_ne_zero_left ha]
state_before: case a
a b k m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
a✝ : ℕ
⊢ Prime a✝ ∧ a✝ ∣ a ∧ a✝ ∣ b ↔ (Prime a✝ ∧ a✝ ∣ a) ∧ Prime a✝ ∧ a✝ ∣ b
state_after: no goals
tactic: aesop
Theorem: AddCon.induction_on_addUnits
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
inst✝ : Monoid M
c : Con M
p : c.Quotientˣ → Prop
u : c.Quotientˣ
H : ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1), p { val := ↑x, inv := ↑y, val_inv := ⋯, inv_val := ⋯ }
⊢ p u
state_after: case mk.mk.mk
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
inst✝ : Monoid M
c : Con M
p : c.Quotientˣ → Prop
H : ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1), p { val := ↑x, inv := ↑y, val_inv := ⋯, inv_val := ⋯ }
val✝ inv✝ : c.Quotient
x y : M
h₁ : Quot.mk r x * Quot.mk r y = 1
h₂ : Quot.mk r y * Quot.mk r x = 1
⊢ p { val := Quot.mk r x, inv := Quot.mk r y, val_inv := h₁, inv_val := h₂ }
tactic: rcases u with ⟨⟨x⟩, ⟨y⟩, h₁, h₂⟩
state_before: case mk.mk.mk
M : Type u_1
N : Type u_2
P : Type u_3
α : Type u_4
inst✝ : Monoid M
c : Con M
p : c.Quotientˣ → Prop
H : ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1), p { val := ↑x, inv := ↑y, val_inv := ⋯, inv_val := ⋯ }
val✝ inv✝ : c.Quotient
x y : M
h₁ : Quot.mk r x * Quot.mk r y = 1
h₂ : Quot.mk r y * Quot.mk r x = 1
⊢ p { val := Quot.mk r x, inv := Quot.mk r y, val_inv := h₁, inv_val := h₂ }
state_after: no goals
tactic: exact H x y (c.eq.1 h₁) (c.eq.1 h₂)
Theorem: Multiset.sum_replicate
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
n : ℕ
a : α
⊢ (replicate n a).prod = a ^ n
state_after: no goals
tactic: simp [replicate, List.prod_replicate]
Theorem: WithZeroTopology.singleton_mem_nhds_of_units
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

Proof steps:
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ✝ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
γ : Γ₀ˣ
⊢ {↑γ} ∈ 𝓝 ↑γ
state_after: no goals
tactic: simp
Theorem: Nat.getLast_digit_ne_zero
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n b m : ℕ
hm : m ≠ 0
⊢ (b.digits m).getLast ⋯ ≠ 0
state_after: case zero
n m : ℕ
hm : m ≠ 0
⊢ (digits 0 m).getLast ⋯ ≠ 0

case succ.zero
n m : ℕ
hm : m ≠ 0
⊢ ((0 + 1).digits m).getLast ⋯ ≠ 0

case succ.succ
n m : ℕ
hm : m ≠ 0
b : ℕ
⊢ ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
tactic: rcases b with (_ | _ | b)
state_before: case succ.succ
n m : ℕ
hm : m ≠ 0
b : ℕ
⊢ ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
state_after: case succ.succ
n m b : ℕ
⊢ ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
tactic: revert hm
state_before: case succ.succ
n m b : ℕ
⊢ ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
state_after: case succ.succ
n m b : ℕ
⊢ ∀ (n : ℕ),
    (∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0) →
      ∀ (hm : n ≠ 0), ((b + 1 + 1).digits n).getLast ⋯ ≠ 0
tactic: apply Nat.strongInductionOn m
state_before: case succ.succ
n m b : ℕ
⊢ ∀ (n : ℕ),
    (∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0) →
      ∀ (hm : n ≠ 0), ((b + 1 + 1).digits n).getLast ⋯ ≠ 0
state_after: case succ.succ
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
⊢ ((b + 1 + 1).digits n).getLast ⋯ ≠ 0
tactic: intro n IH hn
state_before: case succ.succ
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
⊢ ((b + 1 + 1).digits n).getLast ⋯ ≠ 0
state_after: case pos
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : n < b + 2
⊢ ((b + 1 + 1).digits n).getLast ⋯ ≠ 0

case neg
n✝ m b n : ℕ
IH : ∀ m < n, ∀ (hm : m ≠ 0), ((b + 1 + 1).digits m).getLast ⋯ ≠ 0
hn : n ≠ 0
hnb : ¬n < b + 2
⊢ ((b + 1 + 1).digits n).getLast ⋯ ≠ 0
tactic: by_cases hnb : n < b + 2
Theorem: Real.pi_gt_31415
File: Mathlib/Data/Real/Pi/Bounds.lean

Proof steps:
state_before: ⊢ 3.1415 < π
state_after: no goals
tactic: pi_lower_bound
        [11482 / 8119, 5401 / 2923, 2348 / 1197, 11367 / 5711, 25705 / 12868, 23235 / 11621]
Theorem: CategoryTheory.Functor.IsDenseSubsite.isIso_ranCounit_app_of_isDenseSubsite
File: Mathlib/CategoryTheory/Sites/DenseSubsite.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
G : C ⥤ D
J : GrothendieckTopology C
K : GrothendieckTopology D
A : Type w
inst✝² : Category.{w', w} A
inst✝¹ : ∀ (X : Dᵒᵖ), Limits.HasLimitsOfShape (StructuredArrow X G.op) A
inst✝ : IsDenseSubsite J K G
Y : Sheaf J A
U : C
X : A
⊢ IsIso ((yoneda.map ((G.op.ranCounit.app Y.val).app (op U))).app (op X))
state_after: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
G : C ⥤ D
J : GrothendieckTopology C
K : GrothendieckTopology D
A : Type w
inst✝² : Category.{w', w} A
inst✝¹ : ∀ (X : Dᵒᵖ), Limits.HasLimitsOfShape (StructuredArrow X G.op) A
inst✝ : IsDenseSubsite J K G
Y : Sheaf J A
U : C
X : A
⊢ Function.Bijective ((yoneda.map ((G.op.ranCounit.app Y.val).app (op U))).app (op X))
tactic: rw [isIso_iff_bijective]
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
G : C ⥤ D
J : GrothendieckTopology C
K : GrothendieckTopology D
A : Type w
inst✝² : Category.{w', w} A
inst✝¹ : ∀ (X : Dᵒᵖ), Limits.HasLimitsOfShape (StructuredArrow X G.op) A
inst✝ : IsDenseSubsite J K G
Y : Sheaf J A
U : C
X : A
⊢ Function.Bijective ((yoneda.map ((G.op.ranCounit.app Y.val).app (op U))).app (op X))
state_after: case left
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
G : C ⥤ D
J : GrothendieckTopology C
K : GrothendieckTopology D
A : Type w
inst✝² : Category.{w', w} A
inst✝¹ : ∀ (X : Dᵒᵖ), Limits.HasLimitsOfShape (StructuredArrow X G.op) A
inst✝ : IsDenseSubsite J K G
Y : Sheaf J A
U : C
X : A
⊢ Function.Injective ((yoneda.map ((G.op.ranCounit.app Y.val).app (op U))).app (op X))

case right
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
G : C ⥤ D
J : GrothendieckTopology C
K : GrothendieckTopology D
A : Type w
inst✝² : Category.{w', w} A
inst✝¹ : ∀ (X : Dᵒᵖ), Limits.HasLimitsOfShape (StructuredArrow X G.op) A
inst✝ : IsDenseSubsite J K G
Y : Sheaf J A
U : C
X : A
⊢ Function.Surjective ((yoneda.map ((G.op.ranCounit.app Y.val).app (op U))).app (op X))
tactic: constructor
Theorem: Denumerable.sigma_ofNat_val
File: Mathlib/Logic/Denumerable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Denumerable α
inst✝¹ : Denumerable β
γ : α → Type u_3
inst✝ : (a : α) → Denumerable (γ a)
n : ℕ
⊢ some (ofNat (Sigma γ) n) = some ⟨ofNat α (unpair n).1, ofNat (γ (ofNat α (unpair n).1)) (unpair n).2⟩
state_after: α : Type u_1
β : Type u_2
inst✝² : Denumerable α
inst✝¹ : Denumerable β
γ : α → Type u_3
inst✝ : (a : α) → Denumerable (γ a)
n : ℕ
⊢ ((decode (unpair n).1).bind fun a => Option.map (Sigma.mk a) (decode (unpair n).2)) =
    some ⟨ofNat α (unpair n).1, ofNat (γ (ofNat α (unpair n).1)) (unpair n).2⟩
tactic: rw [← decode_eq_ofNat, decode_sigma_val]
state_before: α : Type u_1
β : Type u_2
inst✝² : Denumerable α
inst✝¹ : Denumerable β
γ : α → Type u_3
inst✝ : (a : α) → Denumerable (γ a)
n : ℕ
⊢ ((decode (unpair n).1).bind fun a => Option.map (Sigma.mk a) (decode (unpair n).2)) =
    some ⟨ofNat α (unpair n).1, ofNat (γ (ofNat α (unpair n).1)) (unpair n).2⟩
state_after: no goals
tactic: simp
Theorem: LocalizedModule.smul'_mul
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u
inst✝⁷ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
T : Type u_1
inst✝⁴ : CommSemiring T
inst✝³ : Algebra R T
inst✝² : IsLocalization S T
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : T
p₁ p₂ : LocalizedModule S A
⊢ x • p₁ * p₂ = x • (p₁ * p₂)
state_after: case h
R : Type u
inst✝⁷ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
T : Type u_1
inst✝⁴ : CommSemiring T
inst✝³ : Algebra R T
inst✝² : IsLocalization S T
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : T
a₁ s₁ : A
a₂ s₂ : ↥S
⊢ x • mk a₁ a₂ * mk s₁ s₂ = x • (mk a₁ a₂ * mk s₁ s₂)
tactic: induction p₁, p₂ using induction_on₂ with | _ a₁ s₁ a₂ s₂ => _
state_before: case h
R : Type u
inst✝⁷ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
T : Type u_1
inst✝⁴ : CommSemiring T
inst✝³ : Algebra R T
inst✝² : IsLocalization S T
A : Type u_2
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : T
a₁ s₁ : A
a₂ s₂ : ↥S
⊢ x • mk a₁ a₂ * mk s₁ s₂ = x • (mk a₁ a₂ * mk s₁ s₂)
state_after: no goals
tactic: rw [mk_mul_mk, smul_def, smul_def, mk_mul_mk, mul_assoc, smul_mul_assoc]
Theorem: Ideal.sup_mul_inf
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
I J : Ideal A
⊢ (I ⊔ J) * (I ⊓ J) = I * J
state_after: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
I J : Ideal A
this : NormalizedGCDMonoid (Ideal A) := toNormalizedGCDMonoid (Ideal A)
⊢ (I ⊔ J) * (I ⊓ J) = I * J
tactic: letI := UniqueFactorizationMonoid.toNormalizedGCDMonoid (Ideal A)
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
I J : Ideal A
this : NormalizedGCDMonoid (Ideal A) := toNormalizedGCDMonoid (Ideal A)
hgcd : gcd I J = I ⊔ J
hlcm : lcm I J = I ⊓ J
⊢ (I ⊔ J) * (I ⊓ J) = I * J
state_after: no goals
tactic: rw [← hgcd, ← hlcm, associated_iff_eq.mp (gcd_mul_lcm _ _)]
Theorem: Function.LeftInverse.eq_rightInverse
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ f : α → β
g₁ g₂ : β → α
h₁ : LeftInverse g₁ f
h₂ : RightInverse g₂ f
⊢ g₁ = g₁ ∘ f ∘ g₂
state_after: no goals
tactic: rw [h₂.comp_eq_id, comp_id]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f✝ f : α → β
g₁ g₂ : β → α
h₁ : LeftInverse g₁ f
h₂ : RightInverse g₂ f
⊢ g₁ ∘ f ∘ g₂ = g₂
state_after: no goals
tactic: rw [← comp.assoc, h₁.comp_eq_id, id_comp]
Theorem: Sym2.GameAdd.fst_snd
File: Mathlib/Order/GameAdd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a : α
b✝ : β
a₁ a₂ b : α
h : rα a₁ a₂
⊢ GameAdd rα s(a₁, b) s(b, a₂)
state_after: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a : α
b✝ : β
a₁ a₂ b : α
h : rα a₁ a₂
⊢ GameAdd rα s(b, a₁) s(b, a₂)
tactic: rw [Sym2.eq_swap]
state_before: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a : α
b✝ : β
a₁ a₂ b : α
h : rα a₁ a₂
⊢ GameAdd rα s(b, a₁) s(b, a₂)
state_after: no goals
tactic: exact GameAdd.snd h
Theorem: preimage_mul_ball
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✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r✝ r₁ r₂ : ℝ
a b : E
r : ℝ
⊢ (fun x => b * x) ⁻¹' ball a r = ball (a / b) r
state_after: case h
𝓕 : 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✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r✝ r₁ r₂ : ℝ
a b : E
r : ℝ
c : E
⊢ c ∈ (fun x => b * x) ⁻¹' ball a r ↔ c ∈ ball (a / b) r
tactic: ext c
state_before: case h
𝓕 : 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✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a✝ a₁ a₂ b✝ b₁ b₂ : E
r✝ r₁ r₂ : ℝ
a b : E
r : ℝ
c : E
⊢ c ∈ (fun x => b * x) ⁻¹' ball a r ↔ c ∈ ball (a / b) r
state_after: no goals
tactic: simp only [dist_eq_norm_div, Set.mem_preimage, mem_ball, div_div_eq_mul_div, mul_comm]
Theorem: IsCoprime.mul_add_left_right
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (x * z + y)
state_after: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (y + x * z)
tactic: rw [add_comm]
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime x (y + x * z)
state_after: no goals
tactic: exact h.add_mul_left_right z
Theorem: Multiset.finset_sum_eq_sup_iff_disjoint
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β✝ : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
β : Type u_9
i : Finset β
f : β → Multiset α
⊢ i.sum f = i.sup f ↔ ∀ x ∈ i, ∀ y ∈ i, x ≠ y → (f x).Disjoint (f y)
state_after: case h₁
ι : Type u_1
α : Type u_2
β✝ : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
β : Type u_9
f : β → Multiset α
⊢ ∅.sum f = ∅.sup f ↔ ∀ x ∈ ∅, ∀ y ∈ ∅, x ≠ y → (f x).Disjoint (f y)

case h₂
ι : Type u_1
α : Type u_2
β✝ : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
β : Type u_9
f : β → Multiset α
z : β
i : Finset β
hz : z ∉ i
hr : i.sum f = i.sup f ↔ ∀ x ∈ i, ∀ y ∈ i, x ≠ y → (f x).Disjoint (f y)
⊢ (Finset.cons z i hz).sum f = (Finset.cons z i hz).sup f ↔
    ∀ x ∈ Finset.cons z i hz, ∀ y ∈ Finset.cons z i hz, x ≠ y → (f x).Disjoint (f y)
tactic: induction' i using Finset.cons_induction_on with z i hz hr
Theorem: Asymptotics.isLittleO_zero
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c✝ c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
c : ℝ
hc : 0 < c
x : α
⊢ x ∈ {x | (fun x => ‖0‖ ≤ c * ‖g' x‖) x}
state_after: no goals
tactic: simpa using mul_nonneg hc.le (norm_nonneg <| g' x)
Theorem: Matrix.eval_charpolyRev
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ eval 0 M.charpolyRev = 1
state_after: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ ((evalRingHom 0).mapMatrix (1 - X • M.map ⇑C)).det = det 1
tactic: rw [charpolyRev, ← coe_evalRingHom, RingHom.map_det, ← det_one (R := R) (n := n)]
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ ((evalRingHom 0).mapMatrix (1 - X • M.map ⇑C)).det = det 1
state_after: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
this : (1 - X • M.map ⇑C).map (eval 0) = 1
⊢ ((evalRingHom 0).mapMatrix (1 - X • M.map ⇑C)).det = det 1
tactic: have : (1 - (X : R[X]) • M.map C).map (eval 0) = 1 := by
    ext i j; rcases eq_or_ne i j with hij | hij <;> simp [hij, one_apply]
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
this : (1 - X • M.map ⇑C).map (eval 0) = 1
⊢ ((evalRingHom 0).mapMatrix (1 - X • M.map ⇑C)).det = det 1
state_after: no goals
tactic: congr
Theorem: Function.mulSupport_one_sub'
File: Mathlib/Algebra/GroupWithZero/Indicator.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝¹ : One R
inst✝ : AddGroup R
f : ι → R
⊢ mulSupport (1 - f) = support f
state_after: no goals
tactic: rw [sub_eq_add_neg, mulSupport_one_add', support_neg']
Theorem: DirectSum.linearEquivFunOnFintype_symm_coe
File: Mathlib/Algebra/DirectSum/Module.lean

Proof steps:
state_before: R : Type u
inst✝⁵ : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : ι → Type w
inst✝⁴ : (i : ι) → AddCommMonoid (M i)
inst✝³ : (i : ι) → Module R (M i)
N : Type u₁
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
φ : (i : ι) → M i →ₗ[R] N
ψ ψ' : (⨁ (i : ι), M i) →ₗ[R] N
inst✝ : Fintype ι
f : ⨁ (i : ι), M i
⊢ (linearEquivFunOnFintype R ι M).symm ⇑f = f
state_after: no goals
tactic: simp [linearEquivFunOnFintype]
Theorem: Finset.image_add_right'
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq β
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
s t : Finset α
a b : α
⊢ image (fun x => x * b⁻¹) t = t.preimage (fun x => x * b) ⋯
state_after: no goals
tactic: simp
Theorem: Filter.neg_le_iff_le_neg
File: Mathlib/Order/Filter/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : InvolutiveInv α
f g : Filter α
s : Set α
⊢ f⁻¹ ≤ g ↔ f ≤ g⁻¹
state_after: no goals
tactic: rw [← Filter.inv_le_inv_iff, inv_inv]
Theorem: FirstOrder.Language.card_functions_sum_skolem₁_le
File: Mathlib/ModelTheory/Skolem.lean

Proof steps:
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × (L.sum L.skolem₁).Functions n) ≤ max ℵ₀ L.card
state_after: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × L.BoundedFormula Empty (n + 1)) ≤ max ℵ₀ L.card
tactic: rw [card_functions_sum_skolem₁]
state_before: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × L.BoundedFormula Empty (n + 1)) ≤ max ℵ₀ L.card
state_after: L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × L.BoundedFormula Empty (n + 1)) ≤ #((n : ℕ) × L.BoundedFormula Empty n)

L : Language
M : Type w
inst✝¹ : Nonempty M
inst✝ : L.Structure M
⊢ #((n : ℕ) × L.BoundedFormula Empty n) ≤ max ℵ₀ L.card
tactic: trans #(Σ n, L.BoundedFormula Empty n)
Theorem: AlgebraicGeometry.compactSpace_iff_quasiCompact
File: Mathlib/AlgebraicGeometry/Morphisms/QuasiCompact.lean

Proof steps:
state_before: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
⊢ CompactSpace ↑↑X.toPresheafedSpace ↔ QuasiCompact (terminal.from X)
state_after: no goals
tactic: rw [HasAffineProperty.iff_of_isAffine (P := @QuasiCompact)]
Theorem: Cubic.d_eq_three_roots
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 : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ φ P.d = φ P.a * -(x * y * z)
state_after: no goals
tactic: injection eq_sum_three_roots ha h3
Theorem: Finset.prod_Ico_eq_mul_inv
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝¹ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
δ : Type u_3
inst✝ : CommGroup δ
f : ℕ → δ
m n : ℕ
h : m ≤ n
⊢ (∏ k ∈ Ico m n, f k) * ∏ k ∈ range m, f k = ∏ k ∈ range n, f k
state_after: no goals
tactic: (rw [mul_comm]; exact prod_range_mul_prod_Ico f h)
Theorem: Rat.divInt_eq_div
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q a b c : ℚ
n d : ℤ
⊢ n /. d = ↑n / ↑d
state_after: no goals
tactic: simp [div_def']
Theorem: LieSubmodule.map_id
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
⊢ map LieModuleHom.id N = N
state_after: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
m✝ : M
⊢ m✝ ∈ map LieModuleHom.id N ↔ m✝ ∈ N
tactic: ext
state_before: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
m✝ : M
⊢ m✝ ∈ map LieModuleHom.id N ↔ m✝ ∈ N
state_after: no goals
tactic: simp