ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: infIooOrderIsoIooSup_symm_apply_coe
File: Mathlib/Order/ModularLattice.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z a b : α
c : ↑(Ioo (a ⊓ b) a)
⊢ ↑((fun c => ⟨a ⊓ ↑c, ⋯⟩) ((fun c => ⟨↑c ⊔ b, ⋯⟩) c)) = ↑c
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z a b : α
c : ↑(Ioo (a ⊓ b) a)
⊢ a ⊓ (↑c ⊔ b) = ↑c
tactic: dsimp
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z a b : α
c : ↑(Ioo (a ⊓ b) a)
⊢ a ⊓ (↑c ⊔ b) = ↑c
state_after: no goals
tactic: rw [sup_comm, ← inf_sup_assoc_of_le _ c.prop.2.le, sup_eq_right.2 c.prop.1.le]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z a b : α
c : ↑(Ioo b (a ⊔ b))
⊢ ↑((fun c => ⟨↑c ⊔ b, ⋯⟩) ((fun c => ⟨a ⊓ ↑c, ⋯⟩) c)) = ↑c
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z a b : α
c : ↑(Ioo b (a ⊔ b))
⊢ a ⊓ ↑c ⊔ b = ↑c
tactic: dsimp
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z a b : α
c : ↑(Ioo b (a ⊔ b))
⊢ a ⊓ ↑c ⊔ b = ↑c
state_after: no goals
tactic: rw [inf_comm, inf_sup_assoc_of_le _ c.prop.1.le, inf_eq_left.2 c.prop.2.le]
Theorem: CategoryTheory.PreGaloisCategory.card_fiber_eq_of_iso
File: Mathlib/CategoryTheory/Galois/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
i : X ≅ Y
⊢ Nat.card ↑(F.obj X) = Nat.card ↑(F.obj Y)
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
i : X ≅ Y
e : ↑(F.obj X) ≃ ↑(F.obj Y)
⊢ Nat.card ↑(F.obj X) = Nat.card ↑(F.obj Y)
tactic: have e : F.obj X ≃ F.obj Y := Iso.toEquiv (mapIso (F ⋙ FintypeCat.incl) i)
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X Y : C
i : X ≅ Y
e : ↑(F.obj X) ≃ ↑(F.obj Y)
⊢ Nat.card ↑(F.obj X) = Nat.card ↑(F.obj Y)
state_after: no goals
tactic: exact Nat.card_eq_of_bijective e (Equiv.bijective e)
Theorem: Subgroup.eq_bot_or_eq_top_of_prime_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
H : Subgroup G
hp : Fact (Nat.Prime (Fintype.card G))
⊢ H = ⊥ ∨ H = ⊤
state_after: no goals
tactic: classical
  have := card_subgroup_dvd_card H
  rwa [Nat.card_eq_fintype_card (α := G), Nat.dvd_prime hp.1, ← Nat.card_eq_fintype_card,
    ← eq_bot_iff_card, card_eq_iff_eq_top] at this
