ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ordinal.IsNormal.le_iff_deriv
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: f✝ : Ordinal.{u} → Ordinal.{u}
f : Ordinal.{u_1} → Ordinal.{u_1}
H : IsNormal f
a : Ordinal.{u_1}
⊢ f a ≤ a ↔ ∃ o, deriv f o = a
state_after: f✝ : Ordinal.{u} → Ordinal.{u}
f : Ordinal.{u_1} → Ordinal.{u_1}
H : IsNormal f
a : Ordinal.{u_1}
⊢ f a ≤ a ↔ ∃ o, derivFamily (fun x => f) o = a
tactic: unfold deriv
state_before: f✝ : Ordinal.{u} → Ordinal.{u}
f : Ordinal.{u_1} → Ordinal.{u_1}
H : IsNormal f
a : Ordinal.{u_1}
⊢ f a ≤ a ↔ ∃ o, derivFamily (fun x => f) o = a
state_after: f✝ : Ordinal.{u} → Ordinal.{u}
f : Ordinal.{u_1} → Ordinal.{u_1}
H : IsNormal f
a : Ordinal.{u_1}
⊢ f a ≤ a ↔ Unit → f a ≤ a
tactic: rw [← le_iff_derivFamily fun _ : Unit => H]
state_before: f✝ : Ordinal.{u} → Ordinal.{u}
f : Ordinal.{u_1} → Ordinal.{u_1}
H : IsNormal f
a : Ordinal.{u_1}
⊢ f a ≤ a ↔ Unit → f a ≤ a
state_after: no goals
tactic: exact ⟨fun h _ => h, fun h => h Unit.unit⟩
Theorem: WittVector.wittPolyProdRemainder_vars
File: Mathlib/RingTheory/WittVector/MulCoeff.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ (wittPolyProdRemainder p n).vars ⊆ univ ×ˢ range n
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ (∑ i ∈ range n, ↑p ^ i * wittMul p i ^ p ^ (n - i)).vars ⊆ univ ×ˢ range n
tactic: rw [wittPolyProdRemainder]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ (∑ i ∈ range n, ↑p ^ i * wittMul p i ^ p ^ (n - i)).vars ⊆ univ ×ˢ range n
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ((range n).biUnion fun i => (↑p ^ i * wittMul p i ^ p ^ (n - i)).vars) ⊆ univ ×ˢ range n
tactic: refine Subset.trans (vars_sum_subset _ _) ?_
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ((range n).biUnion fun i => (↑p ^ i * wittMul p i ^ p ^ (n - i)).vars) ⊆ univ ×ˢ range n
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ∀ x ∈ range n, (↑p ^ x * wittMul p x ^ p ^ (n - x)).vars ⊆ univ ×ˢ range n
tactic: rw [biUnion_subset]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ∀ x ∈ range n, (↑p ^ x * wittMul p x ^ p ^ (n - x)).vars ⊆ univ ×ˢ range n
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n x : ℕ
hx : x ∈ range n
⊢ (↑p ^ x * wittMul p x ^ p ^ (n - x)).vars ⊆ univ ×ˢ range n
tactic: intro x hx
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n x : ℕ
hx : x ∈ range n
⊢ (↑p ^ x * wittMul p x ^ p ^ (n - x)).vars ⊆ univ ×ˢ range n
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n x : ℕ
hx : x ∈ range n
⊢ (↑p ^ x).vars ∪ (wittMul p x ^ p ^ (n - x)).vars ⊆ univ ×ˢ range n
tactic: apply Subset.trans (vars_mul _ _)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n x : ℕ
hx : x ∈ range n
⊢ (↑p ^ x).vars ∪ (wittMul p x ^ p ^ (n - x)).vars ⊆ univ ×ˢ range n
state_after: case refine_1
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n x : ℕ
hx : x ∈ range n
⊢ (↑p ^ x).vars ⊆ univ ×ˢ range n

