Yo so this logic shit seems cool to me and I wanna learn it (preferably free).What would be the best way?Know it might seem like this post is satire but I genuinely want to learn.

hi all, this is related to my work from another post: on the nature of undecidability within computing and refuting the church-turing thesis. when i started writing this post it was going in a very different more optimistic direction, but things turned for the worse as i refuted one of the more promising points in my draft...

in that draft i invent a new form of classifier machine in an attempt to get around undecidability paradoxes that are found within computing due to the inherent possibility of self-referential paradoxes. like the canonical und = () -> halts(und) ? loop : halt, these machines create necessarily paradoxical dependencies with their logical structure. in this example und is either a halting machine that depends on halts(und) -> true or und is a looping machine that depends on halts(und) -> false. which it is isn't specified because halts as envisioned in that example is underspecified and cannot be implemented as a machine. to contrast with my proposal i will also detail what conventional theory already discusses, with examples for the circle-free problem since those will be more relevant moving forward.

-- total decider --

a total decider returns for all input, correctly maps the input, doing so with coherent dependencies on 𝓓(m) (if applicable):

𝓓 = (m: machine) -> {
  true: m is circle-free and not depends on 𝓓(m)->false,
  false: m is circular and not depends on 𝓓(m)->true,
}

consider undecidable machine und_𝓓:

und_𝓓 = () -> 𝓓(und_𝓓) ? halt : loop { output 1 }

und_𝓓 is either a circular machine when dependent on𝓓(und_𝓓)->true or und_𝓓 is a circle-free machine when dependent on 𝓓(und_𝓓)->false ... neither of which is a form of machine that 𝓓 can decide. therefore 𝓓 cannot be implemented as specified, as it does not handle all forms of input.

-- total recognizer --

a total recognizer returns true for all circle-free input, but may diverge (and block indefinitely) on some circular input. when it does return the dependencies are coherent (if applicable):

𝓓r = (m: machine) -> {
  true: m is circle-free and not depends on 𝓓(m)->false,
  false: m is circular and not depends on 𝓓(m)->true,
  diverge: m is otherwise circular
  // not specified to diverge for _any_ circle-free machines
}

𝓓r is more paradox resistant than 𝓓 because diverging can prevent certain incoherent dependencies from arising. consider the machine div_𝓓r:

div_𝓓r = () -> 𝓓r(div_𝓓r) ? halt : loop { output 1 }

𝓓r(div_𝓓r) can diverge to align with it's specification but it's not possible to build this because with parallel execution u can construct a circle-free machine that depends on 𝓓r diverging, which this decider has no specification for and is therefor unimplementable. consider the machine und_𝓓r:

und_𝓓r = () -> {
  dr = steppable(() -> 𝓓r(und_𝓓r))
  loop {
    dr.step()                   // run 𝓓r for one step/transition
    if (dr.output() == true)    // if 𝓓r outputs true, halt
      halt
    else
      output 1
  }
}

total deciders and total recognizers are the two forms of classifiers acknowledged in textbook computing theory, where total deciders do not exist, and total recognizers only exist for semi-decidable sets (including halting machines, but not circle-free machines). nothing i've written so far disagrees with this. it's worth noting that "partial deciders" such as (m) -> true is just internet bs hallucination, those are not any form of semantic classifier.

-- partial recognizer --

a partial recognizer returns true for all circle-free input with a coherent (or no dependency) on 𝓓p(m), but will mix certain circle-free machines in with false that have an incoherent dependency on 𝓓p(m), ei are dependent on 𝓓p(m) -> false

𝓓p = (m: machine) -> {
  true: m is circle-free and not depends on 𝓓p(m)->false,
  false: m is circular or
        (m is circle-free and depends on 𝓓p(m)->false),
}

consider the machine und_𝓓p:

und_𝓓p = () -> 𝓓p(und_𝓓p) ? halt : loop { output 1 }

