ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Int.fract_eq_iff
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : fract a = b
⊢ 0 ≤ b ∧ b < 1 ∧ ∃ z, a - b = ↑z
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : fract a = b
⊢ 0 ≤ fract a ∧ fract a < 1 ∧ ∃ z, a - fract a = ↑z
tactic: rw [← h]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : fract a = b
⊢ 0 ≤ fract a ∧ fract a < 1 ∧ ∃ z, a - fract a = ↑z
state_after: no goals
tactic: exact ⟨fract_nonneg _, fract_lt_one _, ⟨⌊a⌋, sub_sub_cancel _ _⟩⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ (0 ≤ b ∧ b < 1 ∧ ∃ z, a - b = ↑z) → fract a = b
state_after: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
h₀ : 0 ≤ b
h₁ : b < 1
z : ℤ
hz : a - b = ↑z
⊢ fract a = b
tactic: rintro ⟨h₀, h₁, z, hz⟩
state_before: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
h₀ : 0 ≤ b
h₁ : b < 1
z : ℤ
hz : a - b = ↑z
⊢ fract a = b
state_after: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
h₀ : 0 ≤ b
h₁ : b < 1
z : ℤ
hz : a - b = ↑z
⊢ a - b ≤ a ∧ a < a - b + 1
tactic: rw [← self_sub_floor, eq_comm, eq_sub_iff_add_eq, add_comm, ← eq_sub_iff_add_eq, hz,
      Int.cast_inj, floor_eq_iff, ← hz]
state_before: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
h₀ : 0 ≤ b
h₁ : b < 1
z : ℤ
hz : a - b = ↑z
⊢ a - b ≤ a ∧ a < a - b + 1
state_after: no goals
tactic: constructor <;> simpa [sub_eq_add_neg, add_assoc]
Theorem: AffineSubspace.midpoint_mem_perpBisector
File: Mathlib/Geometry/Euclidean/PerpBisector.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
c c₁ c₂ p₁✝ p₂✝ p₁ p₂ : P
⊢ midpoint ℝ p₁ p₂ ∈ perpBisector p₁ p₂
state_after: no goals
tactic: simp [mem_perpBisector_iff_inner_eq_zero]
Theorem: IsCyclotomicExtension.discr_prime_pow_ne_two'
File: Mathlib/NumberTheory/Cyclotomic/Discriminant.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
L : Type v
ζ : L
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} K L
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
hirr : Irreducible (cyclotomic (↑(p ^ (k + 1))) K)
hk : p ^ (k + 1) ≠ 2
⊢ discr K ⇑(IsPrimitiveRoot.powerBasis K hζ).basis =
    (-1) ^ (↑p ^ k * (↑p - 1) / 2) * ↑↑p ^ (↑p ^ k * ((↑p - 1) * (k + 1) - 1))
state_after: no goals
tactic: simpa [totient_prime_pow hp.out (succ_pos k)] using discr_prime_pow_ne_two hζ hirr hk
Theorem: BddOrd.Iso.mk_hom
File: Mathlib/Order/Category/BddOrd.lean