case refine_2
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n x : ℕ
hx : x ∈ range n
⊢ (wittMul p x ^ p ^ (n - x)).vars ⊆ univ ×ˢ range n
tactic: refine union_subset ?_ ?_
Theorem: AffineSubspace.eq_bot_or_nonempty
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
Q : AffineSubspace k P
⊢ Q = ⊥ ∨ (↑Q).Nonempty
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
Q : AffineSubspace k P
⊢ Q = ⊥ ∨ Q ≠ ⊥
tactic: rw [nonempty_iff_ne_bot]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
Q : AffineSubspace k P
⊢ Q = ⊥ ∨ Q ≠ ⊥
state_after: no goals
tactic: apply eq_or_ne
Theorem: CliffordAlgebraComplex.ofComplex_comp_toComplex
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

Proof steps:
state_before: ⊢ ofComplex.comp toComplex = AlgHom.id ℝ (CliffordAlgebra Q)
state_after: case a.h

⊢ ((ofComplex.comp toComplex).toLinearMap ∘ₗ ι Q) 1 = ((AlgHom.id ℝ (CliffordAlgebra Q)).toLinearMap ∘ₗ ι Q) 1
tactic: ext
state_before: case a.h

⊢ ((ofComplex.comp toComplex).toLinearMap ∘ₗ ι Q) 1 = ((AlgHom.id ℝ (CliffordAlgebra Q)).toLinearMap ∘ₗ ι Q) 1
state_after: case a.h

⊢ ofComplex (toComplex ((ι Q) 1)) = (ι Q) 1
tactic: dsimp only [LinearMap.comp_apply, Subtype.coe_mk, AlgHom.id_apply, AlgHom.toLinearMap_apply,
    AlgHom.comp_apply]
state_before: case a.h

⊢ ofComplex (toComplex ((ι Q) 1)) = (ι Q) 1
state_after: no goals
tactic: rw [toComplex_ι, one_smul, ofComplex_I]
Theorem: Nat.le_three_of_sqrt_eq_one
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : n.sqrt = 1
⊢ n.sqrt < 2
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
h : n.sqrt = 1
⊢ 1 < 2
tactic: rw [h]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : n.sqrt = 1
⊢ 1 < 2
state_after: no goals
tactic: decide
Theorem: MeasureTheory.trim_eq_self
File: Mathlib/MeasureTheory/Measure/Trim.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
⊢ μ.trim ⋯ = μ
state_after: no goals
tactic: simp [Measure.trim]
Theorem: Grp.SurjectiveOfEpiAuxs.h_apply_infinity
File: Mathlib/Algebra/Category/Grp/EpiMono.lean

Proof steps:
state_before: A B : Grp
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ (h x) ∞ = ∞
state_after: A B : Grp
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ (((Equiv.symm τ).trans (g x)).trans τ) ∞ = ∞
tactic: change ((τ).symm.trans (g x)).trans τ _ = _
state_before: A B : Grp
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ (((Equiv.symm τ).trans (g x)).trans τ) ∞ = ∞
state_after: A B : Grp
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ τ ((g x) ((Equiv.symm τ) ∞)) = ∞
tactic: simp only [MonoidHom.coe_mk, Equiv.toFun_as_coe, Equiv.coe_trans, Function.comp_apply]
state_before: A B : Grp
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ τ ((g x) ((Equiv.symm τ) ∞)) = ∞
state_after: A B : Grp
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ τ (fromCoset ⟨x • ↑⟨↑(MonoidHom.range f), ⋯⟩, ⋯⟩) = ∞
tactic: rw [τ_symm_apply_infinity, g_apply_fromCoset]
state_before: A B : Grp
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ τ (fromCoset ⟨x • ↑⟨↑(MonoidHom.range f), ⋯⟩, ⋯⟩) = ∞
state_after: no goals
tactic: simpa only using τ_apply_fromCoset' f x hx
Theorem: Setoid.classes_eqv_classes
File: Mathlib/Data/Setoid/Partition.lean