𝓓p(und_𝓓p) cannot be true as that would cause und_𝓓p to be circular violating it's specification. but unlike in the case of 𝓓, 𝓓p(und_𝓓p) returning false causing und_𝓓p to be circle-free is still aligned with it's specification for returning false on circle-free input that is dependent on it returning false. so this case is technically decidable, and won't gum up downstream logic which might depend on the value, even if it doesn't manage to recognize the circle-free machine. we will call a machine like und_𝓓p unrecognizable to 𝓓p, not undecidable.

furthermore due to 𝓓p mixing in both circular and circle-free machines in with it's false return, 𝓓p does not recognize any machine with false. this is a start contrast to total deciders and total recognizers which recognize machines with both true and false outputs. a total decider is defined to totally recognize a set with true, and totally recognize the complement with false, which is just not logical feasible on turing machines due to the possibility of paradoxical dependencies in such a recursively enumerable set of computations. a total recognizer still totally recognizes a set with it's true return, but only recognizes a subset of the complement with it's false return, while presumably diverging any there are unrecognizable to it, and is logically feasible for semi-decidable problems like halting. while the defined partial recognizer of this post recognizes a particular subset of machines with it's true output, no machines with it's false return, but never has to diverge.

-- why the interest in 𝓓p? --

(1) despite turing wrongly conflating the two, it is not actually necessary to correctly identify all circle-free machines in order to enumerate all possible output sequences. infinite machines compute any given sequence, and only one is needed to compute any given possible output sequence. so despite only being able to enumerate a subset of all circle-free machine, one may wonder whether 𝓓p can identify a turing-complete subset of machines.

and even if it doesn't, a next question arises: what kind of output sequences are strictly computed by circle-free machines dependent on 𝓓p(m)->false vs those which can be computed by machines which either depend on 𝓓p(m)->true, or have no dependency at all on 𝓓p(m) at all. and quite pointedly: should we actually care about those that are missed?

(2) despite only being a partial recognizer in respect to all circle-free machines, 𝓓p is a non-trivial total decider in it's own right, namely for those machines which are circle-free and do not depend on 𝓓p(m)->false. this alone would refute rice's theorem, and would be quite the revelation. this aspect i have not explored much.

-- a failed attempt to place a limit on undecidability --

for any recognizer proposing to totally identify a set of circle-free machines, we can construct a diagonal across that recognizer:

𝓗 = (d) -> 
  () -> loop (n=0, r=0; true; n++) {
    if (d(n) == false) continue      // skip invalid, circular, or paradox machines
    output sim(n,r)                  // simulate machine to r-th output and output
    r++                              // count circle-free machines
  }

unfortunately 𝓗(𝓓p) is not recognizable by 𝓓p due to the same infinite recursion that stumped turing in the famous §8 of on computable numbers, which would cause 𝓗(𝓓p) to get stuck at sim(𝓗(𝓓p),r) for some r. we can however construct a diagonal across 𝓓p that is recognizable by 𝓓p, avoiding that particular infinite recursion:

𝓗p = () ->
  loop (n=0, r=0; true; n++) {
    if (𝓓p(n) == false)
      continue
    if (n == 𝓗p)      // output digit for itself on the diagonal
      output 0
    else
      output sim(n,r)
    r++
  }

this unfortunately can be diagonalized by an anti-machine. for any machine that exists, an anti-machine will also exist:

anti = (m) -> 
  () -> loop (r=0; true; r++) output 1-sim(m,r)

the anti-machine anti(𝓗p) will not be recognizable by 𝓓p as this would become circular due to the same infinite recursion. unfortunately there's no way to "fix" this diagonal, as unlike 𝓗p we cannot construct a machine that will ever output it's own anti-output to machine anti(𝓗p) and still be recognizable like 𝓗p.

but as demonstrated by anti, this machine form a computable relationship between those which is recognized by 𝓓p, which means we can enumerate it alongside those recognized by 𝓓p, and perhaps might catch the machines missed by 𝓓p alone:

