tasksource/leandojo huggingface dataset:
Theorem: Int.pow_right_injective
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: convert Nat.pow_right_injective h using 2
state_before: α : Type ?u.317239
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
x : ℤ
h : 1 < natAbs x
⊢ Function.Injective (natAbs ∘ (fun x x_1 => x ^ x_1) x)

tactic: rw [Function.comp_apply, natAbs_pow]
state_before: case h.e'_3.h
α : Type ?u.317239
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
x : ℤ
h : 1 < natAbs x
x✝ : ℕ
⊢ (natAbs ∘ (fun x x_1 => x ^ x_1) x) x✝ = natAbs x ^ x✝

tactic: exact Function.Injective.of_comp this
state_before: α : Type ?u.317239
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
x : ℤ
h : 1 < natAbs x
this : Function.Injective (natAbs ∘ (fun x x_1 => x ^ x_1) x)
⊢ Function.Injective ((fun x x_1 => x ^ x_1) x)
Theorem: isClosed_setOf_map_mul
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: simp only [setOf_forall]
state_before: ι : Type ?u.64907
α : Type ?u.64910
X : Type ?u.64913
M : Type ?u.64916
N : Type ?u.64919
inst✝⁵ : TopologicalSpace X
M₁ : Type u_1
M₂ : Type u_2
inst✝⁴ : TopologicalSpace M₂
inst✝³ : T2Space M₂
inst✝² : Mul M₁
inst✝¹ : Mul M₂
inst✝ : ContinuousMul M₂
⊢ IsClosed {f | ∀ (x y : M₁), f (x * y) = f x * f y}

tactic: exact
  isClosed_iInter fun x =>
    isClosed_iInter fun y =>
      isClosed_eq (continuous_apply _)
        (by continuity)
state_before: ι : Type ?u.64907
α : Type ?u.64910
X : Type ?u.64913
M : Type ?u.64916
N : Type ?u.64919
inst✝⁵ : TopologicalSpace X
M₁ : Type u_1
M₂ : Type u_2
inst✝⁴ : TopologicalSpace M₂
inst✝³ : T2Space M₂
inst✝² : Mul M₁
inst✝¹ : Mul M₂
inst✝ : ContinuousMul M₂
⊢ IsClosed (⋂ (i : M₁) (i_1 : M₁), {x | x (i * i_1) = x i * x i_1})

tactic: continuity
state_before: ι : Type ?u.64907
α : Type ?u.64910
X : Type ?u.64913
M : Type ?u.64916
N : Type ?u.64919
inst✝⁵ : TopologicalSpace X
M₁ : Type u_1
M₂ : Type u_2
inst✝⁴ : TopologicalSpace M₂
inst✝³ : T2Space M₂
inst✝² : Mul M₁
inst✝¹ : Mul M₂
inst✝ : ContinuousMul M₂
x y : M₁
⊢ Continuous fun x_1 => x_1 x * x_1 y
Theorem: Submodule.quotientQuotientEquivQuotientAux_mk_mk
File: Mathlib/LinearAlgebra/Isomorphisms.lean

tactic: simp
state_before: R : Type u_2
M : Type u_1
M₂ : Type ?u.145062
M₃ : Type ?u.145065
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
S T : Submodule R M
h : S ≤ T
x : M
⊢ ↑(quotientQuotientEquivQuotientAux S T h) (Quotient.mk (Quotient.mk x)) = Quotient.mk x
Theorem: Finset.centerMass_singleton
File: Mathlib/Analysis/Convex/Combination.lean

tactic: rw [centerMass, sum_singleton, sum_singleton, ← mul_smul, inv_mul_cancel hw, one_smul]
state_before: R : Type u_1
E : Type u_2
F : Type ?u.26653
ι : Type u_3
ι' : Type ?u.26659
α : Type ?u.26662
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
hw : w i ≠ 0
⊢ centerMass {i} w z = z i
Theorem: Finset.wellFoundedOn_sup
File: Mathlib/Order/WellFoundedSet.lean