Theorem: supIrred_iff_not_isMin
File: Mathlib/Order/Irreducible.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝ : LinearOrder α
a x✝¹ x✝ : α
⊢ x✝¹ ⊔ x✝ = a → x✝¹ = a ∨ x✝ = a
state_after: no goals
tactic: simpa only [sup_eq_max, max_eq_iff] using Or.imp And.left And.left
Theorem: IsUnit.div_mul_cancel_left
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionCommMonoid α
a b✝ c d : α
h : IsUnit a
b : α
⊢ a / (a * b) = b⁻¹
state_after: no goals
tactic: rw [mul_comm, h.div_mul_cancel_right]
Theorem: Int.le_add_iff_lt_of_dvd_sub
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n : ℤ
ha : 0 < a
hab : a ∣ c - b
⊢ a + b ≤ c ↔ b < c
state_after: no goals
tactic: rw [Int.add_le_iff_le_sub, ← Int.sub_pos, le_iff_pos_of_dvd ha hab]
Theorem: CategoryTheory.MonoidalCategory.tensor_hom_inv_id
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ (g ⊗ f.hom) ≫ (h ⊗ f.inv) = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)
state_after: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ g ≫ h ⊗ 𝟙 V = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)
tactic: rw [← tensor_comp, f.hom_inv_id]
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ≅ W
g : X ⟶ Y
h : Y ⟶ Z
⊢ g ≫ h ⊗ 𝟙 V = (g ⊗ 𝟙 V) ≫ (h ⊗ 𝟙 V)
state_after: no goals
tactic: simp [tensorHom_id]
Theorem: MeasureTheory.LocallyIntegrableOn.continuousOn_smul
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹¹ : MeasurableSpace X
inst✝¹⁰ : TopologicalSpace X
inst✝⁹ : MeasurableSpace Y
inst✝⁸ : TopologicalSpace Y
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s✝ : Set X
inst✝⁵ : OpensMeasurableSpace X
A K : Set X
inst✝⁴ : LocallyCompactSpace X
inst✝³ : T2Space X
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : SecondCountableTopologyEither X 𝕜
inst✝ : NormedSpace 𝕜 E
f : X → E
g : X → 𝕜
s : Set X
hs : IsOpen s
hf : LocallyIntegrableOn f s μ
hg : ContinuousOn g s
⊢ LocallyIntegrableOn (fun x => g x • f x) s μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹¹ : MeasurableSpace X
inst✝¹⁰ : TopologicalSpace X
inst✝⁹ : MeasurableSpace Y
inst✝⁸ : TopologicalSpace Y
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s✝ : Set X
inst✝⁵ : OpensMeasurableSpace X
A K : Set X
inst✝⁴ : LocallyCompactSpace X
inst✝³ : T2Space X
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : SecondCountableTopologyEither X 𝕜
inst✝ : NormedSpace 𝕜 E
f : X → E
g : X → 𝕜
s : Set X
hs : IsOpen s
hf : ∀ k ⊆ s, IsCompact k → IntegrableOn f k μ
hg : ContinuousOn g s
⊢ ∀ k ⊆ s, IsCompact k → IntegrableOn (fun x => g x • f x) k μ
tactic: rw [MeasureTheory.locallyIntegrableOn_iff (Or.inr hs)] at hf ⊢
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹¹ : MeasurableSpace X
inst✝¹⁰ : TopologicalSpace X
inst✝⁹ : MeasurableSpace Y
inst✝⁸ : TopologicalSpace Y
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s✝ : Set X
inst✝⁵ : OpensMeasurableSpace X
A K : Set X
inst✝⁴ : LocallyCompactSpace X
inst✝³ : T2Space X
𝕜 : Type u_6
inst✝² : NormedField 𝕜
inst✝¹ : SecondCountableTopologyEither X 𝕜
inst✝ : NormedSpace 𝕜 E
f : X → E
g : X → 𝕜
s : Set X
hs : IsOpen s
hf : ∀ k ⊆ s, IsCompact k → IntegrableOn f k μ
hg : ContinuousOn g s
⊢ ∀ k ⊆ s, IsCompact k → IntegrableOn (fun x => g x • f x) k μ
state_after: no goals
tactic: exact fun k hk_sub hk_c => (hf k hk_sub hk_c).continuousOn_smul (hg.mono hk_sub) hk_c
Theorem: Monotone.continuousAt_iff_leftLim_eq_rightLim
File: Mathlib/Topology/Order/LeftRightLim.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
⊢ ContinuousAt f x ↔ leftLim f x = rightLim f x
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
h : ContinuousAt f x
⊢ leftLim f x = rightLim f x

case refine_2
α : Type u_1
β : Type u_2
inst✝⁵ : LinearOrder α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
f : α → β
hf : Monotone f
x y : α
inst✝¹ : TopologicalSpace α
inst✝ : OrderTopology α
h : leftLim f x = rightLim f x
⊢ ContinuousAt f x
tactic: refine ⟨fun h => ?_, fun h => ?_⟩
Theorem: AlgebraicGeometry.Scheme.zariskiTopology_openCover
File: Mathlib/AlgebraicGeometry/Sites/BigZariski.lean

Proof steps:
state_before: Y : Scheme
U : Y.OpenCover
⊢ zariskiTopology.sieves Y (Sieve.generate (Presieve.ofArrows U.obj U.map))
state_after: Y : Scheme
U : Y.OpenCover
V : Y.OpenCover :=
  { J := ↑↑Y.toPresheafedSpace, obj := fun y => U.obj (U.f y), map := fun y => U.map (U.f y), f := id, covers := ⋯,
    IsOpen := ⋯ }