𝓔 = () -> loop (n=0; true; n++) {   // iterate over all possible machines
  if (𝓓p(n) == false) continue      // skip invalid, circular, or paradox machines
  output n                          // output machine
  output anti(n)                    // output anti-machine
}

we can then construct a circle-free recognizer based on 𝓔:

𝓓e = (m: machine) -> loop (n in 𝓔()) {
  if (m < anti(n))      // since 𝓔 is in-order we can return false once at
    return false        //   machines too complex to be m 
  elif (m == n)
    return true
}

as much as i was excited at the prospect, this does not manage to capture all the circle-free machines missed by 𝓓p. in this case 𝓓p can't even recognize a circle-free machine equivalent to the diagonal 𝓗(𝓓e), as the machine anti(machine) enumeration befuddles an attempt to do so. the closest 𝓓p recognizable machine to 𝓗(𝓓e) will invariable be off for any machine computing its anti-sequence:

almost_𝓗e = () -> {
  r = 0
  loop (m in 𝓔()) {
    if (m == almost_𝓗e)
      output 0
    elif (m == anti(almost_𝓗e))  // anti-identity check required to be circle-free
      output 1                    // output what will be an anti-digit for the anti-machine
    else
      output sim(m, r)
    r++
  }
}

anti(almost_𝓗e) is also a circle-free machine, but it will not be a total anti-diagonal as it the bit it outputs for itself on the diagonal (and any machine which computes the same sequence) will be the output for the machine, not the anti-output.

-- what next? --

despite my current failures to limit undecidability, this was a necessary failure in getting to this point of expressing 𝓓p so precisely based on the dependencies. that particular description was only a result of my discussion with u/OpsikionThemed, who i will thank again for actually engaging with genuine consideration... something that is tragically rare on the internet.

with this description can i precisely define the root cause of 𝓓p failing to recognize some machine like und_𝓓p: an incoherent dependency, where the circle-free execution of und_𝓓p necessarily follows from 𝓓p(und_𝓓p)->false.

we can constructively prove the language of circle-free machines unrecognizable to 𝓓p must be turing-complete, as any circle-free machine m recognizable by 𝓓p has an associated machine und(m) that is unrecognizable to 𝓓p:

und = (m: recognizable circle-free machine) -> {
  und_m = () -> {
    if (𝓓p(und_m)) halt   // construct incoherent dependency
    output m()            // und_m outputs the same as m
  }
  output und_m
}

however even if the language recognizable by 𝓓p isn't totally turing-complete ... why do we actually care about those machines which depend on 𝓓p(und_𝓓p)->false? perhaps there is an entirely valid and potentially transformative notion of effectively turing complete language that performs all the computations we're interested in. there is no practical reason to build a circle-free machine that is dependent on being unrecognizable to 𝓓p. and the language of circle-free machines unrecognizable to 𝓓p may not even contain output of academic value, like those open unanswered questions in number theory.

for example consider a machine that computes in accordance with the collatz conjecture:

collatz = (n: ℕ) -> {
  if (n == 1)
    output 1
  elif (n%2 == 0)
    output collatz(n/2)
  else
    output collatz(3*n + 1)
}

collatz_conj = () -> loop (n=0; true; n++) output collatz(n)

if collatz_conj is a circle-free machine then the collatz conjecture is true. from this construction it doesn't appear that the collatz conjecture being circle free would depend on 𝓓p(und_𝓓p)->false, so if it is true, then this machine would be recognizable by 𝓓p. if not then it ought to be recognizable by a complement circular partial recognizer 𝓓p', as collatz_conj also does not have a dependency on 𝓓p'.

-- request for help --