tactic: simp
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.113342
r : α → α → Prop
inst✝ : IsStrictOrder α r
s : Finset ι
f : ι → Set α
⊢ Set.WellFoundedOn (sup ∅ f) r ↔ ∀ (i : ι), i ∈ ∅ → Set.WellFoundedOn (f i) r

tactic: simp [-sup_set_eq_biUnion, hs]
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.113342
r : α → α → Prop
inst✝ : IsStrictOrder α r
s✝ : Finset ι
f : ι → Set α
a : ι
s : Finset ι
ha : ¬a ∈ s
hs : Set.WellFoundedOn (sup s f) r ↔ ∀ (i : ι), i ∈ s → Set.WellFoundedOn (f i) r
⊢ Set.WellFoundedOn (sup (cons a s ha) f) r ↔ ∀ (i : ι), i ∈ cons a s ha → Set.WellFoundedOn (f i) r
Theorem: pow_bit1_nonpos_iff
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: simp only [le_iff_lt_or_eq, pow_bit1_neg_iff]
state_before: α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
⊢ a ^ bit1 n ≤ 0 ↔ a ≤ 0

tactic: refine' ⟨_, _⟩
state_before: α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
⊢ a < 0 ∨ a ^ bit1 n = 0 ↔ a < 0 ∨ a = 0

tactic: rintro (hpos | hz)
state_before: case refine'_1
α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
⊢ a < 0 ∨ a ^ bit1 n = 0 → a < 0 ∨ a = 0

tactic: left
state_before: case refine'_1.inl
α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hpos : a < 0
⊢ a < 0 ∨ a = 0

tactic: exact hpos
state_before: case refine'_1.inl.h
α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hpos : a < 0
⊢ a < 0

tactic: right
state_before: case refine'_1.inr
α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hz : a ^ bit1 n = 0
⊢ a < 0 ∨ a = 0

tactic: exact (pow_eq_zero_iff'.1 hz).1
state_before: case refine'_1.inr.h
α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hz : a ^ bit1 n = 0
⊢ a = 0

tactic: rintro (hneg | hz)
state_before: case refine'_2
α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
⊢ a < 0 ∨ a = 0 → a < 0 ∨ a ^ bit1 n = 0

tactic: left
state_before: case refine'_2.inl
α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hneg : a < 0
⊢ a < 0 ∨ a ^ bit1 n = 0

tactic: exact hneg
state_before: case refine'_2.inl.h
α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hneg : a < 0
⊢ a < 0

tactic: right
state_before: case refine'_2.inr
α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hz : a = 0
⊢ a < 0 ∨ a ^ bit1 n = 0

tactic: simp [hz, bit1]
state_before: case refine'_2.inr.h
α : Type ?u.308458
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hz : a = 0
⊢ a ^ bit1 n = 0
Theorem: tsub_tsub_tsub_le_tsub
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [tsub_le_iff_left, tsub_le_iff_left, add_left_comm]
state_before: α : Type u_1
β : Type ?u.13993
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ c - a - (c - b) ≤ b - a

tactic: exact le_tsub_add.trans (add_le_add_left le_add_tsub _)
state_before: α : Type u_1
β : Type ?u.13993
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ c ≤ c - b + (a + (b - a))
Theorem: Polynomial.isEquivalent_atTop_lead
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

tactic: by_cases h : P = 0
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
⊢ (fun x => eval x P) ~[atTop] fun x => leadingCoeff P * x ^ natDegree P

tactic: simp [h, IsEquivalent.refl]
state_before: case pos
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : P = 0
⊢ (fun x => eval x P) ~[atTop] fun x => leadingCoeff P * x ^ natDegree P

tactic: simp only [Polynomial.eval_eq_sum_range, sum_range_succ]
state_before: case neg
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : ¬P = 0
⊢ (fun x => eval x P) ~[atTop] fun x => leadingCoeff P * x ^ natDegree P

tactic: exact
  IsLittleO.add_isEquivalent
    (IsLittleO.sum fun i hi =>
      IsLittleO.const_mul_left
        ((IsLittleO.const_mul_right fun hz => h <| leadingCoeff_eq_zero.mp hz) <|
          isLittleO_pow_pow_atTop_of_lt (mem_range.mp hi))
        _)
    IsEquivalent.refl
state_before: case neg
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : ¬P = 0
⊢ (fun x =>
      (Finset.sum (range (natDegree P)) fun i => coeff P i * x ^ i) + coeff P (natDegree P) * x ^ natDegree P) ~[atTop]
    fun x => leadingCoeff P * x ^ natDegree P
Theorem: PadicSeq.norm_neg
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simp
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : PadicSeq p
⊢ ∀ (k : ℕ), padicNorm p (↑(-a) k) = padicNorm p (↑a k)
Theorem: Polynomial.prod_multiset_X_sub_C_of_monic_of_roots_card_eq
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: convert C_leadingCoeff_mul_prod_multiset_X_sub_C hroots
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hp : Monic p
hroots : ↑Multiset.card (roots p) = natDegree p
⊢ Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots p)) = p

