ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Rel.edgeDensity_add_edgeDensity_compl
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
hs : s.Nonempty
ht : t.Nonempty
⊢ edgeDensity r s t + edgeDensity (fun x y => ¬r x y) s t = 1
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
hs : s.Nonempty
ht : t.Nonempty
⊢ ↑(interedges r s t).card + ↑(interedges (fun x y => ¬r x y) s t).card = ↑s.card * ↑t.card

𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
hs : s.Nonempty
ht : t.Nonempty
⊢ ↑s.card * ↑t.card ≠ 0
tactic: rw [edgeDensity, edgeDensity, div_add_div_same, div_eq_one_iff_eq]
Theorem: aestronglyMeasurable_union_iff
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 ι
m : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
f g : α → β
inst✝ : PseudoMetrizableSpace β
s t : Set α
⊢ AEStronglyMeasurable f (μ.restrict (s ∪ t)) ↔
    AEStronglyMeasurable f (μ.restrict s) ∧ AEStronglyMeasurable f (μ.restrict t)
state_after: no goals
tactic: simp only [union_eq_iUnion, aestronglyMeasurable_iUnion_iff, Bool.forall_bool, cond, and_comm]
Theorem: CategoryTheory.Monad.ForgetCreatesLimits.liftedCone_π_app_f
File: Mathlib/CategoryTheory/Monad/Limits.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ ((Functor.const J).obj (conePoint D c t)).map f ≫ (fun j => { f := c.π.app j, h := ⋯ }) Y =
    (fun j => { f := c.π.app j, h := ⋯ }) X ≫ D.map f
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ (((Functor.const J).obj (conePoint D c t)).map f ≫ (fun j => { f := c.π.app j, h := ⋯ }) Y).f =
    ((fun j => { f := c.π.app j, h := ⋯ }) X ≫ D.map f).f
