ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: minimals_Ico
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
inst✝ : PartialOrder α
a b : α
hab : a < b
⊢ minimals (fun x x_1 => x ≤ x_1) (Ico a b) = {a}
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
inst✝ : PartialOrder α
a b : α
hab : a < b
⊢ minimals (fun x x_1 => x ≤ x_1) {x | x < b ∧ a ≤ x} = {a}
tactic: simp_rw [Ico, and_comm (a := _ ≤ _)]
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
inst✝ : PartialOrder α
a b : α
hab : a < b
⊢ minimals (fun x x_1 => x ≤ x_1) {x | x < b ∧ a ≤ x} = {a}
state_after: no goals
tactic: exact maximals_Ioc (α := αᵒᵈ) hab
Theorem: MeasureTheory.L1.setToL1_smul
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
hT : DominatedFinMeasAdditive μ T C
h_smul : ∀ (c : 𝕜) (s : Set α) (x : E), (T s) (c • x) = c • (T s) x
c : 𝕜
f : ↥(Lp E 1 μ)
⊢ (setToL1 hT) (c • f) = c • (setToL1 hT) f
state_after: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
hT : DominatedFinMeasAdditive μ T C
h_smul : ∀ (c : 𝕜) (s : Set α) (x : E), (T s) (c • x) = c • (T s) x
c : 𝕜
f : ↥(Lp E 1 μ)
⊢ (setToL1' 𝕜 hT h_smul) (c • f) = c • (setToL1' 𝕜 hT h_smul) f
tactic: rw [setToL1_eq_setToL1' hT h_smul, setToL1_eq_setToL1' hT h_smul]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
hT : DominatedFinMeasAdditive μ T C
h_smul : ∀ (c : 𝕜) (s : Set α) (x : E), (T s) (c • x) = c • (T s) x
c : 𝕜
f : ↥(Lp E 1 μ)
⊢ (setToL1' 𝕜 hT h_smul) (c • f) = c • (setToL1' 𝕜 hT h_smul) f
state_after: no goals
tactic: exact ContinuousLinearMap.map_smul _ _ _
Theorem: Finset.le_card_add_mul_mulEnergy
File: Mathlib/Combinatorics/Additive/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ s.card ^ 2 * t.card ^ 2 =
    (filter
          (fun x =>
            match x with
            | (a, b) => a * b ∈ s * t)
          (s ×ˢ t)).card ^
      2
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ ∀ x ∈ s ×ˢ t,
    match x with
    | (a, b) => a * b ∈ s * t
tactic: rw [filter_eq_self.2, card_product, mul_pow]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ ∀ x ∈ s ×ˢ t,
    match x with
    | (a, b) => a * b ∈ s * t
state_after: no goals
tactic: aesop (add unsafe mul_mem_mul)
Theorem: NumberField.InfinitePlace.isReal_of_mk_isReal
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
φ : K →+* ℂ
h : (mk φ).IsReal
⊢ ComplexEmbedding.IsReal φ
state_after: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
φ : K →+* ℂ
h : ¬ComplexEmbedding.IsReal φ
⊢ ¬(mk φ).IsReal
tactic: contrapose! h
state_before: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
φ : K →+* ℂ
h : ¬ComplexEmbedding.IsReal φ
⊢ ¬(mk φ).IsReal
state_after: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
φ : K →+* ℂ
h : ¬ComplexEmbedding.IsReal φ
⊢ (mk φ).IsComplex
tactic: rw [not_isReal_iff_isComplex]
state_before: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
φ : K →+* ℂ
h : ¬ComplexEmbedding.IsReal φ
⊢ (mk φ).IsComplex
state_after: no goals
tactic: exact ⟨φ, h, rfl⟩
Theorem: Ideal.mul_sub_mul_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ a * c - b * d ∈ I
state_after: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ (a - b) * c + b * (c - d) ∈ I
tactic: rw [show a * c - b * d = (a - b) * c + b * (c - d) by rw [sub_mul, mul_sub]; abel]
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ (a - b) * c + b * (c - d) ∈ I
state_after: no goals
tactic: exact I.add_mem (I.mul_mem_right _ h1) (I.mul_mem_left _ h2)
Theorem: Finset.product_eq_empty
File: Mathlib/Data/Finset/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ s' : Finset α
t✝ t' : Finset β
a : α
b : β
s : Finset α
t : Finset β
⊢ s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅
state_after: no goals
tactic: rw [← not_nonempty_iff_eq_empty, nonempty_product, not_and_or, not_nonempty_iff_eq_empty,
    not_nonempty_iff_eq_empty]
