ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.reflects_mono_of_reflectsLimit
File: Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsLimit (cospan f f) F
inst✝ : Mono (F.map f)
⊢ Mono f
state_after: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsLimit (cospan f f) F
inst✝ : Mono (F.map f)
this : IsLimit (PullbackCone.mk (𝟙 (F.obj X)) (𝟙 (F.obj X)) ⋯)
⊢ Mono f
tactic: have := PullbackCone.isLimitMkIdId (F.map f)
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsLimit (cospan f f) F
inst✝ : Mono (F.map f)
this : IsLimit (PullbackCone.mk (𝟙 (F.obj X)) (𝟙 (F.obj X)) ⋯)
⊢ Mono f
state_after: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsLimit (cospan f f) F
inst✝ : Mono (F.map f)
this : IsLimit (PullbackCone.mk (F.map (𝟙 X)) (F.map (𝟙 X)) ⋯)
⊢ Mono f
tactic: simp_rw [← F.map_id] at this
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : ReflectsLimit (cospan f f) F
inst✝ : Mono (F.map f)
this : IsLimit (PullbackCone.mk (F.map (𝟙 X)) (F.map (𝟙 X)) ⋯)
⊢ Mono f
state_after: no goals
tactic: apply PullbackCone.mono_of_isLimitMkIdId _ (isLimitOfIsLimitPullbackConeMap F _ this)
Theorem: Polynomial.nextCoeff_ne_zero
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p : R[X]
⊢ p.nextCoeff ≠ 0 ↔ p.natDegree ≠ 0 ∧ p.coeff (p.natDegree - 1) ≠ 0
state_after: no goals
tactic: simp [nextCoeff]
Theorem: IsPiSystem.insert_univ
File: Mathlib/MeasureTheory/PiSystem.lean

Proof steps:
state_before: α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
⊢ IsPiSystem (insert univ S)
state_after: α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s : Set α
hs : s ∈ insert univ S
t : Set α
ht : t ∈ insert univ S
hst : (s ∩ t).Nonempty
⊢ s ∩ t ∈ insert univ S
tactic: intro s hs t ht hst
state_before: α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s : Set α
hs : s ∈ insert univ S
t : Set α
ht : t ∈ insert univ S
hst : (s ∩ t).Nonempty
⊢ s ∩ t ∈ insert univ S
state_after: case inl
α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s t : Set α
ht : t ∈ insert univ S
hst : (s ∩ t).Nonempty
hs : s = univ
⊢ s ∩ t ∈ insert univ S

case inr
α : Type u_1
S : Set (Set α)
h_pi : IsPiSystem S
s t : Set α
ht : t ∈ insert univ S
hst : (s ∩ t).Nonempty
hs : s ∈ S
⊢ s ∩ t ∈ insert univ S
tactic: cases' hs with hs hs
Theorem: exists_mem_Ico_zpow
File: Mathlib/Algebra/Order/Archimedean.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝² : LinearOrderedSemifield α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x y ε : α
hx : 0 < x
hy : 1 < y
⊢ ∃ n, x ∈ Ico (y ^ n) (y ^ (n + 1))
state_after: no goals
tactic: classical exact
      let ⟨N, hN⟩ := pow_unbounded_of_one_lt x⁻¹ hy
      have he : ∃ m : ℤ, y ^ m ≤ x :=
        ⟨-N,
          le_of_lt
            (by
              rw [zpow_neg y ↑N, zpow_natCast]
              exact (inv_lt hx (lt_trans (inv_pos.2 hx) hN)).1 hN)⟩
      let ⟨M, hM⟩ := pow_unbounded_of_one_lt x hy
      have hb : ∃ b : ℤ, ∀ m, y ^ m ≤ x → m ≤ b :=
        ⟨M, fun m hm =>
          le_of_not_lt fun hlt =>
            not_lt_of_ge (zpow_le_of_le hy.le hlt.le)
              (lt_of_le_of_lt hm (by rwa [← zpow_natCast] at hM))⟩
      let ⟨n, hn₁, hn₂⟩ := Int.exists_greatest_of_bdd hb he
      ⟨n, hn₁, lt_of_not_ge fun hge => not_le_of_gt (Int.lt_succ _) (hn₂ _ hge)⟩