Proof steps:
state_before: α : Type u_1
r : Setoid α
a : α
⊢ ∀ (y : Set α), y ∈ r.classes ∧ a ∈ y → y = {x | r.Rel x a}
state_after: case intro.intro
α : Type u_1
r : Setoid α
a w✝ : α
ha : a ∈ {x | r.Rel x w✝}
⊢ {x | r.Rel x w✝} = {x | r.Rel x a}
tactic: rintro y ⟨⟨_, rfl⟩, ha⟩
state_before: case intro.intro
α : Type u_1
r : Setoid α
a w✝ : α
ha : a ∈ {x | r.Rel x w✝}
⊢ {x | r.Rel x w✝} = {x | r.Rel x a}
state_after: case intro.intro.h
α : Type u_1
r : Setoid α
a w✝ : α
ha : a ∈ {x | r.Rel x w✝}
x : α
⊢ x ∈ {x | r.Rel x w✝} ↔ x ∈ {x | r.Rel x a}
tactic: ext x
state_before: case intro.intro.h
α : Type u_1
r : Setoid α
a w✝ : α
ha : a ∈ {x | r.Rel x w✝}
x : α
⊢ x ∈ {x | r.Rel x w✝} ↔ x ∈ {x | r.Rel x a}
state_after: no goals
tactic: exact ⟨fun hx => r.trans' hx (r.symm' ha), fun hx => r.trans' hx ha⟩
Theorem: PMF.bind_bind
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : α → PMF β
g : β → PMF γ
b : γ
⊢ ((p.bind f).bind g) b = (p.bind fun a => (f a).bind g) b
state_after: no goals
tactic: simpa only [ENNReal.coe_inj.symm, bind_apply, ENNReal.tsum_mul_left.symm,
      ENNReal.tsum_mul_right.symm, mul_assoc, mul_left_comm, mul_comm] using ENNReal.tsum_comm
Theorem: Mathlib.Meta.NormNum.jacobiSymNat.zero_left
File: Mathlib/Tactic/NormNum/LegendreSymbol.lean

Proof steps:
state_before: b : ℕ
hb : (b / 2).beq 0 = false
⊢ jacobiSymNat 0 b = 0
state_after: b : ℕ
hb : (b / 2).beq 0 = false
⊢ 1 < b
tactic: rw [jacobiSymNat, Nat.cast_zero, jacobiSym.zero_left ?_]
state_before: b : ℕ
hb : (b / 2).beq 0 = false
⊢ 1 < b
state_after: no goals
tactic: calc
    1 < 2 * 1       := by decide
    _ ≤ 2 * (b / 2) :=
      Nat.mul_le_mul_left _ (Nat.succ_le.mpr (Nat.pos_of_ne_zero (Nat.ne_of_beq_eq_false hb)))
    _ ≤ b           := Nat.mul_div_le b 2
Theorem: NumberField.mixedEmbedding.commMap_canonical_eq_mixed
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

Proof steps:
state_before: K : Type u_1
inst✝ : Field K
x : K
⊢ (commMap K) ((canonicalEmbedding K) x) = (mixedEmbedding K) x
state_after: K : Type u_1
inst✝ : Field K
x : K
⊢ (fun w => ((↑w).embedding x).re) = (Pi.ringHom fun w => embedding_of_isReal ⋯) x ∧
    (fun w => (↑w).embedding x) = (Pi.ringHom fun w => (↑w).embedding) x
tactic: simp only [canonicalEmbedding, commMap, LinearMap.coe_mk, AddHom.coe_mk, Pi.ringHom_apply,
    mixedEmbedding, RingHom.prod_apply, Prod.mk.injEq]
state_before: K : Type u_1
inst✝ : Field K
x : K
⊢ (fun w => ((↑w).embedding x).re) = (Pi.ringHom fun w => embedding_of_isReal ⋯) x ∧
    (fun w => (↑w).embedding x) = (Pi.ringHom fun w => (↑w).embedding) x