tactic: rw [hp.leadingCoeff, C_1, one_mul]
state_before: case h.e'_2
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hp : Monic p
hroots : ↑Multiset.card (roots p) = natDegree p
⊢ Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots p)) =
    ↑C (leadingCoeff p) * Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots p))
Theorem: AdjoinRoot.root_isInv
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: convert sub_eq_zero.1 ((eval₂_sub _).symm.trans <| eval₂_root <| C r * X - 1) <;>
  simp only [eval₂_mul, eval₂_C, eval₂_X, eval₂_one]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
f : R[X]
inst✝¹ : CommRing S
i : R →+* S
a : S
h : eval₂ i a f = 0
inst✝ : Algebra R S
hfx : ↑(aeval a) f = 0
r : R
⊢ ↑(of (↑C r * X - 1)) r * root (↑C r * X - 1) = 1
Theorem: Set.preimage_const_mul_Icc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ici_inter_Iic, h]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ (fun x x_1 => x * x_1) c ⁻¹' Icc a b = Icc (a / c) (b / c)
Theorem: norm_pow_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp only [Nat.zero_eq, pow_zero, norm_one, le_rfl]
state_before: α : Type u_1
β : Type ?u.132724
γ : Type ?u.132727
ι : Type ?u.132730
inst✝¹ : SeminormedRing α
inst✝ : NormOneClass α
a : α
n : ℕ
⊢ ‖a ^ Nat.zero‖ ≤ ‖a‖ ^ Nat.zero
Theorem: CategoryTheory.GrothendieckTopology.Plus.isSheaf_plus_plus
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: apply isSheaf_of_sep
state_before: C : Type u
inst✝⁷ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
⊢ Presheaf.IsSheaf J (plusObj J (plusObj J P))

tactic: intro X S x y
state_before: case hsep
C : Type u
inst✝⁷ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
⊢ ∀ (X : C) (S : Cover J X) (x y : (forget D).obj ((plusObj J P).obj X.op)),
    (∀ (I : Cover.Arrow S), (forget D).map ((plusObj J P).map I.f.op) x = (forget D).map ((plusObj J P).map I.f.op) y) →
      x = y

tactic: apply sep
state_before: case hsep
C : Type u
inst✝⁷ : Category C
J : GrothendieckTopology C
D : Type w
inst✝⁶ : Category D
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
P : Cᵒᵖ ⥤ D
X : C
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj X.op)
⊢ (∀ (I : Cover.Arrow S), (forget D).map ((plusObj J P).map I.f.op) x = (forget D).map ((plusObj J P).map I.f.op) y) →
    x = y
Theorem: List.prod_hom
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: simp only [prod, foldl_map, ← map_one f]
state_before: ι : Type ?u.22722
α : Type ?u.22725
M : Type u_1
N : Type u_3
P : Type ?u.22734
M₀ : Type ?u.22737
G : Type ?u.22740
R : Type ?u.22743
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List M
F : Type u_2
inst✝ : MonoidHomClass F M N
f : F
⊢ prod (map (↑f) l) = ↑f (prod l)

