ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: irrational_sqrt_ratCast_iff
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
⊢ Irrational √↑q ↔ ¬IsSquare q ∧ 0 ≤ q
state_after: case inl
q : ℚ
hq : 0 ≤ q
⊢ Irrational √↑q ↔ ¬IsSquare q ∧ 0 ≤ q

case inr
q : ℚ
hq : q < 0
⊢ Irrational √↑q ↔ ¬IsSquare q ∧ 0 ≤ q
tactic: obtain hq | hq := le_or_lt 0 q
Theorem: ArithmeticFunction.zeta_mul_pow_eq_sigma
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
k : ℕ
⊢ ζ * pow k = σ k
state_after: case h
R : Type u_1
k x✝ : ℕ
⊢ (ζ * pow k) x✝ = (σ k) x✝
tactic: ext
state_before: case h
R : Type u_1
k x✝ : ℕ
⊢ (ζ * pow k) x✝ = (σ k) x✝
state_after: case h
R : Type u_1
k x✝ : ℕ
⊢ ∑ i ∈ x✝.divisors, (pow k) i = { toFun := fun n => ∑ d ∈ n.divisors, d ^ k, map_zero' := ⋯ } x✝
tactic: rw [sigma, zeta_mul_apply]
state_before: case h
R : Type u_1
k x✝ : ℕ
⊢ ∑ i ∈ x✝.divisors, (pow k) i = { toFun := fun n => ∑ d ∈ n.divisors, d ^ k, map_zero' := ⋯ } x✝
state_after: case h
R : Type u_1
k x✝ : ℕ
⊢ ∀ x ∈ x✝.divisors, (pow k) x = x ^ k
tactic: apply sum_congr rfl
state_before: case h
R : Type u_1
k x✝ : ℕ
⊢ ∀ x ∈ x✝.divisors, (pow k) x = x ^ k
state_after: case h
R : Type u_1
k x✝ x : ℕ
hx : x ∈ x✝.divisors
⊢ (pow k) x = x ^ k
tactic: intro x hx
state_before: case h
R : Type u_1
k x✝ x : ℕ
hx : x ∈ x✝.divisors
⊢ (pow k) x = x ^ k
state_after: R : Type u_1
k x✝ x : ℕ
hx : x ∈ x✝.divisors
⊢ ¬x = 0
tactic: rw [pow_apply, if_neg (not_and_of_not_right _ _)]
state_before: R : Type u_1
k x✝ x : ℕ
hx : x ∈ x✝.divisors
⊢ ¬x = 0
state_after: R : Type u_1
k x✝ x : ℕ
hx : x = 0
⊢ x ∉ x✝.divisors
tactic: contrapose! hx
state_before: R : Type u_1
k x✝ x : ℕ
hx : x = 0
⊢ x ∉ x✝.divisors
state_after: no goals
tactic: simp [hx]
Theorem: SimpleGraph.Walk.append_nil
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ p.append nil = p
state_after: no goals
tactic: induction p with
  | nil => rfl
  | cons _ _ ih => rw [cons_append, ih]
Theorem: OrderHom.coe_iInf
File: Mathlib/Order/Hom/Order.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_3
inst✝ : CompleteLattice β
f : ι → α →o β
⊢ ⇑(⨅ i, f i) = ⨅ i, ⇑(f i)
state_after: case h
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_3
inst✝ : CompleteLattice β
f : ι → α →o β
x : α
⊢ (⨅ i, f i) x = (⨅ i, ⇑(f i)) x
tactic: funext x
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
ι : Sort u_3
inst✝ : CompleteLattice β
f : ι → α →o β
x : α
⊢ (⨅ i, f i) x = (⨅ i, ⇑(f i)) x
state_after: no goals
tactic: simp [iInf_apply]
Theorem: NonemptyFinLinOrd.epi_iff_surjective
File: Mathlib/Order/Category/NonemptyFinLinOrd.lean

Proof steps:
state_before: A B : NonemptyFinLinOrd
f : A ⟶ B
⊢ Epi f ↔ Function.Surjective ⇑f
state_after: case mp
A B : NonemptyFinLinOrd
f : A ⟶ B
⊢ Epi f → Function.Surjective ⇑f

case mpr
A B : NonemptyFinLinOrd
f : A ⟶ B
⊢ Function.Surjective ⇑f → Epi f
tactic: constructor
Theorem: Set.Icc_diff_Ioo_same
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ Icc a b \ Ioo a b = {a, b}
state_after: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ {a, b} ⊆ Icc a b
tactic: rw [← Icc_diff_both, diff_diff_cancel_left]
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a ≤ b
⊢ {a, b} ⊆ Icc a b
state_after: no goals
tactic: simp [insert_subset_iff, h]
Theorem: CategoryTheory.Functor.mapTriangleRotateIso_hom_app_hom₁
File: Mathlib/CategoryTheory/Triangulated/Functor.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₁ ≫ (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂).hom =
    (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₁
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₂ ≫ ((F.commShiftIso 1).symm.app T.obj₁).hom =
    (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₂
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
T : Triangle C
⊢ ((F.mapTriangle ⋙ rotate D).obj T).mor₃ ≫
      (shiftFunctor D 1).map (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁).hom =
    ((F.commShiftIso 1).symm.app T.obj₁).hom ≫ ((rotate C ⋙ F.mapTriangle).obj T).mor₃
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝¹⁰ : Category.{?u.192876, u_1} C
inst✝⁹ : Category.{?u.192880, u_2} D
inst✝⁸ : Category.{?u.192884, u_3} E
inst✝⁷ : HasShift C ℤ
inst✝⁶ : HasShift D ℤ
inst✝⁵ : HasShift E ℤ
F : C ⥤ D
inst✝⁴ : F.CommShift ℤ
G : D ⥤ E
inst✝³ : G.CommShift ℤ
inst✝² : Preadditive C
inst✝¹ : Preadditive D
inst✝ : F.Additive
⊢ ∀ {X Y : Triangle C} (f : X ⟶ Y),
    (F.mapTriangle ⋙ rotate D).map f ≫
        ((fun T =>
              ((F.mapTriangle ⋙ rotate D).obj T).isoMk ((rotate C ⋙ F.mapTriangle).obj T)
                (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁) (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂)
                ((F.commShiftIso 1).symm.app T.obj₁) ⋯ ⋯ ⋯)
            Y).hom =
      ((fun T =>
              ((F.mapTriangle ⋙ rotate D).obj T).isoMk ((rotate C ⋙ F.mapTriangle).obj T)
                (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₁) (Iso.refl ((F.mapTriangle ⋙ rotate D).obj T).obj₂)
                ((F.commShiftIso 1).symm.app T.obj₁) ⋯ ⋯ ⋯)
            X).hom ≫
        (rotate C ⋙ F.mapTriangle).map f
state_after: no goals
tactic: aesop_cat
Theorem: Metric.infDist_empty
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ infDist x ∅ = 0
state_after: no goals
tactic: simp [infDist]
Theorem: MeasureTheory.condexp_bot
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean

Proof steps:
state_before: α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁷ : RCLike 𝕜
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace 𝕜 F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g : α → F'
s : Set α
inst✝ : IsProbabilityMeasure μ
f : α → F'
⊢ μ[f|⊥] = fun x => ∫ (x : α), f x ∂μ
state_after: α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁷ : RCLike 𝕜
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace 𝕜 F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g : α → F'
s : Set α
inst✝ : IsProbabilityMeasure μ
f : α → F'
⊢ (fun x => (μ Set.univ).toReal⁻¹ • ∫ (x : α), f x ∂μ) = fun x => ∫ (x : α), f x ∂μ
tactic: refine (condexp_bot' f).trans ?_
state_before: α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁷ : RCLike 𝕜
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace 𝕜 F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g : α → F'
s : Set α
inst✝ : IsProbabilityMeasure μ
f : α → F'
⊢ (fun x => (μ Set.univ).toReal⁻¹ • ∫ (x : α), f x ∂μ) = fun x => ∫ (x : α), f x ∂μ
state_after: no goals
tactic: rw [measure_univ, ENNReal.one_toReal, inv_one, one_smul]
Theorem: NNReal.coe_iSup
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
ι : Sort u_1
s : ι → ℝ≥0
⊢ ↑(⨆ i, s i) = ⨆ i, ↑(s i)
state_after: r r₁ r₂ : ℝ≥0
x y : ℝ
ι : Sort u_1
s : ι → ℝ≥0
⊢ sSup (Set.range (toReal ∘ fun i => s i)) = sSup (Set.range fun i => ↑(s i))
tactic: rw [iSup, iSup, coe_sSup, ← Set.range_comp]
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
ι : Sort u_1
s : ι → ℝ≥0
⊢ sSup (Set.range (toReal ∘ fun i => s i)) = sSup (Set.range fun i => ↑(s i))
state_after: no goals
tactic: rfl
Theorem: Nat.div_add_mod'
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
⊢ a / b * b + a % b = a
state_after: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
⊢ b * (a / b) + a % b = a
tactic: rw [Nat.mul_comm]
state_before: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
⊢ b * (a / b) + a % b = a
state_after: no goals
tactic: exact div_add_mod _ _
Theorem: ball_zero_eq
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₂ r : ℝ
a : E
⊢ a ∈ ball 1 r ↔ a ∈ {x | ‖x‖ < r}
state_after: no goals
tactic: simp
Theorem: FirstOrder.Language.Substructure.fg_iff_structure_fg
File: Mathlib/ModelTheory/FinitelyGenerated.lean

Proof steps:
state_before: L : Language
M : Type u_1
inst✝ : L.Structure M
S : L.Substructure M
⊢ S.FG ↔ Structure.FG L ↥S
state_after: L : Language
M : Type u_1
inst✝ : L.Structure M
S : L.Substructure M
⊢ S.FG ↔ ⊤.FG
tactic: rw [Structure.fg_def]
state_before: L : Language
M : Type u_1
inst✝ : L.Structure M
S : L.Substructure M
⊢ S.FG ↔ ⊤.FG
state_after: case refine_1
L : Language
M : Type u_1
inst✝ : L.Structure M
S : L.Substructure M
h : S.FG
⊢ (map S.subtype.toHom ⊤).FG

case refine_2
L : Language
M : Type u_1
inst✝ : L.Structure M
S : L.Substructure M
h : ⊤.FG
⊢ S.FG
tactic: refine ⟨fun h => FG.of_map_embedding S.subtype ?_, fun h => ?_⟩
Theorem: zpow_le_max_iff_min_le
File: Mathlib/Algebra/Order/Field/Power.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a✝ b✝ c✝ d e : α
m n : ℤ
x : α
hx : 1 < x
a b c : ℤ
⊢ x ^ (-c) ≤ max (x ^ (-a)) (x ^ (-b)) ↔ min a b ≤ c
state_after: no goals
tactic: simp_rw [le_max_iff, min_le_iff, zpow_le_iff_le hx, neg_le_neg_iff]
Theorem: Mathlib.Vector.mapAccumr₂_mapAccumr₂_left_left
File: Mathlib/Data/Vector/MapLemmas.lean

Proof steps:
state_before: α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
γ σ₁ φ σ₂ : Type
s₂ : σ₂
s₁ : σ₁
f₁ : γ → α → σ₁ → σ₁ × φ
f₂ : α → β → σ₂ → σ₂ × γ
⊢ mapAccumr₂ f₁ (mapAccumr₂ f₂ xs ys s₂).2 xs s₁ =
    let m :=
      mapAccumr₂
        (fun x y x_1 =>
          match x_1 with
          | (s₁, s₂) =>
            let r₂ := f₂ x y s₂;
            let r₁ := f₁ r₂.2 x s₁;
            ((r₁.1, r₂.1), r₁.2))
        xs ys (s₁, s₂);
    (m.1.1, m.2)
state_after: no goals
tactic: induction xs, ys using Vector.revInductionOn₂ generalizing s₁ s₂ <;> simp_all
Theorem: Set.image_id_eq
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 α
⊢ image id = id
state_after: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s t x✝¹ : Set α
x✝ : α
⊢ x✝ ∈ id '' x✝¹ ↔ x✝ ∈ id x✝¹
tactic: ext
state_before: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : α → β
s t x✝¹ : Set α
x✝ : α
⊢ x✝ ∈ id '' x✝¹ ↔ x✝ ∈ id x✝¹
state_after: no goals
tactic: simp
Theorem: Primrec.vector_get
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
a : Vector α n × Fin n
⊢ a.1.toList.get? ↑a.2 = some (a.1.get a.2)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
a : Vector α n × Fin n
⊢ a.1.toList.get? ↑a.2 = a.1.toList.get? ↑(Fin.cast ⋯ a.2)
tactic: rw [Vector.get_eq_get, ← List.get?_eq_get]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
a : Vector α n × Fin n
⊢ a.1.toList.get? ↑a.2 = a.1.toList.get? ↑(Fin.cast ⋯ a.2)
state_after: no goals
tactic: rfl
Theorem: iteratedDeriv_eq_equiv_comp
File: Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ iteratedDeriv n f = ⇑(ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F).symm ∘ iteratedFDeriv 𝕜 n f
state_after: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDeriv n f x = (⇑(ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F).symm ∘ iteratedFDeriv 𝕜 n f) x
tactic: ext x
state_before: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDeriv n f x = (⇑(ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F).symm ∘ iteratedFDeriv 𝕜 n f) x
state_after: no goals
tactic: rfl
Theorem: List.get_enum
File: Mathlib/Data/List/Enum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : List α
i : Fin l.enum.length
⊢ l.enum.get i = (↑i, l.get (Fin.cast ⋯ i))
state_after: no goals
tactic: simp
Theorem: Filter.mem_comap_prod_mk
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l✝ : Filter α
f : α → β
l : Filter β
p : α → Prop
s✝ : Set α
x : α
s : Set β
F : Filter (α × β)
⊢ s ∈ comap (Prod.mk x) F ↔ {p | p.1 = x → p.2 ∈ s} ∈ F
state_after: no goals
tactic: simp_rw [mem_comap', Prod.ext_iff, and_imp, @forall_swap β (_ = _), forall_eq, eq_comm]
Theorem: CategoryTheory.Under.pushout_map
File: Mathlib/CategoryTheory/Adjunction/Over.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : HasPushouts C
X Y : C
f : X ⟶ Y
x x' : Under X
u : x ⟶ x'
⊢ x.hom ≫ u.right ≫ pushout.inl x'.hom f = f ≫ pushout.inr x'.hom f
state_after: no goals
tactic: simp [← pushout.condition]
Theorem: FirstOrder.Language.Theory.ModelsBoundedFormula.realize_sentence
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
h : T ⊨ᵇ φ
M : Type u_1
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Nonempty M
⊢ M ⊨ φ
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
h : ¬(T ∪ {Formula.not φ}).IsSatisfiable
M : Type u_1
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Nonempty M
⊢ M ⊨ φ
tactic: rw [models_iff_not_satisfiable] at h
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
h : ¬(T ∪ {Formula.not φ}).IsSatisfiable
M : Type u_1
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Nonempty M
⊢ M ⊨ φ
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : Type u_1
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Nonempty M
h : ¬M ⊨ φ
⊢ (T ∪ {Formula.not φ}).IsSatisfiable
tactic: contrapose! h
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : Type u_1
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Nonempty M
h : ¬M ⊨ φ
⊢ (T ∪ {Formula.not φ}).IsSatisfiable
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : Type u_1
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Nonempty M
h : ¬M ⊨ φ
this : M ⊨ T ∪ {Formula.not φ}
⊢ (T ∪ {Formula.not φ}).IsSatisfiable
tactic: have : M ⊨ T ∪ {Formula.not φ} := by
    simp only [Set.union_singleton, model_iff, Set.mem_insert_iff, forall_eq_or_imp,
      Sentence.realize_not]
    rw [← model_iff]
    exact ⟨h, inferInstance⟩
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : Type u_1
inst✝² : L.Structure M
inst✝¹ : M ⊨ T
inst✝ : Nonempty M
h : ¬M ⊨ φ
this : M ⊨ T ∪ {Formula.not φ}
⊢ (T ∪ {Formula.not φ}).IsSatisfiable
state_after: no goals
tactic: exact Model.isSatisfiable M
Theorem: Polynomial.leadingCoeff_monic_mul
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
hp : p.Monic
⊢ (p * q).leadingCoeff = q.leadingCoeff
state_after: case inl
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q : R[X]
ι : Type u_1
p : R[X]
hp : p.Monic
⊢ (p * 0).leadingCoeff = leadingCoeff 0

case inr
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q✝ : R[X]
ι : Type u_1
p q : R[X]
hp : p.Monic
H : q ≠ 0
⊢ (p * q).leadingCoeff = q.leadingCoeff
tactic: rcases eq_or_ne q 0 with (rfl | H)
Theorem: Nat.bit_mod_two_eq_one_iff
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: f : Bool → Bool → Bool
a : Bool
x : ℕ
⊢ bit a x % 2 = 1 ↔ a = true
state_after: f : Bool → Bool → Bool
a : Bool
x : ℕ
⊢ (if a = true then 1 else 0) = 1 ↔ a = true
tactic: rw [bit_mod_two]
state_before: f : Bool → Bool → Bool
a : Bool
x : ℕ
⊢ (if a = true then 1 else 0) = 1 ↔ a = true
state_after: no goals
tactic: split_ifs <;> simp_all
Theorem: SubMulAction.coe_pow
File: Mathlib/GroupTheory/GroupAction/SubMulAction/Pointwise.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : Monoid M
inst✝¹ : IsScalarTower R M M
inst✝ : SMulCommClass R M M
p : SubMulAction R M
x✝ : 1 ≠ 0
⊢ ↑(p ^ 1) = ↑p ^ 1
state_after: no goals
tactic: rw [pow_one, pow_one]
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : Monoid M
inst✝¹ : IsScalarTower R M M
inst✝ : SMulCommClass R M M
p : SubMulAction R M
n : ℕ
x✝ : n + 2 ≠ 0
⊢ ↑(p ^ (n + 2)) = ↑p ^ (n + 2)
state_after: no goals
tactic: rw [pow_succ _ (n + 1), pow_succ _ (n + 1), coe_mul, coe_pow _ n.succ_ne_zero]
Theorem: Set.empty_card'
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
h : Fintype ↑∅
⊢ Fintype.card ↑∅ = 0
state_after: no goals
tactic: simp
Theorem: Polynomial.aeval_endomorphism
File: Mathlib/Algebra/Polynomial/AlgebraMap.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
M : Type u_3
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
p : R[X]
⊢ ((aeval f) p) v = p.sum fun n b => b • (f ^ n) v
state_after: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
M : Type u_3
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
p : R[X]
⊢ (p.sum fun e a => (algebraMap R (M →ₗ[R] M)) a * f ^ e) v = p.sum fun n b => b • (f ^ n) v
tactic: rw [aeval_def, eval₂_eq_sum]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type u_1
B : Type u_2
a b : R
n : ℕ
M : Type u_3
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
f : M →ₗ[R] M
v : M
p : R[X]
⊢ (p.sum fun e a => (algebraMap R (M →ₗ[R] M)) a * f ^ e) v = p.sum fun n b => b • (f ^ n) v
state_after: no goals
tactic: exact map_sum (LinearMap.applyₗ v) _ _
Theorem: MeasureTheory.StronglyMeasurable.mul_iff_right
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
mα : MeasurableSpace α
inst✝² : TopologicalSpace β
inst✝¹ : CommGroup β
inst✝ : TopologicalGroup β
hf : StronglyMeasurable f
h : StronglyMeasurable (f * g)
⊢ g = f * g * f⁻¹
state_after: no goals
tactic: simp only [mul_inv_cancel_comm]
Theorem: ArithmeticFunction.IsMultiplicative.natCast
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
f : ArithmeticFunction ℕ
inst✝ : Semiring R
h : f.IsMultiplicative
⊢ ↑f 1 = 1
state_after: no goals
tactic: simp [h]
state_before: R : Type u_1
f : ArithmeticFunction ℕ
inst✝ : Semiring R
h : f.IsMultiplicative
m n : ℕ
cop : m.Coprime n
⊢ ↑f (m * n) = ↑f m * ↑f n
state_after: no goals
tactic: simp [h.2 cop]
Theorem: Filter.not_frequently
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
⊢ (¬∃ᶠ (x : α) in f, p x) ↔ ∀ᶠ (x : α) in f, ¬p x
state_after: no goals
tactic: simp only [Filter.Frequently, not_not]
Theorem: CategoryTheory.Sieve.functorPushforward_functor
File: Mathlib/CategoryTheory/Sites/Sieves.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S✝ R : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
S : Sieve X
e : C ≌ D
⊢ functorPushforward e.functor S = functorPullback e.inverse (pullback (e.unitInv.app X) S)
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y✝ Z : C
f : Y✝ ⟶ X
S✝ R : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
S : Sieve X
e : C ≌ D
Y : D
iYX : Y ⟶ e.functor.obj X
⊢ (functorPushforward e.functor S).arrows iYX ↔ (functorPullback e.inverse (pullback (e.unitInv.app X) S)).arrows iYX
tactic: ext Y iYX
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y✝ Z : C
f : Y✝ ⟶ X
S✝ R : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
S : Sieve X
e : C ≌ D
Y : D
iYX : Y ⟶ e.functor.obj X
⊢ (functorPushforward e.functor S).arrows iYX ↔ (functorPullback e.inverse (pullback (e.unitInv.app X) S)).arrows iYX
state_after: case h.mp
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y✝ Z : C
f : Y✝ ⟶ X
S✝ R : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
S : Sieve X
e : C ≌ D
Y : D
iYX : Y ⟶ e.functor.obj X
⊢ (functorPushforward e.functor S).arrows iYX → (functorPullback e.inverse (pullback (e.unitInv.app X) S)).arrows iYX

case h.mpr
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y✝ Z : C
f : Y✝ ⟶ X
S✝ R : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
S : Sieve X
e : C ≌ D
Y : D
iYX : Y ⟶ e.functor.obj X
⊢ (functorPullback e.inverse (pullback (e.unitInv.app X) S)).arrows iYX → (functorPushforward e.functor S).arrows iYX
tactic: constructor
Theorem: Perfection.pthRoot_frobenius
File: Mathlib/RingTheory/Perfection.lean

Proof steps:
state_before: R : Type u₁
inst✝¹ : CommSemiring R
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x : Ring.Perfection R p
n : ℕ
⊢ (coeff R p n) (((pthRoot R p).comp (frobenius (Ring.Perfection R p) p)) x) =
    (coeff R p n) ((RingHom.id (Ring.Perfection R p)) x)
state_after: no goals
tactic: rw [RingHom.comp_apply, RingHom.id_apply, coeff_pthRoot, coeff_frobenius]