state_after: no goals
tactic: exact ⟨rfl, rfl⟩
Theorem: ENNReal.rpow_rpow_inv
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: y : ℝ
hy : y ≠ 0
x : ℝ≥0∞
⊢ (x ^ y) ^ y⁻¹ = x
state_after: no goals
tactic: rw [← rpow_mul, mul_inv_cancel hy, rpow_one]
Theorem: wittPolynomial_zero
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type u_2
inst✝ : CommRing S
⊢ W_ R 0 = X 0
state_after: no goals
tactic: simp only [wittPolynomial, X, sum_singleton, range_one, pow_zero, zero_add, tsub_self]
Theorem: Path.trans_apply
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
⊢ (if ↑t ≤ 1 / 2 then γ.extend (2 * ↑t) else γ'.extend (2 * ↑t - 1)) =
    if h : ↑t ≤ 1 / 2 then γ ⟨2 * ↑t, ⋯⟩ else γ' ⟨2 * ↑t - 1, ⋯⟩
state_after: no goals
tactic: split_ifs <;> rw [extend_extends]
Theorem: Finset.not_mem_union
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
⊢ a ∉ s ∪ t ↔ a ∉ s ∧ a ∉ t
state_after: no goals
tactic: rw [mem_union, not_or]
Theorem: Nat.filter_range_nth_subset_insert
File: Mathlib/Data/Nat/Nth.lean

Proof steps:
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
⊢ filter p (range (nth p (k + 1))) ⊆ insert (nth p k) (filter p (range (nth p k)))
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
k a : ℕ
ha : a ∈ filter p (range (nth p (k + 1)))
⊢ a ∈ insert (nth p k) (filter p (range (nth p k)))
tactic: intro a ha
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
k a : ℕ
ha : a ∈ filter p (range (nth p (k + 1)))
⊢ a ∈ insert (nth p k) (filter p (range (nth p k)))
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
k a : ℕ
ha : a < nth p (k + 1) ∧ p a
⊢ a = nth p k ∨ a < nth p k ∧ p a
tactic: simp only [mem_insert, mem_filter, mem_range] at ha ⊢
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
k a : ℕ
ha : a < nth p (k + 1) ∧ p a
⊢ a = nth p k ∨ a < nth p k ∧ p a
state_after: no goals
tactic: exact (le_nth_of_lt_nth_succ ha.1 ha.2).eq_or_lt.imp_right fun h => ⟨h, ha.2⟩
Theorem: Set.Nonempty.smul_zero
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Zero β
inst✝ : SMulZeroClass α β
s : Set α
t : Set β
a : α
hs : s.Nonempty
⊢ 0 ⊆ s • 0
state_after: no goals
tactic: simpa [mem_smul] using hs
Theorem: Multiset.map_join
File: Mathlib/Data/Multiset/Bind.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
f : α → β
S : Multiset (Multiset α)
⊢ map f S.join = (map (map f) S).join
state_after: no goals
tactic: induction S using Multiset.induction with
  | empty => simp
  | cons _ _ ih => simp [ih]
Theorem: PartENat.withTopEquiv_le
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: x y : PartENat
⊢ withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y
state_after: no goals
tactic: simp
Theorem: SeparationQuotient.preimage_image_mk_closed
File: Mathlib/Topology/Inseparable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
t : Set (SeparationQuotient X)
hs : IsClosed s
⊢ mk ⁻¹' (mk '' s) = s
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
t : Set (SeparationQuotient X)
hs : IsClosed s
⊢ mk ⁻¹' (mk '' s) ⊆ s
tactic: refine Subset.antisymm ?_ (subset_preimage_image _ _)
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
t : Set (SeparationQuotient X)
hs : IsClosed s
⊢ mk ⁻¹' (mk '' s) ⊆ s
state_after: case intro.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s : Set X
f g : X → Y
t : Set (SeparationQuotient X)
hs : IsClosed s
x y : X
hys : y ∈ s
hxy : mk y = mk x
⊢ x ∈ s
tactic: rintro x ⟨y, hys, hxy⟩
state_before: case intro.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s : Set X
f g : X → Y
t : Set (SeparationQuotient X)
hs : IsClosed s
x y : X
hys : y ∈ s
hxy : mk y = mk x
⊢ x ∈ s
state_after: no goals
tactic: exact ((mk_eq_mk.1 hxy).mem_closed_iff hs).1 hys
Theorem: AlgebraicGeometry.ProjectiveSpectrum.Proj.awayToSection_germ
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
⊢ awayToSection 𝒜 f ≫ (structureSheaf 𝒜).presheaf.germ x =
    HomogeneousLocalization.mapId 𝒜 ⋯ ≫ (Proj.stalkIso' 𝒜 ↑x).toCommRingCatIso.inv
state_after: case w
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
z : (forget CommRingCat).obj (CommRingCat.of (A⁰_ f))
⊢ (awayToSection 𝒜 f ≫ (structureSheaf 𝒜).presheaf.germ x) z =
    (HomogeneousLocalization.mapId 𝒜 ⋯ ≫ (Proj.stalkIso' 𝒜 ↑x).toCommRingCatIso.inv) z
tactic: ext z
state_before: case w
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
z : (forget CommRingCat).obj (CommRingCat.of (A⁰_ f))
⊢ (awayToSection 𝒜 f ≫ (structureSheaf 𝒜).presheaf.germ x) z =
    (HomogeneousLocalization.mapId 𝒜 ⋯ ≫ (Proj.stalkIso' 𝒜 ↑x).toCommRingCatIso.inv) z
state_after: case w
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
z : (forget CommRingCat).obj (CommRingCat.of (A⁰_ f))
⊢ (Proj.stalkIso' 𝒜 ↑x).toEquiv ((awayToSection 𝒜 f ≫ (structureSheaf 𝒜).presheaf.germ x) z) =
    (HomogeneousLocalization.mapId 𝒜 ⋯) z
tactic: apply (Proj.stalkIso' 𝒜 x).eq_symm_apply.mpr
state_before: case w
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↥(pbo f)
z : (forget CommRingCat).obj (CommRingCat.of (A⁰_ f))
⊢ (Proj.stalkIso' 𝒜 ↑x).toEquiv ((awayToSection 𝒜 f ≫ (structureSheaf 𝒜).presheaf.germ x) z) =
    (HomogeneousLocalization.mapId 𝒜 ⋯) z
state_after: no goals
tactic: apply Proj.stalkIso'_germ
Theorem: CategoryTheory.Limits.limit.coneMorphism_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

Proof steps:
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F✝ F : J ⥤ C
inst✝ : HasLimit F
c : Cone F
j : J
⊢ (coneMorphism c).hom ≫ π F j = c.π.app j
state_after: no goals
tactic: simp
Theorem: ContinuousMultilinearMap.uncurry_curryRight
File: Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 Ei G
⊢ f.curryRight.uncurryRight = f
state_after: case H
𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 Ei G
m : (i : Fin n.succ) → Ei i
⊢ f.curryRight.uncurryRight m = f m
tactic: ext m
state_before: case H
𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin n.succ → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin n.succ) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 Ei G
m : (i : Fin n.succ) → Ei i
⊢ f.curryRight.uncurryRight m = f m
state_after: no goals
tactic: rw [uncurryRight_apply, curryRight_apply, snoc_init_self]
Theorem: Sum.sum_rec_congr
File: Mathlib/Data/Sum/Basic.lean

Proof steps:
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
P : α ⊕ β → Sort u_3
f : (i : α) → P (inl i)
g : (i : β) → P (inr i)
x y : α ⊕ β
h : x = y
⊢ rec f g x = cast ⋯ (rec f g y)
state_after: case refl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
P : α ⊕ β → Sort u_3
f : (i : α) → P (inl i)
g : (i : β) → P (inr i)
x : α ⊕ β
⊢ rec f g x = cast ⋯ (rec f g x)
tactic: cases h
state_before: case refl
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
P : α ⊕ β → Sort u_3
f : (i : α) → P (inl i)
g : (i : β) → P (inr i)
x : α ⊕ β
⊢ rec f g x = cast ⋯ (rec f g x)
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.integral_add
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
G : Type u_5
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f✝ g✝ : α → E
m : MeasurableSpace α
μ : Measure α
f g : α → G
hf : Integrable f μ
hg : Integrable g μ
⊢ ∫ (a : α), f a + g a ∂μ = ∫ (a : α), f a ∂μ + ∫ (a : α), g a ∂μ
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
G : Type u_5
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f✝ g✝ : α → E
m : MeasurableSpace α
μ : Measure α
f g : α → G
hf : Integrable f μ
hg : Integrable g μ
hG : CompleteSpace G
⊢ ∫ (a : α), f a + g a ∂μ = ∫ (a : α), f a ∂μ + ∫ (a : α), g a ∂μ

case neg
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
G : Type u_5
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f✝ g✝ : α → E
m : MeasurableSpace α
μ : Measure α
f g : α → G
hf : Integrable f μ
hg : Integrable g μ
hG : ¬CompleteSpace G
⊢ ∫ (a : α), f a + g a ∂μ = ∫ (a : α), f a ∂μ + ∫ (a : α), g a ∂μ
tactic: by_cases hG : CompleteSpace G
Theorem: Rat.divInt_self
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: a : Rat
⊢ a.num /. ↑a.den = a
state_after: no goals
tactic: rw [divInt_ofNat, mkRat_self]
Theorem: IsNilpotent.pow_succ
File: Mathlib/RingTheory/Nilpotent/Defs.lean

Proof steps:
state_before: R : Type u_1
S✝ : Type u_2
x✝ y : R
n : ℕ
S : Type u_3
inst✝ : MonoidWithZero S
x : S
hx : IsNilpotent x
⊢ IsNilpotent (x ^ n.succ)
state_after: case intro
R : Type u_1
S✝ : Type u_2
x✝ y : R
n : ℕ
S : Type u_3
inst✝ : MonoidWithZero S
x : S
N : ℕ
hN : x ^ N = 0
⊢ IsNilpotent (x ^ n.succ)
tactic: obtain ⟨N,hN⟩ := hx
state_before: case intro
R : Type u_1
S✝ : Type u_2
x✝ y : R
n : ℕ
S : Type u_3
inst✝ : MonoidWithZero S
x : S
N : ℕ
hN : x ^ N = 0
⊢ IsNilpotent (x ^ n.succ)
state_after: case h
R : Type u_1
S✝ : Type u_2
x✝ y : R
n : ℕ
S : Type u_3
inst✝ : MonoidWithZero S
x : S
N : ℕ
hN : x ^ N = 0
⊢ (x ^ n.succ) ^ N = 0
tactic: use N
state_before: case h
R : Type u_1
S✝ : Type u_2
x✝ y : R
n : ℕ
S : Type u_3
inst✝ : MonoidWithZero S
x : S
N : ℕ
hN : x ^ N = 0
⊢ (x ^ n.succ) ^ N = 0
state_after: no goals
tactic: rw [← pow_mul, Nat.succ_mul, pow_add, hN, mul_zero]
Theorem: ProbabilityTheory.Kernel.fst_prod
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel α γ
inst✝ : IsMarkovKernel η
⊢ (κ ×ₖ η).fst = κ
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel α γ
inst✝ : IsMarkovKernel η
⊢ (κ ⊗ₖ (prodMkLeft β η).swapLeft).fst = κ
tactic: rw [prod]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel α γ
inst✝ : IsMarkovKernel η
⊢ (κ ⊗ₖ (prodMkLeft β η).swapLeft).fst = κ
state_after: no goals
tactic: simp