tactic: exact l.foldl_hom f (. * .) (. * f .) 1 (fun x y => (map_mul f x y).symm)
state_before: ι : Type ?u.22722
α : Type ?u.22725
M : Type u_1
N : Type u_3
P : Type ?u.22734
M₀ : Type ?u.22737
G : Type ?u.22740
R : Type ?u.22743
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List M
F : Type u_2
inst✝ : MonoidHomClass F M N
f : F
⊢ foldl (fun x y => x * ↑f y) (↑f 1) l = ↑f (foldl (fun x x_1 => x * x_1) 1 l)
Theorem: DihedralGroup.orderOf_r
File: Mathlib/GroupTheory/SpecificGroups/Dihedral.lean

tactic: conv_lhs => rw [← ZMod.nat_cast_zmod_val i]
state_before: n : ℕ
inst✝ : NeZero n
i : ZMod n
⊢ orderOf (r i) = n / Nat.gcd n (ZMod.val i)

tactic: rw [← r_one_pow, orderOf_pow, orderOf_r_one]
state_before: n : ℕ
inst✝ : NeZero n
i : ZMod n
⊢ orderOf (r ↑(ZMod.val i)) = n / Nat.gcd n (ZMod.val i)
Theorem: List.map_diff
File: Mathlib/Data/List/Basic.lean

tactic: simp only [diff_eq_foldl, foldl_map, map_foldl_erase finj]
state_before: ι : Type ?u.428249
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
finj : Injective f
l₁ l₂ : List α
⊢ map f (List.diff l₁ l₂) = List.diff (map f l₁) (map f l₂)
Theorem: finprod_div_distrib
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simp only [div_eq_mul_inv, finprod_mul_distrib hf ((mulSupport_inv g).symm.rec hg),
  finprod_inv_distrib]
