tasksource/leandojo huggingface dataset:
Theorem: Part.mem_toFinset
File: Mathlib/Data/Finset/PImage.lean

tactic: simp [toFinset]
state_before: α : Type u_1
β : Type ?u.68
o : Part α
inst✝ : Decidable o.Dom
x : α
⊢ x ∈ toFinset o ↔ x ∈ o
Theorem: Matrix.add_cons
File: Mathlib/Data/Fin/VecNotation.lean

tactic: ext i
state_before: α : Type u
m n o : ℕ
m' : Type ?u.61403
n' : Type ?u.61406
o' : Type ?u.61409
inst✝ : Add α
v : Fin (Nat.succ n) → α
y : α
w : Fin n → α
⊢ v + vecCons y w = vecCons (vecHead v + y) (vecTail v + w)

tactic: refine' Fin.cases _ _ i <;> simp [vecHead, vecTail]
state_before: case h
α : Type u
m n o : ℕ
m' : Type ?u.61403
n' : Type ?u.61406
o' : Type ?u.61409
inst✝ : Add α
v : Fin (Nat.succ n) → α
y : α
w : Fin n → α
i : Fin (Nat.succ n)
⊢ (v + vecCons y w) i = vecCons (vecHead v + y) (vecTail v + w) i
Theorem: Multiset.max_le_of_forall_le
File: Mathlib/Data/Multiset/Fold.lean

tactic: induction l using Quotient.inductionOn
state_before: α✝ : Type ?u.20522
β : Type ?u.20525
α : Type u_1
inst✝ : CanonicallyLinearOrderedAddMonoid α
l : Multiset α
n : α
h : ∀ (x : α), x ∈ l → x ≤ n
⊢ fold max ⊥ l ≤ n

tactic: simpa using List.max_le_of_forall_le _ _ h
state_before: case h
α✝ : Type ?u.20522
β : Type ?u.20525
α : Type u_1
inst✝ : CanonicallyLinearOrderedAddMonoid α
n : α
a✝ : List α
h : ∀ (x : α), x ∈ Quotient.mk (List.isSetoid α) a✝ → x ≤ n
⊢ fold max ⊥ (Quotient.mk (List.isSetoid α) a✝) ≤ n
Theorem: LinearMap.stdBasis_eq_pi_diag
File: Mathlib/LinearAlgebra/StdBasis.lean

tactic: ext (x j)
state_before: R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i : ι
⊢ stdBasis R φ i = pi (diag i)

tactic: convert (update_apply (R := R) (φ := φ) (ι := ι) 0 x i j _).symm
state_before: case h.h
R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i : ι
x : φ i
j : ι
⊢ ↑(stdBasis R φ i) x j = ↑(pi (diag i)) x j