⊢ zariskiTopology.sieves Y (Sieve.generate (Presieve.ofArrows U.obj U.map))
tactic: let V : OpenCover.{u} Y :=
    { J := Y
      obj := fun y => U.obj (U.f y)
      map := fun y => U.map (U.f y)
      f := id
      covers := U.covers
      IsOpen := fun _ => U.IsOpen _ }
state_before: Y : Scheme
U : Y.OpenCover
V : Y.OpenCover :=
  { J := ↑↑Y.toPresheafedSpace, obj := fun y => U.obj (U.f y), map := fun y => U.map (U.f y), f := id, covers := ⋯,
    IsOpen := ⋯ }
⊢ zariskiTopology.sieves Y (Sieve.generate (Presieve.ofArrows U.obj U.map))
state_after: Y : Scheme
U : Y.OpenCover
V : Y.OpenCover :=
  { J := ↑↑Y.toPresheafedSpace, obj := fun y => U.obj (U.f y), map := fun y => U.map (U.f y), f := id, covers := ⋯,
    IsOpen := ⋯ }
⊢ Presieve.ofArrows V.obj V.map ≤ (Sieve.generate (Presieve.ofArrows U.obj U.map)).arrows
tactic: refine ⟨_, zariskiPretopology_openCover V, ?_⟩
state_before: Y : Scheme
U : Y.OpenCover
V : Y.OpenCover :=
  { J := ↑↑Y.toPresheafedSpace, obj := fun y => U.obj (U.f y), map := fun y => U.map (U.f y), f := id, covers := ⋯,
    IsOpen := ⋯ }
⊢ Presieve.ofArrows V.obj V.map ≤ (Sieve.generate (Presieve.ofArrows U.obj U.map)).arrows
state_after: case mk
Y✝ : Scheme
U : Y✝.OpenCover
V : Y✝.OpenCover :=
  { J := ↑↑Y✝.toPresheafedSpace, obj := fun y => U.obj (U.f y), map := fun y => U.map (U.f y), f := id, covers := ⋯,
    IsOpen := ⋯ }
Y : Scheme
y : V.J
⊢ V.map y ∈ (Sieve.generate (Presieve.ofArrows U.obj U.map)).arrows
tactic: rintro _ _ ⟨y⟩
state_before: case mk
Y✝ : Scheme
U : Y✝.OpenCover
V : Y✝.OpenCover :=
  { J := ↑↑Y✝.toPresheafedSpace, obj := fun y => U.obj (U.f y), map := fun y => U.map (U.f y), f := id, covers := ⋯,
    IsOpen := ⋯ }
Y : Scheme
y : V.J
⊢ V.map y ∈ (Sieve.generate (Presieve.ofArrows U.obj U.map)).arrows
state_after: no goals
tactic: exact ⟨_, 𝟙 _, U.map (U.f y), ⟨_⟩, by simp⟩
Theorem: Polynomial.map_contract
File: Mathlib/Algebra/Polynomial/Expand.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ p : ℕ
hp : p ≠ 0
f : R →+* S
q : R[X]
n : ℕ
⊢ (map f (contract p q)).coeff n = (contract p (map f q)).coeff n
state_after: no goals
tactic: simp only [coeff_map, coeff_contract hp]
Theorem: Surreal.mk_add
File: Mathlib/SetTheory/Surreal/Basic.lean

Proof steps:
state_before: x y : PGame
hx : x.Numeric
hy : y.Numeric
⊢ mk (x + y) ⋯ = mk x hx + mk y hy
state_after: no goals
tactic: rfl
Theorem: Computation.mem_map
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Computation α
m : a ∈ s
⊢ f a ∈ map f s
state_after: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Computation α
m : a ∈ s
⊢ f a ∈ s.bind (pure ∘ f)
tactic: rw [← bind_pure]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Computation α
m : a ∈ s
⊢ f a ∈ s.bind (pure ∘ f)
state_after: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Computation α
m : a ∈ s
⊢ f a ∈ (pure ∘ f) a
tactic: apply mem_bind m
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Computation α
m : a ∈ s
⊢ f a ∈ (pure ∘ f) a
state_after: no goals
tactic: apply ret_mem
Theorem: univLE_total
File: Mathlib/SetTheory/Cardinal/UnivLE.lean

