1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MvPolynomial.quotient_mk_comp_C_injective
File: Mathlib/FieldTheory/MvPolynomial.lean

tactic: refine (injective_iff_map_eq_zero _).2 fun x hx => ?_
state_before: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
⊢ Function.Injective ⇑((Ideal.Quotient.mk I).comp C)
state_after: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : ((Ideal.Quotient.mk I).comp C) x = 0
⊢ x = 0

tactic: rw [RingHom.comp_apply, Ideal.Quotient.eq_zero_iff_mem] at hx
state_before: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : ((Ideal.Quotient.mk I).comp C) x = 0
⊢ x = 0
state_after: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
⊢ x = 0

tactic: refine _root_.by_contradiction fun hx0 => absurd (I.eq_top_iff_one.2 ?_) hI
state_before: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
⊢ x = 0
state_after: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
hx0 : ¬x = 0
⊢ 1 ∈ I

tactic: have := I.mul_mem_left (MvPolynomial.C x⁻¹) hx
state_before: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
hx0 : ¬x = 0
⊢ 1 ∈ I
state_after: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
hx0 : ¬x = 0
this : C x⁻¹ * C x ∈ I
⊢ 1 ∈ I

tactic: rwa [← MvPolynomial.C.map_mul, inv_mul_cancel hx0, MvPolynomial.C_1] at this
state_before: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
hx0 : ¬x = 0
this : C x⁻¹ * C x ∈ I
⊢ 1 ∈ I
state_after: no goals
Theorem: RingQuot.Rel.sub_right
File: Mathlib/Algebra/RingQuot.lean

tactic: simp only [sub_eq_add_neg, h.neg.add_right]
state_before: R✝ : Type uR
inst✝⁴ : Semiring R✝
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
R : Type uR
inst✝ : Ring R
r : R → R → Prop
a b c : R
h : Rel r b c
⊢ Rel r (a - b) (a - c)
state_after: no goals
Theorem: Cardinal.mk_finsupp_of_fintype
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp
state_before: α✝ β✝ α β : Type u
inst✝¹ : Fintype α
inst✝ : Zero β
⊢ #(α →₀ β) = #β ^ Fintype.card α
state_after: no goals
Theorem: exists₂_imp
File: Mathlib/Logic/Basic.lean

tactic: simp
state_before: α : Sort u_1
r p q : α → Prop
P Q : (x : α) → p x → Prop
b : Prop
⊢ (∃ x h, P x h) → b ↔ ∀ (x : α) (h : p x), P x h → b
state_after: no goals
Theorem: Int.bit_negSucc
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [bit_val, Nat.bit_val]
state_before: b : Bool
n : ℕ
⊢ bit b -[n+1] = -[Nat.bit (!b) n+1]
state_after: b : Bool
n : ℕ
⊢ (2 * -[n+1] + bif b then 1 else 0) = -[2 * n + bif !b then 1 else 0+1]

tactic: cases b <;> rfl
state_before: b : Bool
n : ℕ
⊢ (2 * -[n+1] + bif b then 1 else 0) = -[2 * n + bif !b then 1 else 0+1]
state_after: no goals
Theorem: CoxeterSystem.isRightInversion_inv_iff
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

tactic: apply and_congr_right
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w t : W
⊢ cs.IsRightInversion w⁻¹ t ↔ cs.IsLeftInversion w t
state_after: case h
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w t : W
⊢ cs.IsReflection t → (cs.length (w⁻¹ * t) < cs.length w⁻¹ ↔ cs.length (t * w) < cs.length w)

tactic: intro ht
state_before: case h
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w t : W
⊢ cs.IsReflection t → (cs.length (w⁻¹ * t) < cs.length w⁻¹ ↔ cs.length (t * w) < cs.length w)
state_after: case h
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w t : W
ht : cs.IsReflection t
⊢ cs.length (w⁻¹ * t) < cs.length w⁻¹ ↔ cs.length (t * w) < cs.length w