tactic: rfl
state_before: case h.e'_2.h.e'_1
R : Type u_3
ι : Type u_1
inst✝³ : Semiring R
φ : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i : ι
x : φ i
j : ι
⊢ x = ↑id x
Theorem: InnerProductGeometry.angle_smul_left_of_pos
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [angle_comm, angle_smul_right_of_pos y x hr, angle_comm]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
r : ℝ
hr : 0 < r
⊢ angle (r • x) y = angle x y
Theorem: MeasureTheory.L1.SimpleFunc.integral_L1_eq_integral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.423076
𝕜 : Type ?u.423079
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : { x // x ∈ simpleFunc E 1 μ }
⊢ L1.integral ↑f = integral f

tactic: exact setToL1_eq_setToL1SCLM (dominatedFinMeasAdditive_weightedSMul μ) f
state_before: α : Type u_1
E : Type u_2
F : Type ?u.423076
𝕜 : Type ?u.423079
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : { x // x ∈ simpleFunc E 1 μ }
⊢ ↑L1.integralCLM ↑f = MeasureTheory.SimpleFunc.integral μ (toSimpleFunc f)
Theorem: Polynomial.degree_modByMonic_le
File: Mathlib/Data/Polynomial/Div.lean

tactic: nontriviality R
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hq : Monic q
⊢ degree (p %ₘ q) ≤ degree q

tactic: exact (degree_modByMonic_lt _ hq).le
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
hq : Monic q
✝ : Nontrivial R
⊢ degree (p %ₘ q) ≤ degree q
Theorem: real_inner_smul_self_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [inner_smul_right, ← real_inner_self_eq_norm_mul_norm]
state_before: 𝕜 : Type ?u.3142239
E : Type ?u.3142242
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : F
r : ℝ
⊢ inner x (r • x) = r * (‖x‖ * ‖x‖)
Theorem: Finsupp.eq_zero_of_comapDomain_eq_zero
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [← support_eq_empty, ← support_eq_empty, comapDomain]
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.301425
ι : Type ?u.301428
M : Type u_1
M' : Type ?u.301434
N : Type ?u.301437
P : Type ?u.301440
G : Type ?u.301443
H : Type ?u.301446
R : Type ?u.301449
S : Type ?u.301452
inst✝ : AddCommMonoid M
f : α → β
l : β →₀ M
hf : Set.BijOn f (f ⁻¹' ↑l.support) ↑l.support
⊢ comapDomain f l (_ : Set.InjOn f (f ⁻¹' ↑l.support)) = 0 → l = 0

tactic: simp only [Finset.ext_iff, Finset.not_mem_empty, iff_false_iff, mem_preimage]
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.301425
ι : Type ?u.301428
M : Type u_1
M' : Type ?u.301434
N : Type ?u.301437
P : Type ?u.301440
G : Type ?u.301443
H : Type ?u.301446
R : Type ?u.301449
S : Type ?u.301452
inst✝ : AddCommMonoid M
f : α → β
l : β →₀ M
hf : Set.BijOn f (f ⁻¹' ↑l.support) ↑l.support
⊢ { support := preimage l.support f (_ : Set.InjOn f (f ⁻¹' ↑l.support)), toFun := fun a => ↑l (f a),
          mem_support_toFun :=
            (_ :
              ∀ (a : α),
                a ∈ preimage l.support f (_ : Set.InjOn f (f ⁻¹' ↑l.support)) ↔ (fun a => ↑l (f a)) a ≠ 0) }.support =
      ∅ →
    l.support = ∅

tactic: intro h a ha
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.301425
ι : Type ?u.301428
M : Type u_1
M' : Type ?u.301434
N : Type ?u.301437
P : Type ?u.301440
G : Type ?u.301443
H : Type ?u.301446
R : Type ?u.301449
S : Type ?u.301452
inst✝ : AddCommMonoid M
f : α → β
l : β →₀ M
hf : Set.BijOn f (f ⁻¹' ↑l.support) ↑l.support
⊢ (∀ (a : α), ¬f a ∈ l.support) → ∀ (a : β), ¬a ∈ l.support

tactic: cases' hf.2.2 ha with b hb
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.301425
ι : Type ?u.301428
M : Type u_1
M' : Type ?u.301434
N : Type ?u.301437
P : Type ?u.301440
G : Type ?u.301443
H : Type ?u.301446
R : Type ?u.301449
S : Type ?u.301452
inst✝ : AddCommMonoid M
f : α → β
l : β →₀ M
hf : Set.BijOn f (f ⁻¹' ↑l.support) ↑l.support
h : ∀ (a : α), ¬f a ∈ l.support
a : β
ha : a ∈ l.support
⊢ False

tactic: exact h b (hb.2.symm ▸ ha)
state_before: case intro
α : Type u_3
β : Type u_2
γ : Type ?u.301425
ι : Type ?u.301428
M : Type u_1
M' : Type ?u.301434
N : Type ?u.301437
P : Type ?u.301440
G : Type ?u.301443
H : Type ?u.301446
R : Type ?u.301449
S : Type ?u.301452
inst✝ : AddCommMonoid M
f : α → β
l : β →₀ M
hf : Set.BijOn f (f ⁻¹' ↑l.support) ↑l.support
h : ∀ (a : α), ¬f a ∈ l.support
a : β
ha : a ∈ l.support
b : α
hb : b ∈ f ⁻¹' ↑l.support ∧ f b = a
⊢ False
Theorem: FreeAbelianGroup.support_zero
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

tactic: simp only [support, Finsupp.support_zero, AddMonoidHom.map_zero]
state_before: X : Type u_1
⊢ support 0 = ∅
Theorem: sign_eq_zero_iff
File: Mathlib/Data/Sign.lean

tactic: refine' ⟨fun h => _, fun h => h.symm ▸ sign_zero⟩
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
⊢ ↑sign a = 0 ↔ a = 0

tactic: rw [sign_apply] at h
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : ↑sign a = 0
⊢ a = 0

tactic: split_ifs at h with h_1 h_2
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : (if 0 < a then 1 else if a < 0 then -1 else 0) = 0
⊢ a = 0

tactic: cases' h
state_before: case inr.inr
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h_1 : ¬0 < a
h_2 : ¬a < 0
h : 0 = 0
⊢ a = 0

tactic: exact (le_of_not_lt h_1).eq_of_not_lt h_2
state_before: case inr.inr.refl
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h_1 : ¬0 < a
h_2 : ¬a < 0
⊢ a = 0
Theorem: SimpleGraph.Iso.connectedComponentEquiv_refl
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: ext ⟨v⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
⊢ connectedComponentEquiv refl = Equiv.refl (ConnectedComponent G)

tactic: rfl
state_before: case H.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
x✝ : ConnectedComponent G
v : V
⊢ ↑(connectedComponentEquiv refl) (Quot.mk (Reachable G) v) =
    ↑(Equiv.refl (ConnectedComponent G)) (Quot.mk (Reachable G) v)
Theorem: Ordinal.mod_eq_of_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp only [mod_def, div_eq_zero_of_lt h, mul_zero, sub_zero]
state_before: α : Type ?u.257723
β : Type ?u.257726
γ : Type ?u.257729
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
h : a < b
⊢ a % b = a
Theorem: CauchyFilter.uniformInducing_pureCauchy
File: Mathlib/Topology/UniformSpace/Completion.lean

tactic: simp [preimage, gen, pureCauchy, prod_principal_principal]
state_before: α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s : Set (α × α)
x✝ : α × α
a₁ a₂ : α
⊢ (a₁, a₂) ∈ ((preimage fun x => (pureCauchy x.fst, pureCauchy x.snd)) ∘ gen) s ↔ (a₁, a₂) ∈ id s

tactic: simp [this]
state_before: α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
this : (preimage fun x => (pureCauchy x.fst, pureCauchy x.snd)) ∘ gen = id
⊢ Filter.lift' (𝓤 α) ((preimage fun x => (pureCauchy x.fst, pureCauchy x.snd)) ∘ gen) = 𝓤 α
Theorem: ENNReal.tendsto_atTop_zero_of_tsum_ne_top
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [← Nat.cofinite_eq_atTop]
state_before: α : Type ?u.262359
β : Type ?u.262362
γ : Type ?u.262365
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : ℕ → ℝ≥0∞
hf : (∑' (x : ℕ), f x) ≠ ⊤
⊢ Tendsto f atTop (𝓝 0)

tactic: exact tendsto_cofinite_zero_of_tsum_ne_top hf
state_before: α : Type ?u.262359
β : Type ?u.262362
γ : Type ?u.262365
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
f : ℕ → ℝ≥0∞
hf : (∑' (x : ℕ), f x) ≠ ⊤
⊢ Tendsto f cofinite (𝓝 0)
Theorem: MeasureTheory.weightedSMul_smul_measure
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: ext1 x
state_before: α : Type u_1
E : Type ?u.30268
F : Type u_2
𝕜 : Type ?u.30274
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
⊢ weightedSMul (c • μ) s = ENNReal.toReal c • weightedSMul μ s

tactic: push_cast
state_before: case h
α : Type u_1
E : Type ?u.30268
F : Type u_2
𝕜 : Type ?u.30274
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ ↑(weightedSMul (c • μ) s) x = ↑(ENNReal.toReal c • weightedSMul μ s) x

tactic: simp_rw [Pi.smul_apply, weightedSMul_apply]
state_before: case h
α : Type u_1
E : Type ?u.30268
F : Type u_2
𝕜 : Type ?u.30274
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ ↑(weightedSMul (c • μ) s) x = (ENNReal.toReal c • ↑(weightedSMul μ s)) x

tactic: push_cast
state_before: case h
α : Type u_1
E : Type ?u.30268
F : Type u_2
𝕜 : Type ?u.30274
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ ENNReal.toReal (↑↑(c • μ) s) • x = ENNReal.toReal c • ENNReal.toReal (↑↑μ s) • x

tactic: simp_rw [Pi.smul_apply, smul_eq_mul, toReal_mul, smul_smul]
state_before: case h
α : Type u_1
E : Type ?u.30268
F : Type u_2
𝕜 : Type ?u.30274
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
c : ℝ≥0∞
s : Set α
x : F
⊢ ENNReal.toReal ((c • ↑↑μ) s) • x = ENNReal.toReal c • ENNReal.toReal (↑↑μ s) • x
Theorem: Bornology.isBounded_union
File: Mathlib/Topology/Bornology/Basic.lean

tactic: simp only [← isCobounded_compl_iff, compl_union, isCobounded_inter]
state_before: ι : Type ?u.4828
α : Type u_1
β : Type ?u.4834
inst✝ : Bornology α
s t : Set α
x : α
⊢ IsBounded (s ∪ t) ↔ IsBounded s ∧ IsBounded t
Theorem: PGame.zero_le_lf
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [le_iff_forall_lf]
state_before: x : PGame
⊢ 0 ≤ x ↔ ∀ (j : RightMoves x), 0 ⧏ moveRight x j

tactic: simp
state_before: x : PGame
⊢ ((∀ (i : LeftMoves 0), moveLeft 0 i ⧏ x) ∧ ∀ (j : RightMoves x), 0 ⧏ moveRight x j) ↔
    ∀ (j : RightMoves x), 0 ⧏ moveRight x j
Theorem: IsLocalization.integerNormalization_aeval_eq_zero
File: Mathlib/RingTheory/Localization/Integral.lean

tactic: rw [aeval_def, IsScalarTower.algebraMap_eq R S R', integerNormalization_eval₂_eq_zero _ _ _ hx]
state_before: R : Type u_1
inst✝⁸ : CommRing R
M : Submonoid R
S : Type u_3
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P : Type ?u.52206
inst✝⁵ : CommRing P
inst✝⁴ : IsLocalization M S
R' : Type u_2
inst✝³ : CommRing R'
inst✝² : Algebra R R'
inst✝¹ : Algebra S R'
inst✝ : IsScalarTower R S R'
p : S[X]
x : R'
hx : ↑(aeval x) p = 0
⊢ ↑(aeval x) (integerNormalization M p) = 0
Theorem: Int.isUnit_iff
File: Mathlib/Data/Int/Units.lean

tactic: refine' ⟨fun h => isUnit_eq_one_or h, fun h => _⟩
state_before: a : ℤ
⊢ IsUnit a ↔ a = 1 ∨ a = -1

tactic: rcases h with (rfl | rfl)
state_before: a : ℤ
h : a = 1 ∨ a = -1
⊢ IsUnit a

tactic: exact isUnit_one
state_before: case inl

⊢ IsUnit 1

tactic: exact isUnit_one.neg
state_before: case inr

⊢ IsUnit (-1)
Theorem: finprod_eq_dif
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: split_ifs with h
state_before: G : Type ?u.38544
M : Type u_1
N : Type ?u.38550
α : Sort ?u.38553
β : Sort ?u.38556
ι : Sort ?u.38559
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
p : Prop
inst✝ : Decidable p
f : p → M
⊢ (∏ᶠ (i : p), f i) = if h : p then f h else 1

tactic: haveI : Unique p := ⟨⟨h⟩, fun _ => rfl⟩
state_before: case inl
G : Type ?u.38544
M : Type u_1
N : Type ?u.38550
α : Sort ?u.38553
β : Sort ?u.38556
ι : Sort ?u.38559
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
p : Prop
inst✝ : Decidable p
f : p → M
h : p
⊢ (∏ᶠ (i : p), f i) = f h

tactic: exact finprod_unique f
state_before: case inl
G : Type ?u.38544
M : Type u_1
N : Type ?u.38550
α : Sort ?u.38553
β : Sort ?u.38556
ι : Sort ?u.38559
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
p : Prop
inst✝ : Decidable p
f : p → M
h : p
this : Unique p
⊢ (∏ᶠ (i : p), f i) = f h

tactic: haveI : IsEmpty p := ⟨h⟩
state_before: case inr
G : Type ?u.38544
M : Type u_1
N : Type ?u.38550
α : Sort ?u.38553
β : Sort ?u.38556
ι : Sort ?u.38559
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
p : Prop
inst✝ : Decidable p
f : p → M
h : ¬p
⊢ (∏ᶠ (i : p), f i) = 1

tactic: exact finprod_of_isEmpty f
state_before: case inr
G : Type ?u.38544
M : Type u_1
N : Type ?u.38550
α : Sort ?u.38553
β : Sort ?u.38556
ι : Sort ?u.38559
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
p : Prop
inst✝ : Decidable p
f : p → M
h : ¬p
this : IsEmpty p
⊢ (∏ᶠ (i : p), f i) = 1
Theorem: Nat.cast_bit1
File: Mathlib/Data/Nat/Cast/Defs.lean

tactic: rw [bit1, cast_add_one, cast_bit0]
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
n : ℕ
⊢ ↑(bit1 n) = bit1 ↑n

tactic: rfl
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
n : ℕ
⊢ bit0 ↑n + 1 = bit1 ↑n
Theorem: Matrix.J_squared
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

tactic: rw [J, fromBlocks_multiply]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ J l R ⬝ J l R = -1

tactic: simp only [Matrix.zero_mul, Matrix.neg_mul, zero_add, neg_zero, Matrix.one_mul, add_zero]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ fromBlocks (0 ⬝ 0 + (-1) ⬝ 1) (0 ⬝ (-1) + (-1) ⬝ 0) (1 ⬝ 0 + 0 ⬝ 1) (1 ⬝ (-1) + 0 ⬝ 0) = -1

tactic: rw [← neg_zero, ← Matrix.fromBlocks_neg, ← fromBlocks_one]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : CommRing R
inst✝ : Fintype l
⊢ fromBlocks (-1) 0 0 (-1) = -1
Theorem: Mathlib.Meta.NormNum.IsInt.to_isNat
File: Mathlib/Tactic/NormNum/Core.lean

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
a✝ : ℕ
⊢ ↑(Int.ofNat a✝) = ↑a✝
Theorem: nontrivial_of_invariantBasisNumber
File: Mathlib/LinearAlgebra/InvariantBasisNumber.lean

tactic: by_contra h
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
⊢ Nontrivial R

tactic: refine' zero_ne_one (eq_of_fin_equiv R _)
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
⊢ False

tactic: haveI := not_nontrivial_iff_subsingleton.1 h
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
⊢ (Fin 0 → R) ≃ₗ[R] Fin 1 → R

tactic: haveI : Subsingleton (Fin 1 → R) :=
  Subsingleton.intro <| fun a b => funext fun x => Subsingleton.elim _ _
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this : Subsingleton R
⊢ (Fin 0 → R) ≃ₗ[R] Fin 1 → R

tactic: exact
  { toFun := 0
    invFun := 0
    map_add' := by aesop
    map_smul' := by aesop
    left_inv := fun _ => by simp
    right_inv := fun _ => by simp }
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this✝ : Subsingleton R
this : Subsingleton (Fin 1 → R)
⊢ (Fin 0 → R) ≃ₗ[R] Fin 1 → R

tactic: aesop
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this✝ : Subsingleton R
this : Subsingleton (Fin 1 → R)
⊢ ∀ (x y : Fin 0 → R), OfNat.ofNat 0 (x + y) = OfNat.ofNat 0 x + OfNat.ofNat 0 y

tactic: aesop
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this✝ : Subsingleton R
this : Subsingleton (Fin 1 → R)
⊢ ∀ (r : R) (x : Fin 0 → R),
    AddHom.toFun { toFun := 0, map_add' := (_ : ∀ (x y : Fin 0 → R), OfNat.ofNat 0 (x + y) = 0 + 0) } (r • x) =
      ↑(RingHom.id R) r •
        AddHom.toFun { toFun := 0, map_add' := (_ : ∀ (x y : Fin 0 → R), OfNat.ofNat 0 (x + y) = 0 + 0) } x

tactic: simp
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this✝ : Subsingleton R
this : Subsingleton (Fin 1 → R)
x✝ : Fin 0 → R
⊢ OfNat.ofNat 0
      (AddHom.toFun
        { toAddHom := { toFun := 0, map_add' := (_ : ∀ (x y : Fin 0 → R), OfNat.ofNat 0 (x + y) = 0 + 0) },
            map_smul' := (_ : ∀ (r : R) (x : Fin 0 → R), OfNat.ofNat 0 (r • x) = r • 0) }.toAddHom
        x✝) =
    x✝

tactic: simp
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : InvariantBasisNumber R
h : ¬Nontrivial R
this✝ : Subsingleton R
this : Subsingleton (Fin 1 → R)
x✝ : Fin 1 → R
⊢ AddHom.toFun
      { toAddHom := { toFun := 0, map_add' := (_ : ∀ (x y : Fin 0 → R), OfNat.ofNat 0 (x + y) = 0 + 0) },
          map_smul' := (_ : ∀ (r : R) (x : Fin 0 → R), OfNat.ofNat 0 (r • x) = r • 0) }.toAddHom
      (OfNat.ofNat 0 x✝) =
    x✝
Theorem: CategoryTheory.MorphismProperty.naturalityProperty.stableUnderComposition
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: simp only [naturalityProperty] at hf hg⊢
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : naturalityProperty app f
hg : naturalityProperty app g
⊢ naturalityProperty app (f ≫ g)

tactic: simp only [Functor.map_comp, Category.assoc, hg]
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : F₁.map f ≫ app Y = app X ≫ F₂.map f
hg : F₁.map g ≫ app Z = app Y ≫ F₂.map g
⊢ F₁.map (f ≫ g) ≫ app Z = app X ≫ F₂.map (f ≫ g)

tactic: slice_lhs 1 2 => rw [hf]
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : F₁.map f ≫ app Y = app X ≫ F₂.map f
hg : F₁.map g ≫ app Z = app Y ≫ F₂.map g
⊢ F₁.map f ≫ app Y ≫ F₂.map g = app X ≫ F₂.map f ≫ F₂.map g

tactic: rw [Category.assoc]
state_before: C : Type u
inst✝¹ : Category C
D : Type u_2
inst✝ : Category D
F₁ F₂ : C ⥤ D
app : (X : C) → F₁.obj X ⟶ F₂.obj X
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : F₁.map f ≫ app Y = app X ≫ F₂.map f
hg : F₁.map g ≫ app Z = app Y ≫ F₂.map g
⊢ (app X ≫ F₂.map f) ≫ F₂.map g = app X ≫ F₂.map f ≫ F₂.map g
Theorem: Submodule.sub_mem_sup
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: rw [sub_eq_add_neg]
state_before: R : Type ?u.157648
S✝ : Type ?u.157651
M : Type ?u.157654
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S✝
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : Module S✝ M
inst✝⁴ : SMul S✝ R
inst✝³ : IsScalarTower S✝ R M
p q : Submodule R M
R' : Type u_1
M' : Type u_2
inst✝² : Ring R'
inst✝¹ : AddCommGroup M'
inst✝ : Module R' M'
S T : Submodule R' M'
s t : M'
hs : s ∈ S
ht : t ∈ T
⊢ s - t ∈ S ⊔ T

tactic: exact add_mem_sup hs (neg_mem ht)
state_before: R : Type ?u.157648
S✝ : Type ?u.157651
M : Type ?u.157654
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S✝
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : Module S✝ M
inst✝⁴ : SMul S✝ R
inst✝³ : IsScalarTower S✝ R M
p q : Submodule R M
R' : Type u_1
M' : Type u_2
inst✝² : Ring R'
inst✝¹ : AddCommGroup M'
inst✝ : Module R' M'
S T : Submodule R' M'
s t : M'
hs : s ∈ S
ht : t ∈ T
⊢ s + -t ∈ S ⊔ T
Theorem: padicNorm.neg
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: simp [hq]
state_before: p : ℕ
q : ℚ
hq : q = 0
⊢ padicNorm p (-q) = padicNorm p q

tactic: simp [padicNorm, hq]
state_before: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ padicNorm p (-q) = padicNorm p q
Theorem: Set.Ioo_inter_Ioc_of_right_lt
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [inter_comm, Ioc_inter_Ioo_of_left_lt h, max_comm]
state_before: α : Type u_1
β : Type ?u.196902
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
h : b₂ < b₁
⊢ Ioo a₁ b₁ ∩ Ioc a₂ b₂ = Ioc (max a₁ a₂) b₂
Theorem: Finsupp.total_zero_apply
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: simp [Finsupp.total_apply]
state_before: α : Type u_1
M : Type u_3
N : Type ?u.294176
P : Type ?u.294179
R : Type u_2
S : Type ?u.294185
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : Module R N
inst✝⁶ : AddCommMonoid P
inst✝⁵ : Module R P
α' : Type ?u.294277
M' : Type ?u.294280
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v : α → M
v' : α' → M'
x : α →₀ R
⊢ ↑(Finsupp.total α M R 0) x = 0
Theorem: IsometryEquiv.image_emetric_closedBall
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.preimage_symm, h.symm.preimage_emetric_closedBall, symm_symm]
state_before: ι : Type ?u.750293
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
h : α ≃ᵢ β
x : α
r : ℝ≥0∞
⊢ ↑h '' EMetric.closedBall x r = EMetric.closedBall (↑h x) r
Theorem: Rel.interedges_mono
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: simp_rw [mem_interedges_iff]
state_before: 𝕜 : Type ?u.2805
ι : Type ?u.2808
κ : Type ?u.2811
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
x : α × β
⊢ x ∈ interedges r s₂ t₂ → x ∈ interedges r s₁ t₁

tactic: exact fun h ↦ ⟨hs h.1, ht h.2.1, h.2.2⟩
state_before: 𝕜 : Type ?u.2805
ι : Type ?u.2808
κ : Type ?u.2811
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
hs : s₂ ⊆ s₁
ht : t₂ ⊆ t₁
x : α × β
⊢ x.fst ∈ s₂ ∧ x.snd ∈ t₂ ∧ r x.fst x.snd → x.fst ∈ s₁ ∧ x.snd ∈ t₁ ∧ r x.fst x.snd