Theorem: CategoryTheory.SimplicialObject.Augmented.toArrow_obj_left
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (𝟭 C).map ((drop.map η).app (op [0])) ≫
      ((fun X => { left := drop.obj X _[0], right := point.obj X, hom := X.hom.app (op [0]) }) Y✝).hom =
    ((fun X => { left := drop.obj X _[0], right := point.obj X, hom := X.hom.app (op [0]) }) X✝).hom ≫
      (𝟭 C).map (point.map η)
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left.app (op [0]) ≫ Y✝.hom.app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left.app (op [0]) ≫ Y✝.hom.app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (η.left ≫ Y✝.hom).app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
tactic: rw [← NatTrans.comp_app]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (η.left ≫ Y✝.hom).app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (X✝.hom ≫ (const C).map η.right).app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
tactic: erw [η.w]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (X✝.hom ≫ (const C).map η.right).app (op [0]) = X✝.hom.app (op [0]) ≫ η.right
state_after: no goals
tactic: rfl
Theorem: MonoidHom.functions_ext
File: Mathlib/Algebra/BigOperators/Pi.lean

Proof steps:
state_before: I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_2
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_3
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), g (Pi.mulSingle i x) = h (Pi.mulSingle i x)
⊢ g = h
state_after: case intro
I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_2
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_3
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), g (Pi.mulSingle i x) = h (Pi.mulSingle i x)
val✝ : Fintype I
⊢ g = h
tactic: cases nonempty_fintype I
state_before: case intro
I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_2
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_3
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), g (Pi.mulSingle i x) = h (Pi.mulSingle i x)
val✝ : Fintype I
⊢ g = h
state_after: case intro.h
I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_2
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_3
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), g (Pi.mulSingle i x) = h (Pi.mulSingle i x)
val✝ : Fintype I
k : (i : I) → Z i
⊢ g k = h k
tactic: ext k
state_before: case intro.h
I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_2
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_3
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), g (Pi.mulSingle i x) = h (Pi.mulSingle i x)
val✝ : Fintype I
k : (i : I) → Z i
⊢ g k = h k
state_after: case intro.h
I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_2
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_3
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), g (Pi.mulSingle i x) = h (Pi.mulSingle i x)
val✝ : Fintype I
k : (i : I) → Z i
⊢ ∏ x : I, g (Pi.mulSingle x (k x)) = ∏ x : I, h (Pi.mulSingle x (k x))
tactic: rw [← Finset.univ_prod_mulSingle k, map_prod, map_prod]
state_before: case intro.h
I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_2
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_3
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), g (Pi.mulSingle i x) = h (Pi.mulSingle i x)
val✝ : Fintype I
k : (i : I) → Z i
⊢ ∏ x : I, g (Pi.mulSingle x (k x)) = ∏ x : I, h (Pi.mulSingle x (k x))
state_after: no goals
tactic: simp only [H]
Theorem: lp.norm_compl_sum_single
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type u_3
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
hp : 0 < p.toReal
f : ↥(lp E p)
s : Finset α
⊢ ‖f - ∑ i ∈ s, lp.single p i (↑f i)‖ ^ p.toReal = ‖f‖ ^ p.toReal - ∑ i ∈ s, ‖↑f i‖ ^ p.toReal
state_after: no goals
tactic: linarith [lp.norm_sub_norm_compl_sub_single hp f s]
Theorem: ZMod.pow_div_two_eq_neg_one_or_one
File: Mathlib/NumberTheory/LegendreSymbol/Basic.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : a ≠ 0
⊢ a ^ (p / 2) = 1 ∨ a ^ (p / 2) = -1
state_after: case inl
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : a ≠ 0
hp2 : p = 2
⊢ a ^ (p / 2) = 1 ∨ a ^ (p / 2) = -1

case inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : a ≠ 0
hp_odd : p % 2 = 1
⊢ a ^ (p / 2) = 1 ∨ a ^ (p / 2) = -1
tactic: cases' Prime.eq_two_or_odd (@Fact.out p.Prime _) with hp2 hp_odd
state_before: case inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : a ≠ 0
hp_odd : p % 2 = 1
⊢ a ^ (p / 2) = 1 ∨ a ^ (p / 2) = -1
state_after: case inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : a ≠ 0
hp_odd : p % 2 = 1
⊢ a ^ (p - 1) = 1
tactic: rw [← mul_self_eq_one_iff, ← pow_add, ← two_mul, two_mul_odd_div_two hp_odd]
state_before: case inr
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
ha : a ≠ 0
hp_odd : p % 2 = 1
⊢ a ^ (p - 1) = 1
state_after: no goals
tactic: exact pow_card_sub_one_eq_one ha
Theorem: mfderivWithin_eq_fderivWithin
File: Mathlib/Geometry/Manifold/MFDeriv/FDeriv.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : NormedSpace 𝕜 E'
f : E → E'
s : Set E
x : E
⊢ mfderivWithin 𝓘(𝕜, E) 𝓘(𝕜, E') f s x = fderivWithin 𝕜 f s x
state_after: case pos
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : NormedSpace 𝕜 E'
f : E → E'
s : Set E
x : E
h : MDifferentiableWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') f s x
⊢ mfderivWithin 𝓘(𝕜, E) 𝓘(𝕜, E') f s x = fderivWithin 𝕜 f s x

case neg
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : NormedSpace 𝕜 E'
f : E → E'
s : Set E
x : E
h : ¬MDifferentiableWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') f s x
⊢ mfderivWithin 𝓘(𝕜, E) 𝓘(𝕜, E') f s x = fderivWithin 𝕜 f s x
tactic: by_cases h : MDifferentiableWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') f s x
Theorem: DFinsupp.sigmaCurry_add
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
α : ι → Type u_2
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → AddZeroClass (δ i j)
f g : Π₀ (i : (x : ι) × α x), δ i.fst i.snd
⊢ (f + g).sigmaCurry = f.sigmaCurry + g.sigmaCurry
state_after: case h.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
α : ι → Type u_2
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → AddZeroClass (δ i j)
f g : Π₀ (i : (x : ι) × α x), δ i.fst i.snd
i : ι
j : α i
⊢ ((f + g).sigmaCurry i) j = ((f.sigmaCurry + g.sigmaCurry) i) j
tactic: ext (i j)
state_before: case h.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
κ : Type u_1
α : ι → Type u_2
δ : (i : ι) → α i → Type v
inst✝ : (i : ι) → (j : α i) → AddZeroClass (δ i j)
f g : Π₀ (i : (x : ι) × α x), δ i.fst i.snd
i : ι
j : α i
⊢ ((f + g).sigmaCurry i) j = ((f.sigmaCurry + g.sigmaCurry) i) j
state_after: no goals
tactic: rfl
Theorem: HomologicalComplex.pOpcycles_opcyclesToCycles
File: Mathlib/Algebra/Homology/HomologySequence.lean

Proof steps:
state_before: C : Type u_1
ι : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : HasZeroMorphisms C
c : ComplexShape ι
K L : HomologicalComplex C c
φ : K ⟶ L
i j : ι
inst✝³ : K.HasHomology i
inst✝² : K.HasHomology j
inst✝¹ : L.HasHomology i
inst✝ : L.HasHomology j
⊢ K.pOpcycles i ≫ K.opcyclesToCycles i j = K.toCycles i j
state_after: no goals
tactic: simp only [← cancel_mono (K.iCycles j), assoc, opcyclesToCycles_iCycles,
    p_fromOpcycles, toCycles_i]
Theorem: neg_one_geom_sum
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
inst✝ : Ring α
n : ℕ
⊢ ∑ i ∈ range n, (-1) ^ i = if Even n then 0 else 1
state_after: case zero
α : Type u
inst✝ : Ring α
⊢ ∑ i ∈ range 0, (-1) ^ i = if Even 0 then 0 else 1

case succ
α : Type u
inst✝ : Ring α
k : ℕ
hk : ∑ i ∈ range k, (-1) ^ i = if Even k then 0 else 1
⊢ ∑ i ∈ range (k + 1), (-1) ^ i = if Even (k + 1) then 0 else 1
tactic: induction' n with k hk
Theorem: CategoryTheory.eqToHom_map
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
p : X = Y
⊢ F.map (eqToHom p) = eqToHom ⋯
state_after: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X : C
⊢ F.map (eqToHom ⋯) = eqToHom ⋯
tactic: cases p
state_before: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X : C
⊢ F.map (eqToHom ⋯) = eqToHom ⋯
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.colimit.map_desc
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 : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
c : Cocone G
⊢ colimMap α ≫ desc G c = desc F ((Cocones.precompose α).obj c)
state_after: case w
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 : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
c : Cocone G
j : J
⊢ ι F j ≫ colimMap α ≫ desc G c = ι F j ≫ desc F ((Cocones.precompose α).obj c)
tactic: ext j
state_before: case w
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 : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
c : Cocone G
j : J
⊢ ι F j ≫ colimMap α ≫ desc G c = ι F j ≫ desc F ((Cocones.precompose α).obj c)
state_after: no goals
tactic: simp [← assoc, colimit.ι_map, assoc, colimit.ι_desc, colimit.ι_desc]
Theorem: CompactIccSpace.mk'
File: Mathlib/Topology/Algebra/Order/Compact.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
h : ∀ {a b : α}, a ≤ b → IsCompact (Icc a b)
a b : α
hab : ¬a ≤ b
⊢ IsCompact (Icc a b)
state_after: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
h : ∀ {a b : α}, a ≤ b → IsCompact (Icc a b)
a b : α
hab : ¬a ≤ b
⊢ IsCompact ∅
tactic: rw [Icc_eq_empty hab]
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
h : ∀ {a b : α}, a ≤ b → IsCompact (Icc a b)
a b : α
hab : ¬a ≤ b
⊢ IsCompact ∅
state_after: no goals
tactic: exact isCompact_empty
Theorem: WeierstrassCurve.Affine.CoordinateRing.map_injective
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
hf : Function.Injective ⇑f
y : W.CoordinateRing
hy : (map W f) y = 0
⊢ y = 0
state_after: case intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
hf : Function.Injective ⇑f
p q : R[X]
hy : (map W f) (p • 1 + q • (mk W) Y) = 0
⊢ p • 1 + q • (mk W) Y = 0
tactic: obtain ⟨p, q, rfl⟩ := exists_smul_basis_eq y
state_before: case intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
hf : Function.Injective ⇑f
p q : R[X]
hy : (map W f) (p • 1 + q • (mk W) Y) = 0
⊢ p • 1 + q • (mk W) Y = 0
state_after: case intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
hf : Function.Injective ⇑f
p q : R[X]
hy : Polynomial.map f p • 1 + Polynomial.map f q • (mk (WeierstrassCurve.map W f)) Y = 0
⊢ p • 1 + q • (mk W) Y = 0
tactic: simp_rw [map_add, CoordinateRing.map_smul, map_one, map_mk, map_X] at hy
state_before: case intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
hf : Function.Injective ⇑f
p q : R[X]
hy : Polynomial.map f p • 1 + Polynomial.map f q • (mk (WeierstrassCurve.map W f)) Y = 0
⊢ p • 1 + q • (mk W) Y = 0
state_after: case intro.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
hf : Function.Injective ⇑f
p q : R[X]
hy : Polynomial.map f p • 1 + Polynomial.map f q • (mk (WeierstrassCurve.map W f)) Y = 0
hp : Polynomial.map f p = 0
hq : Polynomial.map f q = 0
⊢ p • 1 + q • (mk W) Y = 0
tactic: obtain ⟨hp, hq⟩ := smul_basis_eq_zero hy
state_before: case intro.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
hf : Function.Injective ⇑f
p q : R[X]
hy : Polynomial.map f p • 1 + Polynomial.map f q • (mk (WeierstrassCurve.map W f)) Y = 0
hp : Polynomial.map f p = 0
hq : Polynomial.map f q = 0
⊢ p • 1 + q • (mk W) Y = 0
state_after: case intro.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
hf : Function.Injective ⇑f
p q : R[X]
hy : Polynomial.map f p • 1 + Polynomial.map f q • (mk (WeierstrassCurve.map W f)) Y = 0
hp : p = 0
hq : q = 0
⊢ p • 1 + q • (mk W) Y = 0
tactic: rw [Polynomial.map_eq_zero_iff hf] at hp hq
state_before: case intro.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
hf : Function.Injective ⇑f
p q : R[X]
hy : Polynomial.map f p • 1 + Polynomial.map f q • (mk (WeierstrassCurve.map W f)) Y = 0
hp : p = 0
hq : q = 0
⊢ p • 1 + q • (mk W) Y = 0
state_after: no goals
tactic: simp_rw [hp, hq, zero_smul, add_zero]
Theorem: Matrix.det_succ_column
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

Proof steps:
state_before: m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin n.succ) (Fin n.succ) R
j : Fin n.succ
⊢ A.det = ∑ i : Fin n.succ, (-1) ^ (↑i + ↑j) * A i j * (A.submatrix i.succAbove j.succAbove).det
state_after: m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin n.succ) (Fin n.succ) R
j : Fin n.succ
⊢ ∑ j_1 : Fin n.succ, (-1) ^ (↑j + ↑j_1) * Aᵀ j j_1 * (Aᵀ.submatrix j.succAbove j_1.succAbove).det =
    ∑ i : Fin n.succ, (-1) ^ (↑i + ↑j) * A i j * (A.submatrix i.succAbove j.succAbove).det
tactic: rw [← det_transpose, det_succ_row _ j]
state_before: m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin n.succ) (Fin n.succ) R
j : Fin n.succ
⊢ ∑ j_1 : Fin n.succ, (-1) ^ (↑j + ↑j_1) * Aᵀ j j_1 * (Aᵀ.submatrix j.succAbove j_1.succAbove).det =
    ∑ i : Fin n.succ, (-1) ^ (↑i + ↑j) * A i j * (A.submatrix i.succAbove j.succAbove).det