tactic: rw [← length_inv, mul_inv_rev, inv_inv, ht.inv, cs.length_inv w]
state_before: case h
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w t : W
ht : cs.IsReflection t
⊢ cs.length (w⁻¹ * t) < cs.length w⁻¹ ↔ cs.length (t * w) < cs.length w
state_after: no goals
Theorem: Nat.mul_self_inj
File: Mathlib/Data/Nat/Defs.lean

tactic: simp [Nat.le_antisymm_iff, mul_self_le_mul_self_iff]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m * m = n * n ↔ m = n
state_after: no goals
Theorem: Algebra.iInf_toSubmodule
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: simp
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
ι : Sort u_1
S : ι → Subalgebra R A
⊢ ↑(toSubmodule (⨅ i, S i)) = ↑(⨅ i, toSubmodule (S i))
state_after: no goals
Theorem: nnqsmul_nonneg
File: Mathlib/Algebra/Order/Nonneg/Field.lean

tactic: rw [NNRat.smul_def]
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a : α
q : ℚ≥0
ha : 0 ≤ a
⊢ 0 ≤ q • a
state_after: α : Type u_1
inst✝ : LinearOrderedSemifield α
a : α
q : ℚ≥0
ha : 0 ≤ a
⊢ 0 ≤ ↑q * a

tactic: exact mul_nonneg q.cast_nonneg ha
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a : α
q : ℚ≥0
ha : 0 ≤ a
⊢ 0 ≤ ↑q * a
state_after: no goals
Theorem: Nat.bodd_bit
File: Mathlib/Data/Nat/Bits.lean

tactic: rw [bit_val]
state_before: m n✝ : ℕ
b : Bool
n : ℕ
⊢ (bit b n).bodd = b
state_after: m n✝ : ℕ
b : Bool
n : ℕ
⊢ (2 * n + bif b then 1 else 0).bodd = b

tactic: simp only [Nat.mul_comm, Nat.add_comm, bodd_add, bodd_mul, bodd_succ, bodd_zero, Bool.not_false,
  Bool.not_true, Bool.and_false, Bool.xor_false]
state_before: m n✝ : ℕ
b : Bool
n : ℕ
⊢ (2 * n + bif b then 1 else 0).bodd = b
state_after: m n✝ : ℕ
b : Bool
n : ℕ
⊢ (bif b then 1 else 0).bodd = b

tactic: cases b <;> cases bodd n <;> rfl
state_before: m n✝ : ℕ
b : Bool
n : ℕ
⊢ (bif b then 1 else 0).bodd = b
state_after: no goals
Theorem: HasGradientAtFilter.congr_of_eventuallyEq
File: Mathlib/Analysis/Calculus/Gradient/Basic.lean

tactic: rwa [hL.hasGradientAtFilter_iff hx rfl]
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
f₀ f₁ : F → 𝕜
f₀' f₁' x₀ x₁ : F
s₀ s₁ t : Set F
L₀ L₁ : Filter F
h : HasGradientAtFilter f f' x L
hL : f₁ =ᶠ[L] f
hx : f₁ x = f x
⊢ HasGradientAtFilter f₁ f' x L
state_after: no goals
Theorem: Multiset.aemeasurable_prod
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [← Pi.multiset_prod_apply] using s.aemeasurable_prod' hs
state_before: α✝ : Type u_1
M : Type u_2
ι : Type u_3
α : Type u_4
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : ι → α → M
s : Multiset (α → M)
hs : ∀ f ∈ s, AEMeasurable f μ
⊢ AEMeasurable (fun x => (map (fun f => f x) s).prod) μ
state_after: no goals
Theorem: Filter.pi_inf_principal_pi_eq_bot
File: Mathlib/Order/Filter/Pi.lean

tactic: rw [← univ_pi_piecewise_univ I, pi_inf_principal_univ_pi_eq_bot]
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), (f i).NeBot
I : Set ι
⊢ pi f ⊓ 𝓟 (I.pi s) = ⊥ ↔ ∃ i ∈ I, f i ⊓ 𝓟 (s i) = ⊥
state_after: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), (f i).NeBot
I : Set ι
⊢ (∃ i, f i ⊓ 𝓟 (I.piecewise s (fun x => univ) i) = ⊥) ↔ ∃ i ∈ I, f i ⊓ 𝓟 (s i) = ⊥

