1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.ShortComplex.ab_exact_iff
File: Mathlib/Algebra/Homology/ShortComplex/Ab.lean

tactic: rw [exact_iff_surjective_abToCycles]
state_before: S : ShortComplex Ab
⊢ S.Exact ↔ ∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂
state_after: S : ShortComplex Ab
⊢ Function.Surjective ⇑S.abToCycles ↔ ∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂

tactic: constructor
state_before: S : ShortComplex Ab
⊢ Function.Surjective ⇑S.abToCycles ↔ ∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂
state_after: case mp
S : ShortComplex Ab
⊢ Function.Surjective ⇑S.abToCycles → ∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂

case mpr
S : ShortComplex Ab
⊢ (∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂) → Function.Surjective ⇑S.abToCycles

tactic: intro h x₂ hx₂
state_before: case mp
S : ShortComplex Ab
⊢ Function.Surjective ⇑S.abToCycles → ∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂
state_after: case mp
S : ShortComplex Ab
h : Function.Surjective ⇑S.abToCycles
x₂ : ↑S.X₂
hx₂ : S.g x₂ = 0
⊢ ∃ x₁, S.f x₁ = x₂

tactic: obtain ⟨x₁, hx₁⟩ := h ⟨x₂, hx₂⟩
state_before: case mp
S : ShortComplex Ab
h : Function.Surjective ⇑S.abToCycles
x₂ : ↑S.X₂
hx₂ : S.g x₂ = 0
⊢ ∃ x₁, S.f x₁ = x₂
state_after: case mp.intro
S : ShortComplex Ab
h : Function.Surjective ⇑S.abToCycles
x₂ : ↑S.X₂
hx₂ : S.g x₂ = 0
x₁ : ↑S.X₁
hx₁ : S.abToCycles x₁ = ⟨x₂, hx₂⟩
⊢ ∃ x₁, S.f x₁ = x₂

tactic: exact ⟨x₁, by simpa only [Subtype.ext_iff, abToCycles_apply_coe] using hx₁⟩
state_before: case mp.intro
S : ShortComplex Ab
h : Function.Surjective ⇑S.abToCycles
x₂ : ↑S.X₂
hx₂ : S.g x₂ = 0
x₁ : ↑S.X₁
hx₁ : S.abToCycles x₁ = ⟨x₂, hx₂⟩
⊢ ∃ x₁, S.f x₁ = x₂
state_after: no goals

tactic: simpa only [Subtype.ext_iff, abToCycles_apply_coe] using hx₁
state_before: S : ShortComplex Ab
h : Function.Surjective ⇑S.abToCycles
x₂ : ↑S.X₂
hx₂ : S.g x₂ = 0
x₁ : ↑S.X₁
hx₁ : S.abToCycles x₁ = ⟨x₂, hx₂⟩
⊢ S.f x₁ = x₂
state_after: no goals

tactic: rintro h ⟨x₂, hx₂⟩
state_before: case mpr
S : ShortComplex Ab
⊢ (∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂) → Function.Surjective ⇑S.abToCycles
state_after: case mpr.mk
S : ShortComplex Ab
h : ∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂
x₂ : ↑S.X₂
hx₂ : x₂ ∈ AddMonoidHom.ker S.g
⊢ ∃ a, S.abToCycles a = ⟨x₂, hx₂⟩

tactic: obtain ⟨x₁, rfl⟩ := h x₂ hx₂
state_before: case mpr.mk
S : ShortComplex Ab
h : ∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂
x₂ : ↑S.X₂
hx₂ : x₂ ∈ AddMonoidHom.ker S.g
⊢ ∃ a, S.abToCycles a = ⟨x₂, hx₂⟩
state_after: case mpr.mk.intro
S : ShortComplex Ab
h : ∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂
x₁ : ↑S.X₁
hx₂ : S.f x₁ ∈ AddMonoidHom.ker S.g
⊢ ∃ a, S.abToCycles a = ⟨S.f x₁, hx₂⟩