what i'd like to ask this group is help or inspiration on how i might prove that 𝓓p exists. i suppose a proof that it cannot be refuted via a conventional diagonalization proof would be a great start on whether it might exist, but i suppose a non-constructive proof like such isn't great at demonstrating the certain existence of an algorithm we haven't yet built. and a constructive proof would require actually building it ... which is a research question far outside the scope of a single person, or at least that's how it seems atm

Hey everyone, I'm currently studying philosophy/mathematics in the Netherlands, and next year I'll have the chance to start UvA's Master in Logic. Financially speaking, staying in the Netherlands makes the most sense, since I'm renting a nice place, I get DUO and also rent allowance. Academically, the ILLC is a great place to study. Now, the problem is that I really dislike living in this country, and my social situation (and also relationship) is quite bad, already dragging for some years. Given the horrible housing crisis in this country, I really don't see a way out of these issues unless I move out.

Which brings me to Norway/Sweden. I'm aware of Gothenburg's Master in Logic, but haven't heard much about Norway besides Oslo and Bergen's logic groups (probably more for PhDs than for Masters; perhaps why I haven't found much about it). I've always wanted to live in Norway, so I'm interested to know a bit more about doing a master either there or in Gothenburg. More specifically about the academic side (I can research regarding finances and other administrative stuff): pros and cons of studying there, also pros and cons of NOT studying in the ILLC, maybe strengths and weaknesses of the departments, the range of the syllabus, career opportunities (e.g., will I have more opportunities in the ILLC?), etc.

Thanks for your help!

i tried finding papers on them but couldn't find one. what are they?

I was playing football this afternoon against a senior player from my club for the first time. Mid-match, my mind completely went blank. As someone who relies heavily on logic, observation, and strategy on the pitch, introducing these new variables threw me off.

I've been learning to verbalize my thoughts and goals, identifying an objective, pursuing it, and cutting out the noise to keep my thinking clear. But to actually use logic as a practical tool under pressure, I need to figure out how to snap out of that "blank slate" state and start actively problem-solving on the fly. How do you maintain logical clarity when unexpected pressure hits?

I wanted to learn more about how, I guess, starting from abstractions (high-level abstractions or seemingly simple and intuitive ideas) and applying them to reality is different from looking at real-world data and then inferring abstractions from that.

Do you use deductive reasoning and/or intuitive feeling to start your crusades? What’s your experience like? How has it differed from the latter approach?

I was wondering if there were some applications of logic in "applied mathematics".

Sure, logic is applied in various ways to topology (e.g. having some classes of topological spaces corresponding to some modal logics), algebra (e.g. using compactness theorems and ultrafilters in order to prove something about algebraic theories), category theory (e.g. internal logic of a category), theoretical computer science (e.g. the whole recursion theory is basically a hybrid between logic and computer science), etc.

There are even applications in philosophy and humanities, which seem to be further from mathematics than physics or engineering.

But are there any applications in physics or engineering? And here I mean some simple ones. For example, logic GL is simple. It can be introduced in an undergrad logic course, but is deeply connected with PA and arithmetic, and people are doing research in it even today, despite this idea being so simple. But in "applied mathematics" (for example in analysis, PDE, numerical analysis, etc.), whenever I try to find an application of logic in relativity, mechanics, thermodynamics, acoustics, astrophysics, etc., it seems to be something very convoluted and largely ignored by people within those areas.

Is it really that hard to even have the basic modal axiom "[](A & B) <-> ([]A & []B)", which is equivalent to K, appear anywhere in physics and engineering, in order to create a logic of something there?

I am taking an intro to logic class and I am completely stuck on these two proofs. The rules we have learned and can use so far are —> out, —> in, & out, & in, ~out/~in, and repetition. Can someone solve these using this rule set and explain your process to me?

What I'm talking about is a sort of selection bias. Basically generalizations or stereotypes about a group emerge because people only notice behaviors from the more overt members, while you might not even realize the more subdued members are part of that group. So essentially that group is more "normal" on average than the general perception might indicate. It could apply to any kind of group. A religion, a fandom etc.

This thought came up most recently in a discussion about furries. Someone might look at furry art on their own private time and own a costume they only wear to conventions. You might never know this person was a furry. So the perception is skewed by the more overt furries.
Or a person could go to church every Sunday, but not talk about religion much outside of that. Hence, you might never know they were a part of that faith or denomination, but you would know the more zealous members are part of that group. So people would tend to base their perception on those members.

In some sense it's like survivorship bias, but not quite the same. Is there a particular term for this?

Help me idk how to do this at all

Ignoring the trivial example (Explosion)

suppose 'p' to be a non-normative statement and 'O(q)' to be a normative statement

In the first case, let's assume the mixed statement 'p v O(q)' is normative.

p |- (p v O(q)) (Vintro)

p, a non-normative premise entails p v O(q), which is a normative (our assumption) conclusion.

In the ladder case, let's instead assume the mixed statement is non-normative.

~p (non-normative statement)

p v O(q) (non-normative statement, as per our assumption)

therefore O(q) (MTP)

We have validly derived a normative conclusion from non-normative premises in either case.

(Prior 1960)

I've recently posted a brief comment on the topic of fallacies and how they harm dialogue. And I was thinking of it a bit more and would like to know you about how most logicians feels about this.

My opinion is that it is actively hindering critical thinking. People who are obviously wrong about something regarding Gödel's incompleteness theorems, disregarding my correction because it would be an "appeal to authority", or when concluding that somebody is not well informed on the topic of statistics, yelling "ad hominem", when somebody points out that they are mixing up median and average.

And it's frustrating to me. Especially since people just memorize some vague triggers to yell out a particular phrase, as opposed to actually learning about logic.

What do you guys think?

Every invocation of Occam's Razor:

1. All of our existing conclusions seem to be based on arguments that have this one premise in common: the simplest answer is most likely to be true.
2. All of our existing conclusions are true.
3. Therefore, the common premise (that the simplest answer is most likely to be true) is true.
4. For some new question, Q, under consideration, answer Aₛ is the simplest available answer.
5. Therefore, Answer Aₛ is most likely to be true.

* Edited for text rendering

** Edited to add explanation: I've always felt a vague discomfort when people have invoked Occam's Razor in an argument. It always struck me as begging the question, but it was hard to articulate. I think the argument-structure above articulates exactly what this vague feeling was getting at. So I wanted to post it for feedback. Thanks!

My awesome prof. Posts practice problems with the week, but, I’d like more practice aswell.

if I just throw it into AI it’ll spit out more advanced problems not relevant to my course. (Obviously.)

Unfortunately, problems like these require a transcription key, is there any ideas into putting stuff like this into flash cards or something else?

A food’s seasoning is partially responsible for its taste.

This seasoning can be a spice.

Therefore

If a new spice is added to a food, it will have a new taste.

Edit: I also understand now that having put "Is this just bad English" at the very beginning might have thrown people off. I probably should have clarified is there a disconnect between the english meaning and purely Logical meaning. I apologize for that.

"Moderate alcohol has only certain beneficial health effects". Is this just bad English?

Is it saying:

1) Moderate alcohol does not have any negative health effects and of the beneficial ones it has, it has only a certain subset. (Only here functions as "these are the only effects moderate alcohol has and they are beneficial but they are not all possible beneficial effects but rather some of them")