state_after: m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin n.succ) (Fin n.succ) R
j i : Fin n.succ
x✝ : i ∈ univ
⊢ (-1) ^ (↑j + ↑i) * Aᵀ j i * (Aᵀ.submatrix j.succAbove i.succAbove).det =
    (-1) ^ (↑i + ↑j) * A i j * (A.submatrix i.succAbove j.succAbove).det
tactic: refine Finset.sum_congr rfl fun i _ => ?_
state_before: m : Type u_1
n✝ : Type u_2
inst✝⁴ : DecidableEq n✝
inst✝³ : Fintype n✝
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
n : ℕ
A : Matrix (Fin n.succ) (Fin n.succ) R
j i : Fin n.succ
x✝ : i ∈ univ
⊢ (-1) ^ (↑j + ↑i) * Aᵀ j i * (Aᵀ.submatrix j.succAbove i.succAbove).det =
    (-1) ^ (↑i + ↑j) * A i j * (A.submatrix i.succAbove j.succAbove).det
state_after: no goals
tactic: rw [add_comm, ← det_transpose, transpose_apply, transpose_submatrix, transpose_transpose]
Theorem: WeierstrassCurve.baseChange_Ψ
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
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
n : ℤ
⊢ (W.baseChange B).Ψ n = Polynomial.map (mapRingHom ↑f) ((W.baseChange A).Ψ n)
state_after: no goals
tactic: rw [← map_Ψ, map_baseChange]
Theorem: isOpenMap_inr
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
u : Set Y
hu : IsOpen u
⊢ IsOpen (inr '' u)
state_after: no goals
tactic: simpa [isOpen_sum_iff, preimage_image_eq u Sum.inr_injective]
Theorem: top_symmDiff'
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : CoheytingAlgebra α
a : α
⊢ ⊤ ∆ a = ￢a
state_after: no goals
tactic: simp [symmDiff]
Theorem: inner_eq_norm_mul_iff
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
x y : E
⊢ ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖ ↔ ↑‖y‖ • x = ↑‖x‖ • y
state_after: case inl
𝕜 : 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
y : E
⊢ ⟪0, y⟫_𝕜 = ↑‖0‖ * ↑‖y‖ ↔ ↑‖y‖ • 0 = ↑‖0‖ • y