tactic: exact ⟨x₁, rfl⟩
state_before: case mpr.mk.intro
S : ShortComplex Ab
h : ∀ (x₂ : ↑S.X₂), S.g x₂ = 0 → ∃ x₁, S.f x₁ = x₂
x₁ : ↑S.X₁
hx₂ : S.f x₁ ∈ AddMonoidHom.ker S.g
⊢ ∃ a, S.abToCycles a = ⟨S.f x₁, hx₂⟩
state_after: no goals
Theorem: ProbabilityTheory.condCount_univ
File: Mathlib/Probability/CondCount.lean

tactic: rw [condCount, cond_apply _ MeasurableSet.univ, ← ENNReal.div_eq_inv_mul, Set.univ_inter]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : Fintype Ω
s : Set Ω
⊢ (condCount Set.univ) s = Measure.count s / ↑(Fintype.card Ω)
state_after: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : Fintype Ω
s : Set Ω
⊢ Measure.count s / Measure.count Set.univ = Measure.count s / ↑(Fintype.card Ω)

tactic: congr
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : Fintype Ω
s : Set Ω
⊢ Measure.count s / Measure.count Set.univ = Measure.count s / ↑(Fintype.card Ω)
state_after: case e_a
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : Fintype Ω
s : Set Ω
⊢ Measure.count Set.univ = ↑(Fintype.card Ω)

