1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: FractionalIdeal.isFractional_of_le_one
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

tactic: use 1, S.one_mem
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
⊢ IsFractional S I
state_after: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
⊢ ∀ b ∈ I, IsInteger R (1 • b)

tactic: intro b hb
state_before: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
⊢ ∀ b ∈ I, IsInteger R (1 • b)
state_after: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b : P
hb : b ∈ I
⊢ IsInteger R (1 • b)

tactic: rw [one_smul]
state_before: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b : P
hb : b ∈ I
⊢ IsInteger R (1 • b)
state_after: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b : P
hb : b ∈ I
⊢ IsInteger R b

tactic: obtain ⟨b', b'_mem, rfl⟩ := h hb
state_before: case right
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b : P
hb : b ∈ I
⊢ IsInteger R b
state_after: case right.intro.refl
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b' : R
hb : (Algebra.linearMap R P) b' ∈ I
⊢ IsInteger R ((Algebra.linearMap R P) b')

tactic: exact Set.mem_range_self b'
state_before: case right.intro.refl
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
h : I ≤ 1
b' : R
hb : (Algebra.linearMap R P) b' ∈ I
⊢ IsInteger R ((Algebra.linearMap R P) b')
state_after: no goals
Theorem: String.drop_empty
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: rw [drop_eq, List.drop_nil]
state_before: n : Nat
⊢ "".drop n = ""
state_after: no goals
Theorem: Polynomial.iterate_derivative_X_sub_pow
File: Mathlib/Algebra/Polynomial/Derivative.lean

tactic: rw [sub_eq_add_neg, ← C_neg, iterate_derivative_X_add_pow]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommRing R
n k : ℕ
c : R
⊢ (⇑derivative)^[k] ((X - C c) ^ n) = n.descFactorial k • (X - C c) ^ (n - k)
state_after: no goals
Theorem: CategoryTheory.Limits.limitUncurryIsoLimitCompLim_hom_π_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

tactic: dsimp [limitUncurryIsoLimitCompLim, IsLimit.conePointUniqueUpToIso, IsLimit.uniqueUpToIso]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ (limitUncurryIsoLimitCompLim F).hom ≫ limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k = limit.π (uncurry.obj F) (j, k)
state_after: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ limit.lift (F ⋙ lim) (coneOfConeUncurry (fun j => limit.isLimit (F.obj j)) (limit.cone (uncurry.obj F))) ≫
      limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k =
    limit.π (uncurry.obj F) (j, k)

tactic: simp
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ limit.lift (F ⋙ lim) (coneOfConeUncurry (fun j => limit.isLimit (F.obj j)) (limit.cone (uncurry.obj F))) ≫
      limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k =
    limit.π (uncurry.obj F) (j, k)
state_after: no goals
Theorem: BoxIntegral.BoxAdditiveMap.map_split_add
File: Mathlib/Analysis/BoxIntegral/Partition/Additive.lean

tactic: rw [← f.sum_partition_boxes hI (isPartitionSplit I i x), sum_split_boxes]
state_before: ι : Type u_1
M : Type u_2
n : ℕ
N : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : AddCommMonoid N
I₀ : WithTop (Box ι)
I J : Box ι
i✝ : ι
f : ι →ᵇᵃ[I₀] M
hI : ↑I ≤ I₀
i : ι
x : ℝ
⊢ Option.elim' 0 (⇑f) (I.splitLower i x) + Option.elim' 0 (⇑f) (I.splitUpper i x) = f I
state_after: no goals
Theorem: Finset.isUnit_iff_singleton
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp only [isUnit_iff, Group.isUnit, and_true_iff]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq β
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
s t : Finset α
a b : α
⊢ IsUnit s ↔ ∃ a, s = {a}
state_after: no goals
Theorem: Real.arctan_eq_arccos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: rw [arctan_eq_arcsin, arccos_eq_arcsin]
state_before: x : ℝ
h : 0 ≤ x
⊢ arctan x = arccos (√(1 + x ^ 2))⁻¹
state_after: x : ℝ
h : 0 ≤ x
⊢ arcsin (x / √(1 + x ^ 2)) = arcsin √(1 - (√(1 + x ^ 2))⁻¹ ^ 2)

x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (√(1 + x ^ 2))⁻¹

tactic: swap
state_before: x : ℝ
h : 0 ≤ x
⊢ arcsin (x / √(1 + x ^ 2)) = arcsin √(1 - (√(1 + x ^ 2))⁻¹ ^ 2)

x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (√(1 + x ^ 2))⁻¹
state_after: x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (√(1 + x ^ 2))⁻¹

x : ℝ
h : 0 ≤ x
⊢ arcsin (x / √(1 + x ^ 2)) = arcsin √(1 - (√(1 + x ^ 2))⁻¹ ^ 2)

tactic: congr 1
state_before: x : ℝ
h : 0 ≤ x
⊢ arcsin (x / √(1 + x ^ 2)) = arcsin √(1 - (√(1 + x ^ 2))⁻¹ ^ 2)
state_after: case e_a
x : ℝ
h : 0 ≤ x
⊢ x / √(1 + x ^ 2) = √(1 - (√(1 + x ^ 2))⁻¹ ^ 2)

tactic: rw_mod_cast [← sqrt_inv, sq_sqrt, ← one_div, one_sub_div, add_sub_cancel_left, sqrt_div,
  sqrt_sq h]
state_before: case e_a
x : ℝ
h : 0 ≤ x
⊢ x / √(1 + x ^ 2) = √(1 - (√(1 + x ^ 2))⁻¹ ^ 2)
state_after: case e_a.hx
x : ℝ
h : 0 ≤ x
⊢ 0 ≤ x ^ 2

case e_a
x : ℝ
h : 0 ≤ x
⊢ 1 + x ^ 2 ≠ 0

case e_a
x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (1 + x ^ 2)⁻¹

tactic: all_goals positivity
state_before: case e_a.hx
x : ℝ
h : 0 ≤ x
⊢ 0 ≤ x ^ 2

case e_a
x : ℝ
h : 0 ≤ x
⊢ 1 + x ^ 2 ≠ 0

case e_a
x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (1 + x ^ 2)⁻¹
state_after: no goals

tactic: exact inv_nonneg.2 (sqrt_nonneg _)
state_before: x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (√(1 + x ^ 2))⁻¹
state_after: no goals

tactic: positivity
state_before: case e_a
x : ℝ
h : 0 ≤ x
⊢ 0 ≤ (1 + x ^ 2)⁻¹
state_after: no goals
Theorem: Finset.Colex.isInitSeg_initSeg
File: Mathlib/Combinatorics/Colex.lean

tactic: refine ⟨fun t ht => (mem_initSeg.1 ht).1.symm, fun t₁ t₂ ht₁ ht₂ ↦ mem_initSeg.2 ⟨ht₂.2.symm, ?_⟩⟩
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
r : ℕ
inst✝ : Fintype α
⊢ IsInitSeg (initSeg s) s.card
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
r : ℕ
inst✝ : Fintype α
t₁ t₂ : Finset α
ht₁ : t₁ ∈ initSeg s
ht₂ : { ofColex := t₂ } < { ofColex := t₁ } ∧ t₂.card = s.card
⊢ { ofColex := t₂ } ≤ { ofColex := s }

tactic: rw [mem_initSeg] at ht₁
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
r : ℕ
inst✝ : Fintype α
t₁ t₂ : Finset α
ht₁ : t₁ ∈ initSeg s
ht₂ : { ofColex := t₂ } < { ofColex := t₁ } ∧ t₂.card = s.card
⊢ { ofColex := t₂ } ≤ { ofColex := s }
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
r : ℕ
inst✝ : Fintype α
t₁ t₂ : Finset α
ht₁ : s.card = t₁.card ∧ { ofColex := t₁ } ≤ { ofColex := s }
ht₂ : { ofColex := t₂ } < { ofColex := t₁ } ∧ t₂.card = s.card
⊢ { ofColex := t₂ } ≤ { ofColex := s }

tactic: exact ht₂.1.le.trans ht₁.2
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : LinearOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
r : ℕ
inst✝ : Fintype α
t₁ t₂ : Finset α
ht₁ : s.card = t₁.card ∧ { ofColex := t₁ } ≤ { ofColex := s }
ht₂ : { ofColex := t₂ } < { ofColex := t₁ } ∧ t₂.card = s.card
⊢ { ofColex := t₂ } ≤ { ofColex := s }
state_after: no goals
Theorem: DihedralGroup.reciprocalFactors_odd
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: have h0 : n ≠ 0 := by
  rintro rfl
  norm_num at h2
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h1 : n ≠ 1
h2 : Odd n
⊢ reciprocalFactors n = n % 4 * n :: reciprocalFactors (n / 4 + 1)
state_after: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h1 : n ≠ 1
h2 : Odd n
h0 : n ≠ 0
⊢ reciprocalFactors n = n % 4 * n :: reciprocalFactors (n / 4 + 1)

tactic: rw [reciprocalFactors, dif_neg h0, dif_neg h1, if_neg (Nat.odd_iff_not_even.mp h2)]
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h1 : n ≠ 1
h2 : Odd n
h0 : n ≠ 0
⊢ reciprocalFactors n = n % 4 * n :: reciprocalFactors (n / 4 + 1)
state_after: no goals

tactic: rintro rfl
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h1 : n ≠ 1
h2 : Odd n
⊢ n ≠ 0
state_after: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
h1 : 0 ≠ 1
h2 : Odd 0
⊢ False

tactic: norm_num at h2
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
h1 : 0 ≠ 1
h2 : Odd 0
⊢ False
state_after: no goals
Theorem: CategoryTheory.Presheaf.IsSheaf.amalgamate_map
File: Mathlib/CategoryTheory/Sites/Sheaf.lean

tactic: apply (hP _ _ S.condition).valid_glue
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
A✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} A✝
J : GrothendieckTopology C
A : Type u₂
inst✝ : Category.{v₂, u₂} A
E : A
X : C
P : Cᵒᵖ ⥤ A
hP : IsSheaf J P
S : J.Cover X
x : (I : S.Arrow) → E ⟶ P.obj { unop := I.Y }
hx : ∀ ⦃I₁ I₂ : S.Arrow⦄ (r : I₁.Relation I₂), x I₁ ≫ P.map r.g₁.op = x I₂ ≫ P.map r.g₂.op
I : S.Arrow
⊢ hP.amalgamate S x hx ≫ P.map I.f.op = x I
state_after: no goals
Theorem: IsOpen.isClopenable
File: Mathlib/Topology/MetricSpace/Polish.lean

tactic: simpa using hs.isClosed_compl.isClopenable.compl
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : PolishSpace α
s : Set α
hs : IsOpen s
⊢ IsClopenable s
state_after: no goals
Theorem: DFinsupp.filter_def
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext i
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
⊢ filter p f = mk (Finset.filter p f.support) fun i => f ↑i
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
⊢ (filter p f) i = (mk (Finset.filter p f.support) fun i => f ↑i) i

tactic: by_cases h1 : p i <;> by_cases h2 : f i ≠ 0 <;> simp at h2 <;> simp [h1, h2]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
⊢ (filter p f) i = (mk (Finset.filter p f.support) fun i => f ↑i) i
state_after: no goals
Theorem: affineIndependent_of_ne_of_mem_of_not_mem_of_mem
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: rw [← affineIndependent_equiv (Equiv.swap (1 : Fin 3) 2)]
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 : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k ![p₁, p₂, p₃]
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 : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2))