tactic: ext1
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ (((Functor.const J).obj (conePoint D c t)).map f ≫ (fun j => { f := c.π.app j, h := ⋯ }) Y).f =
    ((fun j => { f := c.π.app j, h := ⋯ }) X ≫ D.map f).f
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ 𝟙 c.pt ≫ c.π.app Y = c.π.app X ≫ (D.map f).f
tactic: dsimp
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ 𝟙 c.pt ≫ c.π.app Y = c.π.app X ≫ (D.map f).f
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ 𝟙 c.pt ≫ c.π.app Y = c.π.app Y
tactic: erw [c.w f]
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
X Y : J
f : X ⟶ Y
⊢ 𝟙 c.pt ≫ c.π.app Y = c.π.app Y
state_after: no goals
tactic: simp
Theorem: MeasureTheory.OuterMeasure.trim_congr
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ : OuterMeasure α
H : ∀ {s : Set α}, MeasurableSet s → m₁ s = m₂ s
⊢ m₁.trim = m₂.trim
state_after: no goals
tactic: simp (config := { contextual := true }) only [trim, H]
Theorem: add_one_zsmul
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (↑n + 1) = a ^ ↑n * a
state_after: no goals
tactic: simp only [← Int.ofNat_succ, zpow_natCast, pow_succ]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n : ℤ
a : G
⊢ a ^ (Int.negSucc 0 + 1) = a ^ Int.negSucc 0 * a
state_after: no goals
tactic: simp [Int.negSucc_eq', Int.add_left_neg]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (Int.negSucc (n + 1) + 1) = a ^ Int.negSucc (n + 1) * a
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (Int.negSucc (n + 1) + 1) = (a ^ (n + 1))⁻¹
tactic: rw [zpow_negSucc, pow_succ', mul_inv_rev, inv_mul_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (Int.negSucc (n + 1) + 1) = (a ^ (n + 1))⁻¹
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (-↑(n + 1)) = (a ^ (n + 1))⁻¹
tactic: rw [Int.negSucc_eq, Int.neg_add, Int.neg_add_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (-↑(n + 1)) = (a ^ (n + 1))⁻¹
state_after: no goals
tactic: exact zpow_negSucc _ _
Theorem: SimpleGraph.isNClique_empty
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
⊢ G.IsNClique n ∅ ↔ n = 0
state_after: no goals
tactic: simp [isNClique_iff, eq_comm]
Theorem: skewAdjoint.conjugate'
File: Mathlib/Algebra/Star/SelfAdjoint.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝¹ : Ring R
inst✝ : StarRing R
x : R
hx : x ∈ skewAdjoint R
z : R
⊢ star z * x * z ∈ skewAdjoint R
state_after: no goals
tactic: simp only [mem_iff, star_mul, star_star, mem_iff.mp hx, neg_mul, mul_neg, mul_assoc]
Theorem: MeasureTheory.FiniteMeasure.ext_of_forall_lintegral_eq
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝⁷ : MeasurableSpace Ω
R : Type u_2
inst✝⁶ : SMul R ℝ≥0
inst✝⁵ : SMul R ℝ≥0∞
inst✝⁴ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝² : TopologicalSpace Ω
inst✝¹ : HasOuterApproxClosed Ω
inst✝ : BorelSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (f : Ω →ᵇ ℝ≥0), ∫⁻ (x : Ω), ↑(f x) ∂↑μ = ∫⁻ (x : Ω), ↑(f x) ∂↑ν
⊢ μ = ν
state_after: case a
Ω : Type u_1
inst✝⁷ : MeasurableSpace Ω
R : Type u_2
inst✝⁶ : SMul R ℝ≥0
inst✝⁵ : SMul R ℝ≥0∞
inst✝⁴ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝² : TopologicalSpace Ω
inst✝¹ : HasOuterApproxClosed Ω
inst✝ : BorelSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (f : Ω →ᵇ ℝ≥0), ∫⁻ (x : Ω), ↑(f x) ∂↑μ = ∫⁻ (x : Ω), ↑(f x) ∂↑ν
⊢ ↑μ = ↑ν
tactic: apply Subtype.ext
state_before: case a
Ω : Type u_1
inst✝⁷ : MeasurableSpace Ω
R : Type u_2
inst✝⁶ : SMul R ℝ≥0
inst✝⁵ : SMul R ℝ≥0∞
inst✝⁴ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝² : TopologicalSpace Ω
inst✝¹ : HasOuterApproxClosed Ω
inst✝ : BorelSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (f : Ω →ᵇ ℝ≥0), ∫⁻ (x : Ω), ↑(f x) ∂↑μ = ∫⁻ (x : Ω), ↑(f x) ∂↑ν
⊢ ↑μ = ↑ν
state_after: no goals
tactic: exact ext_of_forall_lintegral_eq_of_IsFiniteMeasure h
Theorem: Matrix.mulVec_vecMul
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalCommSemiring α
inst✝¹ : Fintype n
inst✝ : Fintype o
A : Matrix m n α
B : Matrix o n α
x : o → α
⊢ A *ᵥ x ᵥ* B = (A * Bᵀ) *ᵥ x
state_after: no goals
tactic: rw [← mulVec_mulVec, mulVec_transpose]
Theorem: NNRat.toNNRat_prod_of_nonneg
File: Mathlib/Data/NNRat/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
s : Finset α
f : α → ℚ
hf : ∀ a ∈ s, 0 ≤ f a
⊢ (∏ a ∈ s, f a).toNNRat = ∏ a ∈ s, (f a).toNNRat
state_after: ι : Type u_1
α : Type u_2
s : Finset α
f : α → ℚ
hf : ∀ a ∈ s, 0 ≤ f a
⊢ ∏ i ∈ s, f i = ∏ a ∈ s, ↑(f a).toNNRat
tactic: rw [← coe_inj, coe_prod, Rat.coe_toNNRat _ (Finset.prod_nonneg hf)]
state_before: ι : Type u_1
α : Type u_2
s : Finset α
f : α → ℚ
hf : ∀ a ∈ s, 0 ≤ f a
⊢ ∏ i ∈ s, f i = ∏ a ∈ s, ↑(f a).toNNRat
state_after: no goals
tactic: exact Finset.prod_congr rfl fun x hxs ↦ by rw [Rat.coe_toNNRat _ (hf x hxs)]
Theorem: AddUnits.map_id
File: Mathlib/Algebra/Group/Units/Hom.lean

Proof steps:
state_before: α : Type u_1
M : Type u
N : Type v
P : Type w
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
⊢ map (MonoidHom.id M) = MonoidHom.id Mˣ
state_after: case h.a
α : Type u_1
M : Type u
N : Type v
P : Type w
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
x✝ : Mˣ
⊢ ↑((map (MonoidHom.id M)) x✝) = ↑((MonoidHom.id Mˣ) x✝)
tactic: ext
state_before: case h.a
α : Type u_1
M : Type u
N : Type v
P : Type w
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
x✝ : Mˣ
⊢ ↑((map (MonoidHom.id M)) x✝) = ↑((MonoidHom.id Mˣ) x✝)
state_after: no goals
tactic: rfl
Theorem: Real.exists_rat_pow_btwn_rat
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: z x✝ y✝ : ℝ
n : ℕ
hn : n ≠ 0
x y : ℚ
h : x < y
hy : 0 < y
⊢ ∃ q, 0 < q ∧ x < q ^ n ∧ q ^ n < y
state_after: no goals
tactic: apply_mod_cast exists_rat_pow_btwn_rat_aux hn x y <;> assumption
Theorem: orderOf_pow_dvd
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m n : ℕ
⊢ orderOf (x ^ n) ∣ orderOf x
state_after: no goals
tactic: rw [orderOf_dvd_iff_pow_eq_one, pow_right_comm, pow_orderOf_eq_one, one_pow]
Theorem: EReal.closedEmbedding_coe_ennreal
File: Mathlib/Topology/Instances/EReal.lean

Proof steps:
state_before: α : Type u_1
inst✝ : TopologicalSpace α
⊢ IsClosed (range ENNReal.toEReal)
state_after: α : Type u_1
inst✝ : TopologicalSpace α
⊢ IsClosed (Ici 0)
tactic: rw [range_coe_ennreal]
state_before: α : Type u_1
inst✝ : TopologicalSpace α
⊢ IsClosed (Ici 0)
state_after: no goals
tactic: exact isClosed_Ici
Theorem: MeasurableSpace.generateFrom_iUnion_memPartition
File: Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
t : ℕ → Set α
⊢ generateFrom (⋃ n, memPartition t n) = generateFrom (range t)
state_after: case refine_1
α : Type u_1
β : Type u_2
t : ℕ → Set α
u : Set α
hu : u ∈ ⋃ n, memPartition t n
⊢ MeasurableSet u

case refine_2
α : Type u_1
β : Type u_2
t : ℕ → Set α
u : Set α
hu : u ∈ range t
⊢ MeasurableSet u
tactic: refine le_antisymm (generateFrom_le fun u hu ↦ ?_) (generateFrom_le fun u hu ↦ ?_)
Theorem: Perfection.frobenius_pthRoot
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) (((frobenius (Ring.Perfection R p) p).comp (pthRoot R 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, RingHom.map_frobenius, coeff_pthRoot,
        ← @RingHom.map_frobenius (Ring.Perfection R p) _ R, coeff_frobenius]
Theorem: Finset.prod_add
File: Mathlib/Algebra/BigOperators/Ring.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
s✝ s₁ s₂ : Finset ι
i : ι
a : α
f✝ g✝ : ι → α
inst✝¹ : CommSemiring α
inst✝ : DecidableEq ι
f g : ι → α
s : Finset ι
⊢ ∏ i ∈ s, (f i + g i) = ∑ t ∈ s.powerset, (∏ i ∈ t, f i) * ∏ i ∈ s \ t, g i
state_after: no goals
tactic: classical
  calc
    ∏ i ∈ s, (f i + g i) =
        ∏ i ∈ s, ∑ p ∈ ({True, False} : Finset Prop), if p then f i else g i := by simp
    _ = ∑ p ∈ (s.pi fun _ => {True, False} : Finset (∀ a ∈ s, Prop)),
          ∏ a ∈ s.attach, if p a.1 a.2 then f a.1 else g a.1 := prod_sum _ _ _
    _ = ∑ t ∈ s.powerset, (∏ a ∈ t, f a) * ∏ a ∈ s \ t, g a :=
      sum_bij'
        (fun f _ ↦ s.filter fun a ↦ ∃ h : a ∈ s, f a h)
        (fun t _ a _ => a ∈ t)
        (by simp)
        (by simp [Classical.em])
        (by simp_rw [mem_filter, Function.funext_iff, eq_iff_iff, mem_pi, mem_insert]; tauto)
        (by simp_rw [ext_iff, @mem_filter _ _ (id _), mem_powerset]; tauto)
        (fun a _ ↦ by
          simp only [prod_ite, filter_attach', prod_map, Function.Embedding.coeFn_mk,
            Subtype.map_coe, id_eq, prod_attach, filter_congr_decidable]
          congr 2 with x
          simp only [mem_filter, mem_sdiff, not_and, not_exists, and_congr_right_iff]
          tauto)
Theorem: EMetric.hausdorffEdist_self_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t u : Set α
Φ : α → β
⊢ hausdorffEdist s (closure s) = 0
state_after: no goals
tactic: rw [hausdorffEdist_zero_iff_closure_eq_closure, closure_closure]
Theorem: TensorProduct.directSumLeft_symm_lof_tmul
File: Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean

Proof steps:
state_before: R : Type u
inst✝¹⁴ : CommSemiring R
S : Type ?u.131591
inst✝¹³ : Semiring S
inst✝¹² : Algebra R S
ι₁ : Type v₁
ι₂ : Type v₂
inst✝¹¹ : DecidableEq ι₁
inst✝¹⁰ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁹ : (i₁ : ι₁) → AddCommMonoid (M₁ i₁)
inst✝⁸ : AddCommMonoid M₁'
inst✝⁷ : (i₂ : ι₂) → AddCommMonoid (M₂ i₂)
inst✝⁶ : AddCommMonoid M₂'
inst✝⁵ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝⁴ : Module R M₁'
inst✝³ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝² : Module R M₂'
inst✝¹ : (i₁ : ι₁) → Module S (M₁ i₁)
inst✝ : ∀ (i₁ : ι₁), IsScalarTower R S (M₁ i₁)
i : ι₁
x : M₁ i
y : M₂'
⊢ (directSumLeft R M₁ M₂').symm ((lof R ι₁ (fun i => M₁ i ⊗[R] M₂') i) (x ⊗ₜ[R] y)) = (lof R ι₁ M₁ i) x ⊗ₜ[R] y
state_after: no goals
tactic: rw [LinearEquiv.symm_apply_eq, directSumLeft_tmul_lof]
Theorem: Finset.mulEnergy_comm
File: Mathlib/Combinatorics/Additive/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
s t : Finset α
⊢ Eₘ[s, t] = Eₘ[t, s]
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
s t : Finset α
⊢ (filter ((fun x => x.1.1 * x.2.1 = x.1.2 * x.2.2) ∘ ⇑(Equiv.prodComm (α × α) (α × α)).symm)
        (map (Equiv.prodComm (α × α) (α × α)).toEmbedding ((s ×ˢ s) ×ˢ t ×ˢ t))).card =
    Eₘ[t, s]
tactic: rw [mulEnergy, ← Finset.card_map (Equiv.prodComm _ _).toEmbedding, map_filter]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
s t : Finset α
⊢ (filter ((fun x => x.1.1 * x.2.1 = x.1.2 * x.2.2) ∘ ⇑(Equiv.prodComm (α × α) (α × α)).symm)
        (map (Equiv.prodComm (α × α) (α × α)).toEmbedding ((s ×ˢ s) ×ˢ t ×ˢ t))).card =
    Eₘ[t, s]
state_after: no goals
tactic: simp [-Finset.card_map, eq_comm, mulEnergy, mul_comm, map_eq_image, Function.comp]
Theorem: mulIndicator_biUnion_finset_eventuallyEq
File: Mathlib/Order/Filter/IndicatorFunction.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
ι : Type u_5
inst✝ : One β
s : ι → Set α
f : α → β
a : α
⊢ (fun n => (⋃ i ∈ n, s i).mulIndicator f a) =ᶠ[atTop] fun x => (iUnion s).mulIndicator f a
state_after: α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
ι : Type u_5
inst✝ : One β
s : ι → Set α
f : α → β
a : α
⊢ (fun n => (⋃ i ∈ n, s i).mulIndicator f a) =ᶠ[atTop] fun x => (⋃ t, ⋃ i ∈ t, s i).mulIndicator f a
tactic: rw [iUnion_eq_iUnion_finset s]
state_before: α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
ι : Type u_5
inst✝ : One β
s : ι → Set α
f : α → β
a : α
⊢ (fun n => (⋃ i ∈ n, s i).mulIndicator f a) =ᶠ[atTop] fun x => (⋃ t, ⋃ i ∈ t, s i).mulIndicator f a
state_after: case hs
α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
ι : Type u_5
inst✝ : One β
s : ι → Set α
f : α → β
a : α
⊢ Monotone fun i => ⋃ i_1 ∈ i, s i_1
tactic: apply Monotone.mulIndicator_eventuallyEq_iUnion
state_before: case hs
α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
ι : Type u_5
inst✝ : One β
s : ι → Set α
f : α → β
a : α
⊢ Monotone fun i => ⋃ i_1 ∈ i, s i_1
state_after: no goals
tactic: exact fun _ _ ↦ biUnion_subset_biUnion_left
Theorem: Complex.arg_neg_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z : ℂ
⊢ (-I).arg = -(π / 2)
state_after: no goals
tactic: simp [arg, le_refl]
Theorem: List.sublist_singleton
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
⊢ l <+ [a] ↔ l = [] ∨ l = [a]
state_after: no goals
tactic: constructor <;> rintro (_ | _) <;> aesop
Theorem: LinearMap.map_comp_lTensor
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g✝ : P →ₗ[R] Q
f✝ : N →ₗ[R] P
f : M →ₗ[R] P
g : N →ₗ[R] Q
g' : S →ₗ[R] N
⊢ map f g ∘ₗ lTensor M g' = map f (g ∘ₗ g')
state_after: no goals
tactic: simp only [lTensor, rTensor, ← map_comp, id_comp, comp_id]
Theorem: CategoryTheory.Equivalence.changeInverse_unitIso_inv_app
File: Mathlib/CategoryTheory/Equivalence.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
e : C ≌ D
G : D ⥤ C
iso : e.inverse ≅ G
X : C
⊢ e.functor.map ((e.unitIso ≪≫ isoWhiskerLeft e.functor iso).hom.app X) ≫
      (isoWhiskerRight iso.symm e.functor ≪≫ e.counitIso).hom.app (e.functor.obj X) =
    𝟙 (e.functor.obj X)
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
e : C ≌ D
G : D ⥤ C
iso : e.inverse ≅ G
X : C
⊢ e.functor.map (e.unitIso.hom.app X ≫ iso.hom.app (e.functor.obj X)) ≫
      e.functor.map (iso.inv.app (e.functor.obj X)) ≫ e.counitIso.hom.app (e.functor.obj X) =
    𝟙 (e.functor.obj X)
tactic: dsimp
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
e : C ≌ D
G : D ⥤ C
iso : e.inverse ≅ G
X : C
⊢ e.functor.map (e.unitIso.hom.app X ≫ iso.hom.app (e.functor.obj X)) ≫
      e.functor.map (iso.inv.app (e.functor.obj X)) ≫ e.counitIso.hom.app (e.functor.obj X) =
    𝟙 (e.functor.obj X)
state_after: no goals
tactic: rw [← map_comp_assoc, assoc, iso.hom_inv_id_app, comp_id, functor_unit_comp]
Theorem: List.prev_cons_cons_eq'
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y z : α
h : x ∈ y :: z :: l
hx : x = y
⊢ (y :: z :: l).prev x h = (z :: l).getLast ⋯
state_after: no goals
tactic: rw [prev, dif_pos hx]
Theorem: cfcₙ_apply
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f g : R → R
a : A
hf : autoParam (ContinuousOn f (σₙ R a)) _auto✝
hf0 : autoParam (f 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfcₙ f a = (cfcₙHom ha) { toFun := (σₙ R a).restrict f, continuous_toFun := ⋯, map_zero' := hf0 }
state_after: no goals
tactic: rw [cfcₙ_def, dif_pos ⟨ha, hf, hf0⟩]
Theorem: EuclideanGeometry.angle_eq_angle_of_angle_eq_pi_of_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁ p₂ p1 p2 p3 p4 p5 : P
hapc : ∠ p1 p5 p3 = π
hbpd : ∠ p2 p5 p4 = π
⊢ ∠ p1 p5 p2 = ∠ p3 p5 p4
state_after: no goals
tactic: linarith [angle_add_angle_eq_pi_of_angle_eq_pi p1 hbpd, angle_comm p4 p5 p1,
    angle_add_angle_eq_pi_of_angle_eq_pi p4 hapc, angle_comm p4 p5 p3]
Theorem: Int.natMod_lt
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n✝ : ℤ
n : ℕ
hn : n ≠ 0
⊢ 0 < ↑n
state_after: no goals
tactic: omega
Theorem: DiscreteQuotient.proj_bot_inj
File: Mathlib/Topology/DiscreteQuotient.lean

Proof steps:
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
S : DiscreteQuotient X
inst✝ : DiscreteTopology X
x y : X
⊢ ⊥.proj x = ⊥.proj y ↔ x = y
state_after: no goals
tactic: simp
Theorem: intervalIntegrable_inv_iff
File: Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean

Proof steps:
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a b : ℝ
⊢ IntervalIntegrable (fun x => x⁻¹) volume a b ↔ a = b ∨ 0 ∉ [[a, b]]
state_after: no goals
tactic: simp only [← intervalIntegrable_sub_inv_iff, sub_zero]
Theorem: Submodule.map_op_mul
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ map (↑(opLinearEquiv R)) (M * N) = map (↑(opLinearEquiv R)) N * map (↑(opLinearEquiv R)) M
state_after: case a
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ map (↑(opLinearEquiv R)) (M * N) ≤ map (↑(opLinearEquiv R)) N * map (↑(opLinearEquiv R)) M

case a
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ map (↑(opLinearEquiv R)) N * map (↑(opLinearEquiv R)) M ≤ map (↑(opLinearEquiv R)) (M * N)
tactic: apply le_antisymm
Theorem: FirstOrder.Language.Substructure.cg_iff_empty_or_exists_nat_generating_family
File: Mathlib/ModelTheory/FinitelyGenerated.lean

Proof steps:
state_before: L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ N.CG ↔ ↑N = ∅ ∨ ∃ s, (closure L).toFun (range s) = N
state_after: L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ S, S.Countable ∧ (closure L).toFun S = N) ↔ ↑N = ∅ ∨ ∃ s, (closure L).toFun (range s) = N
tactic: rw [cg_def]
state_before: L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ S, S.Countable ∧ (closure L).toFun S = N) ↔ ↑N = ∅ ∨ ∃ s, (closure L).toFun (range s) = N
state_after: case mp
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ S, S.Countable ∧ (closure L).toFun S = N) → ↑N = ∅ ∨ ∃ s, (closure L).toFun (range s) = N

case mpr
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (↑N = ∅ ∨ ∃ s, (closure L).toFun (range s) = N) → ∃ S, S.Countable ∧ (closure L).toFun S = N
tactic: constructor