Theorem: IsUnit.mul_right_dvd
File: Mathlib/Algebra/Divisibility/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a b u : α
hu : IsUnit u
⊢ a * u ∣ b ↔ a ∣ b
state_after: case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ a * ↑u ∣ b ↔ a ∣ b
tactic: rcases hu with ⟨u, rfl⟩
state_before: case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ a * ↑u ∣ b ↔ a ∣ b
state_after: no goals
tactic: apply Units.mul_right_dvd
Theorem: Quiver.reverse_inj
File: Mathlib/Combinatorics/Quiver/Symmetric.lean

Proof steps:
state_before: U : Type u_1
V : Type u_2
W : Type u_3
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h : HasInvolutiveReverse V
a b : V
f g : a ⟶ b
⊢ reverse f = reverse g ↔ f = g
state_after: case mp
U : Type u_1
V : Type u_2
W : Type u_3
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h : HasInvolutiveReverse V
a b : V
f g : a ⟶ b
⊢ reverse f = reverse g → f = g

case mpr
U : Type u_1
V : Type u_2
W : Type u_3
inst✝² : Quiver U
inst✝¹ : Quiver V
inst✝ : Quiver W
h : HasInvolutiveReverse V
a b : V
f g : a ⟶ b
⊢ f = g → reverse f = reverse g
tactic: constructor
Theorem: Orthonormal.inner_right_finsupp
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
ι : Type u_4
v : ι → E
hv : Orthonormal 𝕜 v
l : ι →₀ 𝕜
i : ι
⊢ ⟪v i, (Finsupp.total ι E 𝕜 v) l⟫_𝕜 = l i
state_after: no goals
tactic: classical
  simpa [Finsupp.total_apply, Finsupp.inner_sum, orthonormal_iff_ite.mp hv] using Eq.symm