tactic: refine exists_congr fun i => ?_
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), (f i).NeBot
I : Set ι
⊢ (∃ i, f i ⊓ 𝓟 (I.piecewise s (fun x => univ) i) = ⊥) ↔ ∃ i ∈ I, f i ⊓ 𝓟 (s i) = ⊥
state_after: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), (f i).NeBot
I : Set ι
i : ι
⊢ f i ⊓ 𝓟 (I.piecewise s (fun x => univ) i) = ⊥ ↔ i ∈ I ∧ f i ⊓ 𝓟 (s i) = ⊥

tactic: by_cases hi : i ∈ I <;> simp [hi, NeBot.ne']
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), (f i).NeBot
I : Set ι
i : ι
⊢ f i ⊓ 𝓟 (I.piecewise s (fun x => univ) i) = ⊥ ↔ i ∈ I ∧ f i ⊓ 𝓟 (s i) = ⊥
state_after: no goals
Theorem: Finset.card_inter_add_card_sdiff
File: Mathlib/Data/Finset/Card.lean

tactic: rw [add_comm, card_sdiff_add_card_inter]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s✝ t✝ u : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
s t : Finset α
⊢ (s ∩ t).card + (s \ t).card = s.card
state_after: no goals
Theorem: Real.ofCauchy_inv
File: Mathlib/Data/Real/Basic.lean

