ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: WeierstrassCurve.Jacobian.nonsingular_iff_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ W.Nonsingular P ↔ W.Equation P ∧ ((eval P) W.polynomialX ≠ 0 ∨ (eval P) W.polynomialY ≠ 0)
state_after: no goals
tactic: rw [nonsingular_of_Z_ne_zero hPz, Affine.Nonsingular, ← equation_of_Z_ne_zero hPz,
    ← eval_polynomialX_of_Z_ne_zero hPz, div_ne_zero_iff, and_iff_left <| pow_ne_zero 4 hPz,
    ← eval_polynomialY_of_Z_ne_zero hPz, div_ne_zero_iff, and_iff_left <| pow_ne_zero 3 hPz]
Theorem: Set.image2_mk_eq_prod
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ ∀ (x : α × β), x ∈ image2 Prod.mk s t ↔ x ∈ s ×ˢ t
state_after: no goals
tactic: simp
Theorem: isUnit_of_associated_mul
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p b : α
h : p * b ~ᵤ p
hp : p ≠ 0
⊢ IsUnit b
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p b : α
hp : p ≠ 0
a : αˣ
ha : p * b * ↑a = p
⊢ IsUnit b
tactic: cases' h with a ha
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p b : α
hp : p ≠ 0
a : αˣ
ha : p * b * ↑a = p
⊢ IsUnit b
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p b : α
hp : p ≠ 0
a : αˣ
ha : p * b * ↑a = p
⊢ p * (b * ↑a) = p * 1
tactic: refine isUnit_of_mul_eq_one b a ((mul_right_inj' hp).mp ?_)
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p b : α
hp : p ≠ 0
a : αˣ
ha : p * b * ↑a = p
⊢ p * (b * ↑a) = p * 1
state_after: no goals
tactic: rwa [← mul_assoc, mul_one]
Theorem: Cardinal.mk_ord_out
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal.{u_3}
⊢ #(Quotient.out c.ord).α = c
state_after: no goals
tactic: simp
Theorem: CategoryTheory.ShortComplex.SnakeInput.w₀₂_τ₂
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ S.v₀₁.τ₂ ≫ S.v₁₂.τ₂ = 0
state_after: no goals
tactic: rw [← comp_τ₂, S.w₀₂, zero_τ₂]
Theorem: Algebra.mem_sInf
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

Proof steps:
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Set (Subalgebra R A)
x : A
⊢ x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
state_after: no goals
tactic: simp only [← SetLike.mem_coe, coe_sInf, Set.mem_iInter₂]
Theorem: CochainComplex.mappingCone.inr_fst
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.33393, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
⊢ (Cochain.ofHom (inr φ)).comp ↑(fst φ) ⋯ = 0
state_after: case h
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.33393, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + 1 = q
⊢ ((Cochain.ofHom (inr φ)).comp ↑(fst φ) ⋯).v p q hpq = Cochain.v 0 p q hpq
tactic: ext p q hpq
state_before: case h
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.33393, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + 1 = q
⊢ ((Cochain.ofHom (inr φ)).comp ↑(fst φ) ⋯).v p q hpq = Cochain.v 0 p q hpq
state_after: no goals
tactic: simp [Cochain.comp_v _ _ (zero_add 1) p p q (by omega) (by omega)]
Theorem: MvPolynomial.C_eq_coe_nat
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
n : ℕ
⊢ C ↑n = ↑n
state_after: no goals
tactic: induction n <;> simp [*]
Theorem: Ideal.jacobson_bot_polynomial_of_jacobson_bot
File: Mathlib/RingTheory/JacobsonIdeal.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝ : CommRing R
h : ⊥.jacobson = ⊥
⊢ ⊥.jacobson = ⊥
state_after: R : Type u
S : Type v
inst✝ : CommRing R
h : ⊥.jacobson = ⊥
⊢ sInf (map C '' {J | J.IsMaximal}) ≤ ⊥
tactic: refine eq_bot_iff.2 (le_trans jacobson_bot_polynomial_le_sInf_map_maximal ?_)
state_before: R : Type u
S : Type v
inst✝ : CommRing R
h : ⊥.jacobson = ⊥
⊢ sInf (map C '' {J | J.IsMaximal}) ≤ ⊥
state_after: R : Type u
S : Type v
inst✝ : CommRing R
h : ⊥.jacobson = ⊥
f : R[X]
hf : f ∈ sInf (map C '' {J | J.IsMaximal})
n : ℕ
⊢ f.coeff n = 0
tactic: refine fun f hf => (Submodule.mem_bot R[X]).2 <| Polynomial.ext fun n =>
    Trans.trans (?_ : coeff f n = 0) (coeff_zero n).symm
state_before: R : Type u
S : Type v
inst✝ : CommRing R
h : ⊥.jacobson = ⊥
f : R[X]
hf : f ∈ sInf (map C '' {J | J.IsMaximal})
n : ℕ
⊢ f.coeff n = 0
state_after: R : Type u
S : Type v
inst✝ : CommRing R
h : ⊥.jacobson = ⊥
f : R[X]
hf : f ∈ sInf (map C '' {J | J.IsMaximal})
n : ℕ
⊢ f.coeff n ∈ ⊥.jacobson
tactic: suffices f.coeff n ∈ Ideal.jacobson ⊥ by rwa [h, Submodule.mem_bot] at this
state_before: R : Type u
S : Type v
inst✝ : CommRing R
h : ⊥.jacobson = ⊥
f : R[X]
hf : f ∈ sInf (map C '' {J | J.IsMaximal})
n : ℕ
⊢ f.coeff n ∈ ⊥.jacobson
state_after: no goals
tactic: exact mem_sInf.2 fun j hj => (mem_map_C_iff.1 ((mem_sInf.1 hf) ⟨j, ⟨hj.2, rfl⟩⟩)) n
Theorem: Relation.transGen_reflGen
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
⊢ TransGen (ReflGen r) = ReflTransGen r
state_after: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x y : α
⊢ TransGen (ReflGen r) x y ↔ ReflTransGen r x y
tactic: ext x y
state_before: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x y : α
⊢ TransGen (ReflGen r) x y ↔ ReflTransGen r x y
state_after: case h.h.a.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x y : α
h : TransGen (ReflGen r) x y
⊢ ReflTransGen r x y

case h.h.a.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x y : α
h : ReflTransGen r x y
⊢ TransGen (ReflGen r) x y
tactic: refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
Theorem: ComplexShape.σ_symm
File: Mathlib/Algebra/Homology/ComplexShapeSigns.lean

Proof steps:
state_before: I₁ : Type u_1
I₂ : Type u_2
I₁₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
c₁₂ : ComplexShape I₁₂
inst✝⁴ : TotalComplexShape c₁ c₂ c₁₂
inst✝³ : TotalComplexShape c₂ c₁ c₁₂
inst✝² : TotalComplexShapeSymmetry c₁ c₂ c₁₂
inst✝¹ : TotalComplexShapeSymmetry c₂ c₁ c₁₂
inst✝ : TotalComplexShapeSymmetrySymmetry c₁ c₂ c₁₂
i₁ : I₁
i₂ : I₂
⊢ c₂.σ c₁ c₁₂ i₂ i₁ = c₁.σ c₂ c₁₂ i₁ i₂
state_after: no goals
tactic: apply TotalComplexShapeSymmetrySymmetry.σ_symm
Theorem: Ideal.map_eq_bot_iff_of_injective
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
I : Ideal R
f : F
hf : Function.Injective ⇑f
⊢ map f I = ⊥ ↔ I = ⊥
state_after: no goals
tactic: rw [map_eq_bot_iff_le_ker, (RingHom.injective_iff_ker_eq_bot f).mp hf, le_bot_iff]
Theorem: CategoryTheory.Adjunction.homEquiv_apply_eq
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
g : A ⟶ G.obj B
h : (adj.homEquiv A B) f = g
⊢ f = (adj.homEquiv A B).symm g
state_after: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
⊢ f = (adj.homEquiv A B).symm ((adj.homEquiv A B) f)
tactic: cases h
state_before: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
⊢ f = (adj.homEquiv A B).symm ((adj.homEquiv A B) f)
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
g : A ⟶ G.obj B
h : f = (adj.homEquiv A B).symm g
⊢ (adj.homEquiv A B) f = g
state_after: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
g : A ⟶ G.obj B
⊢ (adj.homEquiv A B) ((adj.homEquiv A B).symm g) = g
tactic: cases h
state_before: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
g : A ⟶ G.obj B
⊢ (adj.homEquiv A B) ((adj.homEquiv A B).symm g) = g
state_after: no goals
tactic: simp
Theorem: QuaternionAlgebra.Basis.k_mul_j
File: Mathlib/Algebra/QuaternionBasis.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
⊢ q.k * q.j = c₂ • q.i
state_after: no goals
tactic: rw [← i_mul_j, mul_assoc, j_mul_j, mul_smul_comm, mul_one]
Theorem: MeasureTheory.absolutelyContinuous_inv
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
⊢ μ ≪ μ.inv
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
s : Set G
x✝ : MeasurableSet s
⊢ μ.inv s = 0 → μ s = 0
tactic: refine AbsolutelyContinuous.mk fun s _ => ?_
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
s : Set G
x✝ : MeasurableSet s
⊢ μ.inv s = 0 → μ s = 0
state_after: no goals
tactic: simp_rw [inv_apply μ s, measure_inv_null, imp_self]
Theorem: HasCompactMulSupport.intro'
File: Mathlib/Topology/Support.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace α'
inst✝² : One β
inst✝¹ : One γ
inst✝ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
K : Set α
hK : IsCompact K
h'K : IsClosed K
hfK : ∀ x ∉ K, f x = 1
⊢ HasCompactMulSupport f
state_after: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace α'
inst✝² : One β
inst✝¹ : One γ
inst✝ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
K : Set α
hK : IsCompact K
h'K : IsClosed K
hfK : ∀ x ∉ K, f x = 1
this : mulTSupport f ⊆ K
⊢ HasCompactMulSupport f
tactic: have : mulTSupport f ⊆ K := by
    rw [← h'K.closure_eq]
    apply closure_mono (mulSupport_subset_iff'.2 hfK)
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace α'
inst✝² : One β
inst✝¹ : One γ
inst✝ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
K : Set α
hK : IsCompact K
h'K : IsClosed K
hfK : ∀ x ∉ K, f x = 1
this : mulTSupport f ⊆ K
⊢ HasCompactMulSupport f
state_after: no goals
tactic: exact IsCompact.of_isClosed_subset hK ( isClosed_mulTSupport f) this
Theorem: CategoryTheory.Groupoid.isThin_iff
File: Mathlib/CategoryTheory/Groupoid/Basic.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Groupoid C
⊢ Quiver.IsThin C ↔ ∀ (c : C), Subsingleton (c ⟶ c)
state_after: C : Type u_1
inst✝ : Groupoid C
h : ∀ (c : C), Subsingleton (c ⟶ c)
c d : C
f g : c ⟶ d
⊢ f = g
tactic: refine ⟨fun h c => h c c, fun h c d => Subsingleton.intro fun f g => ?_⟩
state_before: C : Type u_1
inst✝ : Groupoid C
h : ∀ (c : C), Subsingleton (c ⟶ c)
c d : C
f g : c ⟶ d
⊢ f = g
state_after: C : Type u_1
inst✝ : Groupoid C
h : ∀ (c : C), Subsingleton (c ⟶ c)
c d : C
f g : c ⟶ d
this : Subsingleton (d ⟶ d)
⊢ f = g
tactic: haveI := h d
state_before: C : Type u_1
inst✝ : Groupoid C
h : ∀ (c : C), Subsingleton (c ⟶ c)
c d : C
f g : c ⟶ d
this : Subsingleton (d ⟶ d)
⊢ f = g
state_after: no goals
tactic: calc
    f = f ≫ inv g ≫ g := by simp only [inv_eq_inv, IsIso.inv_hom_id, Category.comp_id]
    _ = f ≫ inv f ≫ g := by congr 1
                            simp only [inv_eq_inv, IsIso.inv_hom_id, eq_iff_true_of_subsingleton]
    _ = g := by simp only [inv_eq_inv, IsIso.hom_inv_id_assoc]
Theorem: CategoryTheory.Functor.commShiftOfLocalization_iso_hom_app
File: Mathlib/CategoryTheory/Shift/Localization.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝¹² : Category.{v₁, u₁} C
inst✝¹¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝¹⁰ : Category.{v₃, u₃} E
L : C ⥤ D
W : MorphismProperty C
inst✝⁹ : L.IsLocalization W
A : Type w
inst✝⁸ : AddMonoid A
inst✝⁷ : HasShift C A
inst✝⁶ : W.IsCompatibleWithShift A
inst✝⁵ : W.HasLocalization
F : C ⥤ E
F' : D ⥤ E
inst✝⁴ : Lifting L W F F'
inst✝³ : HasShift D A
inst✝² : HasShift E A
inst✝¹ : L.CommShift A
inst✝ : F.CommShift A
a : A
X : C
⊢ (F'.commShiftIso a).hom.app (L.obj X) =
    F'.map ((L.commShiftIso a).inv.app X) ≫
      (Lifting.iso L W F F').hom.app ((shiftFunctor C a).obj X) ≫
        (F.commShiftIso a).hom.app X ≫ (shiftFunctor E a).map ((Lifting.iso L W F F').inv.app X)
state_after: no goals
tactic: apply commShiftOfLocalization.iso_hom_app
Theorem: Nat.Partrec'.tail
File: Mathlib/Computability/Halting.lean

Proof steps:
state_before: n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ (mOfFn fun i => (↑fun v => v.get i.succ) v) >>= f = f v.tail
state_after: n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f v.tail
tactic: simp
state_before: n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f v.tail
state_after: n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f (ofFn v.tail.get)
tactic: rw [← ofFn_get v.tail]
state_before: n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f (ofFn v.tail.get)
state_after: case e_a.e_a
n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ (fun i => v.get i.succ) = v.tail.get
tactic: congr
state_before: case e_a.e_a
n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
⊢ (fun i => v.get i.succ) = v.tail.get
state_after: case e_a.e_a.h
n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
i : Fin n
⊢ v.get i.succ = v.tail.get i
tactic: funext i
state_before: case e_a.e_a.h
n : ℕ
f : Vector ℕ n →. ℕ
hf : Partrec' f
v : Vector ℕ n.succ
i : Fin n
⊢ v.get i.succ = v.tail.get i
state_after: no goals
tactic: simp
Theorem: inv_neg_one
File: Mathlib/Algebra/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a b : K
⊢ (-1)⁻¹ = -1
state_after: no goals
tactic: rw [← neg_inv, inv_one]
Theorem: Matrix.TransvectionStruct.inv_mul
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
t : TransvectionStruct n R
⊢ t.inv.toMatrix * t.toMatrix = 1
state_after: case mk
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
i✝ j✝ : n
t_hij : i✝ ≠ j✝
c✝ : R
⊢ { i := i✝, j := j✝, hij := t_hij, c := c✝ }.inv.toMatrix * { i := i✝, j := j✝, hij := t_hij, c := c✝ }.toMatrix = 1
tactic: rcases t with ⟨_, _, t_hij⟩
state_before: case mk
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
i✝ j✝ : n
t_hij : i✝ ≠ j✝
c✝ : R
⊢ { i := i✝, j := j✝, hij := t_hij, c := c✝ }.inv.toMatrix * { i := i✝, j := j✝, hij := t_hij, c := c✝ }.toMatrix = 1
state_after: no goals
tactic: simp [toMatrix, transvection_mul_transvection_same, t_hij]
Theorem: InnerProductGeometry.norm_add_sq_eq_norm_sq_add_norm_sq_iff_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ angle x y = π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ ⟪x, y⟫_ℝ = 0 ↔ angle x y = π / 2
tactic: rw [norm_add_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ ⟪x, y⟫_ℝ = 0 ↔ angle x y = π / 2
state_after: no goals
tactic: exact inner_eq_zero_iff_angle_eq_pi_div_two x y
Theorem: SemiconjBy.zero_right
File: Mathlib/Algebra/GroupWithZero/Semiconj.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MulZeroClass G₀
a : G₀
⊢ SemiconjBy a 0 0
state_after: no goals
tactic: simp only [SemiconjBy, mul_zero, zero_mul]
Theorem: HomogeneousIdeal.toIdeal_iSup
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

Proof steps:
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_5
s : κ → HomogeneousIdeal 𝒜
⊢ (⨆ i, s i).toIdeal = ⨆ i, (s i).toIdeal
state_after: no goals
tactic: rw [iSup, toIdeal_sSup, iSup_range]
Theorem: Submodule.span_eq_iSup_of_singleton_spans
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s✝ t s : Set M
⊢ span R s = ⨆ x ∈ s, span R {x}
state_after: no goals
tactic: simp only [← span_iUnion, Set.biUnion_of_singleton s]
Theorem: LinearMap.eqLocus_eq_top
File: Mathlib/Algebra/Module/Submodule/EqLocus.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : Semiring R₂
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M
inst✝² : Module R₂ M₂
τ₁₂ : R →+* R₂
F : Type u_5
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f g : F
⊢ eqLocus f g = ⊤ ↔ f = g
state_after: no goals
tactic: simp [SetLike.ext_iff, DFunLike.ext_iff]
Theorem: MeasureTheory.Measure.integral_comp_inv_smul
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

Proof steps:
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
inst✝³ : FiniteDimensional ℝ E
μ : Measure E
inst✝² : μ.IsAddHaarMeasure
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
f : E → F
R : ℝ
⊢ ∫ (x : E), f (R⁻¹ • x) ∂μ = |R ^ finrank ℝ E| • ∫ (x : E), f x ∂μ
state_after: no goals
tactic: rw [integral_comp_smul μ f R⁻¹, inv_pow, inv_inv]
Theorem: List.splitAt_eq_take_drop.go_eq_take_drop
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
n : ℕ
l : List α
⊢ splitAt n l = (take n l, drop n l)
state_after: case pos
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
n : ℕ
l : List α
h : n < l.length
⊢ (if n < l.length then (#[].toList ++ take n l, drop n l) else (l, [])) = (take n l, drop n l)

case neg
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
n : ℕ
l : List α
h : ¬n < l.length
⊢ (if n < l.length then (#[].toList ++ take n l, drop n l) else (l, [])) = (take n l, drop n l)
tactic: by_cases h : n < l.length <;> rw [splitAt, go_eq_take_drop]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs✝ ys : List α
ls : List (List α)
f : List α → List α
n✝ : ℕ
l✝ : List α
n : ℕ
l xs : List α
acc : Array α
⊢ splitAt.go l xs n acc = if n < xs.length then (acc.toList ++ take n xs, drop n xs) else (l, [])
state_after: case pos
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs✝ ys : List α
ls : List (List α)
f : List α → List α
n✝ : ℕ
l✝ : List α
n : ℕ
l xs : List α
acc : Array α
h : n < xs.length
⊢ splitAt.go l xs n acc = (acc.toList ++ take n xs, drop n xs)

case neg
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs✝ ys : List α
ls : List (List α)
f : List α → List α
n✝ : ℕ
l✝ : List α
n : ℕ
l xs : List α
acc : Array α
h : ¬n < xs.length
⊢ splitAt.go l xs n acc = (l, [])
tactic: split_ifs with h
Theorem: Scott.isωSup_iff_isLUB
File: Mathlib/Topology/OmegaCompletePartialOrder.lean

Proof steps:
state_before: α : Type u
inst✝ : Preorder α
c : Chain α
x : α
⊢ IsωSup c x ↔ IsLUB (range ⇑c) x
state_after: no goals
tactic: simp [IsωSup, IsLUB, IsLeast, upperBounds, lowerBounds]
Theorem: NonUnitalAlgebra.mem_sInf
File: Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean

Proof steps:
state_before: F : Type u_1
R : Type u
A : Type v
B : Type w
inst✝¹⁰ : CommSemiring R
inst✝⁹ : NonUnitalNonAssocSemiring A
inst✝⁸ : Module R A
inst✝⁷ : IsScalarTower R A A
inst✝⁶ : SMulCommClass R A A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : Module R B
inst✝³ : IsScalarTower R B B
inst✝² : SMulCommClass R B B
inst✝¹ : FunLike F A B
inst✝ : NonUnitalAlgHomClass F R A B
S : Set (NonUnitalSubalgebra R A)
x : A
⊢ x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
state_after: no goals
tactic: simp only [← SetLike.mem_coe, coe_sInf, Set.mem_iInter₂]
Theorem: _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_zsmul
File: Mathlib/RingTheory/WittVector/Basic.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
x✝ y : 𝕎 R
m : ℤ
x : 𝕎 R
⊢ WittVector.ghostFun (m • x) = m • WittVector.ghostFun x
state_after: no goals
tactic: ghost_fun_tac m • (X 0), ![x.coeff]