Proof steps:
state_before: α β : BddOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
⊢ ↑e ≫ ↑e.symm = 𝟙 α
state_after: case w
α β : BddOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
x✝ : (forget BddOrd).obj α
⊢ (↑e ≫ ↑e.symm) x✝ = (𝟙 α) x✝
tactic: ext
state_before: case w
α β : BddOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
x✝ : (forget BddOrd).obj α
⊢ (↑e ≫ ↑e.symm) x✝ = (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : BddOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
⊢ ↑e.symm ≫ ↑e = 𝟙 β
state_after: case w
α β : BddOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
x✝ : (forget BddOrd).obj β
⊢ (↑e.symm ≫ ↑e) x✝ = (𝟙 β) x✝
tactic: ext
state_before: case w
α β : BddOrd
e : ↑α.toPartOrd ≃o ↑β.toPartOrd
x✝ : (forget BddOrd).obj β
⊢ (↑e.symm ≫ ↑e) x✝ = (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: Int.bitwise_or
File: Mathlib/Data/Int/Bitwise.lean

Proof steps:
state_before: ⊢ bitwise or = lor
state_after: case h.h
m n : ℤ
⊢ bitwise or m n = m.lor n
tactic: funext m n
state_before: case h.h
m n : ℤ
⊢ bitwise or m n = m.lor n
state_after: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !(x || !y)) m n = Nat.bitwise (fun a b => a && !b) n m

case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise (fun x y => !(!x || y)) m n = Nat.bitwise (fun a b => a && !b) m n

case h.h.negSucc.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !(!x || !y)) m n = m &&& n
tactic: cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
Theorem: CategoryTheory.Limits.opCompYonedaSectionsEquiv_apply_app
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.95502, u_1} J
inst✝ : Category.{?u.96011, u_2} C
F : J ⥤ C
X : C
s : ↑(F.op ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ (fun j => ↑s (op j)) j' = (fun j => ↑s (op j)) j ≫ ((const J).obj X).map f
state_after: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.95502, u_1} J
inst✝ : Category.{?u.96011, u_2} C
F : J ⥤ C
X : C
s : ↑(F.op ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ ↑s (op j') = ↑s (op j) ≫ 𝟙 X
tactic: dsimp
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.95502, u_1} J
inst✝ : Category.{?u.96011, u_2} C
F : J ⥤ C
X : C
s : ↑(F.op ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ ↑s (op j') = ↑s (op j) ≫ 𝟙 X
state_after: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.95502, u_1} J
inst✝ : Category.{?u.96011, u_2} C
F : J ⥤ C
X : C
s : ↑(F.op ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ ↑s (op j') = ↑s (op j)
tactic: rw [Category.comp_id]
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.95502, u_1} J
inst✝ : Category.{?u.96011, u_2} C
F : J ⥤ C
X : C
s : ↑(F.op ⋙ yoneda.obj X).sections
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ ↑s (op j') = ↑s (op j)
state_after: no goals
tactic: exact (s.property f.op)
state_before: J : Type u_1
C : Type u_2
inst✝¹ : Category.{?u.95502, u_1} J
inst✝ : Category.{?u.96011, u_2} C
F : J ⥤ C
X : C
τ : F ⟶ (const J).obj X
j j' : Jᵒᵖ
f : j ⟶ j'
⊢ (F.op ⋙ yoneda.obj X).map f ((fun j => τ.app (unop j)) j) = (fun j => τ.app (unop j)) j'
state_after: no goals
tactic: simp [τ.naturality f.unop]
Theorem: Nat.minFac_eq_two_iff
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n✝ n : ℕ
⊢ n.minFac = 2 ↔ 2 ∣ n
state_after: case mp
n✝ n : ℕ
⊢ n.minFac = 2 → 2 ∣ n

case mpr
n✝ n : ℕ
⊢ 2 ∣ n → n.minFac = 2
tactic: constructor
Theorem: _private.Mathlib.Data.Nat.Choose.Basic.0.Nat.choose_le_middle_of_le_half_left
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: n r : ℕ
hr : r ≤ n / 2
⊢ n.choose r ≤ n.choose (n / 2)
state_after: no goals
tactic: induction hr using decreasingInduction with
  | self => rfl
  | of_succ k hk ih => exact (choose_le_succ_of_lt_half_left hk).trans ih
Theorem: SetTheory.PGame.birthday_zero_add
File: Mathlib/SetTheory/Game/Birthday.lean

Proof steps:
state_before: a b x : PGame
⊢ (0 + a).birthday = a.birthday
state_after: no goals
tactic: simp
Theorem: FormalMultilinearSeries.rightInv_coeff_zero
File: Mathlib/Analysis/Analytic/Inverse.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
⊢ p.rightInv i 0 = 0
state_after: no goals
tactic: rw [rightInv]
Theorem: IsPrimitiveRoot.card_nthRootsFinset
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h✝ : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ (nthRootsFinset n R).card = n
state_after: no goals
tactic: rw [nthRootsFinset, ← Multiset.toFinset_eq (nthRoots_one_nodup h), card_mk, h.card_nthRoots_one]
Theorem: HomologicalComplex.shortExact_iff_degreewise_shortExact
File: Mathlib/Algebra/Homology/HomologicalComplexAbelian.lean

Proof steps:
state_before: C : Type u_1
ι : Type u_2
c : ComplexShape ι
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Abelian C
S : ShortComplex (HomologicalComplex C c)
⊢ S.ShortExact ↔ ∀ (i : ι), (S.map (eval C c i)).ShortExact
state_after: case mp
C : Type u_1
ι : Type u_2
c : ComplexShape ι
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Abelian C
S : ShortComplex (HomologicalComplex C c)
⊢ S.ShortExact → ∀ (i : ι), (S.map (eval C c i)).ShortExact

case mpr
C : Type u_1
ι : Type u_2
c : ComplexShape ι
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Abelian C
S : ShortComplex (HomologicalComplex C c)
⊢ (∀ (i : ι), (S.map (eval C c i)).ShortExact) → S.ShortExact
tactic: constructor
Theorem: String.Iterator.ValidFor.prev_nil
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: r : List Char
it : Iterator
h : ValidFor [] r it
⊢ ValidFor [] r it.prev
state_after: r : List Char
it : Iterator
h : ValidFor [] r it
⊢ ValidFor [] r { s := { data := r }, i := 0 }
tactic: simp only [Iterator.prev, h.toString, List.reverseAux_nil, h.pos, utf8Len_nil,
      Pos.mk_zero, prev_zero]
state_before: r : List Char
it : Iterator
h : ValidFor [] r it
⊢ ValidFor [] r { s := { data := r }, i := 0 }
state_after: no goals
tactic: constructor
Theorem: EuclideanGeometry.oangle_self_left
File: Mathlib/Geometry/Euclidean/Angle/Oriented/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
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ : P
⊢ ∡ p₁ p₁ p₂ = 0
state_after: no goals
tactic: simp [oangle]
Theorem: AntilipschitzWith.injective
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
inst✝⁴ : PseudoEMetricSpace α✝
inst✝³ : PseudoEMetricSpace β✝
inst✝² : PseudoEMetricSpace γ
K✝ : ℝ≥0
f✝ : α✝ → β✝
α : Type u_4
β : Type u_5
inst✝¹ : EMetricSpace α
inst✝ : PseudoEMetricSpace β
K : ℝ≥0
f : α → β
hf : AntilipschitzWith K f
x y : α
h : f x = f y
⊢ x = y
state_after: no goals
tactic: simpa only [h, edist_self, mul_zero, edist_le_zero] using hf x y
Theorem: List.length_splitWrtCompositionAux
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
l : List α
ns : List ℕ
⊢ (l.splitWrtCompositionAux ns).length = ns.length
state_after: case nil
n : ℕ
α : Type u_1
l : List α
⊢ (l.splitWrtCompositionAux []).length = [].length

case cons
n : ℕ
α : Type u_1
head✝ : ℕ
tail✝ : List ℕ
tail_ih✝ : ∀ (l : List α), (l.splitWrtCompositionAux tail✝).length = tail✝.length
l : List α
⊢ (l.splitWrtCompositionAux (head✝ :: tail✝)).length = (head✝ :: tail✝).length
tactic: induction ns generalizing l
Theorem: Equiv.induced_symm
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
t t₁ t₂ : TopologicalSpace α✝
t' : TopologicalSpace β✝
f : α✝ → β✝
g : β✝ → α✝
α : Type u_4
β : Type u_5
e : α ≃ β
⊢ TopologicalSpace.induced ⇑e.symm = TopologicalSpace.coinduced ⇑e
state_after: case h.a.h.a
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
t✝ t₁ t₂ : TopologicalSpace α✝
t' : TopologicalSpace β✝
f : α✝ → β✝
g : β✝ → α✝
α : Type u_4
β : Type u_5
e : α ≃ β
t : TopologicalSpace α
U : Set β
⊢ IsOpen U ↔ IsOpen U
tactic: ext t U
state_before: case h.a.h.a
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
t✝ t₁ t₂ : TopologicalSpace α✝
t' : TopologicalSpace β✝
f : α✝ → β✝
g : β✝ → α✝
α : Type u_4
β : Type u_5
e : α ≃ β
t : TopologicalSpace α
U : Set β
⊢ IsOpen U ↔ IsOpen U
state_after: case h.a.h.a
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
t✝ t₁ t₂ : TopologicalSpace α✝
t' : TopologicalSpace β✝
f : α✝ → β✝
g : β✝ → α✝
α : Type u_4
β : Type u_5
e : α ≃ β
t : TopologicalSpace α
U : Set β
⊢ (∃ t_1, IsOpen t_1 ∧ ⇑e.symm ⁻¹' t_1 = U) ↔ IsOpen (⇑e ⁻¹' U)
tactic: rw [isOpen_induced_iff, isOpen_coinduced]
state_before: case h.a.h.a
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
t✝ t₁ t₂ : TopologicalSpace α✝
t' : TopologicalSpace β✝
f : α✝ → β✝
g : β✝ → α✝
α : Type u_4
β : Type u_5
e : α ≃ β
t : TopologicalSpace α
U : Set β
⊢ (∃ t_1, IsOpen t_1 ∧ ⇑e.symm ⁻¹' t_1 = U) ↔ IsOpen (⇑e ⁻¹' U)
state_after: no goals
tactic: simp only [e.symm.preimage_eq_iff_eq_image, exists_eq_right, ← preimage_equiv_eq_image_symm]
Theorem: Irreducible.degree_le_two
File: Mathlib/Analysis/Complex/Polynomial/Basic.lean

Proof steps:
state_before: p : ℝ[X]
hp : Irreducible p
⊢ p.degree ≤ 2
state_after: case intro
p : ℝ[X]
hp : Irreducible p
z : ℂ
hz : (aeval z) p = 0
⊢ p.degree ≤ 2
tactic: obtain ⟨z, hz⟩ : ∃ z : ℂ, aeval z p = 0 :=
    IsAlgClosed.exists_aeval_eq_zero _ p (degree_pos_of_irreducible hp).ne'
state_before: case intro
p : ℝ[X]
hp : Irreducible p
z : ℂ
hz : (aeval z) p = 0
⊢ p.degree ≤ 2
state_after: no goals
tactic: cases eq_or_ne z.im 0 with
  | inl hz0 =>
    lift z to ℝ using hz0
    erw [aeval_ofReal, RCLike.ofReal_eq_zero] at hz
    exact (degree_eq_one_of_irreducible_of_root hp hz).trans_le one_le_two
  | inr hz0 =>
    obtain ⟨q, rfl⟩ := p.quadratic_dvd_of_aeval_eq_zero_im_ne_zero hz hz0
    have hd : degree (X ^ 2 - C (2 * z.re) * X + C (‖z‖ ^ 2)) = 2 := by
      compute_degree!
    have hq : IsUnit q := by
      refine (of_irreducible_mul hp).resolve_left (mt isUnit_iff_degree_eq_zero.1 ?_)
      rw [hd]
      exact two_ne_zero
    refine (degree_mul_le _ _).trans_eq ?_
    rwa [isUnit_iff_degree_eq_zero.1 hq, add_zero]
Theorem: mul_mul_mul_comm
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✝ : CommSemigroup G
a b c d : G
⊢ a * b * (c * d) = a * c * (b * d)
state_after: no goals
tactic: simp only [mul_left_comm, mul_assoc]
Theorem: Set.biUnion_finsetSigma_univ'
File: Mathlib/Data/Fintype/Sigma.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
inst✝ : (i : ι) → Fintype (κ i)
s : Finset ι
f : (i : ι) → κ i → Set α
⊢ ⋃ i ∈ s, ⋃ j, f i j = ⋃ ij ∈ s.sigma fun x => Finset.univ, f ij.fst ij.snd
state_after: no goals
tactic: aesop
Theorem: MeasureTheory.condexp_neg
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 α
f : α → F'
⊢ μ[-f|m] =ᶠ[ae μ] -μ[f|m]
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 α
f : α → F'
this : Module ℝ (α → F') := Pi.module α (fun x => F') ℝ
⊢ μ[-f|m] =ᶠ[ae μ] -μ[f|m]
tactic: letI : Module ℝ (α → F') := @Pi.module α (fun _ => F') ℝ _ _ fun _ => inferInstance
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 α
f : α → F'
this : Module ℝ (α → F') := Pi.module α (fun x => F') ℝ
⊢ μ[-f|m] =ᶠ[ae μ] -μ[f|m]
state_after: no goals
tactic: calc
    μ[-f|m] = μ[(-1 : ℝ) • f|m] := by rw [neg_one_smul ℝ f]
    _ =ᵐ[μ] (-1 : ℝ) • μ[f|m] := condexp_smul (-1) f
    _ = -μ[f|m] := neg_one_smul ℝ (μ[f|m])
Theorem: TensorProduct.one_gradedMul
File: Mathlib/LinearAlgebra/TensorProduct/Graded/External.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
A : Type u_3
B : Type u_4
inst✝¹¹ : CommSemiring ι
inst✝¹⁰ : Module ι (Additive ℤˣ)
inst✝⁹ : DecidableEq ι
𝒜 : ι → Type u_5
ℬ : ι → Type u_6
inst✝⁸ : CommRing R
inst✝⁷ : (i : ι) → AddCommGroup (𝒜 i)
inst✝⁶ : (i : ι) → AddCommGroup (ℬ i)
inst✝⁵ : (i : ι) → Module R (𝒜 i)
inst✝⁴ : (i : ι) → Module R (ℬ i)
inst✝³ : DirectSum.GRing 𝒜
inst✝² : DirectSum.GRing ℬ
inst✝¹ : DirectSum.GAlgebra R 𝒜
inst✝ : DirectSum.GAlgebra R ℬ
x : (⨁ (i : ι), 𝒜 i) ⊗[R] ⨁ (i : ι), ℬ i
⊢ ((gradedMul R 𝒜 ℬ) 1) x = x
state_after: no goals
tactic: simpa only [RingHom.map_one, one_smul] using algebraMap_gradedMul 𝒜 ℬ 1 x
Theorem: WittVector.verschiebung_shift
File: Mathlib/RingTheory/WittVector/Domain.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
⊢ verschiebung (x.shift k.succ) = x.shift k
state_after: case h.zero
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
⊢ (verschiebung (x.shift k.succ)).coeff 0 = (x.shift k).coeff 0

case h.succ
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
k : ℕ
h : ∀ i < k + 1, x.coeff i = 0
n✝ : ℕ
⊢ (verschiebung (x.shift k.succ)).coeff (n✝ + 1) = (x.shift k).coeff (n✝ + 1)
tactic: ext ⟨j⟩
Theorem: Asymptotics.IsEquivalent.refl
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ u ~[l] u
state_after: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ 0 =o[l] u
tactic: rw [IsEquivalent, sub_self]
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ 0 =o[l] u
state_after: no goals
tactic: exact isLittleO_zero _ _
Theorem: CategoryTheory.FinitaryExtensive.vanKampen
File: Mathlib/CategoryTheory/Extensive.lean

Proof steps:
state_before: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
D : Type u''
inst✝¹ : Category.{v'', u''} D
X Y : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
⊢ IsVanKampenColimit c
state_after: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
D : Type u''
inst✝¹ : Category.{v'', u''} D
X✝ Y : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
⊢ IsVanKampenColimit c
tactic: let X := F.obj ⟨WalkingPair.left⟩
state_before: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
D : Type u''
inst✝¹ : Category.{v'', u''} D
X✝ Y : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
⊢ IsVanKampenColimit c
state_after: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
D : Type u''
inst✝¹ : Category.{v'', u''} D
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
⊢ IsVanKampenColimit c
tactic: let Y := F.obj ⟨WalkingPair.right⟩
state_before: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
D : Type u''
inst✝¹ : Category.{v'', u''} D
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
X : C := F.obj { as := WalkingPair.left }
Y : C := F.obj { as := WalkingPair.right }
this : F = pair X Y
⊢ IsVanKampenColimit c
state_after: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
D : Type u''
inst✝¹ : Category.{v'', u''} D
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
Y X : C
this : F = pair X Y
⊢ IsVanKampenColimit c
tactic: clear_value X Y
state_before: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
D : Type u''
inst✝¹ : Category.{v'', u''} D
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
F : Discrete WalkingPair ⥤ C
c : Cocone F
hc : IsColimit c
Y X : C
this : F = pair X Y
⊢ IsVanKampenColimit c
state_after: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
D : Type u''
inst✝¹ : Category.{v'', u''} D
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
Y X : C
c : Cocone (pair X Y)
hc : IsColimit c
⊢ IsVanKampenColimit c
tactic: subst this
state_before: J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
D : Type u''
inst✝¹ : Category.{v'', u''} D
X✝ Y✝ : C
inst✝ : FinitaryExtensive C
Y X : C
c : Cocone (pair X Y)
hc : IsColimit c
⊢ IsVanKampenColimit c
state_after: no goals
tactic: exact FinitaryExtensive.van_kampen' c hc
Theorem: Submonoid.LocalizationMap.toMap_injective_iff
File: Mathlib/GroupTheory/MonoidLocalization/MonoidWithZero.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : CommMonoid M
S : Submonoid M
inst✝ : CommMonoid N
f : S.LocalizationMap N
⊢ Injective ⇑f.toMap ↔ ∀ ⦃x : M⦄, x ∈ S → IsLeftRegular x
state_after: M : Type u_1
N : Type u_2
inst✝¹ : CommMonoid M
S : Submonoid M
inst✝ : CommMonoid N
f : S.LocalizationMap N
⊢ (∀ ⦃a₁ a₂ : M⦄, f.toMap a₁ = f.toMap a₂ → a₁ = a₂) ↔ ∀ ⦃x : M⦄, x ∈ S → IsLeftRegular x
tactic: rw [Injective]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : CommMonoid M
S : Submonoid M
inst✝ : CommMonoid N
f : S.LocalizationMap N
⊢ (∀ ⦃a₁ a₂ : M⦄, f.toMap a₁ = f.toMap a₂ → a₁ = a₂) ↔ ∀ ⦃x : M⦄, x ∈ S → IsLeftRegular x
state_after: case mp
M : Type u_1
N : Type u_2
inst✝¹ : CommMonoid M
S : Submonoid M
inst✝ : CommMonoid N
f : S.LocalizationMap N
h : ∀ ⦃a₁ a₂ : M⦄, f.toMap a₁ = f.toMap a₂ → a₁ = a₂
⊢ ∀ ⦃x : M⦄, x ∈ S → IsLeftRegular x

case mpr
M : Type u_1
N : Type u_2
inst✝¹ : CommMonoid M
S : Submonoid M
inst✝ : CommMonoid N
f : S.LocalizationMap N
h : ∀ ⦃x : M⦄, x ∈ S → IsLeftRegular x
⊢ ∀ ⦃a₁ a₂ : M⦄, f.toMap a₁ = f.toMap a₂ → a₁ = a₂
tactic: constructor <;> intro h
Theorem: Partrec.sum_casesOn_right
File: Mathlib/Computability/Partrec.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 σ
f : α → β ⊕ γ
g : α → β → σ
h : α → γ →. σ
hf : Computable f
hg : Computable₂ g
hh : Partrec₂ h
this :
  Partrec fun a =>
    Option.casesOn (Sum.casesOn (f a) (fun x => Option.none) Option.some)
      (Part.some (Sum.casesOn (f a) (fun b => Option.some (g a b)) fun x => Option.none)) fun c =>
      Part.map Option.some (h a c)
a : α
⊢ (Option.casesOn (Sum.casesOn (f a) (fun x => Option.none) Option.some)
      (Part.some (Sum.casesOn (f a) (fun b => Option.some (g a b)) fun x => Option.none)) fun c =>
      Part.map Option.some (h a c)) =
    Part.map Option.some (Sum.casesOn (f a) (fun b => Part.some (g a b)) (h a))
state_after: no goals
tactic: cases f a <;> simp
Theorem: factorization_one
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : NormalizationMonoid α
inst✝ : DecidableEq α
⊢ factorization 1 = 0
state_after: no goals
tactic: simp [factorization]