case inr
𝕜 : 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
x y : E
h₀ : x ≠ 0
⊢ ⟪x, y⟫_𝕜 = ↑‖x‖ * ↑‖y‖ ↔ ↑‖y‖ • x = ↑‖x‖ • y
tactic: rcases eq_or_ne x 0 with (rfl | h₀)
Theorem: Prod.fst_eq_iff
File: Mathlib/Data/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a : α
b : β
x : α
⊢ (a, b).fst = x ↔ (a, b) = (x, (a, b).snd)
state_after: no goals
tactic: simp
Theorem: MeasureTheory.VectorMeasure.nonneg_of_zero_le_restrict
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi₂ : restrict 0 i ≤ v.restrict i
⊢ 0 ≤ ↑v i
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi₂ : restrict 0 i ≤ v.restrict i
hi₁ : MeasurableSet i
⊢ 0 ≤ ↑v i

case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi₂ : restrict 0 i ≤ v.restrict i
hi₁ : ¬MeasurableSet i
⊢ 0 ≤ ↑v i
tactic: by_cases hi₁ : MeasurableSet i
Theorem: conformalAt_iff'
File: Mathlib/Analysis/Calculus/Conformal/InnerProduct.lean

Proof steps:
state_before: E : Type u_1
F : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace ℝ E
inst✝ : InnerProductSpace ℝ F
f : E → F
x : E
⊢ ConformalAt f x ↔ ∃ c, 0 < c ∧ ∀ (u v : E), ⟪(fderiv ℝ f x) u, (fderiv ℝ f x) v⟫_ℝ = c * ⟪u, v⟫_ℝ
state_after: no goals
tactic: rw [conformalAt_iff_isConformalMap_fderiv, isConformalMap_iff]
Theorem: Equiv.Perm.toList_eq_nil_iff
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p✝ : Perm α
x✝ : α
p : Perm α
x : α
⊢ p.toList x = [] ↔ x ∉ p.support
state_after: no goals
tactic: simp [toList]