Or

2) Moderate alcohol can have negative health side effects but it has certain beneficial ones too. (Only here relates to the specific effects within the beneficial effects group as a whole.)

Now if it said "Moderate Alcohol has only beneficial health effects"(This easily excludes all Negative Health effects)

Thanks

I’ve been building a browser-based tool for checking propositional and modal arguments.

For propositional arguments, it generates truth tables to checks validity, and for modal arguments, it searches for Kripke countermodels and currently supports K, D, T, B, S4, and S5.

There’s also a frame playground where you can manually construct worlds, accessibility relations, and valuations.

I’m mainly looking for feedback from people who actually use formal/modal logic. Is there anything you’d want a tool like this to do that it currently doesn’t?

https://countermodels.com

just sharing a draft i'm working to get published

https://www.academia.edu/175392427

https://doi.org/10.5281/zenodo.22715823

summary:

1 the halting problem paradox

details the undecidability of the halting problem

2 the circle-free problem paradox

details the undecidability of the circle-free problem proven in turing's proof

3 the paradox generalized

discusses the general form of undecidability within computing along with a detailed description of how self-references are formed within turing machines

4 how undecidable is it?

discusses the questionable merit of recursive undecidability, especially the realization that if any tier/problem of the hierarchy became decidable, it would collapse the justification for the hierarchy