Proof steps:
state_before: ⊢ UnivLE.{u, v} ∨ UnivLE.{v, u}
state_after: ⊢ univ.{u, v + 1} ≤ univ.{v, u + 1} ∨ univ.{v, u + 1} ≤ univ.{u, v + 1}
tactic: simp_rw [univLE_iff_cardinal_le]
state_before: ⊢ univ.{u, v + 1} ≤ univ.{v, u + 1} ∨ univ.{v, u + 1} ≤ univ.{u, v + 1}
state_after: no goals
tactic: apply le_total
Theorem: isRadical_iff_span_singleton
File: Mathlib/RingTheory/Nilpotent/Lemmas.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : CommSemiring R
⊢ IsRadical y ↔ (Ideal.span {y}).IsRadical
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝ : CommSemiring R
⊢ (∀ (n : ℕ) (x : R), x ^ n ∈ Ideal.span {y} → x ∈ Ideal.span {y}) ↔ (Ideal.span {y}).IsRadical
tactic: simp_rw [IsRadical, ← Ideal.mem_span_singleton]
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : CommSemiring R
⊢ (∀ (n : ℕ) (x : R), x ^ n ∈ Ideal.span {y} → x ∈ Ideal.span {y}) ↔ (Ideal.span {y}).IsRadical
state_after: no goals
tactic: exact forall_swap.trans (forall_congr' fun r => exists_imp.symm)
Theorem: Nat.coprime_zero_right
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

Proof steps:
state_before: n : Nat
⊢ n.Coprime 0 ↔ n = 1
state_after: no goals
tactic: simp [Coprime]
Theorem: Ring.multichoose_zero_right'
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ multichoose r 0 = r ^ 0
state_after: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ (fun x => Nat.factorial 0 • x) (multichoose r 0) = (fun x => Nat.factorial 0 • x) (r ^ 0)
tactic: refine nsmul_right_injective (Nat.factorial 0) (Nat.factorial_ne_zero 0) ?_
state_before: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ (fun x => Nat.factorial 0 • x) (multichoose r 0) = (fun x => Nat.factorial 0 • x) (r ^ 0)
state_after: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ Nat.factorial 0 • multichoose r 0 = Nat.factorial 0 • r ^ 0
tactic: simp only
state_before: R : Type u_1
inst✝² : AddCommMonoid R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ Nat.factorial 0 • multichoose r 0 = Nat.factorial 0 • r ^ 0
state_after: no goals
tactic: rw [factorial_nsmul_multichoose_eq_ascPochhammer, ascPochhammer_zero, smeval_one, Nat.factorial]
Theorem: Filter.compl_mem_coclosedCompact
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ sᶜ ∈ coclosedCompact X ↔ IsCompact (closure s)
state_after: no goals
tactic: rw [mem_coclosedCompact_iff, compl_compl]
Theorem: Finset.sum_centroidWeightsIndicator_eq_one_of_nonempty
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁵ : DivisionRing k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
inst✝² : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝¹ : CharZero k
inst✝ : Fintype ι
h : s.Nonempty
⊢ ∑ i : ι, centroidWeightsIndicator k s i = 1
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁵ : DivisionRing k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
inst✝² : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝¹ : CharZero k
inst✝ : Fintype ι
h : s.Nonempty
⊢ ∑ i ∈ s, centroidWeights k s i = 1
tactic: rw [sum_centroidWeightsIndicator]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝⁵ : DivisionRing k
inst✝⁴ : AddCommGroup V
inst✝³ : Module k V
inst✝² : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝¹ : CharZero k
inst✝ : Fintype ι
h : s.Nonempty
⊢ ∑ i ∈ s, centroidWeights k s i = 1
state_after: no goals
tactic: exact s.sum_centroidWeights_eq_one_of_nonempty k h
Theorem: Convex.openSegment_closure_interior_subset_interior
File: Mathlib/Analysis/Convex/Topology.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : Convex 𝕜 s
x y : E
hx : x ∈ closure s
hy : y ∈ interior s
⊢ openSegment 𝕜 x y ⊆ interior s
state_after: case intro.intro.intro.intro.intro
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : Convex 𝕜 s
x y : E
hx : x ∈ closure s
hy : y ∈ interior s
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y ∈ interior s
tactic: rintro _ ⟨a, b, ha, hb, hab, rfl⟩
state_before: case intro.intro.intro.intro.intro
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalAddGroup E
inst✝ : ContinuousConstSMul 𝕜 E
s : Set E
hs : Convex 𝕜 s
x y : E
hx : x ∈ closure s
hy : y ∈ interior s
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y ∈ interior s
state_after: no goals
tactic: exact hs.combo_closure_interior_mem_interior hx hy ha.le hb hab
Theorem: Nat.bitwise_comm
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: f : Bool → Bool → Bool
hf : ∀ (b b' : Bool), f b b' = f b' b
n m : ℕ
this : bitwise f = swap (bitwise f)
⊢ bitwise f n m = bitwise f m n
state_after: no goals
tactic: conv_lhs => rw [this]
Theorem: lcm_eq_one_iff
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a b : α
x✝ : a ∣ 1 ∧ b ∣ 1
c : α
hc : 1 = a * c
d : α
hd : 1 = b * d
⊢ lcm ↑(Units.mkOfMulEqOne a c ⋯) ↑(Units.mkOfMulEqOne b d ⋯) = 1
state_after: no goals
tactic: rw [lcm_units_coe_left, normalize_coe_units]
Theorem: List.not_eq_key
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
a : α
l : List (Sigma β)
h₁ : a ∉ l.keys
s : Sigma β
h₂ : s ∈ l
e : a = s.fst
⊢ s.fst ∉ l.keys
state_after: no goals
tactic: rwa [e] at h₁
Theorem: Nat.choose_one_right
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ n.choose 1 = n
state_after: no goals
tactic: induction n <;> simp [*, choose, Nat.add_comm]
Theorem: CategoryTheory.NonPreadditiveAbelian.lift_sub_lift
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ prod.lift a b - prod.lift c d = prod.lift (a - c) (b - d)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ prod.lift (prod.lift a b) (prod.lift c d) ≫ σ = prod.lift (prod.lift a c ≫ σ) (prod.lift b d ≫ σ)
tactic: simp only [sub_def]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ prod.lift (prod.lift a b) (prod.lift c d) ≫ σ = prod.lift (prod.lift a c ≫ σ) (prod.lift b d ≫ σ)
state_after: case h₁
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ (prod.lift (prod.lift a b) (prod.lift c d) ≫ σ) ≫ prod.fst =
    prod.lift (prod.lift a c ≫ σ) (prod.lift b d ≫ σ) ≫ prod.fst

case h₂
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b c d : X ⟶ Y
⊢ (prod.lift (prod.lift a b) (prod.lift c d) ≫ σ) ≫ prod.snd =
    prod.lift (prod.lift a c ≫ σ) (prod.lift b d ≫ σ) ≫ prod.snd
tactic: ext
Theorem: Function.leftInvOn_invFunOn_of_subset_image_image
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : s ⊆ invFunOn f s '' (f '' s)
x : α
hx : x ∈ s
⊢ invFunOn f s (f x) = x
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : s ⊆ invFunOn f s '' (f '' s)
x : α
hx' : x ∈ s
hx : invFunOn f s (f x) ∈ s
⊢ invFunOn f s (f (invFunOn f s (f x))) = invFunOn f s (f x)
tactic: obtain ⟨-, ⟨x, hx', rfl⟩, rfl⟩ := h hx
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
inst✝ : Nonempty α
h : s ⊆ invFunOn f s '' (f '' s)
x : α
hx' : x ∈ s
hx : invFunOn f s (f x) ∈ s
⊢ invFunOn f s (f (invFunOn f s (f x))) = invFunOn f s (f x)
state_after: no goals
tactic: rw [invFunOn_apply_eq (f := f) hx']
Theorem: Metric.mem_closure_range_iff_nat
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s : Set α
e : β → α
a : α
⊢ (∀ (i : ℕ), True → ∃ y ∈ range e, y ∈ ball a (1 / (↑i + 1))) ↔ ∀ (n : ℕ), ∃ k, dist a (e k) < 1 / (↑n + 1)
state_after: no goals
tactic: simp only [mem_ball, dist_comm, exists_range_iff, forall_const]
Theorem: CategoryTheory.Limits.diagramIsoParallelFamily_hom_app
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
j : WalkingParallelFamily J
⊢ F.obj j = (parallelFamily fun j => F.map (line j)).obj j
state_after: no goals
tactic: cases j <;> aesop_cat
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
F : WalkingParallelFamily J ⥤ C
⊢ ∀ {X Y : WalkingParallelFamily J} (f : X ⟶ Y),
    F.map f ≫ ((fun j => eqToIso ⋯) Y).hom =
      ((fun j => eqToIso ⋯) X).hom ≫ (parallelFamily fun j => F.map (line j)).map f
state_after: no goals
tactic: rintro _ _ (_|_) <;> aesop_cat
Theorem: EuclideanGeometry.cos_oangle_left_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
⊢ (∡ p₃ p₁ p₂).cos = dist p₁ p₂ / dist p₁ p₃
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₃ p₁ p₂).sign = 1
⊢ (∡ p₃ p₁ p₂).cos = dist p₁ p₂ / dist p₁ p₃
tactic: have hs : (∡ p₃ p₁ p₂).sign = 1 := by rw [← oangle_rotate_sign, h, Real.Angle.sign_coe_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(π / 2)
hs : (∡ p₃ p₁ p₂).sign = 1
⊢ (∡ p₃ p₁ p₂).cos = dist p₁ p₂ / dist p₁ p₃
state_after: no goals
tactic: rw [oangle_eq_angle_of_sign_eq_one hs, angle_comm, Real.Angle.cos_coe,
    cos_angle_of_angle_eq_pi_div_two (angle_rev_eq_pi_div_two_of_oangle_eq_pi_div_two h),
    dist_comm p₁ p₃]
Theorem: CategoryTheory.Over.mapComp_eq
File: Mathlib/CategoryTheory/Comma/Over.lean

Proof steps:
state_before: T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X Y Z : T
f : X ⟶ Y
g : Y ⟶ Z
⊢ map (f ≫ g) = map f ⋙ map g
state_after: case h_obj
T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X Y Z : T
f : X ⟶ Y
g : Y ⟶ Z
⊢ ∀ (X_1 : Over X), (map (f ≫ g)).obj X_1 = (map f ⋙ map g).obj X_1

case h_map
T : Type u₁
inst✝ : Category.{v₁, u₁} T
X✝ X Y Z : T
f : X ⟶ Y
g : Y ⟶ Z
⊢ autoParam
    (∀ (X_1 Y_1 : Over X) (f_1 : X_1 ⟶ Y_1), (map (f ≫ g)).map f_1 = eqToHom ⋯ ≫ (map f ⋙ map g).map f_1 ≫ eqToHom ⋯)
    _auto✝
tactic: fapply Functor.ext
Theorem: Multiset.mem_Icc
File: Mathlib/Order/Interval/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a b x : α
⊢ x ∈ Icc a b ↔ a ≤ x ∧ x ≤ b
state_after: no goals
tactic: rw [Icc, ← Finset.mem_def, Finset.mem_Icc]
Theorem: multipliable_const_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝⁴ : TopologicalSpace G
inst✝³ : CommGroup G
inst✝² : TopologicalGroup G
f : α → G
inst✝¹ : Infinite β
inst✝ : T2Space G
a : G
⊢ (Multipliable fun x => a) ↔ a = 1
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝⁴ : TopologicalSpace G
inst✝³ : CommGroup G
inst✝² : TopologicalGroup G
f : α → G
inst✝¹ : Infinite β
inst✝ : T2Space G
a : G
h : Multipliable fun x => a
⊢ a = 1

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝⁴ : TopologicalSpace G
inst✝³ : CommGroup G
inst✝² : TopologicalGroup G
f : α → G
inst✝¹ : Infinite β
inst✝ : T2Space G
a : G
⊢ a = 1 → Multipliable fun x => a
tactic: refine ⟨fun h ↦ ?_, ?_⟩