Theorem: Fintype.sum_dite_eq
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι✝ : Type u_1
κ✝ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝³ : Fintype ι
inst✝² : Fintype κ
inst✝¹ : CommMonoid α
inst✝ : DecidableEq ι
i : ι
f : (j : ι) → i = j → α
⊢ (∏ j : ι, if h : i = j then f j h else 1) = f i ⋯
state_after: no goals
tactic: rw [Finset.prod_dite_eq, if_pos (mem_univ _)]
Theorem: List.zipWith_swap_prod_support'
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ l l' : List α
x✝ : α
h : x✝ ∈ {x | (zipWith swap l l').prod x ≠ x}
⊢ x✝ ∈ ↑(l.toFinset ⊔ l'.toFinset)
state_after: no goals
tactic: simpa using mem_or_mem_of_zipWith_swap_prod_ne h
Theorem: WittVector.mul_polyOfInterest_aux1
File: Mathlib/RingTheory/WittVector/MulCoeff.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ∑ i ∈ range (n + 1), ↑p ^ i * wittMul p i ^ p ^ (n - i) = wittPolyProd p n
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ∑ i ∈ range (n + 1), ↑p ^ i * wittMul p i ^ p ^ (n - i) =
    (rename (Prod.mk 0)) (wittPolynomial p ℤ n) * (rename (Prod.mk 1)) (wittPolynomial p ℤ n)
tactic: simp only [wittPolyProd]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ∑ i ∈ range (n + 1), ↑p ^ i * wittMul p i ^ p ^ (n - i) =
    (rename (Prod.mk 0)) (wittPolynomial p ℤ n) * (rename (Prod.mk 1)) (wittPolynomial p ℤ n)
state_after: case h.e'_2
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ∑ i ∈ range (n + 1), ↑p ^ i * wittMul p i ^ p ^ (n - i) =
    (bind₁ (wittStructureInt p (X 0 * X 1))) (wittPolynomial p ℤ n)

case h.e'_3
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ (rename (Prod.mk 0)) (wittPolynomial p ℤ n) * (rename (Prod.mk 1)) (wittPolynomial p ℤ n) =
    (bind₁ fun i => (rename (Prod.mk i)) (wittPolynomial p ℤ n)) (X 0 * X 1)
tactic: convert wittStructureInt_prop p (X (0 : Fin 2) * X 1) n using 1
Theorem: Cardinal.mul_eq_max'
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b : Cardinal.{u_1}
h : ℵ₀ ≤ a * b
⊢ a * b = max a b
state_after: case intro.intro.inl
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a * b
ha : a ≠ 0
hb : b ≠ 0
ha' : ℵ₀ ≤ a
⊢ a * b = max a b

case intro.intro.inr
a b : Cardinal.{u_1}
h : ℵ₀ ≤ a * b
ha : a ≠ 0
hb : b ≠ 0
hb' : ℵ₀ ≤ b
⊢ a * b = max a b
tactic: rcases aleph0_le_mul_iff.mp h with ⟨ha, hb, ha' | hb'⟩
Theorem: AlgebraicGeometry.morphismRestrict_appLE
File: Mathlib/AlgebraicGeometry/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X Y : Scheme
f : X ⟶ Y
U : Y.Opens
V : (↑U).Opens
W : (↑(f ⁻¹ᵁ U)).Opens
e : W ≤ (f ∣_ U) ⁻¹ᵁ V
⊢ Scheme.Hom.appLE (f ∣_ U) V W e = Scheme.Hom.appLE f (U.ι ''ᵁ V) ((f ⁻¹ᵁ U).ι ''ᵁ W) ⋯
state_after: no goals
tactic: rw [Scheme.Hom.appLE, morphismRestrict_app', Scheme.Opens.toScheme_presheaf_map,
    Scheme.Hom.appLE_map]
Theorem: Computation.map_comp
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ map (g ∘ f) ⟨s, al⟩ = map g (map f ⟨s, al⟩)
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ ↑(map (g ∘ f) ⟨s, al⟩) = ↑(map g (map f ⟨s, al⟩))
tactic: apply Subtype.eq
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ ↑(map (g ∘ f) ⟨s, al⟩) = ↑(map g (map f ⟨s, al⟩))
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ Stream'.map (fun o => Option.rec none (fun val => some (g (f val))) o) s =
    Stream'.map
      ((fun o => Option.rec none (fun val => some (g val)) o) ∘ fun o => Option.rec none (fun val => some (f val)) o) s
tactic: dsimp [map]
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ Stream'.map (fun o => Option.rec none (fun val => some (g (f val))) o) s =
    Stream'.map
      ((fun o => Option.rec none (fun val => some (g val)) o) ∘ fun o => Option.rec none (fun val => some (f val)) o) s
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ (fun o => Option.rec none (fun val => some (g (f val))) o) =
    (fun o => Option.rec none (fun val => some (g val)) o) ∘ fun o => Option.rec none (fun val => some (f val)) o
tactic: apply congr_arg fun f : _ → Option γ => Stream'.map f s
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ (fun o => Option.rec none (fun val => some (g (f val))) o) =
    (fun o => Option.rec none (fun val => some (g val)) o) ∘ fun o => Option.rec none (fun val => some (f val)) o
state_after: no goals
tactic: ext ⟨⟩ <;> rfl
Theorem: Finset.mem_diag
File: Mathlib/Data/Finset/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
⊢ x ∈ s.diag ↔ x.1 ∈ s ∧ x.1 = x.2
state_after: no goals
tactic: simp (config := { contextual := true }) [diag]
Theorem: intrinsicFrontier_union_intrinsicInterior
File: Mathlib/Analysis/Convex/Intrinsic.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s✝ t : Set P
x : P
s : Set P
⊢ intrinsicFrontier 𝕜 s ∪ intrinsicInterior 𝕜 s = intrinsicClosure 𝕜 s
state_after: no goals
tactic: rw [union_comm, intrinsicInterior_union_intrinsicFrontier]
Theorem: HomologicalComplex₂.totalFlipIsoX_hom_D₁
File: Mathlib/Algebra/Homology/TotalComplexSymmetry.lean

Proof steps:
state_before: C : Type u_1
I₁ : Type u_2
I₂ : Type u_3
J : Type u_4
inst✝⁷ : Category.{u_5, u_1} C
inst✝⁶ : Preadditive C
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
c : ComplexShape J
inst✝⁵ : TotalComplexShape c₁ c₂ c
inst✝⁴ : TotalComplexShape c₂ c₁ c
inst✝³ : TotalComplexShapeSymmetry c₁ c₂ c
inst✝² : K.HasTotal c
inst✝¹ : K.flip.HasTotal c
inst✝ : DecidableEq J
j j' : J
⊢ (K.totalFlipIsoX c j).hom ≫ K.D₁ c j j' = K.flip.D₂ c j j' ≫ (K.totalFlipIsoX c j').hom
state_after: case pos
C : Type u_1
I₁ : Type u_2
I₂ : Type u_3
J : Type u_4
inst✝⁷ : Category.{u_5, u_1} C
inst✝⁶ : Preadditive C
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
c : ComplexShape J
inst✝⁵ : TotalComplexShape c₁ c₂ c
inst✝⁴ : TotalComplexShape c₂ c₁ c
inst✝³ : TotalComplexShapeSymmetry c₁ c₂ c
inst✝² : K.HasTotal c
inst✝¹ : K.flip.HasTotal c
inst✝ : DecidableEq J
j j' : J
h₀ : c.Rel j j'
⊢ (K.totalFlipIsoX c j).hom ≫ K.D₁ c j j' = K.flip.D₂ c j j' ≫ (K.totalFlipIsoX c j').hom

case neg
C : Type u_1
I₁ : Type u_2
I₂ : Type u_3
J : Type u_4
inst✝⁷ : Category.{u_5, u_1} C
inst✝⁶ : Preadditive C
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
c : ComplexShape J
inst✝⁵ : TotalComplexShape c₁ c₂ c
inst✝⁴ : TotalComplexShape c₂ c₁ c
inst✝³ : TotalComplexShapeSymmetry c₁ c₂ c
inst✝² : K.HasTotal c
inst✝¹ : K.flip.HasTotal c
inst✝ : DecidableEq J
j j' : J
h₀ : ¬c.Rel j j'
⊢ (K.totalFlipIsoX c j).hom ≫ K.D₁ c j j' = K.flip.D₂ c j j' ≫ (K.totalFlipIsoX c j').hom
tactic: by_cases h₀ : c.Rel j j'
Theorem: AddCommGrp.HasLimit.productLimitCone_cone_π
File: Mathlib/Algebra/Category/Grp/Biproducts.lean

Proof steps:
state_before: J : Type w
f : J → AddCommGrp
s : Cone (Discrete.functor f)
m :
  s.pt ⟶ { pt := of ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as }.pt
w :
  ∀ (j : Discrete J),
    m ≫
        { pt := of ((j : J) → ↑(f j)),
                π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as }.π.app
          j =
      s.π.app j
⊢ m = lift f s
state_after: case w
J : Type w
f : J → AddCommGrp
s : Cone (Discrete.functor f)
m :
  s.pt ⟶ { pt := of ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as }.pt
w :
  ∀ (j : Discrete J),
    m ≫
        { pt := of ((j : J) → ↑(f j)),
                π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as }.π.app
          j =
      s.π.app j
x : ↑s.pt
⊢ m x = (lift f s) x
tactic: ext x
state_before: case w
J : Type w
f : J → AddCommGrp
s : Cone (Discrete.functor f)
m :
  s.pt ⟶ { pt := of ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as }.pt
w :
  ∀ (j : Discrete J),
    m ≫
        { pt := of ((j : J) → ↑(f j)),
                π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as }.π.app
          j =
      s.π.app j
x : ↑s.pt
⊢ m x = (lift f s) x
state_after: case w.h
J : Type w
f : J → AddCommGrp
s : Cone (Discrete.functor f)
m :
  s.pt ⟶ { pt := of ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as }.pt
w :
  ∀ (j : Discrete J),
    m ≫
        { pt := of ((j : J) → ↑(f j)),
                π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as }.π.app
          j =
      s.π.app j
x : ↑s.pt
j : J
⊢ m x j = (lift f s) x j
tactic: funext j
state_before: case w.h
J : Type w
f : J → AddCommGrp
s : Cone (Discrete.functor f)
m :
  s.pt ⟶ { pt := of ((j : J) → ↑(f j)), π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as }.pt
w :
  ∀ (j : Discrete J),
    m ≫
        { pt := of ((j : J) → ↑(f j)),
                π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => ↑(f j)) j.as }.π.app
          j =
      s.π.app j
x : ↑s.pt
j : J
⊢ m x j = (lift f s) x j
state_after: no goals
tactic: exact congr_arg (fun g : s.pt ⟶ f j => (g : s.pt → f j) x) (w ⟨j⟩)
Theorem: Polynomial.trailingDegree_eq_iff_natTrailingDegree_eq
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
hp : p ≠ 0
⊢ p.trailingDegree = ↑n ↔ p.natTrailingDegree = n
state_after: no goals
tactic: rw [trailingDegree_eq_natTrailingDegree hp, Nat.cast_inj]
Theorem: WeierstrassCurve.Ψ_even
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
m : ℕ
⊢ W.Ψ (2 * (↑m + 3)) * W.ψ₂ =
    W.Ψ (↑m + 2) ^ 2 * W.Ψ (↑m + 3) * W.Ψ (↑m + 5) - W.Ψ (↑m + 1) * W.Ψ (↑m + 3) * W.Ψ (↑m + 4) ^ 2
state_after: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
m : ℕ
⊢ (C (W.preΨ' (2 * (m + 3))) * if Even (2 * (m + 3)) then W.ψ₂ else 1) * W.ψ₂ =
    (C (W.preΨ' (m + 2)) * if Even (m + 2) then W.ψ₂ else 1) ^ 2 *
          (C (W.preΨ' (m + 3)) * if Even (m + 3) then W.ψ₂ else 1) *
        (C (W.preΨ' (m + 5)) * if Even (m + 5) then W.ψ₂ else 1) -
      (C (W.preΨ' (m + 1)) * if Even (m + 1) then W.ψ₂ else 1) *
          (C (W.preΨ' (m + 3)) * if Even (m + 3) then W.ψ₂ else 1) *
        (C (W.preΨ' (m + 4)) * if Even (m + 4) then W.ψ₂ else 1) ^ 2
tactic: repeat erw [Ψ_ofNat]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
m : ℕ
⊢ (C (W.preΨ' (2 * (m + 3))) * if Even (2 * (m + 3)) then W.ψ₂ else 1) * W.ψ₂ =
    (C (W.preΨ' (m + 2)) * if Even (m + 2) then W.ψ₂ else 1) ^ 2 *
          (C (W.preΨ' (m + 3)) * if Even (m + 3) then W.ψ₂ else 1) *
        (C (W.preΨ' (m + 5)) * if Even (m + 5) then W.ψ₂ else 1) -
      (C (W.preΨ' (m + 1)) * if Even (m + 1) then W.ψ₂ else 1) *
          (C (W.preΨ' (m + 3)) * if Even (m + 3) then W.ψ₂ else 1) *
        (C (W.preΨ' (m + 4)) * if Even (m + 4) then W.ψ₂ else 1) ^ 2
state_after: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
m : ℕ
⊢ C
          (W.preΨ' (m + 2) ^ 2 * W.preΨ' (m + 3) * W.preΨ' (m + 5) -
            W.preΨ' (m + 1) * W.preΨ' (m + 3) * W.preΨ' (m + 4) ^ 2) *
        W.ψ₂ *
      W.ψ₂ =
    (C (W.preΨ' (m + 2)) * if Even m then W.ψ₂ else 1) ^ 2 * (C (W.preΨ' (m + 3)) * if Even m then 1 else W.ψ₂) *
        (C (W.preΨ' (m + 5)) * if Even m then 1 else W.ψ₂) -
      (C (W.preΨ' (m + 1)) * if Even m then 1 else W.ψ₂) * (C (W.preΨ' (m + 3)) * if Even m then 1 else W.ψ₂) *
        (C (W.preΨ' (m + 4)) * if Even m then W.ψ₂ else 1) ^ 2
tactic: simp_rw [preΨ'_even, if_pos <| even_two_mul _, Nat.even_add_one, ite_not]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
m : ℕ
⊢ C
          (W.preΨ' (m + 2) ^ 2 * W.preΨ' (m + 3) * W.preΨ' (m + 5) -
            W.preΨ' (m + 1) * W.preΨ' (m + 3) * W.preΨ' (m + 4) ^ 2) *
        W.ψ₂ *
      W.ψ₂ =
    (C (W.preΨ' (m + 2)) * if Even m then W.ψ₂ else 1) ^ 2 * (C (W.preΨ' (m + 3)) * if Even m then 1 else W.ψ₂) *
        (C (W.preΨ' (m + 5)) * if Even m then 1 else W.ψ₂) -
      (C (W.preΨ' (m + 1)) * if Even m then 1 else W.ψ₂) * (C (W.preΨ' (m + 3)) * if Even m then 1 else W.ψ₂) *
        (C (W.preΨ' (m + 4)) * if Even m then W.ψ₂ else 1) ^ 2
state_after: no goals
tactic: split_ifs <;> C_simp <;> ring1
Theorem: MeasureTheory.exists_pair_mem_lattice_not_disjoint_vadd
File: Mathlib/MeasureTheory/Group/GeometryOfNumbers.lean

Proof steps:
state_before: E : Type u_1
L : Type u_2
inst✝⁶ : MeasurableSpace E
μ : Measure E
F s : Set E
inst✝⁵ : AddCommGroup L
inst✝⁴ : Countable L
inst✝³ : AddAction L E
inst✝² : MeasurableSpace L
inst✝¹ : MeasurableVAdd L E
inst✝ : VAddInvariantMeasure L E μ
fund : IsAddFundamentalDomain L F μ
hS : NullMeasurableSet s μ
h : μ F < μ s
⊢ ∃ x y, x ≠ y ∧ ¬Disjoint (x +ᵥ s) (y +ᵥ s)
state_after: E : Type u_1
L : Type u_2
inst✝⁶ : MeasurableSpace E
μ : Measure E
F s : Set E
inst✝⁵ : AddCommGroup L
inst✝⁴ : Countable L
inst✝³ : AddAction L E
inst✝² : MeasurableSpace L
inst✝¹ : MeasurableVAdd L E
inst✝ : VAddInvariantMeasure L E μ
fund : IsAddFundamentalDomain L F μ
hS : NullMeasurableSet s μ
h : ∀ (x y : L), x ≠ y → Disjoint (x +ᵥ s) (y +ᵥ s)
⊢ μ s ≤ μ F
tactic: contrapose! h
state_before: E : Type u_1
L : Type u_2
inst✝⁶ : MeasurableSpace E
μ : Measure E
F s : Set E
inst✝⁵ : AddCommGroup L
inst✝⁴ : Countable L
inst✝³ : AddAction L E
inst✝² : MeasurableSpace L
inst✝¹ : MeasurableVAdd L E
inst✝ : VAddInvariantMeasure L E μ
fund : IsAddFundamentalDomain L F μ
hS : NullMeasurableSet s μ
h : ∀ (x y : L), x ≠ y → Disjoint (x +ᵥ s) (y +ᵥ s)
⊢ μ s ≤ μ F
state_after: no goals
tactic: exact ((fund.measure_eq_tsum _).trans (measure_iUnion₀
    (Pairwise.mono h fun i j hij => (hij.mono inf_le_left inf_le_left).aedisjoint)
      fun _ => (hS.vadd _).inter fund.nullMeasurableSet).symm).trans_le
      (measure_mono <| Set.iUnion_subset fun _ => Set.inter_subset_right)
Theorem: Turing.TM1to0.tr_supports
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝³ : Inhabited Γ
Λ : Type u_2
inst✝² : Inhabited Λ
σ : Type u_3
inst✝¹ : Inhabited σ
M : Λ → Stmt₁
inst✝ : Fintype σ
S : Finset Λ
ss : TM1.Supports M S
⊢ TM0.Supports (tr M) ↑(trStmts M S)
state_after: case left
Γ : Type u_1
inst✝³ : Inhabited Γ
Λ : Type u_2
inst✝² : Inhabited Λ
σ : Type u_3
inst✝¹ : Inhabited σ
M : Λ → Stmt₁
inst✝ : Fintype σ
S : Finset Λ
ss : TM1.Supports M S
⊢ default ∈ ↑(trStmts M S)

case right
Γ : Type u_1
inst✝³ : Inhabited Γ
Λ : Type u_2
inst✝² : Inhabited Λ
σ : Type u_3
inst✝¹ : Inhabited σ
M : Λ → Stmt₁
inst✝ : Fintype σ
S : Finset Λ
ss : TM1.Supports M S
⊢ ∀ {q : Λ'₁₀} {a : Γ} {q' : Λ'₁₀} {s : Stmt₀}, (q', s) ∈ tr M q a → q ∈ ↑(trStmts M S) → q' ∈ ↑(trStmts M S)
tactic: constructor
Theorem: Multiset.toFinsupp_inter
File: Mathlib/Data/Finsupp/Multiset.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
s t : Multiset α
⊢ toFinsupp (s ∩ t) = toFinsupp s ⊓ toFinsupp t
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
s t : Multiset α
a✝ : α
⊢ (toFinsupp (s ∩ t)) a✝ = (toFinsupp s ⊓ toFinsupp t) a✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
s t : Multiset α
a✝ : α
⊢ (toFinsupp (s ∩ t)) a✝ = (toFinsupp s ⊓ toFinsupp t) a✝
state_after: no goals
tactic: simp [inf_eq_min]