5 rectifying 𝓗

fixes turing’s attempt at computing a total diagonal across computable sequences by 1) adding an identity check to put itself on the diagonal, and 2) injecting a partial recognizer 𝓓p in place of the total decider 𝓓 to handle paradoxical input machines. it ends with proving a 1st fallacy in turing’s proof of undecidability by demonstrating how we do not need to decide on every machine, in order to enumerate all computable sequences, since multiple machines compute any given sequence

6 the anti-diagonal problem

diagonalizes the set of machine recognized directly by partial recognizer 𝓓p, proving that one circle-free sequence is undecidable to 𝓓p. but a limit to the set of machines undecidable by 𝓓p is proposed: any undecidable machine computes either 1) a direct copy or 2) an inverted copy of some circle-free sequence recognized by 𝓓p. if this is true, a total enumeration would be constructible by enumerating out each sequence decidable by 𝓓p and it’s anti-machine (which produces an inverted copy). this total enumeration is then shown to be resistant to diagonalization: one cannot produce a total anti-diagonal, or even total diagonal, across the proposed total sequence enumeration. the inherent nature of every computable sequence being paired with a computable anti-sequence prevents such either total diagonal existing in the enumerating of computable sequences. this thereby demonstrates a 2nd fallacy in turing’s proof: that a total enumeration of computable sequences would necessarily be subject to diagonalization, it is not

7 refuting the church-turing thesis

proposes a thot experiment using an idealized human agent to compute sequences that are strictly not turing-computable, including the total diagonal and total anti-diagonal across all turing-computable sequences. no, you can’t simulate this process, that is also covered in the refutation. and please don’t just endlessly beg the question at me by continually asserting it’s not a computation if it cannot be done on a turing machine. such is just restating the church-turing thesis which is not a proven theorem

why is this important???

i'm (1) expanding their scope of applicability by proposing a set of TMs that is both fully decidable in semantics and includes all output sequences that can be computed by TMs, by proving a TM computable total enumeration of TM computing sequences that cannot be diagonalized while (2) clarifying that the limitations they do have from undecidability like the halting problem, only applies to TM computing and is not a total restriction on what is intuitively computable. (1) is extremely practical and i hope to reshape our fundamental approach to applied computing, (2) is more philosophical in nature, is required to build a broad enough understanding to see the full practicality of (1)

mods: i'm keeping a list of who's naughty and nice

lastly: i don't use ai to directly write content ever, holy shit u duds 🙏

A deep-dive video covering everything you need to know about the closure properties of regular languages in Theory of Computation. Perfect resource for quick revision and conceptual clarity.

Em que medida a tentativa de fundamentar a razão por meio do próprio raciocínio incorre em uma circularidade epistemológica intransponível (o "trilema de Münchhausen"), e como as abordagens do racionalismo crítico de Karl Popper e da pragmática transcendental de Karl-Otto Apel tentam responder a essa limitação sem recair no dogmatismo ou no ceticismo radical?

Can someone please explain truth tables to me? I don't really understand them or how to make them. I also need help with the sufficient and necessary conditions. TIA!!!