state_before: α : Type u_2
β : Type ?u.215706
ι : Type ?u.215709
G : Type u_1
M : Type ?u.215715
N : Type ?u.215718
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f✝ g✝ : α → M
a b : α
s t : Set α
inst✝ : DivisionCommMonoid G
f g : α → G
hf : Set.Finite (mulSupport f)
hg : Set.Finite (mulSupport g)
⊢ (∏ᶠ (i : α), f i / g i) = (∏ᶠ (i : α), f i) / ∏ᶠ (i : α), g i
Theorem: MeasureTheory.AEEqFun.ext
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rwa [← f.mk_coeFn, ← g.mk_coeFn, mk_eq_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.309065
δ : Type ?u.309068
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g : α →ₘ[μ] β
h : ↑f =ᵐ[μ] ↑g
⊢ f = g
Theorem: List.getD_eq_getD_get?
File: Mathlib/Data/List/Basic.lean

tactic: cases' lt_or_le n l.length with h h
state_before: ι : Type ?u.504470
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝ n : ℕ
⊢ getD l n d = Option.getD (get? l n) d

tactic: rw [getD_eq_get _ _ h, get?_eq_get h, Option.getD_some]
state_before: case inl
ι : Type ?u.504470
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝ n : ℕ
h : n < length l
⊢ getD l n d = Option.getD (get? l n) d

tactic: rw [getD_eq_default _ _ h, get?_eq_none.mpr h, Option.getD_none]
state_before: case inr
ι : Type ?u.504470
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝ n : ℕ
h : length l ≤ n
⊢ getD l n d = Option.getD (get? l n) d
Theorem: SimpleGraph.comap_monotone
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: intro G G' h _ _ ha
state_before: ι : Sort ?u.208589
𝕜 : Type ?u.208592
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
f : V ↪ W
⊢ Monotone (SimpleGraph.comap ↑f)

tactic: exact h ha
state_before: ι : Sort ?u.208589
𝕜 : Type ?u.208592
V : Type u
W : Type v
X : Type w
G✝ : SimpleGraph V
G'✝ : SimpleGraph W
a b c u v w : V
e : Sym2 V
f : V ↪ W
G G' : SimpleGraph W
h : G ≤ G'
v✝ w✝ : V
ha : Adj (SimpleGraph.comap (↑f) G) v✝ w✝
⊢ Adj (SimpleGraph.comap (↑f) G') v✝ w✝
Theorem: Multiset.coe_sections
File: Mathlib/Data/Multiset/Sections.lean

tactic: simp
state_before: α : Type u_1
a : List α
l : List (List α)
⊢ Sections ↑(List.map (fun l => ↑l) (a :: l)) = ↑(List.map (fun l => ↑l) (List.sections (a :: l)))

tactic: rw [← cons_coe, sections_cons, bind_map_comm, coe_sections l]
state_before: α : Type u_1
a : List α
l : List (List α)
⊢ Sections ↑(↑a :: List.map (fun l => ↑l) l) =
    ↑(List.map (fun l => ↑l) (List.bind (List.sections l) fun s => List.map (fun a => a :: s) a))
Theorem: TopologicalSpace.noetherianSpace_iff_opens
File: Mathlib/Topology/NoetherianSpace.lean

tactic: rw [noetherianSpace_iff, CompleteLattice.wellFounded_iff_isSupFiniteCompact,
  CompleteLattice.isSupFiniteCompact_iff_all_elements_compact]
state_before: α : Type u_1
β : Type ?u.411
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ NoetherianSpace α ↔ ∀ (s : Opens α), IsCompact ↑s

tactic: exact forall_congr' Opens.isCompactElement_iff
state_before: α : Type u_1
β : Type ?u.411
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
⊢ (∀ (k : Opens α), CompleteLattice.IsCompactElement k) ↔ ∀ (s : Opens α), IsCompact ↑s
Theorem: Int.ceil_neg
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [neg_le, ceil_le, le_floor, Int.cast_neg, neg_le]
state_before: F : Type ?u.207706
α : Type u_1
β : Type ?u.207712
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a : α
z : ℤ
⊢ ⌈-a⌉ ≤ z ↔ -⌊a⌋ ≤ z
Theorem: Finset.biUnion_image
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [biUnion_insert, image_union, ih]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝¹ : Finset α
t✝ : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq γ
s✝ : Finset α
t : α → Finset β
f : β → γ
this : DecidableEq α
a : α
s : Finset α
x✝ : ¬a ∈ s
ih : image f (Finset.biUnion s t) = Finset.biUnion s fun a => image f (t a)
⊢ image f (Finset.biUnion (insert a s) t) = Finset.biUnion (insert a s) fun a => image f (t a)
Theorem: Ordinal.zero_CNF
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

tactic: simp [CNF_ne_zero ho]
state_before: o : Ordinal
ho : o ≠ 0
⊢ CNF 0 o = [(0, o)]
Theorem: Finset.forall_mem_cons
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_cons, or_imp, forall_and, forall_eq]
state_before: α : Type u_1
β : Type ?u.37873
γ : Type ?u.37876
s t : Finset α
a b : α
h : ¬a ∈ s
p : α → Prop
⊢ (∀ (x : α), x ∈ cons a s h → p x) ↔ p a ∧ ∀ (x : α), x ∈ s → p x
Theorem: Cardinal.mk_list_le_max
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: cases finite_or_infinite α
state_before: α : Type u
⊢ (#List α) ≤ max ℵ₀ (#α)

tactic: exact mk_le_aleph0.trans (le_max_left _ _)
state_before: case inl
α : Type u
h✝ : Finite α
⊢ (#List α) ≤ max ℵ₀ (#α)

tactic: rw [mk_list_eq_mk]
state_before: case inr
α : Type u
h✝ : Infinite α
⊢ (#List α) ≤ max ℵ₀ (#α)

tactic: apply le_max_right
state_before: case inr
α : Type u
h✝ : Infinite α
⊢ (#α) ≤ max ℵ₀ (#α)
Theorem: Real.rpow_lt_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← one_rpow z]
state_before: x✝ y z✝ x z : ℝ
hx1 : 0 ≤ x
hx2 : x < 1
hz : 0 < z
⊢ x ^ z < 1

tactic: exact rpow_lt_rpow hx1 hx2 hz
state_before: x✝ y z✝ x z : ℝ
hx1 : 0 ≤ x
hx2 : x < 1
hz : 0 < z
⊢ x ^ z < 1 ^ z
Theorem: List.forIn_eq_bindList
File: Std/Data/List/Lemmas.lean

tactic: induction l generalizing init <;> simp [*, map_eq_pure_bind]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m (ForInStep β)
l : List α
init : β
⊢ forIn l init f = ForInStep.run <$> ForInStep.bindList f l (ForInStep.yield init)

tactic: congr
state_before: case cons
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m (ForInStep β)
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (init : β), forIn tail✝ init f = ForInStep.run <$> ForInStep.bindList f tail✝ (ForInStep.yield init)
init : β
⊢ (do
      let x ← f head✝ init
      match x with
        | ForInStep.done b => pure b
        | ForInStep.yield b => do
          let a ← ForInStep.bindList f tail✝ (ForInStep.yield b)
          pure (ForInStep.run a)) =
    do
    let x ← f head✝ init
    let a ← ForInStep.bindList f tail✝ x
    pure (ForInStep.run a)

tactic: ext (b | b) <;> simp
state_before: case cons.e_a
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m (ForInStep β)
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (init : β), forIn tail✝ init f = ForInStep.run <$> ForInStep.bindList f tail✝ (ForInStep.yield init)
init : β
⊢ (fun x =>
      match x with
      | ForInStep.done b => pure b
      | ForInStep.yield b => do
        let a ← ForInStep.bindList f tail✝ (ForInStep.yield b)
        pure (ForInStep.run a)) =
    fun x => do
    let a ← ForInStep.bindList f tail✝ x
    pure (ForInStep.run a)
Theorem: orthogonalProjection_comp_subtypeL_eq_zero_iff
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: convert orthogonalProjection_inner_eq_zero v u hu using 2
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.813852
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K U V : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ U }
h : ContinuousLinearMap.comp (orthogonalProjection U) (Submodule.subtypeL V) = 0
u : E
hu : u ∈ U
v : E
hv : v ∈ V
⊢ inner v u = 0

tactic: have : orthogonalProjection U v = 0 := FunLike.congr_fun h (⟨_, hv⟩ : V)
state_before: case h.e'_2.h.e'_4
𝕜 : Type u_1
E : Type u_2
F : Type ?u.813852
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K U V : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ U }
h : ContinuousLinearMap.comp (orthogonalProjection U) (Submodule.subtypeL V) = 0
u : E
hu : u ∈ U
v : E
hv : v ∈ V
⊢ v = v - ↑(↑(orthogonalProjection U) v)

tactic: rw [this, Submodule.coe_zero, sub_zero]
state_before: case h.e'_2.h.e'_4
𝕜 : Type u_1
E : Type u_2
F : Type ?u.813852
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K U V : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ U }
h : ContinuousLinearMap.comp (orthogonalProjection U) (Submodule.subtypeL V) = 0
u : E
hu : u ∈ U
v : E
hv : v ∈ V
this : ↑(orthogonalProjection U) v = 0
⊢ v = v - ↑(↑(orthogonalProjection U) v)
Theorem: NNReal.sInf_empty
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [← NNReal.coe_eq_zero, coe_sInf, Set.image_empty, Real.sInf_empty]
state_before: ⊢ sInf ∅ = 0
Theorem: Int.floor_fract
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [floor_eq_iff, Int.cast_zero, zero_add]
state_before: F : Type ?u.161267
α : Type u_1
β : Type ?u.161273
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ ⌊fract a⌋ = 0

tactic: exact ⟨fract_nonneg _, fract_lt_one _⟩
state_before: F : Type ?u.161267
α : Type u_1
β : Type ?u.161273
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ 0 ≤ fract a ∧ fract a < 1