tactic: rw [← Finset.coe_univ, Measure.count_apply, Finset.univ.tsum_subtype' fun _ => (1 : ENNReal)]
state_before: case e_a
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : Fintype Ω
s : Set Ω
⊢ Measure.count Set.univ = ↑(Fintype.card Ω)
state_after: case e_a
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : Fintype Ω
s : Set Ω
⊢ ∑ x : Ω, 1 = ↑(Fintype.card Ω)

case e_a
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : Fintype Ω
s : Set Ω
⊢ MeasurableSet ↑Finset.univ

tactic: simp [Finset.card_univ]
state_before: case e_a
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : Fintype Ω
s : Set Ω
⊢ ∑ x : Ω, 1 = ↑(Fintype.card Ω)
state_after: no goals

tactic: exact (@Finset.coe_univ Ω _).symm ▸ MeasurableSet.univ
state_before: case e_a
Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : Fintype Ω
s : Set Ω
⊢ MeasurableSet ↑Finset.univ
state_after: no goals
Theorem: Polynomial.roots_expand_image_iterateFrobenius
File: Mathlib/FieldTheory/Perfect.lean

tactic: rw [Finset.image_toFinset, roots_expand_pow_map_iterateFrobenius,
  (roots f).toFinset_nsmul _ (expChar_pow_pos R p n).ne']
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
p n : ℕ
inst✝² : ExpChar R p
f : R[X]
inst✝¹ : PerfectRing R p
inst✝ : DecidableEq R
⊢ Finset.image (⇑(iterateFrobenius R p n)) ((expand R (p ^ n)) f).roots.toFinset = f.roots.toFinset
state_after: no goals
Theorem: MeasurableEmbedding.comap_map
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: ext t _
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure α
⊢ Measure.comap f (Measure.map f μ) = μ
state_after: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure α
t : Set α
a✝ : MeasurableSet t
⊢ (Measure.comap f (Measure.map f μ)) t = μ t

tactic: rw [hf.comap_apply, hf.map_apply, preimage_image_eq _ hf.injective]
state_before: case h
R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure α
t : Set α
a✝ : MeasurableSet t
⊢ (Measure.comap f (Measure.map f μ)) t = μ t
state_after: no goals
Theorem: CategoryTheory.Functor.reflectsMonomorphisms.of_iso
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

tactic: apply F.mono_of_mono_map
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsMonomorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
⊢ Mono f
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsMonomorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
⊢ Mono (F.map f)

tactic: haveI : Mono (G.map f ≫ (α.app Y).inv) := mono_comp _ _
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsMonomorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
⊢ Mono (F.map f)
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsMonomorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
this : Mono (G.map f ≫ (α.app Y).inv)
⊢ Mono (F.map f)

tactic: convert (mono_comp _ _ : Mono ((α.app X).hom ≫ G.map f ≫ (α.app Y).inv))
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsMonomorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
this : Mono (G.map f ≫ (α.app Y).inv)
⊢ Mono (F.map f)
state_after: case h.e'_5
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsMonomorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
this : Mono (G.map f ≫ (α.app Y).inv)
⊢ F.map f = (α.app X).hom ≫ G.map f ≫ (α.app Y).inv

tactic: rw [← Category.assoc, Iso.eq_comp_inv, Iso.app_hom, Iso.app_hom, NatTrans.naturality]
state_before: case h.e'_5
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F G : C ⥤ D
inst✝ : F.ReflectsMonomorphisms
α : F ≅ G
X Y : C
f : X ⟶ Y
h : Mono (G.map f)
this : Mono (G.map f ≫ (α.app Y).inv)
⊢ F.map f = (α.app X).hom ≫ G.map f ≫ (α.app Y).inv
state_after: no goals
Theorem: AddLECancellable.tsub_right_inj
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: simp_rw [le_antisymm_iff, ha.tsub_le_tsub_iff_left hb hba, ha.tsub_le_tsub_iff_left hc hca,
  and_comm]
state_before: α : Type u_1
inst✝² : CanonicallyOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
ha : AddLECancellable a
hb : AddLECancellable b
hc : AddLECancellable c
hba : b ≤ a
hca : c ≤ a
⊢ a - b = a - c ↔ b = c
state_after: no goals
Theorem: FiberPrebundle.continuous_proj
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: letI := a.totalSpaceTopology
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
⊢ Continuous TotalSpace.proj
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
this : TopologicalSpace (TotalSpace F E) := a.totalSpaceTopology
⊢ Continuous TotalSpace.proj

tactic: letI := a.toFiberBundle
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
this : TopologicalSpace (TotalSpace F E) := a.totalSpaceTopology
⊢ Continuous TotalSpace.proj
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
this✝ : TopologicalSpace (TotalSpace F E) := a.totalSpaceTopology
this : FiberBundle F E := a.toFiberBundle
⊢ Continuous TotalSpace.proj

tactic: exact FiberBundle.continuous_proj F E
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝³ : TopologicalSpace X
E : B → Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
this✝ : TopologicalSpace (TotalSpace F E) := a.totalSpaceTopology
this : FiberBundle F E := a.toFiberBundle
⊢ Continuous TotalSpace.proj
state_after: no goals
Theorem: Finset.inter_left_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_inter, and_left_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ s₃ : Finset α
x✝ : α
⊢ x✝ ∈ s₁ ∩ (s₂ ∩ s₃) ↔ x✝ ∈ s₂ ∩ (s₁ ∩ s₃)
state_after: no goals
Theorem: Ordinal.lift_isLimit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [lift_zero] using @lift_inj o 0
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
⊢ lift.{u_5, u_4} o = 0 ↔ o = 0
state_after: no goals

tactic: simpa only [lift_succ] using H _ (lift_lt.2 h)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
H : ∀ a < lift.{u_5, u_4} o, succ a < lift.{u_5, u_4} o
a : Ordinal.{u_4}
h : a < o
⊢ lift.{?u.22137, u_4} (succ a) < lift.{?u.22137, u_4} o
state_after: no goals

tactic: obtain ⟨a', rfl⟩ := lift_down h.le
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
H : ∀ a < o, succ a < o
a : Ordinal.{max u_4 u_5}
h : a < lift.{u_5, u_4} o
⊢ succ a < lift.{u_5, u_4} o
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
H : ∀ a < o, succ a < o
a' : Ordinal.{u_4}
h : lift.{u_5, u_4} a' < lift.{u_5, u_4} o
⊢ succ (lift.{u_5, u_4} a') < lift.{u_5, u_4} o

tactic: rw [← lift_succ, lift_lt]
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
H : ∀ a < o, succ a < o
a' : Ordinal.{u_4}
h : lift.{u_5, u_4} a' < lift.{u_5, u_4} o
⊢ succ (lift.{u_5, u_4} a') < lift.{u_5, u_4} o
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
H : ∀ a < o, succ a < o
a' : Ordinal.{u_4}
h : lift.{u_5, u_4} a' < lift.{u_5, u_4} o
⊢ succ a' < o

tactic: exact H a' (lift_lt.1 h)
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
H : ∀ a < o, succ a < o
a' : Ordinal.{u_4}
h : lift.{u_5, u_4} a' < lift.{u_5, u_4} o
⊢ succ a' < o
state_after: no goals
Theorem: Complex.HasDerivAt.complex_of_real
File: Mathlib/NumberTheory/Harmonic/GammaDeriv.lean

tactic: refine HasDerivAt.congr_deriv hf.hasDerivAt ?_
state_before: f : ℂ → ℂ
g : ℝ → ℝ
g' s : ℝ
hf : DifferentiableAt ℂ f ↑s
hg : HasDerivAt g g' s
hfg : ∀ (s : ℝ), f ↑s = ↑(g s)
⊢ HasDerivAt f ↑g' ↑s
state_after: f : ℂ → ℂ
g : ℝ → ℝ
g' s : ℝ
hf : DifferentiableAt ℂ f ↑s
hg : HasDerivAt g g' s
hfg : ∀ (s : ℝ), f ↑s = ↑(g s)
⊢ deriv f ↑s = ↑g'

tactic: rw [← (funext hfg ▸ hf.hasDerivAt.comp_ofReal.deriv :)]
state_before: f : ℂ → ℂ
g : ℝ → ℝ
g' s : ℝ
hf : DifferentiableAt ℂ f ↑s
hg : HasDerivAt g g' s
hfg : ∀ (s : ℝ), f ↑s = ↑(g s)
⊢ deriv f ↑s = ↑g'
state_after: f : ℂ → ℂ
g : ℝ → ℝ
g' s : ℝ
hf : DifferentiableAt ℂ f ↑s
hg : HasDerivAt g g' s
hfg : ∀ (s : ℝ), f ↑s = ↑(g s)
⊢ deriv (fun x => ↑(g x)) s = ↑g'

tactic: exact hg.ofReal_comp.deriv
state_before: f : ℂ → ℂ
g : ℝ → ℝ
g' s : ℝ
hf : DifferentiableAt ℂ f ↑s
hg : HasDerivAt g g' s
hfg : ∀ (s : ℝ), f ↑s = ↑(g s)
⊢ deriv (fun x => ↑(g x)) s = ↑g'
state_after: no goals
Theorem: Interval.mul_eq_one_iff
File: Mathlib/Algebra/Order/Interval/Basic.lean

tactic: cases s
state_before: ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
⊢ s * t = 1 ↔ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1
state_after: case bot
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
t : Interval α
⊢ ⊥ * t = 1 ↔ ∃ a b, ⊥ = pure a ∧ t = pure b ∧ a * b = 1

case coe
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
t : Interval α
a✝ : NonemptyInterval α
⊢ ↑a✝ * t = 1 ↔ ∃ a b, ↑a✝ = pure a ∧ t = pure b ∧ a * b = 1

tactic: cases t
state_before: case coe
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
t : Interval α
a✝ : NonemptyInterval α
⊢ ↑a✝ * t = 1 ↔ ∃ a b, ↑a✝ = pure a ∧ t = pure b ∧ a * b = 1
state_after: case coe.bot
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
a✝ : NonemptyInterval α
⊢ ↑a✝ * ⊥ = 1 ↔ ∃ a b, ↑a✝ = pure a ∧ ⊥ = pure b ∧ a * b = 1

case coe.coe
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
a✝¹ a✝ : NonemptyInterval α
⊢ ↑a✝¹ * ↑a✝ = 1 ↔ ∃ a b, ↑a✝¹ = pure a ∧ ↑a✝ = pure b ∧ a * b = 1

tactic: simp
state_before: case bot
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
t : Interval α
⊢ ⊥ * t = 1 ↔ ∃ a b, ⊥ = pure a ∧ t = pure b ∧ a * b = 1
state_after: no goals

tactic: simp
state_before: case coe.bot
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
a✝ : NonemptyInterval α
⊢ ↑a✝ * ⊥ = 1 ↔ ∃ a b, ↑a✝ = pure a ∧ ⊥ = pure b ∧ a * b = 1
state_after: no goals

tactic: simp_rw [← NonemptyInterval.coe_mul_interval, ← NonemptyInterval.coe_one_interval,
  WithBot.coe_inj, NonemptyInterval.coe_eq_pure]
state_before: case coe.coe
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
a✝¹ a✝ : NonemptyInterval α
⊢ ↑a✝¹ * ↑a✝ = 1 ↔ ∃ a b, ↑a✝¹ = pure a ∧ ↑a✝ = pure b ∧ a * b = 1
state_after: case coe.coe
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
a✝¹ a✝ : NonemptyInterval α
⊢ a✝¹ * a✝ = 1 ↔ ∃ a b, a✝¹ = NonemptyInterval.pure a ∧ a✝ = NonemptyInterval.pure b ∧ a * b = 1

tactic: exact NonemptyInterval.mul_eq_one_iff
state_before: case coe.coe
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
a✝¹ a✝ : NonemptyInterval α
⊢ a✝¹ * a✝ = 1 ↔ ∃ a b, a✝¹ = NonemptyInterval.pure a ∧ a✝ = NonemptyInterval.pure b ∧ a * b = 1
state_after: no goals
Theorem: Part.some_mul_some
File: Mathlib/Data/Part.lean

tactic: simp [mul_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mul α
a b : α
⊢ some a * some b = some (a * b)
state_after: no goals
Theorem: Cardinal.succ_zero
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: norm_cast
state_before: α β : Type u
⊢ succ 0 = 1
state_after: no goals
Theorem: Int.odd_mul
File: Mathlib/Algebra/Ring/Int.lean

tactic: simp [not_or, parity_simps]
state_before: m n : ℤ
⊢ Odd (m * n) ↔ Odd m ∧ Odd n
state_after: no goals
Theorem: Lagrange.eval_nodal
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [nodal, eval_prod, eval_sub, eval_X, eval_C]
state_before: R : Type u_1
inst✝ : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
x : R
⊢ eval x (nodal s v) = ∏ i ∈ s, (x - v i)
state_after: no goals
Theorem: IsCompact.isClosed
File: Mathlib/Topology/Separation.lean

tactic: simpa using xv
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
s : Set X
hs : IsCompact s
x : X
hx : x ∈ sᶜ
u v : Set X
left✝ : IsOpen u
vo : IsOpen v
su : s ⊆ u
xv : {x} ⊆ v
uv : Disjoint u v
⊢ x ∈ v
state_after: no goals
Theorem: Stream'.WSeq.destruct_tail
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp only [tail, destruct_flatten, tail.aux]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ s.tail.destruct = s.destruct >>= tail.aux
state_after: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct = s.destruct >>= tail.aux

tactic: rw [← bind_pure_comp, LawfulMonad.bind_assoc]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ (fun o => Option.rec nil Prod.snd o) <$> s.destruct >>= destruct = s.destruct >>= tail.aux
state_after: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ (s.destruct >>= fun x => Pure.pure (Option.rec nil Prod.snd x) >>= destruct) = s.destruct >>= tail.aux

tactic: apply congr_arg
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ (s.destruct >>= fun x => Pure.pure (Option.rec nil Prod.snd x) >>= destruct) = s.destruct >>= tail.aux
state_after: case h
α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ (fun x => Pure.pure (Option.rec nil Prod.snd x) >>= destruct) = tail.aux

tactic: ext1 (_ | ⟨a, s⟩) <;> apply (@pure_bind Computation _ _ _ _ _ _).trans _ <;> simp
state_before: case h
α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ (fun x => Pure.pure (Option.rec nil Prod.snd x) >>= destruct) = tail.aux
state_after: no goals
Theorem: Finset.Ico_filter_le
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: cases le_total a c with
| inl h => rw [Ico_filter_le_of_left_le h, max_eq_right h]
| inr h => rw [Ico_filter_le_of_le_left h, max_eq_left h]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
⊢ filter (fun x => c ≤ x) (Ico a b) = Ico (max a c) b
state_after: no goals

tactic: rw [Ico_filter_le_of_left_le h, max_eq_right h]
state_before: case inl
ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
h : a ≤ c
⊢ filter (fun x => c ≤ x) (Ico a b) = Ico (max a c) b
state_after: no goals

tactic: rw [Ico_filter_le_of_le_left h, max_eq_left h]
state_before: case inr
ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
h : c ≤ a
⊢ filter (fun x => c ≤ x) (Ico a b) = Ico (max a c) b
state_after: no goals
Theorem: List.ranges_length
File: Mathlib/Data/List/Range.lean

tactic: induction l with
| nil => simp only [ranges, map_nil]
| cons a l hl => simp only [map, length_range, map_map, cons.injEq, true_and]
  conv_rhs => rw [← hl]
  apply map_congr_left
  intro s _
  simp only [Function.comp_apply, length_map]
state_before: α : Type u
l : List ℕ
⊢ map length l.ranges = l
state_after: no goals

tactic: simp only [ranges, map_nil]
state_before: case nil
α : Type u
⊢ map length [].ranges = []
state_after: no goals

tactic: simp only [map, length_range, map_map, cons.injEq, true_and]
state_before: case cons
α : Type u
a : ℕ
l : List ℕ
hl : map length l.ranges = l
⊢ map length (a :: l).ranges = a :: l
state_after: case cons
α : Type u
a : ℕ
l : List ℕ
hl : map length l.ranges = l
⊢ map (length ∘ map fun x => a + x) l.ranges = l

tactic: conv_rhs => rw [← hl]
state_before: case cons
α : Type u
a : ℕ
l : List ℕ
hl : map length l.ranges = l
⊢ map (length ∘ map fun x => a + x) l.ranges = l
state_after: case cons
α : Type u
a : ℕ
l : List ℕ
hl : map length l.ranges = l
⊢ map (length ∘ map fun x => a + x) l.ranges = map length l.ranges

tactic: apply map_congr_left
state_before: case cons
α : Type u
a : ℕ
l : List ℕ
hl : map length l.ranges = l
⊢ map (length ∘ map fun x => a + x) l.ranges = map length l.ranges
state_after: case cons.h
α : Type u
a : ℕ
l : List ℕ
hl : map length l.ranges = l
⊢ ∀ a_1 ∈ l.ranges, (length ∘ map fun x => a + x) a_1 = a_1.length

tactic: intro s _
state_before: case cons.h
α : Type u
a : ℕ
l : List ℕ
hl : map length l.ranges = l
⊢ ∀ a_1 ∈ l.ranges, (length ∘ map fun x => a + x) a_1 = a_1.length
state_after: case cons.h
α : Type u
a : ℕ
l : List ℕ
hl : map length l.ranges = l
s : List ℕ
a✝ : s ∈ l.ranges
⊢ (length ∘ map fun x => a + x) s = s.length

tactic: simp only [Function.comp_apply, length_map]
state_before: case cons.h
α : Type u
a : ℕ
l : List ℕ
hl : map length l.ranges = l
s : List ℕ
a✝ : s ∈ l.ranges
⊢ (length ∘ map fun x => a + x) s = s.length
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.nonsingular_add_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rwa [← X_eq_iff hPz hQz, ne_eq, ← Y_eq_iff' hPz hQz]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Nonsingular P
hQ : W.Nonsingular Q
hPz : P z ≠ 0
hQz : Q z ≠ 0
hxy : P x * Q z ^ 2 = Q x * P z ^ 2 → P y * Q z ^ 3 ≠ W.negY Q * P z ^ 3
⊢ P x / P z ^ 2 = Q x / Q z ^ 2 → P y / P z ^ 3 ≠ W.toAffine.negY (Q x / Q z ^ 2) (Q y / Q z ^ 3)
state_after: no goals
Theorem: Matrix.smul_eq_diagonal_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n α
a : α
⊢ a • M = (diagonal fun x => a) * M
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n α
a : α
i✝ : m
j✝ : n
⊢ (a • M) i✝ j✝ = ((diagonal fun x => a) * M) i✝ j✝

tactic: simp
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n α
a : α
i✝ : m
j✝ : n
⊢ (a • M) i✝ j✝ = ((diagonal fun x => a) * M) i✝ j✝
state_after: no goals