tactic: rw [inv']
state_before: x y : ℝ
f : Cauchy abs
⊢ { cauchy := f⁻¹ } = Real.inv' { cauchy := f }
state_after: no goals
Theorem: Filter.EventuallyConst.mulIndicator_const_iff
File: Mathlib/Order/Filter/EventuallyConst.lean

tactic: rcases eq_or_ne c 1 with rfl | hc <;> simp [mulIndicator_const_iff_of_ne, *]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f : α → β
inst✝ : One β
s : Set α
c : β
⊢ EventuallyConst (s.mulIndicator fun x => c) l ↔ c = 1 ∨ EventuallyConst s l
state_after: no goals
Theorem: CategoryTheory.Limits.Types.pullbackIsoPullback_inv_fst_apply
File: Mathlib/CategoryTheory/Limits/Shapes/Types.lean

tactic: rw [elementwise_of% pullbackIsoPullback_inv_fst]
state_before: W X Y Z : Type u
f : X ⟶ Z
g : Y ⟶ Z
x : (pullbackCone f g).pt
⊢ pullback.fst ((pullbackIsoPullback f g).inv x) = (fun p => (↑p).1) x
state_after: no goals
Theorem: Batteries.RBSet.findP?_insert_of_ne
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: refine Option.ext fun u =>
  findP?_some.trans <| .trans (and_congr_left fun h' => ?_) findP?_some.symm
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
v : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
h : cut v ≠ Ordering.eq
⊢ (t.insert v).findP? cut = t.findP? cut
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
v : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
h : cut v ≠ Ordering.eq
u : α
h' : cut u = Ordering.eq
⊢ u ∈ (t.insert v).toList ↔ u ∈ t.toList

tactic: rw [mem_toList_insert, or_iff_left, and_iff_left]
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
v : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
h : cut v ≠ Ordering.eq
u : α
h' : cut u = Ordering.eq
⊢ u ∈ (t.insert v).toList ↔ u ∈ t.toList
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
v : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
h : cut v ≠ Ordering.eq
u : α
h' : cut u = Ordering.eq
⊢ t.find? v ≠ some u

α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
v : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
h : cut v ≠ Ordering.eq
u : α
h' : cut u = Ordering.eq
⊢ ¬u = v

tactic: exact mt (fun h => by rwa [IsCut.congr (cut := cut) (find?_some_eq_eq h)]) h
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
v : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
h : cut v ≠ Ordering.eq
u : α
h' : cut u = Ordering.eq
⊢ t.find? v ≠ some u
state_after: no goals

tactic: rwa [IsCut.congr (cut := cut) (find?_some_eq_eq h)]
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
v : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
h✝ : cut v ≠ Ordering.eq
u : α
h' : cut u = Ordering.eq
h : t.find? v = some u
⊢ cut v = Ordering.eq
state_after: no goals

tactic: rintro rfl
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
v : α
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
h : cut v ≠ Ordering.eq
u : α
h' : cut u = Ordering.eq
⊢ ¬u = v
state_after: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
u : α
h' : cut u = Ordering.eq
h : cut u ≠ Ordering.eq
⊢ False

tactic: contradiction
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
inst✝¹ : TransCmp cmp
inst✝ : IsStrictCut cmp cut
t : RBSet α cmp
u : α
h' : cut u = Ordering.eq
h : cut u ≠ Ordering.eq
⊢ False
state_after: no goals
Theorem: dimH_def
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

tactic: borelize X
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
s : Set X
⊢ dimH s = ⨆ d, ⨆ (_ : μH[↑d] s = ⊤), ↑d
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝² : EMetricSpace X
inst✝¹ : EMetricSpace Y
s : Set X
inst✝ : BorelSpace X
this✝ : MeasurableSpace X := borel X
⊢ dimH s = ⨆ d, ⨆ (_ : μH[↑d] s = ⊤), ↑d

tactic: rw [dimH]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝² : EMetricSpace X
inst✝¹ : EMetricSpace Y
s : Set X
inst✝ : BorelSpace X
this✝ : MeasurableSpace X := borel X
⊢ dimH s = ⨆ d, ⨆ (_ : μH[↑d] s = ⊤), ↑d
state_after: no goals
Theorem: MeasureTheory.absolutelyContinuous_map_div_left
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: simp_rw [div_eq_mul_inv]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ μ ≪ map (fun h => g / h) μ
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ μ ≪ map (fun h => g * h⁻¹) μ

tactic: erw [← map_map (measurable_const_mul g) measurable_inv]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ μ ≪ map (fun h => g * h⁻¹) μ
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ μ ≪ map (fun x => g * x) (map Inv.inv μ)

tactic: conv_lhs => rw [← map_mul_left_eq_self μ g]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ μ ≪ map (fun x => g * x) (map Inv.inv μ)
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ map (fun x => g * x) μ ≪ map (fun x => g * x) (map Inv.inv μ)

tactic: exact (absolutelyContinuous_inv μ).map (measurable_const_mul g)
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
g : G
⊢ map (fun x => g * x) μ ≪ map (fun x => g * x) (map Inv.inv μ)
state_after: no goals
Theorem: antivary_iff_forall_mul_nonpos
File: Mathlib/Algebra/Order/Monovary.lean

tactic: simp only [smul_eq_mul, antivary_iff_forall_smul_nonpos]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
f g : ι → α
s : Set ι
a b c d : α
⊢ Antivary f g ↔ ∀ (i j : ι), (f j - f i) * (g j - g i) ≤ 0
state_after: no goals
Theorem: pow_dvd_pow
File: Mathlib/Algebra/Divisibility/Basic.lean

tactic: rw [← pow_add, Nat.add_comm, Nat.sub_add_cancel h]
state_before: α : Type u_1
inst✝ : Monoid α
a✝ b c : α
m n : ℕ
a : α
h : m ≤ n
⊢ a ^ n = a ^ m * a ^ (n - m)
state_after: no goals
Theorem: CategoryTheory.Abelian.Pseudoelement.eq_zero_iff
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: simp [h]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
h : f = 0
a : Pseudoelement P
⊢ pseudoApply f a = 0
state_after: no goals
Theorem: Vector.not_mem_map_zero
File: Mathlib/Data/Vector/Mem.lean

tactic: simpa only [Vector.eq_nil v, Vector.map_nil, Vector.toList_nil] using List.not_mem_nil b
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
b : β
v : Vector α 0
f : α → β
⊢ b ∉ (map f v).toList
state_after: no goals
Theorem: Submodule.isClosed_or_dense_of_isCoatom
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: refine (hs.le_iff.mp s.le_topologicalClosure).symm.imp ?_ dense_iff_topologicalClosure_eq_top.mpr
state_before: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
hs : IsCoatom s
⊢ IsClosed ↑s ∨ Dense ↑s
state_after: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
hs : IsCoatom s
⊢ s.topologicalClosure = s → IsClosed ↑s

tactic: exact fun h ↦ h ▸ isClosed_closure
state_before: R R' : Type u
M M' : Type v
inst✝¹⁰ : Semiring R
inst✝⁹ : Ring R'
inst✝⁸ : TopologicalSpace M
inst✝⁷ : AddCommMonoid M
inst✝⁶ : TopologicalSpace M'
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M
inst✝³ : ContinuousConstSMul R M
inst✝² : Module R' M'
inst✝¹ : ContinuousConstSMul R' M'
inst✝ : ContinuousAdd M
s : Submodule R M
hs : IsCoatom s
⊢ s.topologicalClosure = s → IsClosed ↑s
state_after: no goals
Theorem: Algebra.discr_eq_det_embeddingsMatrixReindex_pow_two
File: Mathlib/RingTheory/Discriminant.lean

tactic: rw [discr_def, RingHom.map_det, RingHom.mapMatrix_apply,
  traceMatrix_eq_embeddingsMatrixReindex_mul_trans, det_mul, det_transpose, pow_two]
state_before: A : Type u
B : Type v
C : Type z
ι : Type w
inst✝¹⁶ : DecidableEq ι
inst✝¹⁵ : CommRing A
inst✝¹⁴ : CommRing B
inst✝¹³ : Algebra A B
inst✝¹² : CommRing C
inst✝¹¹ : Algebra A C
ι' : Type u_1
inst✝¹⁰ : Fintype ι'
inst✝⁹ : Fintype ι
inst✝⁸ : DecidableEq ι'
K : Type u
L : Type v
E : Type z
inst✝⁷ : Field K
inst✝⁶ : Field L
inst✝⁵ : Field E
inst✝⁴ : Algebra K L
inst✝³ : Algebra K E
inst✝² : Module.Finite K L
inst✝¹ : IsAlgClosed E
b : ι → L
pb : PowerBasis K L
inst✝ : IsSeparable K L
e : ι ≃ (L →ₐ[K] E)
⊢ (algebraMap K E) (discr K b) = (embeddingsMatrixReindex K E b e).det ^ 2
state_after: no goals
Theorem: lowerBounds_infClosure
File: Mathlib/Order/SupClosed.lean

tactic: rintro a ha _ ⟨t, ht, hts, rfl⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
s✝ t : Set α
a b : α
s : Set α
⊢ lowerBounds s ⊆ lowerBounds (infClosure s)
state_after: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
s✝ t✝ : Set α
a✝ b : α
s : Set α
a : α
ha : a ∈ lowerBounds s
t : Finset α
ht : t.Nonempty
hts : ↑t ⊆ s
⊢ a ≤ t.inf' ht id

tactic: exact le_inf' _ _ fun b hb ↦ ha <| hts hb
state_before: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
s✝ t✝ : Set α
a✝ b : α
s : Set α
a : α
ha : a ∈ lowerBounds s
t : Finset α
ht : t.Nonempty
hts : ↑t ⊆ s
⊢ a ≤ t.inf' ht id
state_after: no goals
Theorem: BoxIntegral.Box.withBotCoe_subset_iff
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: induction I
state_before: ι : Type u_1
I✝ J✝ : Box ι
x y : ι → ℝ
I J : WithBot (Box ι)
⊢ ↑I ⊆ ↑J ↔ I ≤ J
state_after: case bot
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
⊢ ↑⊥ ⊆ ↑J ↔ ⊥ ≤ J

case coe
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
a✝ : Box ι
⊢ ↑↑a✝ ⊆ ↑J ↔ ↑a✝ ≤ J

tactic: induction J
state_before: case coe
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
a✝ : Box ι
⊢ ↑↑a✝ ⊆ ↑J ↔ ↑a✝ ≤ J
state_after: case coe.bot
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝ : Box ι
⊢ ↑↑a✝ ⊆ ↑⊥ ↔ ↑a✝ ≤ ⊥

case coe.coe
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝¹ a✝ : Box ι
⊢ ↑↑a✝¹ ⊆ ↑↑a✝ ↔ ↑a✝¹ ≤ ↑a✝

tactic: simp [le_def]
state_before: case coe.coe
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝¹ a✝ : Box ι
⊢ ↑↑a✝¹ ⊆ ↑↑a✝ ↔ ↑a✝¹ ≤ ↑a✝
state_after: no goals

tactic: simp
state_before: case bot
ι : Type u_1
I J✝ : Box ι
x y : ι → ℝ
J : WithBot (Box ι)
⊢ ↑⊥ ⊆ ↑J ↔ ⊥ ≤ J
state_after: no goals

tactic: simp [subset_empty_iff]
state_before: case coe.bot
ι : Type u_1
I J : Box ι
x y : ι → ℝ
a✝ : Box ι
⊢ ↑↑a✝ ⊆ ↑⊥ ↔ ↑a✝ ≤ ⊥
state_after: no goals
Theorem: CategoryTheory.PresheafOfGroups.OneCohomologyRelation.trans
File: Mathlib/CategoryTheory/Sites/NonabelianCohomology/H1.lean

tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
G : Cᵒᵖ ⥤ Grp
X : C
I : Type w'
U : I → C
γ₁ γ₂ γ₃ : OneCochain G U
α β : ZeroCochain G U
h₁₂ : OneCohomologyRelation γ₁ γ₂ α
h₂₃ : OneCohomologyRelation γ₂ γ₃ β
i j : I
T : C
a : T ⟶ U i
b : T ⟶ U j
⊢ (G.map a.op) ((β * α) i) * γ₁.ev i j a b = γ₃.ev i j a b * (G.map b.op) ((β * α) j)
state_after: C : Type u
inst✝ : Category.{v, u} C
G : Cᵒᵖ ⥤ Grp
X : C
I : Type w'
U : I → C
γ₁ γ₂ γ₃ : OneCochain G U
α β : ZeroCochain G U
h₁₂ : OneCohomologyRelation γ₁ γ₂ α
h₂₃ : OneCohomologyRelation γ₂ γ₃ β
i j : I
T : C
a : T ⟶ U i
b : T ⟶ U j
⊢ (G.map a.op) (β i * α i) * γ₁.ev i j a b = γ₃.ev i j a b * (G.map b.op) (β j * α j)

tactic: rw [map_mul, map_mul, mul_assoc, h₁₂ i j a b, ← mul_assoc,
  h₂₃ i j a b, mul_assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
G : Cᵒᵖ ⥤ Grp
X : C
I : Type w'
U : I → C
γ₁ γ₂ γ₃ : OneCochain G U
α β : ZeroCochain G U
h₁₂ : OneCohomologyRelation γ₁ γ₂ α
h₂₃ : OneCohomologyRelation γ₂ γ₃ β
i j : I
T : C
a : T ⟶ U i
b : T ⟶ U j
⊢ (G.map a.op) (β i * α i) * γ₁.ev i j a b = γ₃.ev i j a b * (G.map b.op) (β j * α j)
state_after: no goals
Theorem: CategoryTheory.OverPresheafAux.MakesOverArrow.map₁
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

tactic: rw [← elementwise_of% NatTrans.comp_app ε μ, hε, h.app]
state_before: C : Type u
inst✝ : Category.{v, u} C
A F G : Cᵒᵖ ⥤ Type v
η : F ⟶ A
μ : G ⟶ A
ε : F ⟶ G
hε : ε ≫ μ = η
X : C
s : yoneda.obj X ⟶ A
u : F.obj { unop := X }
h : MakesOverArrow η s u
⊢ μ.app { unop := X } (ε.app { unop := X } u) = yonedaEquiv s
state_after: no goals
Theorem: WeierstrassCurve.φ_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: erw [φ, ψ_zero, zero_pow two_ne_zero, mul_zero, zero_sub, ψ_one, one_mul,
  zero_sub, ψ_neg, neg_neg, ψ_one]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.φ 0 = 1
state_after: no goals