tactic: convert affineIndependent_of_ne_of_mem_of_mem_of_not_mem hp₁p₃ hp₁ hp₃ hp₂ using 1
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 : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2))
state_after: case h.e'_9
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 : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
⊢ ![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2) = ![p₁, p₃, p₂]

tactic: ext x
state_before: case h.e'_9
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 : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
⊢ ![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2) = ![p₁, p₃, p₂]
state_after: case h.e'_9.h
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 : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
x : Fin 3
⊢ (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2)) x = ![p₁, p₃, p₂] x

tactic: fin_cases x <;> rfl
state_before: case h.e'_9.h
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 : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
x : Fin 3
⊢ (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2)) x = ![p₁, p₃, p₂] x
state_after: no goals
Theorem: AddMonoidAlgebra.lift_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp only [lift_apply', Algebra.smul_def]
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝⁵ : CommSemiring k
inst✝⁴ : AddMonoid G
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type u_3
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : Multiplicative G →* A
f : MonoidAlgebra k G
⊢ ((lift k G A) F) f = sum f fun a b => b • F (Multiplicative.ofAdd a)
state_after: no goals
Theorem: MeasurableSpace.generateFrom_insert_univ
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

tactic: rw [insert_eq, ← generateFrom_sup_generateFrom, generateFrom_singleton_univ, bot_sup_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
S : Set (Set α)
⊢ generateFrom (insert univ S) = generateFrom S
state_after: no goals
Theorem: Nonneg.toNonneg_of_nonneg
File: Mathlib/Algebra/Order/Nonneg/Ring.lean

tactic: simp [toNonneg, h]
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 ≤ a
⊢ toNonneg a = ⟨a, h⟩
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.isGalois_iff_pretransitive
File: Mathlib/CategoryTheory/Galois/GaloisObjects.lean

tactic: rw [isGalois_iff_aux, Equiv.nonempty_congr <| quotientByAutTerminalEquivUniqueQuotient F X]
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X : C
inst✝ : IsConnected X
⊢ IsGalois X ↔ MulAction.IsPretransitive (Aut X) ↑(F.obj X)
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X : C
inst✝ : IsConnected X
⊢ Nonempty (Unique (MulAction.orbitRel.Quotient (Aut X) ↑(F.obj X))) ↔ MulAction.IsPretransitive (Aut X) ↑(F.obj X)

tactic: exact (MulAction.pretransitive_iff_unique_quotient_of_nonempty (Aut X) (F.obj X)).symm
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X : C
inst✝ : IsConnected X
⊢ Nonempty (Unique (MulAction.orbitRel.Quotient (Aut X) ↑(F.obj X))) ↔ MulAction.IsPretransitive (Aut X) ↑(F.obj X)
state_after: no goals
Theorem: Metric.dist_le_infDist_add_diam
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [infDist, diam, dist_edist]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
hs : Bornology.IsBounded s
hy : y ∈ s
⊢ dist x y ≤ infDist x s + diam s
state_after: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
hs : Bornology.IsBounded s
hy : y ∈ s
⊢ (edist x y).toReal ≤ (infEdist x s).toReal + (EMetric.diam s).toReal

tactic: exact toReal_le_add (edist_le_infEdist_add_ediam hy) (infEdist_ne_top ⟨y, hy⟩) hs.ediam_ne_top
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
hs : Bornology.IsBounded s
hy : y ∈ s
⊢ (edist x y).toReal ≤ (infEdist x s).toReal + (EMetric.diam s).toReal
state_after: no goals
Theorem: CompleteLattice.SetIndependent.disjoint_sSup
File: Mathlib/Order/SupIndep.lean

tactic: have := (hs.mono <| insert_subset_iff.mpr ⟨hx, hy⟩) (mem_insert x _)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
x : α
y : Set α
hx : x ∈ s
hy : y ⊆ s
hxy : x ∉ y
⊢ Disjoint x (sSup y)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
x : α
y : Set α
hx : x ∈ s
hy : y ⊆ s
hxy : x ∉ y
this : Disjoint x (sSup (insert x y \ {x}))
⊢ Disjoint x (sSup y)

tactic: rw [insert_diff_of_mem _ (mem_singleton _), diff_singleton_eq_self hxy] at this
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
x : α
y : Set α
hx : x ∈ s
hy : y ⊆ s
hxy : x ∉ y
this : Disjoint x (sSup (insert x y \ {x}))
⊢ Disjoint x (sSup y)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
x : α
y : Set α
hx : x ∈ s
hy : y ⊆ s
hxy : x ∉ y
this : Disjoint x (sSup y)
⊢ Disjoint x (sSup y)

tactic: exact this
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
x : α
y : Set α
hx : x ∈ s
hy : y ⊆ s
hxy : x ∉ y
this : Disjoint x (sSup y)
⊢ Disjoint x (sSup y)
state_after: no goals
Theorem: QuadraticForm.basisRepr_apply
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [← v.equivFun_symm_apply]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
ι : Type u_6
inst✝ : Fintype ι
v : Basis ι R M
Q : QuadraticForm R M
w : ι → R
⊢ (Q.basisRepr v) w = Q (∑ i : ι, w i • v i)
state_after: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
ι : Type u_6
inst✝ : Fintype ι
v : Basis ι R M
Q : QuadraticForm R M
w : ι → R
⊢ (Q.basisRepr v) w = Q (v.equivFun.symm w)

tactic: rfl
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
ι : Type u_6
inst✝ : Fintype ι
v : Basis ι R M
Q : QuadraticForm R M
w : ι → R
⊢ (Q.basisRepr v) w = Q (v.equivFun.symm w)
state_after: no goals
Theorem: WeierstrassCurve.Affine.baseChange_negAddY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: erw [← map_negAddY, map_baseChange]
state_before: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
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
x₁ x₂ y₁ L : A
⊢ (baseChange W B).toAffine.negAddY (f x₁) (f x₂) (f y₁) (f L) = f ((baseChange W A).toAffine.negAddY x₁ x₂ y₁ L)
state_after: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
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
x₁ x₂ y₁ L : A
⊢ (baseChange W B).toAffine.negAddY (f x₁) (f x₂) (f y₁) (f L) =
    (baseChange W B).toAffine.negAddY (f.toRingHom x₁) (f.toRingHom x₂) (f.toRingHom y₁) (f.toRingHom L)

tactic: rfl
state_before: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
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
x₁ x₂ y₁ L : A
⊢ (baseChange W B).toAffine.negAddY (f x₁) (f x₂) (f y₁) (f L) =
    (baseChange W B).toAffine.negAddY (f.toRingHom x₁) (f.toRingHom x₂) (f.toRingHom y₁) (f.toRingHom L)
state_after: no goals
Theorem: Function.semiconj_of_isLUB
File: Mathlib/Order/SemiconjSup.lean

tactic: refine fun y => (H _).unique ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
G : Type u_4
inst✝¹ : PartialOrder α
inst✝ : Group G
f₁ f₂ : G →* α ≃o α
h : α → α
H : ∀ (x : α), IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') x)) (h x)
g : G
⊢ Semiconj h ⇑(f₂ g) ⇑(f₁ g)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
G : Type u_4
inst✝¹ : PartialOrder α
inst✝ : Group G
f₁ f₂ : G →* α ≃o α
h : α → α
H : ∀ (x : α), IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') x)) (h x)
g : G
y : α
⊢ IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') ((f₂ g) y))) ((f₁ g) (h y))

tactic: have := (f₁ g).leftOrdContinuous (H y)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
G : Type u_4
inst✝¹ : PartialOrder α
inst✝ : Group G
f₁ f₂ : G →* α ≃o α
h : α → α
H : ∀ (x : α), IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') x)) (h x)
g : G
y : α
⊢ IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') ((f₂ g) y))) ((f₁ g) (h y))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
G : Type u_4
inst✝¹ : PartialOrder α
inst✝ : Group G
f₁ f₂ : G →* α ≃o α
h : α → α
H : ∀ (x : α), IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') x)) (h x)
g : G
y : α
this : IsLUB (⇑(f₁ g) '' range fun g' => (f₁ g')⁻¹ ((f₂ g') y)) ((f₁ g) (h y))
⊢ IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') ((f₂ g) y))) ((f₁ g) (h y))

tactic: rw [← range_comp, ← (Equiv.mulRight g).surjective.range_comp _] at this
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
G : Type u_4
inst✝¹ : PartialOrder α
inst✝ : Group G
f₁ f₂ : G →* α ≃o α
h : α → α
H : ∀ (x : α), IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') x)) (h x)
g : G
y : α
this : IsLUB (⇑(f₁ g) '' range fun g' => (f₁ g')⁻¹ ((f₂ g') y)) ((f₁ g) (h y))
⊢ IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') ((f₂ g) y))) ((f₁ g) (h y))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
G : Type u_4
inst✝¹ : PartialOrder α
inst✝ : Group G
f₁ f₂ : G →* α ≃o α
h : α → α
H : ∀ (x : α), IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') x)) (h x)
g : G
y : α
this : IsLUB (range ((⇑(f₁ g) ∘ fun g' => (f₁ g')⁻¹ ((f₂ g') y)) ∘ ⇑(Equiv.mulRight g))) ((f₁ g) (h y))
⊢ IsLUB (range fun g' => (f₁ g')⁻¹ ((f₂ g') ((f₂ g) y))) ((f₁ g) (h y))